zsl-im-sdk 1.0.0 → 1.0.2

package/dist/store.js

@@ -0,0 +1,493 @@
+"use strict";
+/**
+ * IM 状态管理 Store
+ * 使用 Vuex 管理会话、消息、用户、WebSocket 连接等状态
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.install = install;
+const vue_1 = __importDefault(require("vue"));
+const vuex_1 = __importDefault(require("vuex"));
+const websocket_1 = __importDefault(require("./websocket"));
+vue_1.default.use(vuex_1.default);
+// ==================== Persistence ====================
+const STORAGE_KEY = 'ZSL_IM_STORE_STATE';
+const loadState = () => {
+    try {
+        const stateStr = uni.getStorageSync(STORAGE_KEY);
+        if (stateStr) {
+            return JSON.parse(stateStr);
+        }
+    }
+    catch (e) {
+        console.error('Load state error:', e);
+    }
+    return {};
+};
+const saveState = (state) => {
+    const persistState = {
+        conversation: state.conversation,
+        message: state.message,
+        user: state.user
+    };
+    try {
+        uni.setStorageSync(STORAGE_KEY, JSON.stringify(persistState));
+    }
+    catch (e) {
+        console.error('Save state error:', e);
+    }
+};
+const persistencePlugin = (store) => {
+    store.subscribe((mutation, state) => {
+        if (mutation.type.startsWith('conversation/') ||
+            mutation.type.startsWith('message/') ||
+            mutation.type.startsWith('user/')) {
+            saveState(state);
+        }
+    });
+};
+// ==================== Vuex Store ====================
+const savedState = loadState();
+const store = new vuex_1.default.Store({
+    state: {
+        conversation: {
+            conversations: [],
+            selectedConversationId: "",
+            ...(savedState.conversation || {})
+        },
+        message: {
+            messages: {},
+            messageQueue: [],
+            ...(savedState.message || {})
+        },
+        user: {
+            currentUser: null,
+            users: {},
+            ...(savedState.user || {})
+        },
+        websocket: {
+            isConnected: false,
+            reconnectAttempts: 0,
+            imInstance: null,
+        },
+        global: {
+            loading: false,
+            error: null,
+        },
+    },
+    plugins: [persistencePlugin],
+    // ==================== Mutations ====================
+    mutations: {
+        // ---------- 会话相关 ----------
+        /** 设置会话列表 */
+        "conversation/SET_CONVERSATIONS"(state, conversations) {
+            state.conversation.conversations = conversations;
+        },
+        /** 添加或更新会话 */
+        "conversation/ADD_CONVERSATION"(state, conversation) {
+            const index = state.conversation.conversations.findIndex((c) => c.conversationId === conversation.conversationId);
+            if (index === -1) {
+                state.conversation.conversations.unshift(conversation);
+            }
+            else {
+                state.conversation.conversations.splice(index, 1, conversation);
+                state.conversation.conversations.unshift(state.conversation.conversations.splice(index, 1)[0]);
+            }
+        },
+        /** 更新会话信息 */
+        "conversation/UPDATE_CONVERSATION"(state, { conversationId, updates, }) {
+            const conversation = state.conversation.conversations.find((c) => c.conversationId === conversationId);
+            if (conversation)
+                Object.assign(conversation, updates);
+        },
+        /** 删除会话 */
+        "conversation/DELETE_CONVERSATION"(state, conversationId) {
+            state.conversation.conversations =
+                state.conversation.conversations.filter((c) => c.conversationId !== conversationId);
+            if (state.conversation.selectedConversationId === conversationId) {
+                state.conversation.selectedConversationId = "";
+            }
+        },
+        /** 设置当前选中的会话 */
+        "conversation/SET_SELECTED_CONVERSATION"(state, conversationId) {
+            state.conversation.selectedConversationId = conversationId;
+        },
+        /** 重置会话状态 */
+        "conversation/RESET_STATE"(state) {
+            state.conversation.conversations = [];
+            state.conversation.selectedConversationId = "";
+        },
+        // ---------- 消息相关 ----------
+        /** 设置指定会话的消息列表 */
+        "message/SET_MESSAGES"(state, { conversationId, messages, }) {
+            state.message.messages[conversationId] = messages;
+        },
+        /** 添加消息 */
+        "message/ADD_MESSAGE"(state, message) {
+            if (!state.message.messages[message.conversationId]) {
+                state.message.messages[message.conversationId] = [];
+            }
+            state.message.messages[message.conversationId].push(message);
+        },
+        /** 更新消息 */
+        "message/UPDATE_MESSAGE"(state, { messageId, conversationId, updates, }) {
+            const messages = state.message.messages[conversationId];
+            if (messages) {
+                const message = messages.find((m) => m.id === messageId);
+                if (message)
+                    Object.assign(message, updates);
+            }
+        },
+        /** 添加到消息队列 */
+        "message/ADD_TO_MESSAGE_QUEUE"(state, message) {
+            state.message.messageQueue.push(message);
+        },
+        /** 从消息队列移除 */
+        "message/REMOVE_FROM_MESSAGE_QUEUE"(state, messageId) {
+            state.message.messageQueue = state.message.messageQueue.filter((m) => m.id !== messageId);
+        },
+        /** 重置消息状态 */
+        "message/RESET_STATE"(state) {
+            state.message.messages = {};
+            state.message.messageQueue = [];
+        },
+        // ---------- 用户相关 ----------
+        /** 设置当前用户 */
+        "user/SET_CURRENT_USER"(state, user) {
+            state.user.currentUser = user;
+        },
+        /** 添加用户 */
+        "user/ADD_USER"(state, user) {
+            state.user.users[user.id] = user;
+        },
+        /** 更新用户信息 */
+        "user/UPDATE_USER"(state, { userId, updates }) {
+            if (state.user.users[userId]) {
+                Object.assign(state.user.users[userId], updates);
+            }
+        },
+        /** 重置用户状态 */
+        "user/RESET_STATE"(state) {
+            state.user.currentUser = null;
+            state.user.users = {};
+        },
+        // ---------- WebSocket 相关 ----------
+        /** 设置连接状态 */
+        "websocket/SET_CONNECTED"(state, isConnected) {
+            console.log("WebSocket 连接状态:", isConnected);
+            state.websocket.isConnected = isConnected;
+            if (isConnected)
+                state.websocket.reconnectAttempts = 0;
+        },
+        /** 增加重连次数 */
+        "websocket/INCREMENT_RECONNECT_ATTEMPTS"(state) {
+            state.websocket.reconnectAttempts++;
+        },
+        /** 设置 IM 实例 */
+        "websocket/SET_IM_INSTANCE"(state, imInstance) {
+            state.websocket.imInstance = imInstance;
+        },
+        /** 重置 WebSocket 状态 */
+        "websocket/RESET_STATE"(state) {
+            if (state.websocket.imInstance) {
+                state.websocket.imInstance.disconnect();
+                state.websocket.imInstance = null;
+            }
+            state.websocket.isConnected = false;
+            state.websocket.reconnectAttempts = 0;
+        },
+        // ---------- 全局状态 ----------
+        /** 设置加载状态 */
+        "global/SET_LOADING"(state, loading) {
+            state.global.loading = loading;
+        },
+        /** 设置错误信息 */
+        "global/SET_ERROR"(state, error) {
+            state.global.error = error;
+        },
+        /** 重置全局状态 */
+        "global/RESET_STATE"(state) {
+            state.global.loading = false;
+            state.global.error = null;
+        },
+    },
+    // ==================== Actions ====================
+    actions: {
+        /** 重置所有状态 */
+        resetState({ commit }) {
+            commit("conversation/RESET_STATE");
+            commit("message/RESET_STATE");
+            commit("user/RESET_STATE");
+            commit("websocket/RESET_STATE");
+            commit("global/RESET_STATE");
+        },
+        /** 连接 WebSocket */
+        async connectWebSocket({ commit, state, dispatch }, payload) {
+            if (!payload)
+                throw new Error("WebSocket 连接参数缺失");
+            const { wsUrl, token, userId } = payload;
+            // 如果已存在实例，先断开
+            if (state.websocket.imInstance) {
+                state.websocket.imInstance.disconnect();
+                commit("websocket/SET_IM_INSTANCE", null);
+            }
+            // 创建新实例
+            const imInstance = new websocket_1.default({ url: wsUrl, token, userId });
+            // 设置事件监听
+            imInstance.on("connect", () => commit("websocket/SET_CONNECTED", true));
+            imInstance.on("disconnect", () => {
+                commit("websocket/SET_CONNECTED", false);
+                commit("websocket/INCREMENT_RECONNECT_ATTEMPTS");
+            });
+            imInstance.on("error", (error) => console.error("WebSocket 错误:", error));
+            imInstance.on("message", (message) => dispatch("handleWebSocketMessage", message));
+            // 撤回消息
+            imInstance.on("recalled", (message) => dispatch("handleWebSocketRecalledMessage", message));
+            imInstance.on("reconnect", (attempt) => console.log(`WebSocket 重连中，第 ${attempt} 次尝试`));
+            commit("websocket/SET_IM_INSTANCE", imInstance);
+            try {
+                await imInstance.connect();
+            }
+            catch (error) {
+                console.error("WebSocket 连接失败:", error);
+                commit("websocket/SET_CONNECTED", false);
+                throw error;
+            }
+        },
+        /** 断开 WebSocket */
+        disconnectWebSocket({ commit, state }) {
+            if (state.websocket.imInstance) {
+                state.websocket.imInstance.disconnect();
+                commit("websocket/SET_IM_INSTANCE", null);
+            }
+            commit("websocket/SET_CONNECTED", false);
+        },
+        /** 处理 WebSocket 消息 */
+        async handleWebSocketMessage({ commit, state, dispatch }, message) {
+            try {
+                console.log("收到 WebSocket 消息:", message);
+                if (!message.conversationId) {
+                    console.error("消息缺少 conversationId:", message);
+                    return;
+                }
+                // 添加消息
+                commit("message/ADD_MESSAGE", message);
+                // 更新会话
+                const conversation = state.conversation.conversations.find((c) => c.conversationId === message.conversationId);
+                if (conversation) {
+                    const updates = {
+                        lastMessageId: message.id,
+                        lastMessageContent: message.content,
+                        lastMessageAt: message.createdAt,
+                        lastMessageType: message.messageType,
+                    };
+                    // 判断是否是当前打开的会话
+                    const isCurrentConversation = message.conversationId ===
+                        state.conversation.selectedConversationId;
+                    if (isCurrentConversation) {
+                        // 如果是当前会话，自动发送已读回执
+                        try {
+                            await dispatch("sendReadReceipt", {
+                                conversationId: message.conversationId,
+                                lastReadMessageId: message.id,
+                            });
+                            console.log("已自动发送已读回执:", message.id);
+                        }
+                        catch (error) {
+                            console.error("发送已读回执失败:", error);
+                        }
+                    }
+                    else {
+                        // 如果不是当前会话，增加未读数
+                        updates.unreadCount = (conversation.unreadCount || 0) + 1;
+                    }
+                    commit("conversation/UPDATE_CONVERSATION", {
+                        conversationId: message.conversationId,
+                        updates,
+                    });
+                }
+            }
+            catch (error) {
+                console.error("处理 WebSocket 消息时出错:", error);
+            }
+        },
+        /** 处理 WebSocket 收到撤回消息 */
+        async handleWebSocketRecalledMessage({ commit, state, dispatch }, message) {
+            try {
+                console.log("收到 WebSocket 撤回消息:", message);
+                if (!message.conversationId) {
+                    console.error("消息缺少 conversationId:", message);
+                    return;
+                }
+                // 更新消息状态为撤回
+                const recalledMsgId = message.id; // 假设撤回消息的内容是原消息ID
+                commit("message/UPDATE_MESSAGE", {
+                    messageId: recalledMsgId,
+                    conversationId: message.conversationId,
+                    updates: { status: "RECALLED" },
+                });
+                // 更新会话最后一条消息（如果是被撤回的那条）
+                const conversation = state.conversation.conversations.find((c) => c.conversationId === message.conversationId);
+                if (conversation && conversation.lastMessageId === recalledMsgId) {
+                    const updates = {
+                        lastMessageContent: "对方撤回了一条消息", // 或者 "你撤回了一条消息"
+                        lastMessageType: "RECALLED",
+                    };
+                    commit("conversation/UPDATE_CONVERSATION", {
+                        conversationId: message.conversationId,
+                        updates,
+                    });
+                }
+            }
+            catch (error) {
+                console.error("处理 WebSocket 撤回消息时出错:", error);
+            }
+        },
+        /** 发送消息 */
+        async sendMessage({ commit, state }, messageData) {
+            const newMessage = {
+                ...messageData,
+                id: `temp-${Date.now()}`,
+                createdAt: new Date().toISOString(),
+                status: "SENDING",
+            };
+            // 添加到队列
+            commit("message/ADD_TO_MESSAGE_QUEUE", newMessage);
+            // 更新会话
+            const conversation = state.conversation.conversations.find((c) => c.conversationId === newMessage.conversationId);
+            if (conversation) {
+                commit("conversation/UPDATE_CONVERSATION", {
+                    conversationId: newMessage.conversationId,
+                    updates: {
+                        lastMessageId: newMessage.id,
+                        lastMessageContent: newMessage.content,
+                        lastMessageAt: newMessage.createdAt,
+                        lastMessageType: newMessage.messageType,
+                    },
+                });
+            }
+            else {
+                // 创建新会话
+                commit("conversation/ADD_CONVERSATION", {
+                    conversationId: newMessage.conversationId,
+                    conversationType: newMessage.conversationId.includes("p2p")
+                        ? "P2P"
+                        : "GROUP",
+                    isMuted: false,
+                    isPinned: false,
+                    lastMessageAt: newMessage.createdAt,
+                    lastMessageContent: newMessage.content,
+                    unreadCount: 1,
+                    user: {
+                        userId: newMessage.senderId,
+                        displayName: "用户：" + newMessage.senderId,
+                        account: newMessage.senderId,
+                        avatarUrl: newMessage.icon || "/static/images/default-avatar.png",
+                    },
+                    lastMessageType: newMessage.messageType,
+                    lastMessageSenderId: newMessage.senderId,
+                    lastMessageSenderName: newMessage.senderId,
+                    status: 0,
+                    recalled: false,
+                    recaller: { id: "", name: "" },
+                    payload: { text: newMessage.content || "" },
+                    lastMessageId: newMessage.id,
+                });
+            }
+            try {
+                // 发送消息
+                if (!state.websocket.imInstance)
+                    throw new Error("WebSocket 未连接");
+                await state.websocket.imInstance.sendText(newMessage.conversationId, newMessage.recipientId, newMessage.content, newMessage.messageType, newMessage.mediaUrl);
+                // 更新状态
+                commit("message/UPDATE_MESSAGE", {
+                    messageId: newMessage.id,
+                    conversationId: newMessage.conversationId,
+                    updates: { status: "SENT" },
+                });
+                commit("message/REMOVE_FROM_MESSAGE_QUEUE", newMessage.id);
+            }
+            catch (error) {
+                commit("message/UPDATE_MESSAGE", {
+                    messageId: newMessage.id,
+                    conversationId: newMessage.conversationId,
+                    updates: { status: "FAILED" },
+                });
+                commit("global/SET_ERROR", "发送消息失败");
+                console.error("发送消息失败:", error);
+                throw error;
+            }
+        },
+        /** 发送已读回执 */
+        async sendReadReceipt({ state }, payload) {
+            if (!state.websocket.imInstance)
+                throw new Error("WebSocket 未连接");
+            return state.websocket.imInstance.sendReadReceipt(payload.conversationId, payload.lastReadMessageId);
+        },
+        /** 撤回消息 */
+        async sendRecallMessage({ state }, payload) {
+            if (!state.websocket.imInstance)
+                throw new Error("WebSocket 未连接");
+            return state.websocket.imInstance.sendRecallMessage(payload.messageId);
+        },
+        /**
+         * 用户登录
+         * 注意：SDK 不包含登录 API，需要在应用层实现
+         * 登录成功后调用 connectWebSocket 连接 WebSocket
+         */
+        async login({ commit, dispatch }, loginParams) {
+            commit("global/SET_LOADING", true);
+            console.log("=====login====", loginParams);
+            try {
+                const { user, wsUrl, token } = loginParams;
+                commit("user/SET_CURRENT_USER", user);
+                commit("user/ADD_USER", user);
+                await dispatch("connectWebSocket", { userId: user.id, wsUrl, token });
+                return user;
+            }
+            catch (error) {
+                commit("global/SET_ERROR", "登录失败");
+                console.error("登录失败:", error);
+                throw error;
+            }
+            finally {
+                commit("global/SET_LOADING", false);
+            }
+        },
+        /** 用户登出 */
+        logout({ dispatch }) {
+            dispatch("disconnectWebSocket");
+            dispatch("resetState");
+        },
+    },
+    // ==================== Getters ====================
+    getters: {
+        /** 排序后的会话列表 */
+        sortedConversations: (state) => [...state.conversation.conversations].sort((a, b) => new Date(b.lastMessageAt).getTime() -
+            new Date(a.lastMessageAt).getTime()),
+        /** 当前选中的会话 */
+        selectedConversation: (state) => state.conversation.conversations.find((c) => c.conversationId === state.conversation.selectedConversationId),
+        /** 获取指定会话的消息列表 */
+        conversationMessages: (state) => (conversationId) => state.message.messages[conversationId] || [],
+        /** 总未读消息数 */
+        unreadCount: (state) => state.conversation.conversations.reduce((total, c) => total + c.unreadCount, 0),
+        /** 获取用户信息 */
+        userInfo: (state) => (userId) => state.user.users[userId] || null,
+        /** WebSocket 连接状态 */
+        isConnected: (state) => state.websocket.isConnected,
+        /** 加载状态 */
+        loading: (state) => state.global.loading,
+        /** 错误信息 */
+        error: (state) => state.global.error,
+    },
+});
+// ==================== 插件安装 ====================
+/** Vue 插件安装函数 */
+function install(vue) {
+    if (vue.prototype) {
+        vue.prototype.$store = store;
+    }
+}
+exports.default = store;

package/dist/types/conversation.type.d.ts

@@ -0,0 +1,42 @@
+import { MessageType } from "./message-type.type";
+export declare enum ConversationType {
+    P2P = 1,// 单聊
+    GROUP = 2
+}
+interface IConversationUserInfo {
+    /** 用户ID (长整型) */
+    id?: string;
+    /** 业务系统标识 */
+    biz?: string;
+    /** 用户账号/唯一标识 */
+    account?: string;
+    /** 认证令牌 */
+    token?: string;
+    /** 显示名称 */
+    displayName?: string;
+    /** 头像URL */
+    avatarUrl?: string | null;
+    /** 用户状态 */
+    status?: string;
+    /** 删除标记: 0=正常, 1=已删除 */
+    isDel?: 0 | 1;
+    /** 创建时间 (ISO格式) */
+    createdAt?: string;
+    /** 更新时间 (ISO格式) */
+    updatedAt?: string | null;
+}
+export interface IConversation {
+    conversationId: string;
+    conversationType: ConversationType;
+    isMuted: boolean;
+    isPinned: boolean;
+    lastMessageAt: string;
+    lastMessageContent: string;
+    unreadCount: number;
+    user: IConversationUserInfo;
+    lastMessageType: MessageType;
+    lastMessageSenderId: string;
+    lastMessageSenderName: string;
+    lastMessageId: string;
+}
+export {};

package/dist/types/conversation.type.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConversationType = void 0;
+var ConversationType;
+(function (ConversationType) {
+    ConversationType[ConversationType["P2P"] = 1] = "P2P";
+    ConversationType[ConversationType["GROUP"] = 2] = "GROUP";
+})(ConversationType || (exports.ConversationType = ConversationType = {}));

package/dist/types/im-user.type.d.ts

@@ -0,0 +1,22 @@
+export interface IIMUserInfo {
+    /** 用户ID */
+    id?: string;
+    /** 业务标识 */
+    biz?: string;
+    /** 账号 */
+    account?: string;
+    /** 认证令牌 */
+    token?: string;
+    /** 显示名称 */
+    displayName?: string;
+    /** 头像URL */
+    avatarUrl?: string | null;
+    /** 状态 */
+    status?: string;
+    /** 是否删除 (0=未删除, 1=已删除) */
+    isDel?: number;
+    /** 创建时间 */
+    createdAt?: string;
+    /** 更新时间 */
+    updatedAt?: string | null;
+}

package/dist/types/im-user.type.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/{types/index.ts → dist/types/index.d.ts}

@@ -1,5 +1,4 @@
-// 导出所有类型
-export * from './conversation.type';
-export * from './im-user.type';
-export * from './message-type.type';
-export * from './socket-data.type';
+export * from './conversation.type';
+export * from './im-user.type';
+export * from './message-type.type';
+export * from './socket-data.type';

package/dist/types/index.js

@@ -0,0 +1,21 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// 导出所有类型
+__exportStar(require("./conversation.type"), exports);
+__exportStar(require("./im-user.type"), exports);
+__exportStar(require("./message-type.type"), exports);
+__exportStar(require("./socket-data.type"), exports);

package/dist/types/message-type.type.d.ts

@@ -0,0 +1,76 @@
+export declare enum MessageType {
+    TEXT = "TEXT",
+    IMAGE = "IMAGE",
+    VIDEO = "VIDEO",
+    CUSTOM = "CUSTOM",
+    TEXT_QUOTE = "TEXT_QUOTE",
+    AUDIO = "AUDIO",
+    IMAGE_TRANSMIT = "IMAGE_TRANSMIT",
+    EMOJI_PACK = "EMOJI_PACK",
+    RED_ENVELOPE = "RED_ENVELOPE",
+    MAP = "MAP",
+    GROUP_NOTICE = "GROUP_NOTICE",
+    UPDATE_GROUP_NAME = "UPDATE_GROUP_NAME",
+    ARTICLE = "ARTICLE",
+    SHARE_SBCF = "SHARE_SBCF",
+    SHARE_MALL = "SHARE_MALL"
+}
+export declare const MessageTypeData: {
+    TEXT: string;
+    IMAGE: string;
+    VIDEO: string;
+    CUSTOM: string;
+    TEXT_QUOTE: string;
+    AUDIO: string;
+    IMAGE_TRANSMIT: string;
+    EMOJI_PACK: string;
+    RED_ENVELOPE: string;
+    MAP: string;
+    GROUP_NOTICE: string;
+    UPDATE_GROUP_NAME: string;
+    ARTICLE: string;
+    SHARE_SBCF: string;
+    SHARE_MALL: string;
+};
+export declare enum MessageStatus {
+    SENT = "SENT",
+    DELIVERED = "DELIVERED",
+    READ = "READ",
+    RECALLED = "RECALLED"
+}
+export interface IMessage {
+    id: string | number;
+    conversationId: string;
+    senderId: string | number;
+    recipientId?: string | number;
+    messageType?: MessageType;
+    content?: string;
+    mediaUrl?: string;
+    metadata?: string;
+    createdAt: string;
+    status: MessageStatus;
+}
+export interface ISearchMessageRes {
+    /** 消息ID */
+    id?: string;
+    /** 会话ID */
+    conversationId?: string;
+    /** 发送者用户ID */
+    senderId?: string;
+    /** 接收者用户ID (单聊) 或群组ID (群聊) */
+    recipientId?: string;
+    /** 消息类型 */
+    messageType?: string;
+    /** 消息内容 */
+    content?: string;
+    /** 媒体文件URL */
+    mediaUrl?: string;
+    /** 自定义消息元数据 (JSON格式) */
+    metadata?: string;
+    /** 消息状态 */
+    status?: string;
+    /** 消息创建时间 */
+    createdAt?: string;
+    /** 消息更新时间 */
+    updatedAt?: string;
+}