@maketribe/ms-app 5.0.8 → 5.0.9

package/dist/types/components/data-model/data-tree-list/index.d.ts

@@ -1,5 +1,5 @@
 export declare const MKDataTreeList: import("@maketribe/utils").SFCWithInstall<{
-    new (...args: any[]): import("vue").CreateComponentPublicInstance<Readonly<globalThis.ExtractPropTypes<{
+    new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<globalThis.ExtractPropTypes<{
         title: {
             type: StringConstructor;
             default: string;
@@ -8,9 +8,276 @@ export declare const MKDataTreeList: import("@maketribe/utils").SFCWithInstall<{
             type: StringConstructor;
         };
         dataTree: {
-            type: {
+            type: ((import("@maketribe/utils").SFCWithInstall<{
+                new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<globalThis.ExtractPropTypes<{
+                    readonly dataTable: {
+                        readonly type: globalThis.PropType<import("@maketribe/dm").DataTable<any, any, Record<string, any>, import("@maketribe/dm").TableColumn>>;
+                        readonly required: true;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __mkPropKey: true;
+                    };
+                    readonly selection: import("@maketribe/utils").PropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
+                    readonly name: {
+                        readonly type: globalThis.PropType<string>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __mkPropKey: true;
+                    };
+                    readonly mode: import("@maketribe/utils").PropFinalized<StringConstructor, unknown, unknown, "table", boolean>;
+                    readonly primaryKey: {
+                        readonly type: globalThis.PropType<string>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __mkPropKey: true;
+                    };
+                    readonly pageSize: {
+                        readonly type: globalThis.PropType<number>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __mkPropKey: true;
+                    };
+                    readonly interfaceURL: {
+                        readonly type: globalThis.PropType<Record<string, any>>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __mkPropKey: true;
+                    };
+                    readonly listInterfaceURL: {
+                        readonly type: globalThis.PropType<string>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __mkPropKey: true;
+                    };
+                    readonly deleteInterfaceURL: {
+                        readonly type: globalThis.PropType<string>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __mkPropKey: true;
+                    };
+                    readonly autoLoad: import("@maketribe/utils").PropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+                    readonly columns: import("@maketribe/utils").PropFinalized<{
+                        (arrayLength: number): import("@maketribe/dm").ColumnOptions[];
+                        (...items: import("@maketribe/dm").ColumnOptions[]): import("@maketribe/dm").ColumnOptions[];
+                        new (arrayLength: number): import("@maketribe/dm").ColumnOptions[];
+                        new (...items: import("@maketribe/dm").ColumnOptions[]): import("@maketribe/dm").ColumnOptions[];
+                        isArray(arg: any): arg is any[];
+                        readonly prototype: any[];
+                        from<T>(arrayLike: ArrayLike<T>): T[];
+                        from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+                        from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+                        from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+                        of<T>(...items: T[]): T[];
+                        fromAsync<T>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T | PromiseLike<T>> | ArrayLike<T | PromiseLike<T>>): Promise<T[]>;
+                        fromAsync<T, U>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T> | ArrayLike<T>, mapFn: (value: Awaited<T>, index: number) => U, thisArg?: any): Promise<Awaited<U>[]>;
+                        readonly [Symbol.species]: ArrayConstructor;
+                    }, unknown, unknown, () => never[], boolean>;
+                    readonly enableQueryParams: import("@maketribe/utils").PropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
+                }>> & Readonly<{}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, import("vue").PublicProps, {
+                    readonly mode: string;
+                    readonly selection: import("@maketribe/utils").PropMergeType<BooleanConstructor, unknown, unknown>;
+                    readonly autoLoad: import("@maketribe/utils").PropMergeType<BooleanConstructor, unknown, unknown>;
+                    readonly columns: import("@maketribe/dm").ColumnOptions[];
+                    readonly enableQueryParams: import("@maketribe/utils").PropMergeType<BooleanConstructor, unknown, unknown>;
+                }, true, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
+                    P: {};
+                    B: {};
+                    D: {};
+                    C: {};
+                    M: {};
+                    Defaults: {};
+                }, Readonly<globalThis.ExtractPropTypes<{
+                    readonly dataTable: {
+                        readonly type: globalThis.PropType<import("@maketribe/dm").DataTable<any, any, Record<string, any>, import("@maketribe/dm").TableColumn>>;
+                        readonly required: true;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __mkPropKey: true;
+                    };
+                    readonly selection: import("@maketribe/utils").PropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
+                    readonly name: {
+                        readonly type: globalThis.PropType<string>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __mkPropKey: true;
+                    };
+                    readonly mode: import("@maketribe/utils").PropFinalized<StringConstructor, unknown, unknown, "table", boolean>;
+                    readonly primaryKey: {
+                        readonly type: globalThis.PropType<string>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __mkPropKey: true;
+                    };
+                    readonly pageSize: {
+                        readonly type: globalThis.PropType<number>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __mkPropKey: true;
+                    };
+                    readonly interfaceURL: {
+                        readonly type: globalThis.PropType<Record<string, any>>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __mkPropKey: true;
+                    };
+                    readonly listInterfaceURL: {
+                        readonly type: globalThis.PropType<string>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __mkPropKey: true;
+                    };
+                    readonly deleteInterfaceURL: {
+                        readonly type: globalThis.PropType<string>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __mkPropKey: true;
+                    };
+                    readonly autoLoad: import("@maketribe/utils").PropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+                    readonly columns: import("@maketribe/utils").PropFinalized<{
+                        (arrayLength: number): import("@maketribe/dm").ColumnOptions[];
+                        (...items: import("@maketribe/dm").ColumnOptions[]): import("@maketribe/dm").ColumnOptions[];
+                        new (arrayLength: number): import("@maketribe/dm").ColumnOptions[];
+                        new (...items: import("@maketribe/dm").ColumnOptions[]): import("@maketribe/dm").ColumnOptions[];
+                        isArray(arg: any): arg is any[];
+                        readonly prototype: any[];
+                        from<T>(arrayLike: ArrayLike<T>): T[];
+                        from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+                        from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+                        from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+                        of<T>(...items: T[]): T[];
+                        fromAsync<T>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T | PromiseLike<T>> | ArrayLike<T | PromiseLike<T>>): Promise<T[]>;
+                        fromAsync<T, U>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T> | ArrayLike<T>, mapFn: (value: Awaited<T>, index: number) => U, thisArg?: any): Promise<Awaited<U>[]>;
+                        readonly [Symbol.species]: ArrayConstructor;
+                    }, unknown, unknown, () => never[], boolean>;
+                    readonly enableQueryParams: import("@maketribe/utils").PropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
+                }>> & Readonly<{}>, {}, {}, {}, {}, {
+                    readonly mode: string;
+                    readonly selection: import("@maketribe/utils").PropMergeType<BooleanConstructor, unknown, unknown>;
+                    readonly autoLoad: import("@maketribe/utils").PropMergeType<BooleanConstructor, unknown, unknown>;
+                    readonly columns: import("@maketribe/dm").ColumnOptions[];
+                    readonly enableQueryParams: import("@maketribe/utils").PropMergeType<BooleanConstructor, unknown, unknown>;
+                }>;
+                __isFragment?: never;
+                __isTeleport?: never;
+                __isSuspense?: never;
+            } & import("vue").ComponentOptionsBase<Readonly<globalThis.ExtractPropTypes<{
+                readonly dataTable: {
+                    readonly type: globalThis.PropType<import("@maketribe/dm").DataTable<any, any, Record<string, any>, import("@maketribe/dm").TableColumn>>;
+                    readonly required: true;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __mkPropKey: true;
+                };
+                readonly selection: import("@maketribe/utils").PropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
+                readonly name: {
+                    readonly type: globalThis.PropType<string>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __mkPropKey: true;
+                };
+                readonly mode: import("@maketribe/utils").PropFinalized<StringConstructor, unknown, unknown, "table", boolean>;
+                readonly primaryKey: {
+                    readonly type: globalThis.PropType<string>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __mkPropKey: true;
+                };
+                readonly pageSize: {
+                    readonly type: globalThis.PropType<number>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __mkPropKey: true;
+                };
+                readonly interfaceURL: {
+                    readonly type: globalThis.PropType<Record<string, any>>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __mkPropKey: true;
+                };
+                readonly listInterfaceURL: {
+                    readonly type: globalThis.PropType<string>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __mkPropKey: true;
+                };
+                readonly deleteInterfaceURL: {
+                    readonly type: globalThis.PropType<string>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __mkPropKey: true;
+                };
+                readonly autoLoad: import("@maketribe/utils").PropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+                readonly columns: import("@maketribe/utils").PropFinalized<{
+                    (arrayLength: number): import("@maketribe/dm").ColumnOptions[];
+                    (...items: import("@maketribe/dm").ColumnOptions[]): import("@maketribe/dm").ColumnOptions[];
+                    new (arrayLength: number): import("@maketribe/dm").ColumnOptions[];
+                    new (...items: import("@maketribe/dm").ColumnOptions[]): import("@maketribe/dm").ColumnOptions[];
+                    isArray(arg: any): arg is any[];
+                    readonly prototype: any[];
+                    from<T>(arrayLike: ArrayLike<T>): T[];
+                    from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+                    from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+                    from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+                    of<T>(...items: T[]): T[];
+                    fromAsync<T>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T | PromiseLike<T>> | ArrayLike<T | PromiseLike<T>>): Promise<T[]>;
+                    fromAsync<T, U>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T> | ArrayLike<T>, mapFn: (value: Awaited<T>, index: number) => U, thisArg?: any): Promise<Awaited<U>[]>;
+                    readonly [Symbol.species]: ArrayConstructor;
+                }, unknown, unknown, () => never[], boolean>;
+                readonly enableQueryParams: import("@maketribe/utils").PropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
+            }>> & Readonly<{}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {
+                readonly mode: string;
+                readonly selection: import("@maketribe/utils").PropMergeType<BooleanConstructor, unknown, unknown>;
+                readonly autoLoad: import("@maketribe/utils").PropMergeType<BooleanConstructor, unknown, unknown>;
+                readonly columns: import("@maketribe/dm").ColumnOptions[];
+                readonly enableQueryParams: import("@maketribe/utils").PropMergeType<BooleanConstructor, unknown, unknown>;
+            }, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
+                $slots: {
+                    [x: string]: ((props: any) => any) | undefined;
+                } & {
+                    default?: (props: {
+                        dataTable: import("@maketribe/dm").DataTable<any, any, Record<string, any>, import("@maketribe/dm").TableColumn>;
+                    }) => any;
+                };
+            })> & {
+                MKDataTableColumn: import("vue").DefineComponent<globalThis.ExtractPropTypes<{
+                    readonly column: {
+                        readonly type: globalThis.PropType<import("@maketribe/dm").TableColumn>;
+                        readonly required: true;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __mkPropKey: true;
+                    };
+                    readonly row: {
+                        readonly type: globalThis.PropType<any>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __mkPropKey: true;
+                    };
+                    readonly index: {
+                        readonly type: globalThis.PropType<number>;
+                        readonly required: true;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __mkPropKey: true;
+                    };
+                }>, () => import("vue/jsx-runtime").JSX.Element | null, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<globalThis.ExtractPropTypes<{
+                    readonly column: {
+                        readonly type: globalThis.PropType<import("@maketribe/dm").TableColumn>;
+                        readonly required: true;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __mkPropKey: true;
+                    };
+                    readonly row: {
+                        readonly type: globalThis.PropType<any>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __mkPropKey: true;
+                    };
+                    readonly index: {
+                        readonly type: globalThis.PropType<number>;
+                        readonly required: true;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __mkPropKey: true;
+                    };
+                }>> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+            }) | {
                 new (options?: import("@maketribe/dm").DataTreeOptions): import("@maketribe/dm").DataTree<any>;
-            };
+            })[];
             required: true;
         };
         autoLoad: {
@@ -36,68 +303,31 @@ export declare const MKDataTreeList: import("@maketribe/utils").SFCWithInstall<{
             type: BooleanConstructor;
             default: boolean;
         };
-    }>> & {
+        defaultExpandAll: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+    }>> & Readonly<{
         onSelect?: ((...args: any[]) => any) | undefined;
-        onEdit?: ((...args: any[]) => any) | undefined;
         onAdd?: ((...args: any[]) => any) | undefined;
+        onEdit?: ((...args: any[]) => any) | undefined;
         onDeleteSuccessfully?: ((...args: any[]) => any) | undefined;
-    }, {
-        dataTree: import("@maketribe/dm").DataTree<any>;
-    }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    }>, {
+        dataTree: any;
+    }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
         select: (...args: any[]) => void;
         add: (...args: any[]) => void;
         edit: (...args: any[]) => void;
         deleteSuccessfully: (...args: any[]) => void;
-    }, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & Readonly<globalThis.ExtractPropTypes<{
-        title: {
-            type: StringConstructor;
-            default: string;
-        };
-        iconName: {
-            type: StringConstructor;
-        };
-        dataTree: {
-            type: {
-                new (options?: import("@maketribe/dm").DataTreeOptions): import("@maketribe/dm").DataTree<any>;
-            };
-            required: true;
-        };
-        autoLoad: {
-            type: BooleanConstructor;
-            default: boolean;
-        };
-        dataItemDescFieldName: {
-            type: StringConstructor;
-            default: string;
-        };
-        curSelectId: {
-            type: (NumberConstructor | StringConstructor)[];
-        };
-        useSort: {
-            type: BooleanConstructor;
-            default: boolean;
-        };
-        useAction: {
-            type: BooleanConstructor;
-            default: boolean;
-        };
-        useFirstSelect: {
-            type: BooleanConstructor;
-            default: boolean;
-        };
-    }>> & {
-        onSelect?: ((...args: any[]) => any) | undefined;
-        onEdit?: ((...args: any[]) => any) | undefined;
-        onAdd?: ((...args: any[]) => any) | undefined;
-        onDeleteSuccessfully?: ((...args: any[]) => any) | undefined;
-    }, {
+    }, import("vue").PublicProps, {
         title: string;
         autoLoad: boolean;
+        defaultExpandAll: boolean;
         dataItemDescFieldName: string;
         useSort: boolean;
         useAction: boolean;
         useFirstSelect: boolean;
-    }, true, {}, {}, {
+    }, true, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
         P: {};
         B: {};
         D: {};
@@ -113,9 +343,276 @@ export declare const MKDataTreeList: import("@maketribe/utils").SFCWithInstall<{
             type: StringConstructor;
         };
         dataTree: {
-            type: {
+            type: ((import("@maketribe/utils").SFCWithInstall<{
+                new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<globalThis.ExtractPropTypes<{
+                    readonly dataTable: {
+                        readonly type: globalThis.PropType<import("@maketribe/dm").DataTable<any, any, Record<string, any>, import("@maketribe/dm").TableColumn>>;
+                        readonly required: true;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __mkPropKey: true;
+                    };
+                    readonly selection: import("@maketribe/utils").PropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
+                    readonly name: {
+                        readonly type: globalThis.PropType<string>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __mkPropKey: true;
+                    };
+                    readonly mode: import("@maketribe/utils").PropFinalized<StringConstructor, unknown, unknown, "table", boolean>;
+                    readonly primaryKey: {
+                        readonly type: globalThis.PropType<string>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __mkPropKey: true;
+                    };
+                    readonly pageSize: {
+                        readonly type: globalThis.PropType<number>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __mkPropKey: true;
+                    };
+                    readonly interfaceURL: {
+                        readonly type: globalThis.PropType<Record<string, any>>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __mkPropKey: true;
+                    };
+                    readonly listInterfaceURL: {
+                        readonly type: globalThis.PropType<string>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __mkPropKey: true;
+                    };
+                    readonly deleteInterfaceURL: {
+                        readonly type: globalThis.PropType<string>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __mkPropKey: true;
+                    };
+                    readonly autoLoad: import("@maketribe/utils").PropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+                    readonly columns: import("@maketribe/utils").PropFinalized<{
+                        (arrayLength: number): import("@maketribe/dm").ColumnOptions[];
+                        (...items: import("@maketribe/dm").ColumnOptions[]): import("@maketribe/dm").ColumnOptions[];
+                        new (arrayLength: number): import("@maketribe/dm").ColumnOptions[];
+                        new (...items: import("@maketribe/dm").ColumnOptions[]): import("@maketribe/dm").ColumnOptions[];
+                        isArray(arg: any): arg is any[];
+                        readonly prototype: any[];
+                        from<T>(arrayLike: ArrayLike<T>): T[];
+                        from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+                        from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+                        from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+                        of<T>(...items: T[]): T[];
+                        fromAsync<T>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T | PromiseLike<T>> | ArrayLike<T | PromiseLike<T>>): Promise<T[]>;
+                        fromAsync<T, U>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T> | ArrayLike<T>, mapFn: (value: Awaited<T>, index: number) => U, thisArg?: any): Promise<Awaited<U>[]>;
+                        readonly [Symbol.species]: ArrayConstructor;
+                    }, unknown, unknown, () => never[], boolean>;
+                    readonly enableQueryParams: import("@maketribe/utils").PropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
+                }>> & Readonly<{}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, import("vue").PublicProps, {
+                    readonly mode: string;
+                    readonly selection: import("@maketribe/utils").PropMergeType<BooleanConstructor, unknown, unknown>;
+                    readonly autoLoad: import("@maketribe/utils").PropMergeType<BooleanConstructor, unknown, unknown>;
+                    readonly columns: import("@maketribe/dm").ColumnOptions[];
+                    readonly enableQueryParams: import("@maketribe/utils").PropMergeType<BooleanConstructor, unknown, unknown>;
+                }, true, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
+                    P: {};
+                    B: {};
+                    D: {};
+                    C: {};
+                    M: {};
+                    Defaults: {};
+                }, Readonly<globalThis.ExtractPropTypes<{
+                    readonly dataTable: {
+                        readonly type: globalThis.PropType<import("@maketribe/dm").DataTable<any, any, Record<string, any>, import("@maketribe/dm").TableColumn>>;
+                        readonly required: true;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __mkPropKey: true;
+                    };
+                    readonly selection: import("@maketribe/utils").PropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
+                    readonly name: {
+                        readonly type: globalThis.PropType<string>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __mkPropKey: true;
+                    };
+                    readonly mode: import("@maketribe/utils").PropFinalized<StringConstructor, unknown, unknown, "table", boolean>;
+                    readonly primaryKey: {
+                        readonly type: globalThis.PropType<string>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __mkPropKey: true;
+                    };
+                    readonly pageSize: {
+                        readonly type: globalThis.PropType<number>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __mkPropKey: true;
+                    };
+                    readonly interfaceURL: {
+                        readonly type: globalThis.PropType<Record<string, any>>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __mkPropKey: true;
+                    };
+                    readonly listInterfaceURL: {
+                        readonly type: globalThis.PropType<string>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __mkPropKey: true;
+                    };
+                    readonly deleteInterfaceURL: {
+                        readonly type: globalThis.PropType<string>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __mkPropKey: true;
+                    };
+                    readonly autoLoad: import("@maketribe/utils").PropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+                    readonly columns: import("@maketribe/utils").PropFinalized<{
+                        (arrayLength: number): import("@maketribe/dm").ColumnOptions[];
+                        (...items: import("@maketribe/dm").ColumnOptions[]): import("@maketribe/dm").ColumnOptions[];
+                        new (arrayLength: number): import("@maketribe/dm").ColumnOptions[];
+                        new (...items: import("@maketribe/dm").ColumnOptions[]): import("@maketribe/dm").ColumnOptions[];
+                        isArray(arg: any): arg is any[];
+                        readonly prototype: any[];
+                        from<T>(arrayLike: ArrayLike<T>): T[];
+                        from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+                        from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+                        from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+                        of<T>(...items: T[]): T[];
+                        fromAsync<T>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T | PromiseLike<T>> | ArrayLike<T | PromiseLike<T>>): Promise<T[]>;
+                        fromAsync<T, U>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T> | ArrayLike<T>, mapFn: (value: Awaited<T>, index: number) => U, thisArg?: any): Promise<Awaited<U>[]>;
+                        readonly [Symbol.species]: ArrayConstructor;
+                    }, unknown, unknown, () => never[], boolean>;
+                    readonly enableQueryParams: import("@maketribe/utils").PropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
+                }>> & Readonly<{}>, {}, {}, {}, {}, {
+                    readonly mode: string;
+                    readonly selection: import("@maketribe/utils").PropMergeType<BooleanConstructor, unknown, unknown>;
+                    readonly autoLoad: import("@maketribe/utils").PropMergeType<BooleanConstructor, unknown, unknown>;
+                    readonly columns: import("@maketribe/dm").ColumnOptions[];
+                    readonly enableQueryParams: import("@maketribe/utils").PropMergeType<BooleanConstructor, unknown, unknown>;
+                }>;
+                __isFragment?: never;
+                __isTeleport?: never;
+                __isSuspense?: never;
+            } & import("vue").ComponentOptionsBase<Readonly<globalThis.ExtractPropTypes<{
+                readonly dataTable: {
+                    readonly type: globalThis.PropType<import("@maketribe/dm").DataTable<any, any, Record<string, any>, import("@maketribe/dm").TableColumn>>;
+                    readonly required: true;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __mkPropKey: true;
+                };
+                readonly selection: import("@maketribe/utils").PropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
+                readonly name: {
+                    readonly type: globalThis.PropType<string>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __mkPropKey: true;
+                };
+                readonly mode: import("@maketribe/utils").PropFinalized<StringConstructor, unknown, unknown, "table", boolean>;
+                readonly primaryKey: {
+                    readonly type: globalThis.PropType<string>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __mkPropKey: true;
+                };
+                readonly pageSize: {
+                    readonly type: globalThis.PropType<number>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __mkPropKey: true;
+                };
+                readonly interfaceURL: {
+                    readonly type: globalThis.PropType<Record<string, any>>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __mkPropKey: true;
+                };
+                readonly listInterfaceURL: {
+                    readonly type: globalThis.PropType<string>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __mkPropKey: true;
+                };
+                readonly deleteInterfaceURL: {
+                    readonly type: globalThis.PropType<string>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __mkPropKey: true;
+                };
+                readonly autoLoad: import("@maketribe/utils").PropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+                readonly columns: import("@maketribe/utils").PropFinalized<{
+                    (arrayLength: number): import("@maketribe/dm").ColumnOptions[];
+                    (...items: import("@maketribe/dm").ColumnOptions[]): import("@maketribe/dm").ColumnOptions[];
+                    new (arrayLength: number): import("@maketribe/dm").ColumnOptions[];
+                    new (...items: import("@maketribe/dm").ColumnOptions[]): import("@maketribe/dm").ColumnOptions[];
+                    isArray(arg: any): arg is any[];
+                    readonly prototype: any[];
+                    from<T>(arrayLike: ArrayLike<T>): T[];
+                    from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+                    from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+                    from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+                    of<T>(...items: T[]): T[];
+                    fromAsync<T>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T | PromiseLike<T>> | ArrayLike<T | PromiseLike<T>>): Promise<T[]>;
+                    fromAsync<T, U>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T> | ArrayLike<T>, mapFn: (value: Awaited<T>, index: number) => U, thisArg?: any): Promise<Awaited<U>[]>;
+                    readonly [Symbol.species]: ArrayConstructor;
+                }, unknown, unknown, () => never[], boolean>;
+                readonly enableQueryParams: import("@maketribe/utils").PropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
+            }>> & Readonly<{}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {
+                readonly mode: string;
+                readonly selection: import("@maketribe/utils").PropMergeType<BooleanConstructor, unknown, unknown>;
+                readonly autoLoad: import("@maketribe/utils").PropMergeType<BooleanConstructor, unknown, unknown>;
+                readonly columns: import("@maketribe/dm").ColumnOptions[];
+                readonly enableQueryParams: import("@maketribe/utils").PropMergeType<BooleanConstructor, unknown, unknown>;
+            }, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
+                $slots: {
+                    [x: string]: ((props: any) => any) | undefined;
+                } & {
+                    default?: (props: {
+                        dataTable: import("@maketribe/dm").DataTable<any, any, Record<string, any>, import("@maketribe/dm").TableColumn>;
+                    }) => any;
+                };
+            })> & {
+                MKDataTableColumn: import("vue").DefineComponent<globalThis.ExtractPropTypes<{
+                    readonly column: {
+                        readonly type: globalThis.PropType<import("@maketribe/dm").TableColumn>;
+                        readonly required: true;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __mkPropKey: true;
+                    };
+                    readonly row: {
+                        readonly type: globalThis.PropType<any>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __mkPropKey: true;
+                    };
+                    readonly index: {
+                        readonly type: globalThis.PropType<number>;
+                        readonly required: true;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __mkPropKey: true;
+                    };
+                }>, () => import("vue/jsx-runtime").JSX.Element | null, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<globalThis.ExtractPropTypes<{
+                    readonly column: {
+                        readonly type: globalThis.PropType<import("@maketribe/dm").TableColumn>;
+                        readonly required: true;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __mkPropKey: true;
+                    };
+                    readonly row: {
+                        readonly type: globalThis.PropType<any>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __mkPropKey: true;
+                    };
+                    readonly index: {
+                        readonly type: globalThis.PropType<number>;
+                        readonly required: true;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __mkPropKey: true;
+                    };
+                }>> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+            }) | {
                 new (options?: import("@maketribe/dm").DataTreeOptions): import("@maketribe/dm").DataTree<any>;
-            };
+            })[];
             required: true;
         };
         autoLoad: {
@@ -141,16 +638,21 @@ export declare const MKDataTreeList: import("@maketribe/utils").SFCWithInstall<{
             type: BooleanConstructor;
             default: boolean;
         };
-    }>> & {
+        defaultExpandAll: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+    }>> & Readonly<{
         onSelect?: ((...args: any[]) => any) | undefined;
-        onEdit?: ((...args: any[]) => any) | undefined;
         onAdd?: ((...args: any[]) => any) | undefined;
+        onEdit?: ((...args: any[]) => any) | undefined;
         onDeleteSuccessfully?: ((...args: any[]) => any) | undefined;
-    }, {
-        dataTree: import("@maketribe/dm").DataTree<any>;
+    }>, {
+        dataTree: any;
     }, {}, {}, {}, {
         title: string;
         autoLoad: boolean;
+        defaultExpandAll: boolean;
         dataItemDescFieldName: string;
         useSort: boolean;
         useAction: boolean;
@@ -168,9 +670,276 @@ export declare const MKDataTreeList: import("@maketribe/utils").SFCWithInstall<{
         type: StringConstructor;
     };
     dataTree: {
-        type: {
+        type: ((import("@maketribe/utils").SFCWithInstall<{
+            new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<globalThis.ExtractPropTypes<{
+                readonly dataTable: {
+                    readonly type: globalThis.PropType<import("@maketribe/dm").DataTable<any, any, Record<string, any>, import("@maketribe/dm").TableColumn>>;
+                    readonly required: true;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __mkPropKey: true;
+                };
+                readonly selection: import("@maketribe/utils").PropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
+                readonly name: {
+                    readonly type: globalThis.PropType<string>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __mkPropKey: true;
+                };
+                readonly mode: import("@maketribe/utils").PropFinalized<StringConstructor, unknown, unknown, "table", boolean>;
+                readonly primaryKey: {
+                    readonly type: globalThis.PropType<string>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __mkPropKey: true;
+                };
+                readonly pageSize: {
+                    readonly type: globalThis.PropType<number>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __mkPropKey: true;
+                };
+                readonly interfaceURL: {
+                    readonly type: globalThis.PropType<Record<string, any>>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __mkPropKey: true;
+                };
+                readonly listInterfaceURL: {
+                    readonly type: globalThis.PropType<string>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __mkPropKey: true;
+                };
+                readonly deleteInterfaceURL: {
+                    readonly type: globalThis.PropType<string>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __mkPropKey: true;
+                };
+                readonly autoLoad: import("@maketribe/utils").PropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+                readonly columns: import("@maketribe/utils").PropFinalized<{
+                    (arrayLength: number): import("@maketribe/dm").ColumnOptions[];
+                    (...items: import("@maketribe/dm").ColumnOptions[]): import("@maketribe/dm").ColumnOptions[];
+                    new (arrayLength: number): import("@maketribe/dm").ColumnOptions[];
+                    new (...items: import("@maketribe/dm").ColumnOptions[]): import("@maketribe/dm").ColumnOptions[];
+                    isArray(arg: any): arg is any[];
+                    readonly prototype: any[];
+                    from<T>(arrayLike: ArrayLike<T>): T[];
+                    from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+                    from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+                    from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+                    of<T>(...items: T[]): T[];
+                    fromAsync<T>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T | PromiseLike<T>> | ArrayLike<T | PromiseLike<T>>): Promise<T[]>;
+                    fromAsync<T, U>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T> | ArrayLike<T>, mapFn: (value: Awaited<T>, index: number) => U, thisArg?: any): Promise<Awaited<U>[]>;
+                    readonly [Symbol.species]: ArrayConstructor;
+                }, unknown, unknown, () => never[], boolean>;
+                readonly enableQueryParams: import("@maketribe/utils").PropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
+            }>> & Readonly<{}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, import("vue").PublicProps, {
+                readonly mode: string;
+                readonly selection: import("@maketribe/utils").PropMergeType<BooleanConstructor, unknown, unknown>;
+                readonly autoLoad: import("@maketribe/utils").PropMergeType<BooleanConstructor, unknown, unknown>;
+                readonly columns: import("@maketribe/dm").ColumnOptions[];
+                readonly enableQueryParams: import("@maketribe/utils").PropMergeType<BooleanConstructor, unknown, unknown>;
+            }, true, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
+                P: {};
+                B: {};
+                D: {};
+                C: {};
+                M: {};
+                Defaults: {};
+            }, Readonly<globalThis.ExtractPropTypes<{
+                readonly dataTable: {
+                    readonly type: globalThis.PropType<import("@maketribe/dm").DataTable<any, any, Record<string, any>, import("@maketribe/dm").TableColumn>>;
+                    readonly required: true;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __mkPropKey: true;
+                };
+                readonly selection: import("@maketribe/utils").PropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
+                readonly name: {
+                    readonly type: globalThis.PropType<string>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __mkPropKey: true;
+                };
+                readonly mode: import("@maketribe/utils").PropFinalized<StringConstructor, unknown, unknown, "table", boolean>;
+                readonly primaryKey: {
+                    readonly type: globalThis.PropType<string>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __mkPropKey: true;
+                };
+                readonly pageSize: {
+                    readonly type: globalThis.PropType<number>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __mkPropKey: true;
+                };
+                readonly interfaceURL: {
+                    readonly type: globalThis.PropType<Record<string, any>>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __mkPropKey: true;
+                };
+                readonly listInterfaceURL: {
+                    readonly type: globalThis.PropType<string>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __mkPropKey: true;
+                };
+                readonly deleteInterfaceURL: {
+                    readonly type: globalThis.PropType<string>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __mkPropKey: true;
+                };
+                readonly autoLoad: import("@maketribe/utils").PropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+                readonly columns: import("@maketribe/utils").PropFinalized<{
+                    (arrayLength: number): import("@maketribe/dm").ColumnOptions[];
+                    (...items: import("@maketribe/dm").ColumnOptions[]): import("@maketribe/dm").ColumnOptions[];
+                    new (arrayLength: number): import("@maketribe/dm").ColumnOptions[];
+                    new (...items: import("@maketribe/dm").ColumnOptions[]): import("@maketribe/dm").ColumnOptions[];
+                    isArray(arg: any): arg is any[];
+                    readonly prototype: any[];
+                    from<T>(arrayLike: ArrayLike<T>): T[];
+                    from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+                    from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+                    from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+                    of<T>(...items: T[]): T[];
+                    fromAsync<T>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T | PromiseLike<T>> | ArrayLike<T | PromiseLike<T>>): Promise<T[]>;
+                    fromAsync<T, U>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T> | ArrayLike<T>, mapFn: (value: Awaited<T>, index: number) => U, thisArg?: any): Promise<Awaited<U>[]>;
+                    readonly [Symbol.species]: ArrayConstructor;
+                }, unknown, unknown, () => never[], boolean>;
+                readonly enableQueryParams: import("@maketribe/utils").PropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
+            }>> & Readonly<{}>, {}, {}, {}, {}, {
+                readonly mode: string;
+                readonly selection: import("@maketribe/utils").PropMergeType<BooleanConstructor, unknown, unknown>;
+                readonly autoLoad: import("@maketribe/utils").PropMergeType<BooleanConstructor, unknown, unknown>;
+                readonly columns: import("@maketribe/dm").ColumnOptions[];
+                readonly enableQueryParams: import("@maketribe/utils").PropMergeType<BooleanConstructor, unknown, unknown>;
+            }>;
+            __isFragment?: never;
+            __isTeleport?: never;
+            __isSuspense?: never;
+        } & import("vue").ComponentOptionsBase<Readonly<globalThis.ExtractPropTypes<{
+            readonly dataTable: {
+                readonly type: globalThis.PropType<import("@maketribe/dm").DataTable<any, any, Record<string, any>, import("@maketribe/dm").TableColumn>>;
+                readonly required: true;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __mkPropKey: true;
+            };
+            readonly selection: import("@maketribe/utils").PropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
+            readonly name: {
+                readonly type: globalThis.PropType<string>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __mkPropKey: true;
+            };
+            readonly mode: import("@maketribe/utils").PropFinalized<StringConstructor, unknown, unknown, "table", boolean>;
+            readonly primaryKey: {
+                readonly type: globalThis.PropType<string>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __mkPropKey: true;
+            };
+            readonly pageSize: {
+                readonly type: globalThis.PropType<number>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __mkPropKey: true;
+            };
+            readonly interfaceURL: {
+                readonly type: globalThis.PropType<Record<string, any>>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __mkPropKey: true;
+            };
+            readonly listInterfaceURL: {
+                readonly type: globalThis.PropType<string>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __mkPropKey: true;
+            };
+            readonly deleteInterfaceURL: {
+                readonly type: globalThis.PropType<string>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __mkPropKey: true;
+            };
+            readonly autoLoad: import("@maketribe/utils").PropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+            readonly columns: import("@maketribe/utils").PropFinalized<{
+                (arrayLength: number): import("@maketribe/dm").ColumnOptions[];
+                (...items: import("@maketribe/dm").ColumnOptions[]): import("@maketribe/dm").ColumnOptions[];
+                new (arrayLength: number): import("@maketribe/dm").ColumnOptions[];
+                new (...items: import("@maketribe/dm").ColumnOptions[]): import("@maketribe/dm").ColumnOptions[];
+                isArray(arg: any): arg is any[];
+                readonly prototype: any[];
+                from<T>(arrayLike: ArrayLike<T>): T[];
+                from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+                from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+                from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+                of<T>(...items: T[]): T[];
+                fromAsync<T>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T | PromiseLike<T>> | ArrayLike<T | PromiseLike<T>>): Promise<T[]>;
+                fromAsync<T, U>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T> | ArrayLike<T>, mapFn: (value: Awaited<T>, index: number) => U, thisArg?: any): Promise<Awaited<U>[]>;
+                readonly [Symbol.species]: ArrayConstructor;
+            }, unknown, unknown, () => never[], boolean>;
+            readonly enableQueryParams: import("@maketribe/utils").PropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
+        }>> & Readonly<{}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {
+            readonly mode: string;
+            readonly selection: import("@maketribe/utils").PropMergeType<BooleanConstructor, unknown, unknown>;
+            readonly autoLoad: import("@maketribe/utils").PropMergeType<BooleanConstructor, unknown, unknown>;
+            readonly columns: import("@maketribe/dm").ColumnOptions[];
+            readonly enableQueryParams: import("@maketribe/utils").PropMergeType<BooleanConstructor, unknown, unknown>;
+        }, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
+            $slots: {
+                [x: string]: ((props: any) => any) | undefined;
+            } & {
+                default?: (props: {
+                    dataTable: import("@maketribe/dm").DataTable<any, any, Record<string, any>, import("@maketribe/dm").TableColumn>;
+                }) => any;
+            };
+        })> & {
+            MKDataTableColumn: import("vue").DefineComponent<globalThis.ExtractPropTypes<{
+                readonly column: {
+                    readonly type: globalThis.PropType<import("@maketribe/dm").TableColumn>;
+                    readonly required: true;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __mkPropKey: true;
+                };
+                readonly row: {
+                    readonly type: globalThis.PropType<any>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __mkPropKey: true;
+                };
+                readonly index: {
+                    readonly type: globalThis.PropType<number>;
+                    readonly required: true;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __mkPropKey: true;
+                };
+            }>, () => import("vue/jsx-runtime").JSX.Element | null, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<globalThis.ExtractPropTypes<{
+                readonly column: {
+                    readonly type: globalThis.PropType<import("@maketribe/dm").TableColumn>;
+                    readonly required: true;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __mkPropKey: true;
+                };
+                readonly row: {
+                    readonly type: globalThis.PropType<any>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __mkPropKey: true;
+                };
+                readonly index: {
+                    readonly type: globalThis.PropType<number>;
+                    readonly required: true;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __mkPropKey: true;
+                };
+            }>> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+        }) | {
             new (options?: import("@maketribe/dm").DataTreeOptions): import("@maketribe/dm").DataTree<any>;
-        };
+        })[];
         required: true;
     };
     autoLoad: {
@@ -196,14 +965,18 @@ export declare const MKDataTreeList: import("@maketribe/utils").SFCWithInstall<{
         type: BooleanConstructor;
         default: boolean;
     };
-}>> & {
+    defaultExpandAll: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>> & Readonly<{
     onSelect?: ((...args: any[]) => any) | undefined;
-    onEdit?: ((...args: any[]) => any) | undefined;
     onAdd?: ((...args: any[]) => any) | undefined;
+    onEdit?: ((...args: any[]) => any) | undefined;
     onDeleteSuccessfully?: ((...args: any[]) => any) | undefined;
-}, {
-    dataTree: import("@maketribe/dm").DataTree<any>;
-}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+}>, {
+    dataTree: any;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
     select: (...args: any[]) => void;
     add: (...args: any[]) => void;
     edit: (...args: any[]) => void;
@@ -211,11 +984,12 @@ export declare const MKDataTreeList: import("@maketribe/utils").SFCWithInstall<{
 }, string, {
     title: string;
     autoLoad: boolean;
+    defaultExpandAll: boolean;
     dataItemDescFieldName: string;
     useSort: boolean;
     useAction: boolean;
     useFirstSelect: boolean;
-}, {}, string, {}> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
+}, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
     $slots: {
         tools?: (props: {
             data: any;