@maketribe/ms-app 3.0.57 → 3.0.58

package/dist/esm/modules/ms/components/rich-text-editor/index.d.ts

@@ -0,0 +1,25 @@
+export declare const MKRichTextEditor: import("@maketribe/utils").SFCWithInstall<import("vue").DefineComponent<{
+    readonly modelValue: {
+        readonly type: import("vue").PropType<string>;
+        readonly required: true;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __mkPropKey: true;
+    };
+    readonly disabled: import("@maketribe/utils").PropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
+}, () => JSX.Element, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:model-value": (modelValue: string) => boolean;
+}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    readonly modelValue: {
+        readonly type: import("vue").PropType<string>;
+        readonly required: true;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __mkPropKey: true;
+    };
+    readonly disabled: import("@maketribe/utils").PropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
+}>> & {
+    "onUpdate:model-value"?: ((modelValue: string) => any) | undefined;
+}, {
+    readonly disabled: import("@maketribe/utils").PropMergeType<BooleanConstructor, unknown, unknown>;
+}, {}>> & Record<string, any>;
+export default MKRichTextEditor;
+export * from "./rich-text-editor-options";

package/dist/esm/modules/ms/components/rich-text-editor/rich-text-editor-options.d.ts

@@ -0,0 +1,15 @@
+import { ExtractPropTypes } from "vue";
+export declare const richTextEditorProps: {
+    readonly modelValue: {
+        readonly type: import("vue").PropType<string>;
+        readonly required: true;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __mkPropKey: true;
+    };
+    readonly disabled: import("@maketribe/utils").PropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
+};
+export type RichTextEditorProps = ExtractPropTypes<typeof richTextEditorProps>;
+export declare const richTextEditorEmits: {
+    "update:model-value": (modelValue: string) => boolean;
+};
+export type RichTextEditorEmits = typeof richTextEditorEmits;

package/dist/esm/modules/ms/components/rich-text-editor/rich-text-editor.d.ts

@@ -0,0 +1,35 @@
+import "tinymce/themes/silver/theme.js";
+import "tinymce/models/dom/model.min.js";
+import "tinymce/icons/default/icons.min.js";
+import "tinymce/skins/ui/oxide/skin.js";
+import "tinymce/skins/ui/oxide/content.js";
+import "tinymce/skins/content/default/content.js";
+import "tinymce/plugins/link";
+import "tinymce/plugins/table";
+import "tinymce/plugins/fullscreen";
+import "tinymce/plugins/code";
+import "./langs/zh-Hans.js";
+declare const _default: import("vue").DefineComponent<{
+    readonly modelValue: {
+        readonly type: import("vue").PropType<string>;
+        readonly required: true;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __mkPropKey: true;
+    };
+    readonly disabled: import("@maketribe/utils").PropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
+}, () => JSX.Element, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:model-value": (modelValue: string) => boolean;
+}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    readonly modelValue: {
+        readonly type: import("vue").PropType<string>;
+        readonly required: true;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __mkPropKey: true;
+    };
+    readonly disabled: import("@maketribe/utils").PropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
+}>> & {
+    "onUpdate:model-value"?: ((modelValue: string) => any) | undefined;
+}, {
+    readonly disabled: import("@maketribe/utils").PropMergeType<BooleanConstructor, unknown, unknown>;
+}, {}>;
+export default _default;

package/dist/esm/modules/ms/components/role-permission-config/index.d.ts

@@ -0,0 +1,21 @@
+export declare const MKRolePermissionConfig: import("@maketribe/utils").SFCWithInstall<import("vue").DefineComponent<{
+    readonly rolePermissionConfigTable: {
+        readonly type: import("vue").PropType<import("../..").RolePermissionConfigTable>;
+        readonly required: true;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __mkPropKey: true;
+    };
+}, () => JSX.Element, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    roleChange: (id: any) => boolean;
+}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    readonly rolePermissionConfigTable: {
+        readonly type: import("vue").PropType<import("../..").RolePermissionConfigTable>;
+        readonly required: true;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __mkPropKey: true;
+    };
+}>> & {
+    onRoleChange?: ((id: any) => any) | undefined;
+}, {}, {}>> & Record<string, any>;
+export default MKRolePermissionConfig;
+export * from "./role-permission-config-options";

package/dist/esm/modules/ms/components/role-permission-config/role-permission-config-options.d.ts

@@ -0,0 +1,15 @@
+import { ExtractPropTypes } from "vue";
+import { RolePermissionConfigTable } from "../../dataviews";
+export declare const rolePermissionConfigProps: {
+    readonly rolePermissionConfigTable: {
+        readonly type: import("vue").PropType<RolePermissionConfigTable>;
+        readonly required: true;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __mkPropKey: true;
+    };
+};
+export type RolePermissionConfigProps = ExtractPropTypes<typeof rolePermissionConfigProps>;
+export declare const rolePermissionConfigEmits: {
+    roleChange: (id: any) => boolean;
+};
+export type RolePermissionConfigEmits = typeof rolePermissionConfigEmits;

package/dist/esm/modules/ms/components/role-permission-config/role-permission-config.d.ts

@@ -0,0 +1,20 @@
+declare const _default: import("vue").DefineComponent<{
+    readonly rolePermissionConfigTable: {
+        readonly type: import("vue").PropType<import("../../dataviews").RolePermissionConfigTable>;
+        readonly required: true;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __mkPropKey: true;
+    };
+}, () => JSX.Element, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    roleChange: (id: any) => boolean;
+}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    readonly rolePermissionConfigTable: {
+        readonly type: import("vue").PropType<import("../../dataviews").RolePermissionConfigTable>;
+        readonly required: true;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __mkPropKey: true;
+    };
+}>> & {
+    onRoleChange?: ((id: any) => any) | undefined;
+}, {}, {}>;
+export default _default;

package/dist/esm/modules/ms/constants/index.d.ts

@@ -0,0 +1 @@
+export declare const MODULE_NAME = "ms";

package/dist/esm/modules/ms/dataviews/department/DepartmentForm.d.ts

@@ -0,0 +1,12 @@
+import { DataForm, DataFormOptions } from "@maketribe/dm";
+export type Department = {
+    id: string;
+    name: string;
+    pid: string | null;
+};
+export declare class DepartmentForm extends DataForm<Department> {
+    constructor(options?: DataFormOptions);
+    protected initialize(): Promise<void>;
+    formatSubmitData(data: any): any;
+    formatItem(item: Department): Department;
+}

package/dist/esm/modules/ms/dataviews/department/DepartmentTable.d.ts

@@ -0,0 +1,8 @@
+import { DataTableOptions, DataTable } from "@maketribe/dm";
+import { Department } from "./DepartmentForm";
+export declare class DepartmentTable<T extends Department = Department, F extends Department = Department> extends DataTable<T, F> {
+    constructor(options?: DataTableOptions);
+    protected initialize(): Promise<void>;
+    setList(list: F[]): void;
+    formatItem(item: T): F;
+}

package/dist/esm/modules/ms/dataviews/department/DepartmentTree.d.ts

@@ -0,0 +1,11 @@
+import { DataTree, DataTreeOptions } from "@maketribe/dm";
+import { Department } from "./DepartmentForm";
+export type DepartmentNode = Department & {
+    children: DepartmentNode[];
+};
+export declare class DepartmentTree<T extends DepartmentNode = DepartmentNode> extends DataTree<T> {
+    constructor(options?: DataTreeOptions);
+    protected loadRequest(params: Record<string, any>): Promise<import("@maketribe/request").ResponseConfig<import("@maketribe/request").R<T[]> & {
+        totalRecCount: string;
+    }, Record<string, any>>>;
+}

package/dist/esm/modules/ms/dataviews/department/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./DepartmentForm";
+export * from "./DepartmentTable";
+export * from "./DepartmentTree";

package/dist/esm/modules/ms/dataviews/index.d.ts

@@ -0,0 +1,10 @@
+export * from "./ms-material";
+export * from "./ms-member";
+export * from "./ms-menu";
+export * from "./ms-role";
+export * from "./ms-config";
+export * from "./ms-ip-white-list";
+export * from "./ms-deny-ip-access-list";
+export * from "./ms-region";
+export * from "./department";
+export * from "./log";

package/dist/esm/modules/ms/dataviews/log/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./operate-log";
+export * from "./login-log";
+export * from "./request-log";
+export * from "./local-log";

package/dist/esm/modules/ms/dataviews/log/local-log/LocalLogTree.d.ts

@@ -0,0 +1,13 @@
+import { DataTree, DataTreeNode, DataTreeOptions } from "@maketribe/dm";
+export type LocalLog = {
+    name: string;
+    path: string;
+    isDirectory: boolean;
+    children: LocalLog[];
+};
+export declare class LocalLogTree extends DataTree<LocalLog> {
+    constructor(options?: DataTreeOptions);
+    protected initialize(): Promise<void>;
+    createDataTreeNode(data: LocalLog): DataTreeNode<LocalLog>;
+    formatItem(item: LocalLog): LocalLog;
+}

package/dist/esm/modules/ms/dataviews/log/local-log/index.d.ts

@@ -0,0 +1 @@
+export * from "./LocalLogTree";

package/dist/esm/modules/ms/dataviews/log/login-log/LoginLogTable.d.ts

@@ -0,0 +1,17 @@
+import { DataTable, DataTableOptions } from "@maketribe/dm";
+import { LoginLogType } from "../../../../../constants";
+export type LoginLogResult = {
+    account: string;
+    ipAddress: string;
+    traceId: string;
+    status: LoginLogType;
+    clientId: string;
+};
+export type LoginLog = LoginLogResult & {
+    statusText: string;
+};
+export declare class LoginLogTable extends DataTable<LoginLogResult, LoginLog> {
+    constructor(options?: DataTableOptions);
+    protected initialize(): Promise<void>;
+    formatItem(item: LoginLogResult): LoginLog;
+}

package/dist/esm/modules/ms/dataviews/log/login-log/index.d.ts

@@ -0,0 +1 @@
+export * from "./LoginLogTable";

package/dist/esm/modules/ms/dataviews/log/operate-log/OperateLogTable.d.ts

@@ -0,0 +1,5 @@
+import { DataTable, DataTableOptions } from "@maketribe/dm";
+export declare class OperateLogTable extends DataTable {
+    constructor(options?: DataTableOptions);
+    protected initialize(): Promise<void>;
+}

package/dist/esm/modules/ms/dataviews/log/operate-log/index.d.ts

@@ -0,0 +1 @@
+export * from "./OperateLogTable";

package/dist/esm/modules/ms/dataviews/log/request-log/RequestLogTable.d.ts

@@ -0,0 +1,20 @@
+import { DataTable, DataTableOptions } from "@maketribe/dm";
+export type RequestLog = {
+    id: string;
+    requestUrl: string;
+    timeOperationElapsedMilliseconds: string;
+    traceId: string;
+    httpMethod: string;
+    createdAt: string;
+    isError: number;
+    content: any;
+};
+export declare class RequestLogTable extends DataTable<RequestLog, RequestLog & {
+    contentText: string;
+}> {
+    constructor(options?: DataTableOptions);
+    protected initialize(): Promise<void>;
+    formatItem(item: RequestLog): RequestLog & {
+        contentText: string;
+    };
+}

package/dist/esm/modules/ms/dataviews/log/request-log/index.d.ts

@@ -0,0 +1 @@
+export * from "./RequestLogTable";

package/dist/esm/modules/ms/dataviews/ms-config/MsConfigForm.d.ts

@@ -0,0 +1,22 @@
+import { DataForm, DataFormOptions, IComponents } from "@maketribe/dm";
+import { ITypeResolver } from "../../../../core";
+import { DATA_MODEL_NAME } from "../../../../constants";
+export type MsConfig<T = any> = {
+    id: string;
+    key: string;
+    type: string;
+    value: T;
+};
+export type MsConfigFormOptions = DataFormOptions & {
+    configComponent?: IComponents;
+};
+export declare class MsConfigForm extends DataForm<MsConfig> implements ITypeResolver<MsConfig> {
+    static [DATA_MODEL_NAME]: string;
+    configComponent: IComponents;
+    constructor(options?: MsConfigFormOptions);
+    protected initialize(): Promise<void>;
+    formatItem(item: MsConfig): MsConfig;
+    formatSubmitData(data: any): any;
+    resolveType(type: string): "MKConfigInput" | "MKConfigInputNumber" | "MKConfigJsonEditor";
+    resolveItemType(config: MsConfig): "MKConfigInput" | "MKConfigInputNumber" | "MKConfigJsonEditor";
+}

package/dist/esm/modules/ms/dataviews/ms-config/MsConfigTable.d.ts

@@ -0,0 +1,13 @@
+import { DataTable, DataTableOptions } from "@maketribe/dm";
+import { MsConfig } from "./MsConfigForm";
+import { R, ResponseConfig } from "@maketribe/request";
+import { DATA_MODEL_NAME } from "../../../../constants";
+export declare class MsConfigTable extends DataTable<MsConfig> {
+    static [DATA_MODEL_NAME]: string;
+    private static _instance;
+    static get instance(): MsConfigTable;
+    constructor(options?: DataTableOptions);
+    protected initialize(): Promise<void>;
+    formatItem(item: MsConfig): MsConfig;
+    static loadConfig<T = any>(key: string): Promise<ResponseConfig<R<MsConfig<T>>>>;
+}

package/dist/esm/modules/ms/dataviews/ms-config/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./MsConfigForm";
+export * from "./MsConfigTable";

package/dist/esm/modules/ms/dataviews/ms-deny-ip-access-list/MsDenyIPAccessListForm.d.ts

@@ -0,0 +1,11 @@
+import { DataForm } from "@maketribe/dm";
+import { DATA_MODEL_NAME } from "../../../../constants";
+export type MsDenyIPAccessList = {
+    id: string;
+    ipAddress: string;
+};
+export declare class MsDenyIPAccessListForm<T = MsDenyIPAccessList, F = T> extends DataForm<T, F> {
+    static [DATA_MODEL_NAME]: string;
+    constructor(options?: {});
+    initialize(): Promise<void>;
+}

package/dist/esm/modules/ms/dataviews/ms-deny-ip-access-list/MsDenyIPAccessListTable.d.ts

@@ -0,0 +1,8 @@
+import { DataTable } from "@maketribe/dm";
+import { MsDenyIPAccessList } from "./MsDenyIPAccessListForm";
+import { DATA_MODEL_NAME } from "../../../../constants";
+export declare class MsDenyIPAccessListTable<T = MsDenyIPAccessList, F = T> extends DataTable<T, F> {
+    static [DATA_MODEL_NAME]: string;
+    constructor(options?: {});
+    initialize(): Promise<void>;
+}

package/dist/esm/modules/ms/dataviews/ms-deny-ip-access-list/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./MsDenyIPAccessListForm";
+export * from "./MsDenyIPAccessListTable";

package/dist/esm/modules/ms/dataviews/ms-ip-white-list/MsIPWhitelistForm.d.ts

@@ -0,0 +1,11 @@
+import { DataForm } from "@maketribe/dm";
+import { DATA_MODEL_NAME } from "../../../../constants";
+export type MsIPWhitelist = {
+    id: string;
+    ipAddress: string;
+};
+export declare class MsIPWhitelistForm<T = MsIPWhitelist, F = T> extends DataForm<T, F> {
+    static [DATA_MODEL_NAME]: string;
+    constructor(options?: {});
+    initialize(): Promise<void>;
+}

package/dist/esm/modules/ms/dataviews/ms-ip-white-list/MsIPWhitelistTable.d.ts

@@ -0,0 +1,8 @@
+import { DataTable } from "@maketribe/dm";
+import { MsIPWhitelist } from "./MsIPWhitelistForm";
+import { DATA_MODEL_NAME } from "../../../../constants";
+export declare class MsIPWhitelistTable<T = MsIPWhitelist, F = T> extends DataTable<T, F> {
+    static [DATA_MODEL_NAME]: string;
+    constructor(options?: {});
+    initialize(): Promise<void>;
+}

package/dist/esm/modules/ms/dataviews/ms-ip-white-list/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./MsIPWhitelistForm";
+export * from "./MsIPWhitelistTable";

package/dist/esm/modules/ms/dataviews/ms-material/MsMaterialComponents.d.ts

@@ -0,0 +1,4 @@
+import { Components } from "@maketribe/dm";
+export declare class MsMaterialComponents extends Components {
+    constructor();
+}

package/dist/esm/modules/ms/dataviews/ms-material/MsMaterialForm.d.ts

@@ -0,0 +1,22 @@
+import { DataForm, DataFormOptions } from "@maketribe/dm";
+import { DATA_MODEL_NAME } from "../../../../constants";
+export type MsMaterial = {
+    id: string;
+    materialGroupId?: string | null;
+    type: string;
+    desc: string;
+    path: string;
+};
+export declare class MsMaterialForm extends DataForm<MsMaterial> {
+    static [DATA_MODEL_NAME]: string;
+    constructor(options?: DataFormOptions);
+    protected initialize(): Promise<void>;
+    formatItem(item: MsMaterial): MsMaterial;
+    formatSubmitData(data: any): {
+        id: any;
+        materialGroupId: any;
+        type: any;
+        desc: any;
+        path: any;
+    };
+}

package/dist/esm/modules/ms/dataviews/ms-material/MsMaterialMan.d.ts

@@ -0,0 +1,31 @@
+import { Group } from "@maketribe/request";
+import { IComponents } from "@maketribe/dm";
+import { MsMaterialTable, MsMaterialType } from "./MsMaterialTable";
+import { MsMaterialGroupNode, MsMaterialGroupTree } from "./ms-material-group";
+import { WebFileUpload, HttpRequest } from "@maketribe/request";
+import { MsMaterialForm } from "./MsMaterialForm";
+export type MsMaterialManOptions = {
+    components?: IComponents;
+    httpRequest?: HttpRequest;
+};
+export declare class MsMaterialMan {
+    currentMaterialTypeId: MsMaterialType["value"] | null;
+    materialTypes: MsMaterialType[];
+    materialTypeValues: MsMaterialType["value"][];
+    materialGroupTree: MsMaterialGroupTree;
+    materialTable: MsMaterialTable;
+    materialForm: MsMaterialForm;
+    protected initing: boolean;
+    protected initd: boolean;
+    upload: WebFileUpload;
+    protected materialConditionGroup: Group;
+    get currentMaterialGroupId(): string | null;
+    get currentMaterialType(): MsMaterialType | null;
+    constructor(options: MsMaterialManOptions);
+    init(): Promise<void>;
+    setAllowAccessMaterialTypeValues(materialTypeValues: MsMaterialType["value"][]): void;
+    getMaterialType(): MsMaterialType[];
+    setCurrentMaterialGroup(materialGroup: MsMaterialGroupNode | null): void;
+    setCurrentMaterialTypeId(materialTypeId: MsMaterialType["value"] | null): void;
+    protected attachMaterialTableCondition(): void;
+}

package/dist/esm/modules/ms/dataviews/ms-material/MsMaterialTable.d.ts

@@ -0,0 +1,26 @@
+import { Component, DataTable, DataTableOptions, IComponents } from "@maketribe/dm";
+import { MsMaterial } from "./MsMaterialForm";
+import { ITypeResolver } from "../../../../core";
+import { DATA_MODEL_NAME } from "../../../../constants";
+export type MsMaterialType = {
+    value: string;
+    accept: string;
+    label: string;
+    limit: number;
+};
+export type MaterialTableOptions = DataTableOptions & {
+    materialComponents: IComponents;
+};
+export declare class MsMaterialTable extends DataTable<MsMaterial> implements ITypeResolver<MsMaterial> {
+    static [DATA_MODEL_NAME]: string;
+    materialTypes: MsMaterialType[];
+    materialComponents: IComponents;
+    constructor(options: MaterialTableOptions);
+    getMaterialTypes(): MsMaterialType[];
+    loadMaterialTypes(): Promise<void>;
+    protected initialize(): Promise<void>;
+    formatItem(item: MsMaterial): MsMaterial;
+    resolveType(type: string): string;
+    resolveItemType(item: MsMaterial): string;
+    resolveMaterialComponent(item: MsMaterial): Component | null;
+}

package/dist/esm/modules/ms/dataviews/ms-material/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./ms-material-group";
+export * from "./MsMaterialForm";
+export * from "./MsMaterialTable";
+export * from "./MsMaterialMan";

package/dist/esm/modules/ms/dataviews/ms-material/ms-material-group/MsMaterialGroupForm.d.ts

@@ -0,0 +1,12 @@
+import { DataForm, DataFormOptions } from "@maketribe/dm";
+import { DATA_MODEL_NAME } from "../../../../../constants";
+export type MsMaterialGroup = {
+    id: string;
+    desc: string;
+    parentGroupId: string | null;
+};
+export declare class MsMaterialGroupForm extends DataForm<MsMaterialGroup> {
+    static [DATA_MODEL_NAME]: string;
+    constructor(options?: DataFormOptions);
+    protected initialize(): Promise<void>;
+}

package/dist/esm/modules/ms/dataviews/ms-material/ms-material-group/MsMaterialGroupTable.d.ts

@@ -0,0 +1,13 @@
+import { DataTable, DataTableOptions } from "@maketribe/dm";
+import { MsMaterialGroup } from "./MsMaterialGroupForm";
+import { DATA_MODEL_NAME } from "../../../../../constants";
+export type MaterialGroupNode = MsMaterialGroup & {
+    children: MaterialGroupNode[];
+};
+export declare class MsMaterialGroupTable extends DataTable<MsMaterialGroup, MaterialGroupNode> {
+    static [DATA_MODEL_NAME]: string;
+    constructor(options?: Omit<DataTableOptions, "name">);
+    protected initialize(): Promise<void>;
+    formatItem(item: MsMaterialGroup): MaterialGroupNode;
+    setList(list: MsMaterialGroup[]): void;
+}

package/dist/esm/modules/ms/dataviews/ms-material/ms-material-group/MsMaterialGroupTree.d.ts

@@ -0,0 +1,18 @@
+import { DataTableOptions, DataTree, DataTreeNode } from "@maketribe/dm";
+import { MsMaterialGroup } from "./MsMaterialGroupForm";
+import { ResponseConfig, R } from "@maketribe/request";
+import { DATA_MODEL_NAME } from "../../../../../constants";
+export type MsMaterialGroupNode = MsMaterialGroup & {
+    children: MsMaterialGroupNode[];
+};
+export declare class MsMaterialGroupTree extends DataTree<MsMaterialGroupNode> {
+    static [DATA_MODEL_NAME]: string;
+    currentDataTreeNode: DataTreeNode<MsMaterialGroupNode> | null;
+    constructor(options?: DataTableOptions);
+    formatItem(item: MsMaterialGroupNode): MsMaterialGroupNode;
+    load(params?: Record<string, any>): Promise<ResponseConfig<R<MsMaterialGroupNode[]> & {
+        totalRecCount: string;
+    }>>;
+    getCurrentNode(): DataTreeNode<MsMaterialGroupNode> | null;
+    setCurrentNode(node: DataTreeNode<MsMaterialGroupNode> | null): void;
+}

package/dist/esm/modules/ms/dataviews/ms-material/ms-material-group/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./MsMaterialGroupForm";
+export * from "./MsMaterialGroupTree";

package/dist/esm/modules/ms/dataviews/ms-member/MsMemberForm.d.ts

@@ -0,0 +1,40 @@
+import { DataForm, DataFormOptions } from "@maketribe/dm";
+import { DATA_MODEL_NAME } from "../../../../constants";
+export type MsMemberResult = {
+    id: string;
+    name: string;
+    wechatNo: string;
+    nickName: string;
+    email: string;
+    phone: string;
+    account: string;
+    avatar: string;
+    roles: any[];
+    valid: number;
+    isLock?: number;
+    errorCount?: number;
+    unlockDatetime?: string;
+    memo?: string;
+};
+export type MsMember = {
+    id: string;
+    name: string;
+    wechatNo: string;
+    nickName: string;
+    email: string;
+    phone: string;
+    account: string;
+    avatar: string | null;
+    roles: any[];
+    valid: number;
+    isLock?: number;
+    errorCount?: number;
+    unlockDatetime?: string;
+    memo?: string;
+};
+export declare class MsMemberForm<T extends MsMemberResult = MsMemberResult, F extends MsMember = MsMember> extends DataForm<T, F> {
+    static [DATA_MODEL_NAME]: string;
+    constructor(options?: DataFormOptions);
+    protected initialize(): Promise<void>;
+    formatItem(item: T): F;
+}

package/dist/esm/modules/ms/dataviews/ms-member/MsMemberTable.d.ts

@@ -0,0 +1,16 @@
+import { DataTable, DataTableOptions } from "@maketribe/dm";
+import { MsMember, MsMemberForm, MsMemberResult } from "./MsMemberForm";
+import { DATA_MODEL_NAME } from "../../../../constants";
+export type MsMemberTableItem = Omit<MsMember, "password" | "confirmPassword"> & {
+    type: number;
+};
+export declare class MsMemberTable extends DataTable<MsMemberResult, MsMemberTableItem> {
+    static [DATA_MODEL_NAME]: string;
+    activeMemberForm: MsMemberForm;
+    isShowActiveMemberForm: boolean;
+    constructor(options?: DataTableOptions);
+    protected initialize(): Promise<void>;
+    protected initActiveMemberForm(): Promise<void>;
+    approveMember(): Promise<void>;
+    formatItem(item: MsMemberResult): MsMemberTableItem;
+}

package/dist/esm/modules/ms/dataviews/ms-member/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./MsMemberForm";
+export * from "./MsMemberTable";

package/dist/esm/modules/ms/dataviews/ms-member/ms-member-role/MsMemberRoleTable.d.ts

@@ -0,0 +1,12 @@
+import { DataFormOptions, DataTable } from "@maketribe/dm";
+import { DATA_MODEL_NAME } from "../../../../../constants";
+export type MsMemberRole = {
+    id: string;
+    memberId: string;
+    roleId: string;
+};
+export declare class MsMemberRoleTable extends DataTable {
+    static [DATA_MODEL_NAME]: string;
+    constructor(options?: DataFormOptions);
+    protected initialize(): Promise<void>;
+}

package/dist/esm/modules/ms/dataviews/ms-menu/MsMenuForm.d.ts

@@ -0,0 +1,27 @@
+import { DataForm, DataFormOptions } from "@maketribe/dm";
+import { MsRouteResult } from "./ms-route";
+import { MsPermissionPointDefine } from "./ms-permission-point";
+import { DATA_MODEL_NAME } from "../../../../constants";
+import { MenuData } from "../../../../core";
+export type MsMenuResult = MenuData & {
+    memo?: string;
+};
+export type MsMenuItem = {
+    id: string;
+    title: string;
+    iconName: string;
+    pid: string;
+    routeId: string;
+    sort: string;
+    type: string;
+    routes: MsRouteResult[];
+    permissionPoints: MsPermissionPointDefine[];
+    memo: string;
+};
+export declare class MsMenuForm extends DataForm<MsMenuResult, MsMenuItem> {
+    static [DATA_MODEL_NAME]: string;
+    constructor(options?: DataFormOptions);
+    protected initialize(): Promise<void>;
+    formatSubmitData(data: any): any;
+    formatItem(item: MsMenuResult): MsMenuItem;
+}

package/dist/esm/modules/ms/dataviews/ms-menu/MsMenuTable.d.ts

@@ -0,0 +1,9 @@
+import { DataTable, DataTableOptions } from "@maketribe/dm";
+import type { MsMenuItem, MsMenuResult } from "./MsMenuForm";
+import { DATA_MODEL_NAME } from "../../../../constants";
+export declare class MsMenuTable<T extends MsMenuItem = MsMenuItem> extends DataTable<MsMenuResult, T> {
+    static [DATA_MODEL_NAME]: string;
+    constructor(options?: Omit<DataTableOptions, "name">);
+    protected initialize(): Promise<void>;
+    formatItem(item: MsMenuResult): T;
+}