@onyx-p/imlib-web 1.7.6 → 1.7.7

package/index.umd.js

@@ -105,11 +105,10 @@
   })(exports.SentStatus || (exports.SentStatus = {}));
   exports.ReceivedStatus = void 0;
   (function (ReceivedStatus) {
-    ReceivedStatus[ReceivedStatus["READ"] = 1] = "READ";
-    ReceivedStatus[ReceivedStatus["LISTENED"] = 2] = "LISTENED";
-    ReceivedStatus[ReceivedStatus["DOWNLOADED"] = 4] = "DOWNLOADED";
-    ReceivedStatus[ReceivedStatus["RETRIEVED"] = 8] = "RETRIEVED";
-    ReceivedStatus[ReceivedStatus["UNREAD"] = 0] = "UNREAD";
+    ReceivedStatus[ReceivedStatus["IDLE"] = 0] = "IDLE";
+    ReceivedStatus[ReceivedStatus["RECEIVED"] = 1] = "RECEIVED";
+    ReceivedStatus[ReceivedStatus["READ"] = 2] = "READ";
+    ReceivedStatus[ReceivedStatus["LISTENED"] = 3] = "LISTENED";
   })(exports.ReceivedStatus || (exports.ReceivedStatus = {}));
   exports.NotificationLevel = void 0;
   (function (NotificationLevel) {
@@ -141,6 +140,8 @@
     Events["CONVERSATION"] = "CONVERSATION";
     Events["PUSH"] = "PUSH";
     Events["RECALL"] = "RECALL";
+    Events["ARRIVAL_RECEIPT_RECEIVED"] = "ARRIVAL_RECEIPT_RECEIVED";
+    Events["READ_RECEIPT_RECEIVED"] = "READ_RECEIPT_RECEIVED";
   })(exports.Events || (exports.Events = {}));
 
   var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
@@ -9493,6 +9494,10 @@
     CmdIds[CmdIds["DeletePrivateDialog"] = 1610682372] = "DeletePrivateDialog";
     CmdIds[CmdIds["DeleteGroupDialog"] = 1610747908] = "DeleteGroupDialog";
     CmdIds[CmdIds["GetDialogChangedStatus"] = 1610711094] = "GetDialogChangedStatus";
+    CmdIds[CmdIds["SendGroupChatArrivalAck"] = 1610747952] = "SendGroupChatArrivalAck";
+    CmdIds[CmdIds["SendGroupChatReadAck"] = 1610747953] = "SendGroupChatReadAck";
+    CmdIds[CmdIds["SendPrivateChatArrivalAck"] = 1610682403] = "SendPrivateChatArrivalAck";
+    CmdIds[CmdIds["SendPrivateChatReadAck"] = 1610682404] = "SendPrivateChatReadAck";
     CmdIds[CmdIds["HeartbeanResp"] = 268468225] = "HeartbeanResp";
     CmdIds[CmdIds["NewMessagePush"] = 1610711040] = "NewMessagePush";
     CmdIds[CmdIds["DialogChangedPush"] = 1610711096] = "DialogChangedPush";
@@ -14510,6 +14515,8 @@
      * @property {Long|null} [seqno] DialogMessage seqno
      * @property {string|null} [replyMarkup] DialogMessage replyMarkup
      * @property {string|null} [extra] DialogMessage extra
+     * @property {boolean|null} [msgArrival] DialogMessage msgArrival
+     * @property {boolean|null} [msgRead] DialogMessage msgRead
      */
 
     /**
@@ -14724,6 +14731,22 @@
      */
     DialogMessage.prototype.extra = "";
 
+    /**
+     * DialogMessage msgArrival.
+     * @member {boolean} msgArrival
+     * @memberof DialogMessage
+     * @instance
+     */
+    DialogMessage.prototype.msgArrival = false;
+
+    /**
+     * DialogMessage msgRead.
+     * @member {boolean} msgRead
+     * @memberof DialogMessage
+     * @instance
+     */
+    DialogMessage.prototype.msgRead = false;
+
     /**
      * Encodes the specified DialogMessage message. Does not implicitly {@link DialogMessage.verify|verify} messages.
      * @function encode
@@ -14760,6 +14783,8 @@
       if (message.seqno != null && Object.hasOwnProperty.call(message, "seqno")) writer.uint32(/* id 23, wireType 0 =*/184).int64(message.seqno);
       if (message.replyMarkup != null && Object.hasOwnProperty.call(message, "replyMarkup")) writer.uint32(/* id 24, wireType 2 =*/194).string(message.replyMarkup);
       if (message.extra != null && Object.hasOwnProperty.call(message, "extra")) writer.uint32(/* id 25, wireType 2 =*/202).string(message.extra);
+      if (message.msgArrival != null && Object.hasOwnProperty.call(message, "msgArrival")) writer.uint32(/* id 26, wireType 0 =*/208).bool(message.msgArrival);
+      if (message.msgRead != null && Object.hasOwnProperty.call(message, "msgRead")) writer.uint32(/* id 27, wireType 0 =*/216).bool(message.msgRead);
       return writer;
     };
 
@@ -14906,6 +14931,16 @@
               message.extra = reader.string();
               break;
             }
+          case 26:
+            {
+              message.msgArrival = reader.bool();
+              break;
+            }
+          case 27:
+            {
+              message.msgRead = reader.bool();
+              break;
+            }
           default:
             reader.skipType(tag & 7);
             break;
@@ -17601,6 +17636,304 @@
     };
     return NewMessageNotificationResp;
   })();
+  $root$1.ChatMessage = (() => {
+    /**
+     * Properties of a ChatMessage.
+     * @exports IChatMessage
+     * @interface IChatMessage
+     * @property {Long|null} [destId] ChatMessage destId
+     * @property {Array.<Long>|null} [msgId] ChatMessage msgId
+     */
+
+    /**
+     * Constructs a new ChatMessage.
+     * @exports ChatMessage
+     * @classdesc Represents a ChatMessage.
+     * @implements IChatMessage
+     * @constructor
+     * @param {IChatMessage=} [properties] Properties to set
+     */
+    function ChatMessage(properties) {
+      this.msgId = [];
+      if (properties) for (let keys = Object.keys(properties), i = 0; i < keys.length; ++i) if (properties[keys[i]] != null) this[keys[i]] = properties[keys[i]];
+    }
+
+    /**
+     * ChatMessage destId.
+     * @member {Long} destId
+     * @memberof ChatMessage
+     * @instance
+     */
+    ChatMessage.prototype.destId = $util$1.Long ? $util$1.Long.fromBits(0, 0, false) : 0;
+
+    /**
+     * ChatMessage msgId.
+     * @member {Array.<Long>} msgId
+     * @memberof ChatMessage
+     * @instance
+     */
+    ChatMessage.prototype.msgId = $util$1.emptyArray;
+
+    /**
+     * Encodes the specified ChatMessage message. Does not implicitly {@link ChatMessage.verify|verify} messages.
+     * @function encode
+     * @memberof ChatMessage
+     * @static
+     * @param {IChatMessage} message ChatMessage message or plain object to encode
+     * @param {$protobuf.Writer} [writer] Writer to encode to
+     * @returns {$protobuf.Writer} Writer
+     */
+    ChatMessage.encode = function encode(message, writer) {
+      if (!writer) writer = $Writer$1.create();
+      if (message.destId != null && Object.hasOwnProperty.call(message, "destId")) writer.uint32(/* id 1, wireType 0 =*/8).int64(message.destId);
+      if (message.msgId != null && message.msgId.length) {
+        writer.uint32(/* id 2, wireType 2 =*/18).fork();
+        for (let i = 0; i < message.msgId.length; ++i) writer.int64(message.msgId[i]);
+        writer.ldelim();
+      }
+      return writer;
+    };
+
+    /**
+     * Decodes a ChatMessage message from the specified reader or buffer.
+     * @function decode
+     * @memberof ChatMessage
+     * @static
+     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
+     * @param {number} [length] Message length if known beforehand
+     * @returns {ChatMessage} ChatMessage
+     * @throws {Error} If the payload is not a reader or valid buffer
+     * @throws {$protobuf.util.ProtocolError} If required fields are missing
+     */
+    ChatMessage.decode = function decode(reader, length) {
+      if (!(reader instanceof $Reader$1)) reader = $Reader$1.create(reader);
+      let end = length === undefined ? reader.len : reader.pos + length,
+        message = new $root$1.ChatMessage();
+      while (reader.pos < end) {
+        let tag = reader.uint32();
+        switch (tag >>> 3) {
+          case 1:
+            {
+              message.destId = reader.int64();
+              break;
+            }
+          case 2:
+            {
+              if (!(message.msgId && message.msgId.length)) message.msgId = [];
+              if ((tag & 7) === 2) {
+                let end2 = reader.uint32() + reader.pos;
+                while (reader.pos < end2) message.msgId.push(reader.int64());
+              } else message.msgId.push(reader.int64());
+              break;
+            }
+          default:
+            reader.skipType(tag & 7);
+            break;
+        }
+      }
+      return message;
+    };
+
+    /**
+     * Gets the default type url for ChatMessage
+     * @function getTypeUrl
+     * @memberof ChatMessage
+     * @static
+     * @param {string} [typeUrlPrefix] your custom typeUrlPrefix(default "type.googleapis.com")
+     * @returns {string} The default type url
+     */
+    ChatMessage.getTypeUrl = function getTypeUrl(typeUrlPrefix) {
+      if (typeUrlPrefix === undefined) {
+        typeUrlPrefix = "type.googleapis.com";
+      }
+      return typeUrlPrefix + "/ChatMessage";
+    };
+    return ChatMessage;
+  })();
+  const SendPrivateChatArrivalAckReq = $root$1.SendPrivateChatArrivalAckReq = (() => {
+    /**
+     * Properties of a SendPrivateChatArrivalAckReq.
+     * @exports ISendPrivateChatArrivalAckReq
+     * @interface ISendPrivateChatArrivalAckReq
+     * @property {Array.<IChatMessage>|null} [chatMessage] SendPrivateChatArrivalAckReq chatMessage
+     */
+
+    /**
+     * Constructs a new SendPrivateChatArrivalAckReq.
+     * @exports SendPrivateChatArrivalAckReq
+     * @classdesc Represents a SendPrivateChatArrivalAckReq.
+     * @implements ISendPrivateChatArrivalAckReq
+     * @constructor
+     * @param {ISendPrivateChatArrivalAckReq=} [properties] Properties to set
+     */
+    function SendPrivateChatArrivalAckReq(properties) {
+      this.chatMessage = [];
+      if (properties) for (let keys = Object.keys(properties), i = 0; i < keys.length; ++i) if (properties[keys[i]] != null) this[keys[i]] = properties[keys[i]];
+    }
+
+    /**
+     * SendPrivateChatArrivalAckReq chatMessage.
+     * @member {Array.<IChatMessage>} chatMessage
+     * @memberof SendPrivateChatArrivalAckReq
+     * @instance
+     */
+    SendPrivateChatArrivalAckReq.prototype.chatMessage = $util$1.emptyArray;
+
+    /**
+     * Encodes the specified SendPrivateChatArrivalAckReq message. Does not implicitly {@link SendPrivateChatArrivalAckReq.verify|verify} messages.
+     * @function encode
+     * @memberof SendPrivateChatArrivalAckReq
+     * @static
+     * @param {ISendPrivateChatArrivalAckReq} message SendPrivateChatArrivalAckReq message or plain object to encode
+     * @param {$protobuf.Writer} [writer] Writer to encode to
+     * @returns {$protobuf.Writer} Writer
+     */
+    SendPrivateChatArrivalAckReq.encode = function encode(message, writer) {
+      if (!writer) writer = $Writer$1.create();
+      if (message.chatMessage != null && message.chatMessage.length) for (let i = 0; i < message.chatMessage.length; ++i) $root$1.ChatMessage.encode(message.chatMessage[i], writer.uint32(/* id 1, wireType 2 =*/10).fork()).ldelim();
+      return writer;
+    };
+
+    /**
+     * Decodes a SendPrivateChatArrivalAckReq message from the specified reader or buffer.
+     * @function decode
+     * @memberof SendPrivateChatArrivalAckReq
+     * @static
+     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
+     * @param {number} [length] Message length if known beforehand
+     * @returns {SendPrivateChatArrivalAckReq} SendPrivateChatArrivalAckReq
+     * @throws {Error} If the payload is not a reader or valid buffer
+     * @throws {$protobuf.util.ProtocolError} If required fields are missing
+     */
+    SendPrivateChatArrivalAckReq.decode = function decode(reader, length) {
+      if (!(reader instanceof $Reader$1)) reader = $Reader$1.create(reader);
+      let end = length === undefined ? reader.len : reader.pos + length,
+        message = new $root$1.SendPrivateChatArrivalAckReq();
+      while (reader.pos < end) {
+        let tag = reader.uint32();
+        switch (tag >>> 3) {
+          case 1:
+            {
+              if (!(message.chatMessage && message.chatMessage.length)) message.chatMessage = [];
+              message.chatMessage.push($root$1.ChatMessage.decode(reader, reader.uint32()));
+              break;
+            }
+          default:
+            reader.skipType(tag & 7);
+            break;
+        }
+      }
+      return message;
+    };
+
+    /**
+     * Gets the default type url for SendPrivateChatArrivalAckReq
+     * @function getTypeUrl
+     * @memberof SendPrivateChatArrivalAckReq
+     * @static
+     * @param {string} [typeUrlPrefix] your custom typeUrlPrefix(default "type.googleapis.com")
+     * @returns {string} The default type url
+     */
+    SendPrivateChatArrivalAckReq.getTypeUrl = function getTypeUrl(typeUrlPrefix) {
+      if (typeUrlPrefix === undefined) {
+        typeUrlPrefix = "type.googleapis.com";
+      }
+      return typeUrlPrefix + "/SendPrivateChatArrivalAckReq";
+    };
+    return SendPrivateChatArrivalAckReq;
+  })();
+  const SendPrivateChatReadAckReq = $root$1.SendPrivateChatReadAckReq = (() => {
+    /**
+     * Properties of a SendPrivateChatReadAckReq.
+     * @exports ISendPrivateChatReadAckReq
+     * @interface ISendPrivateChatReadAckReq
+     * @property {Array.<IChatMessage>|null} [chatMessage] SendPrivateChatReadAckReq chatMessage
+     */
+
+    /**
+     * Constructs a new SendPrivateChatReadAckReq.
+     * @exports SendPrivateChatReadAckReq
+     * @classdesc Represents a SendPrivateChatReadAckReq.
+     * @implements ISendPrivateChatReadAckReq
+     * @constructor
+     * @param {ISendPrivateChatReadAckReq=} [properties] Properties to set
+     */
+    function SendPrivateChatReadAckReq(properties) {
+      this.chatMessage = [];
+      if (properties) for (let keys = Object.keys(properties), i = 0; i < keys.length; ++i) if (properties[keys[i]] != null) this[keys[i]] = properties[keys[i]];
+    }
+
+    /**
+     * SendPrivateChatReadAckReq chatMessage.
+     * @member {Array.<IChatMessage>} chatMessage
+     * @memberof SendPrivateChatReadAckReq
+     * @instance
+     */
+    SendPrivateChatReadAckReq.prototype.chatMessage = $util$1.emptyArray;
+
+    /**
+     * Encodes the specified SendPrivateChatReadAckReq message. Does not implicitly {@link SendPrivateChatReadAckReq.verify|verify} messages.
+     * @function encode
+     * @memberof SendPrivateChatReadAckReq
+     * @static
+     * @param {ISendPrivateChatReadAckReq} message SendPrivateChatReadAckReq message or plain object to encode
+     * @param {$protobuf.Writer} [writer] Writer to encode to
+     * @returns {$protobuf.Writer} Writer
+     */
+    SendPrivateChatReadAckReq.encode = function encode(message, writer) {
+      if (!writer) writer = $Writer$1.create();
+      if (message.chatMessage != null && message.chatMessage.length) for (let i = 0; i < message.chatMessage.length; ++i) $root$1.ChatMessage.encode(message.chatMessage[i], writer.uint32(/* id 1, wireType 2 =*/10).fork()).ldelim();
+      return writer;
+    };
+
+    /**
+     * Decodes a SendPrivateChatReadAckReq message from the specified reader or buffer.
+     * @function decode
+     * @memberof SendPrivateChatReadAckReq
+     * @static
+     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
+     * @param {number} [length] Message length if known beforehand
+     * @returns {SendPrivateChatReadAckReq} SendPrivateChatReadAckReq
+     * @throws {Error} If the payload is not a reader or valid buffer
+     * @throws {$protobuf.util.ProtocolError} If required fields are missing
+     */
+    SendPrivateChatReadAckReq.decode = function decode(reader, length) {
+      if (!(reader instanceof $Reader$1)) reader = $Reader$1.create(reader);
+      let end = length === undefined ? reader.len : reader.pos + length,
+        message = new $root$1.SendPrivateChatReadAckReq();
+      while (reader.pos < end) {
+        let tag = reader.uint32();
+        switch (tag >>> 3) {
+          case 1:
+            {
+              if (!(message.chatMessage && message.chatMessage.length)) message.chatMessage = [];
+              message.chatMessage.push($root$1.ChatMessage.decode(reader, reader.uint32()));
+              break;
+            }
+          default:
+            reader.skipType(tag & 7);
+            break;
+        }
+      }
+      return message;
+    };
+
+    /**
+     * Gets the default type url for SendPrivateChatReadAckReq
+     * @function getTypeUrl
+     * @memberof SendPrivateChatReadAckReq
+     * @static
+     * @param {string} [typeUrlPrefix] your custom typeUrlPrefix(default "type.googleapis.com")
+     * @returns {string} The default type url
+     */
+    SendPrivateChatReadAckReq.getTypeUrl = function getTypeUrl(typeUrlPrefix) {
+      if (typeUrlPrefix === undefined) {
+        typeUrlPrefix = "type.googleapis.com";
+      }
+      return typeUrlPrefix + "/SendPrivateChatReadAckReq";
+    };
+    return SendPrivateChatReadAckReq;
+  })();
 
   /*eslint-disable block-scoped-var, id-length, no-control-regex, no-magic-numbers, no-prototype-builtins, no-redeclare, no-shadow, no-var, sort-vars*/
 
@@ -18385,7 +18718,7 @@
     };
     return RecallGroupChatMessageReq;
   })();
-  const DeleteGroupChatDialogReq = $root.DeleteGroupChatDialogReq = (() => {
+  $root.DeleteGroupChatDialogReq = (() => {
     /**
      * Properties of a DeleteGroupChatDialogReq.
      * @exports IDeleteGroupChatDialogReq
@@ -18475,6 +18808,319 @@
     };
     return DeleteGroupChatDialogReq;
   })();
+  $root.GroupChatMessage = (() => {
+    /**
+     * Properties of a GroupChatMessage.
+     * @exports IGroupChatMessage
+     * @interface IGroupChatMessage
+     * @property {Long|null} [groupId] GroupChatMessage groupId
+     * @property {Long|null} [userId] GroupChatMessage userId
+     * @property {Array.<Long>|null} [msgId] GroupChatMessage msgId
+     */
+
+    /**
+     * Constructs a new GroupChatMessage.
+     * @exports GroupChatMessage
+     * @classdesc Represents a GroupChatMessage.
+     * @implements IGroupChatMessage
+     * @constructor
+     * @param {IGroupChatMessage=} [properties] Properties to set
+     */
+    function GroupChatMessage(properties) {
+      this.msgId = [];
+      if (properties) for (let keys = Object.keys(properties), i = 0; i < keys.length; ++i) if (properties[keys[i]] != null) this[keys[i]] = properties[keys[i]];
+    }
+
+    /**
+     * GroupChatMessage groupId.
+     * @member {Long} groupId
+     * @memberof GroupChatMessage
+     * @instance
+     */
+    GroupChatMessage.prototype.groupId = $util.Long ? $util.Long.fromBits(0, 0, false) : 0;
+
+    /**
+     * GroupChatMessage userId.
+     * @member {Long} userId
+     * @memberof GroupChatMessage
+     * @instance
+     */
+    GroupChatMessage.prototype.userId = $util.Long ? $util.Long.fromBits(0, 0, false) : 0;
+
+    /**
+     * GroupChatMessage msgId.
+     * @member {Array.<Long>} msgId
+     * @memberof GroupChatMessage
+     * @instance
+     */
+    GroupChatMessage.prototype.msgId = $util.emptyArray;
+
+    /**
+     * Encodes the specified GroupChatMessage message. Does not implicitly {@link GroupChatMessage.verify|verify} messages.
+     * @function encode
+     * @memberof GroupChatMessage
+     * @static
+     * @param {IGroupChatMessage} message GroupChatMessage message or plain object to encode
+     * @param {$protobuf.Writer} [writer] Writer to encode to
+     * @returns {$protobuf.Writer} Writer
+     */
+    GroupChatMessage.encode = function encode(message, writer) {
+      if (!writer) writer = $Writer.create();
+      if (message.groupId != null && Object.hasOwnProperty.call(message, "groupId")) writer.uint32(/* id 1, wireType 0 =*/8).int64(message.groupId);
+      if (message.userId != null && Object.hasOwnProperty.call(message, "userId")) writer.uint32(/* id 2, wireType 0 =*/16).int64(message.userId);
+      if (message.msgId != null && message.msgId.length) {
+        writer.uint32(/* id 3, wireType 2 =*/26).fork();
+        for (let i = 0; i < message.msgId.length; ++i) writer.int64(message.msgId[i]);
+        writer.ldelim();
+      }
+      return writer;
+    };
+
+    /**
+     * Decodes a GroupChatMessage message from the specified reader or buffer.
+     * @function decode
+     * @memberof GroupChatMessage
+     * @static
+     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
+     * @param {number} [length] Message length if known beforehand
+     * @returns {GroupChatMessage} GroupChatMessage
+     * @throws {Error} If the payload is not a reader or valid buffer
+     * @throws {$protobuf.util.ProtocolError} If required fields are missing
+     */
+    GroupChatMessage.decode = function decode(reader, length) {
+      if (!(reader instanceof $Reader)) reader = $Reader.create(reader);
+      let end = length === undefined ? reader.len : reader.pos + length,
+        message = new $root.GroupChatMessage();
+      while (reader.pos < end) {
+        let tag = reader.uint32();
+        switch (tag >>> 3) {
+          case 1:
+            {
+              message.groupId = reader.int64();
+              break;
+            }
+          case 2:
+            {
+              message.userId = reader.int64();
+              break;
+            }
+          case 3:
+            {
+              if (!(message.msgId && message.msgId.length)) message.msgId = [];
+              if ((tag & 7) === 2) {
+                let end2 = reader.uint32() + reader.pos;
+                while (reader.pos < end2) message.msgId.push(reader.int64());
+              } else message.msgId.push(reader.int64());
+              break;
+            }
+          default:
+            reader.skipType(tag & 7);
+            break;
+        }
+      }
+      return message;
+    };
+
+    /**
+     * Gets the default type url for GroupChatMessage
+     * @function getTypeUrl
+     * @memberof GroupChatMessage
+     * @static
+     * @param {string} [typeUrlPrefix] your custom typeUrlPrefix(default "type.googleapis.com")
+     * @returns {string} The default type url
+     */
+    GroupChatMessage.getTypeUrl = function getTypeUrl(typeUrlPrefix) {
+      if (typeUrlPrefix === undefined) {
+        typeUrlPrefix = "type.googleapis.com";
+      }
+      return typeUrlPrefix + "/GroupChatMessage";
+    };
+    return GroupChatMessage;
+  })();
+  const SendGroupChatArrivalAckReq = $root.SendGroupChatArrivalAckReq = (() => {
+    /**
+     * Properties of a SendGroupChatArrivalAckReq.
+     * @exports ISendGroupChatArrivalAckReq
+     * @interface ISendGroupChatArrivalAckReq
+     * @property {Array.<IGroupChatMessage>|null} [groupChatMessage] SendGroupChatArrivalAckReq groupChatMessage
+     */
+
+    /**
+     * Constructs a new SendGroupChatArrivalAckReq.
+     * @exports SendGroupChatArrivalAckReq
+     * @classdesc Represents a SendGroupChatArrivalAckReq.
+     * @implements ISendGroupChatArrivalAckReq
+     * @constructor
+     * @param {ISendGroupChatArrivalAckReq=} [properties] Properties to set
+     */
+    function SendGroupChatArrivalAckReq(properties) {
+      this.groupChatMessage = [];
+      if (properties) for (let keys = Object.keys(properties), i = 0; i < keys.length; ++i) if (properties[keys[i]] != null) this[keys[i]] = properties[keys[i]];
+    }
+
+    /**
+     * SendGroupChatArrivalAckReq groupChatMessage.
+     * @member {Array.<IGroupChatMessage>} groupChatMessage
+     * @memberof SendGroupChatArrivalAckReq
+     * @instance
+     */
+    SendGroupChatArrivalAckReq.prototype.groupChatMessage = $util.emptyArray;
+
+    /**
+     * Encodes the specified SendGroupChatArrivalAckReq message. Does not implicitly {@link SendGroupChatArrivalAckReq.verify|verify} messages.
+     * @function encode
+     * @memberof SendGroupChatArrivalAckReq
+     * @static
+     * @param {ISendGroupChatArrivalAckReq} message SendGroupChatArrivalAckReq message or plain object to encode
+     * @param {$protobuf.Writer} [writer] Writer to encode to
+     * @returns {$protobuf.Writer} Writer
+     */
+    SendGroupChatArrivalAckReq.encode = function encode(message, writer) {
+      if (!writer) writer = $Writer.create();
+      if (message.groupChatMessage != null && message.groupChatMessage.length) for (let i = 0; i < message.groupChatMessage.length; ++i) $root.GroupChatMessage.encode(message.groupChatMessage[i], writer.uint32(/* id 1, wireType 2 =*/10).fork()).ldelim();
+      return writer;
+    };
+
+    /**
+     * Decodes a SendGroupChatArrivalAckReq message from the specified reader or buffer.
+     * @function decode
+     * @memberof SendGroupChatArrivalAckReq
+     * @static
+     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
+     * @param {number} [length] Message length if known beforehand
+     * @returns {SendGroupChatArrivalAckReq} SendGroupChatArrivalAckReq
+     * @throws {Error} If the payload is not a reader or valid buffer
+     * @throws {$protobuf.util.ProtocolError} If required fields are missing
+     */
+    SendGroupChatArrivalAckReq.decode = function decode(reader, length) {
+      if (!(reader instanceof $Reader)) reader = $Reader.create(reader);
+      let end = length === undefined ? reader.len : reader.pos + length,
+        message = new $root.SendGroupChatArrivalAckReq();
+      while (reader.pos < end) {
+        let tag = reader.uint32();
+        switch (tag >>> 3) {
+          case 1:
+            {
+              if (!(message.groupChatMessage && message.groupChatMessage.length)) message.groupChatMessage = [];
+              message.groupChatMessage.push($root.GroupChatMessage.decode(reader, reader.uint32()));
+              break;
+            }
+          default:
+            reader.skipType(tag & 7);
+            break;
+        }
+      }
+      return message;
+    };
+
+    /**
+     * Gets the default type url for SendGroupChatArrivalAckReq
+     * @function getTypeUrl
+     * @memberof SendGroupChatArrivalAckReq
+     * @static
+     * @param {string} [typeUrlPrefix] your custom typeUrlPrefix(default "type.googleapis.com")
+     * @returns {string} The default type url
+     */
+    SendGroupChatArrivalAckReq.getTypeUrl = function getTypeUrl(typeUrlPrefix) {
+      if (typeUrlPrefix === undefined) {
+        typeUrlPrefix = "type.googleapis.com";
+      }
+      return typeUrlPrefix + "/SendGroupChatArrivalAckReq";
+    };
+    return SendGroupChatArrivalAckReq;
+  })();
+  const SendGroupChatReadAckReq = $root.SendGroupChatReadAckReq = (() => {
+    /**
+     * Properties of a SendGroupChatReadAckReq.
+     * @exports ISendGroupChatReadAckReq
+     * @interface ISendGroupChatReadAckReq
+     * @property {Array.<IGroupChatMessage>|null} [groupChatMessage] SendGroupChatReadAckReq groupChatMessage
+     */
+
+    /**
+     * Constructs a new SendGroupChatReadAckReq.
+     * @exports SendGroupChatReadAckReq
+     * @classdesc Represents a SendGroupChatReadAckReq.
+     * @implements ISendGroupChatReadAckReq
+     * @constructor
+     * @param {ISendGroupChatReadAckReq=} [properties] Properties to set
+     */
+    function SendGroupChatReadAckReq(properties) {
+      this.groupChatMessage = [];
+      if (properties) for (let keys = Object.keys(properties), i = 0; i < keys.length; ++i) if (properties[keys[i]] != null) this[keys[i]] = properties[keys[i]];
+    }
+
+    /**
+     * SendGroupChatReadAckReq groupChatMessage.
+     * @member {Array.<IGroupChatMessage>} groupChatMessage
+     * @memberof SendGroupChatReadAckReq
+     * @instance
+     */
+    SendGroupChatReadAckReq.prototype.groupChatMessage = $util.emptyArray;
+
+    /**
+     * Encodes the specified SendGroupChatReadAckReq message. Does not implicitly {@link SendGroupChatReadAckReq.verify|verify} messages.
+     * @function encode
+     * @memberof SendGroupChatReadAckReq
+     * @static
+     * @param {ISendGroupChatReadAckReq} message SendGroupChatReadAckReq message or plain object to encode
+     * @param {$protobuf.Writer} [writer] Writer to encode to
+     * @returns {$protobuf.Writer} Writer
+     */
+    SendGroupChatReadAckReq.encode = function encode(message, writer) {
+      if (!writer) writer = $Writer.create();
+      if (message.groupChatMessage != null && message.groupChatMessage.length) for (let i = 0; i < message.groupChatMessage.length; ++i) $root.GroupChatMessage.encode(message.groupChatMessage[i], writer.uint32(/* id 1, wireType 2 =*/10).fork()).ldelim();
+      return writer;
+    };
+
+    /**
+     * Decodes a SendGroupChatReadAckReq message from the specified reader or buffer.
+     * @function decode
+     * @memberof SendGroupChatReadAckReq
+     * @static
+     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
+     * @param {number} [length] Message length if known beforehand
+     * @returns {SendGroupChatReadAckReq} SendGroupChatReadAckReq
+     * @throws {Error} If the payload is not a reader or valid buffer
+     * @throws {$protobuf.util.ProtocolError} If required fields are missing
+     */
+    SendGroupChatReadAckReq.decode = function decode(reader, length) {
+      if (!(reader instanceof $Reader)) reader = $Reader.create(reader);
+      let end = length === undefined ? reader.len : reader.pos + length,
+        message = new $root.SendGroupChatReadAckReq();
+      while (reader.pos < end) {
+        let tag = reader.uint32();
+        switch (tag >>> 3) {
+          case 1:
+            {
+              if (!(message.groupChatMessage && message.groupChatMessage.length)) message.groupChatMessage = [];
+              message.groupChatMessage.push($root.GroupChatMessage.decode(reader, reader.uint32()));
+              break;
+            }
+          default:
+            reader.skipType(tag & 7);
+            break;
+        }
+      }
+      return message;
+    };
+
+    /**
+     * Gets the default type url for SendGroupChatReadAckReq
+     * @function getTypeUrl
+     * @memberof SendGroupChatReadAckReq
+     * @static
+     * @param {string} [typeUrlPrefix] your custom typeUrlPrefix(default "type.googleapis.com")
+     * @returns {string} The default type url
+     */
+    SendGroupChatReadAckReq.getTypeUrl = function getTypeUrl(typeUrlPrefix) {
+      if (typeUrlPrefix === undefined) {
+        typeUrlPrefix = "type.googleapis.com";
+      }
+      return typeUrlPrefix + "/SendGroupChatReadAckReq";
+    };
+    return SendGroupChatReadAckReq;
+  })();
 
   function extractConversationType(destId) {
     const longId = isString(destId) ? Long.fromString(destId) : destId;
@@ -18634,22 +19280,12 @@
     return reqPromise;
   };
   const deleteDialog = dialogId => {
-    let reqPromise;
-    if (extractConversationType(dialogId) == exports.ConversationType.GROUP) {
-      reqPromise = webSocketServer.send(CmdIds$1.DeleteGroupDialog, {
-        groupId: Long.fromString(dialogId)
-      }, {
-        encoder: DeleteGroupChatDialogReq,
-        decoder: BaseResp
-      });
-    } else {
-      reqPromise = webSocketServer.send(CmdIds$1.DeletePrivateDialog, {
-        destId: Long.fromString(dialogId)
-      }, {
-        encoder: DeletePrivateChatDialogReq,
-        decoder: BaseResp
-      });
-    }
+    let reqPromise = webSocketServer.send(CmdIds$1.DeletePrivateDialog, {
+      destId: Long.fromString(dialogId)
+    }, {
+      encoder: DeletePrivateChatDialogReq,
+      decoder: BaseResp
+    });
     return reqPromise;
   };
   const getDialogChangedStatus = offset => webSocketServer.send(CmdIds$1.GetDialogChangedStatus, {
@@ -18658,6 +19294,22 @@
     encoder: GetNewSettingDialogListReq,
     decoder: GetNewSettingDialogListResp
   });
+  const sendGroupChatArrivalAck = params => webSocketServer.send(CmdIds$1.SendGroupChatArrivalAck, params, {
+    encoder: SendGroupChatArrivalAckReq,
+    decoder: BaseResp
+  });
+  const sendGroupChatReadAck = params => webSocketServer.send(CmdIds$1.SendGroupChatReadAck, params, {
+    encoder: SendGroupChatReadAckReq,
+    decoder: BaseResp
+  });
+  const sendPrivateChatArrivalAck = params => webSocketServer.send(CmdIds$1.SendPrivateChatArrivalAck, params, {
+    encoder: SendPrivateChatArrivalAckReq,
+    decoder: BaseResp
+  });
+  const sendPrivateChatReadAck = params => webSocketServer.send(CmdIds$1.SendPrivateChatReadAck, params, {
+    encoder: SendPrivateChatReadAckReq,
+    decoder: BaseResp
+  });
 
   let milliDelta__ = 0;
   const synchronizeServerTime = async () => {
@@ -18889,6 +19541,12 @@
     REDPACKET: 0x10001040,
     TRANSFER: 0x10001030
   };
+  const NotiMessageTypes = {
+    GROUP_ARRIVAL_RECEIPT: 0x60020024,
+    GROUP_READ_RECEIPT: 0x60020025,
+    PRIVATE_ARRIVAL_RECEIPT: 0x6001000C,
+    PRIVATE_READ_RECEIPT: 0x6001000D
+  };
 
   function deepClone(obj) {
     if (!isDef(obj)) {
@@ -19601,13 +20259,13 @@
     destroyed() {},
     syncConversationStatus: function () {}
   };
-  let manager;
+  let manager$1;
   var ConversationManager$1 = {
     create(appkey, currentUserId, updatedConversationFunc) {
-      manager = new ConversationManager(appkey, currentUserId, updatedConversationFunc);
+      manager$1 = new ConversationManager(appkey, currentUserId, updatedConversationFunc);
     },
     get() {
-      return manager ?? nullConversationManager;
+      return manager$1 ?? nullConversationManager;
     }
   };
 
@@ -19689,7 +20347,7 @@
           sentStatus: exports.SentStatus.SENT,
           receivedTime: getServerTime$1().toString(),
           isStatusMessage: messageInstance.isStatusMessage,
-          receivedStatus: exports.ReceivedStatus.READ,
+          receivedStatus: dialogMessage.msgRead ? exports.ReceivedStatus.READ : dialogMessage.msgArrival ? exports.ReceivedStatus.RECEIVED : exports.ReceivedStatus.IDLE,
           disableNotification: localConversation?.notificationStatus === exports.NotificationStatus.OPEN || dialogMessage.srcId.toString() == accountStore.uid
         };
         if (receivedMessage.isStatusMessage && Long.fromNumber(getServerTime$1()).subtract(receivedMessage.sentTime).greaterThan(STATUSMESSAGE_ALIVE_TIMEMS)) {
@@ -19773,6 +20431,117 @@
     parseChatRecordMsgDetails: parseChatRecordMsgDetails$1
   };
 
+  const UNREADMESSAGEUIDS_KEY = 'unreadMessageUids';
+  class MessageReceiptManager {
+    localStore;
+    constructor(appkey, currentUserId) {
+      const suffix = `receipt-${appkey}-${currentUserId}`;
+      this.localStore = new AppStorage(suffix);
+    }
+    storeUnreadMessageUids(messageList) {
+      const validMessages = messageList.filter(m => m.isCounted && m.messageDirection !== exports.MessageDirection.SEND);
+      const messageUids = validMessages.map(m => m.messageUId);
+      const existingUids = this.localStore.get(UNREADMESSAGEUIDS_KEY) || [];
+      const updatedUids = [...new Set([...existingUids, ...messageUids])];
+      this.localStore.set(UNREADMESSAGEUIDS_KEY, updatedUids);
+    }
+    formatReceiptMessages(messages) {
+      const privateMessages = [];
+      const groupMessages = [];
+      messages.forEach(m => {
+        if (m.conversationType === exports.ConversationType.PRIVATE) {
+          privateMessages.push(m);
+        } else {
+          groupMessages.push(m);
+        }
+      });
+      const privateReceiptMessages = Object.entries(privateMessages.reduce((acc, msg) => {
+        if (!acc[msg.targetId]) {
+          acc[msg.targetId] = [];
+        }
+        acc[msg.targetId].push(msg.messageUId);
+        return acc;
+      }, {})).map(([conversationId, messageIds]) => ({
+        destId: Long.fromString(conversationId),
+        msgIds: messageIds
+      }));
+      const groupReceiptMessages = groupMessages.reduce((acc, msg) => {
+        const existingGroup = acc.find(g => g.groupId.equals(Long.fromString(msg.targetId)) && g.userId.equals(Long.fromString(msg.senderUserId)));
+        if (existingGroup) {
+          existingGroup.msgIds.push(msg.messageUId);
+        } else {
+          acc.push({
+            groupId: Long.fromString(msg.targetId),
+            userId: Long.fromString(msg.senderUserId),
+            msgIds: [msg.messageUId]
+          });
+        }
+        return acc;
+      }, []);
+      return {
+        privateReceiptMessages,
+        groupReceiptMessages
+      };
+    }
+    filterValidMessages(messageList) {
+      return messageList.filter(m => m.isCounted && m.messageDirection !== exports.MessageDirection.SEND);
+    }
+    async sendArrivalReceipts(messageList) {
+      this.storeUnreadMessageUids(messageList);
+      const validMessages = this.filterValidMessages(messageList);
+      const {
+        privateReceiptMessages,
+        groupReceiptMessages
+      } = this.formatReceiptMessages(validMessages);
+      if (privateReceiptMessages.length) {
+        await sendPrivateChatArrivalAck({
+          chatMessage: privateReceiptMessages
+        });
+      }
+      if (groupReceiptMessages.length) {
+        await sendGroupChatReadAck({
+          groupChatMessage: groupReceiptMessages
+        });
+      }
+    }
+    async sendReadReceipts(messageList) {
+      const storedUnreadUids = this.localStore.get(UNREADMESSAGEUIDS_KEY) || [];
+      const validMessages = this.filterValidMessages(messageList).filter(m => storedUnreadUids.includes(m.messageUId));
+      try {
+        const {
+          privateReceiptMessages,
+          groupReceiptMessages
+        } = this.formatReceiptMessages(validMessages);
+        if (privateReceiptMessages.length) {
+          await sendPrivateChatReadAck({
+            chatMessage: privateReceiptMessages
+          });
+        }
+        if (groupReceiptMessages.length) {
+          await sendGroupChatArrivalAck({
+            groupChatMessage: groupReceiptMessages
+          });
+        }
+        const latestUnreadUids = this.localStore.get(UNREADMESSAGEUIDS_KEY) || [];
+        const sentMessageUids = validMessages.map(m => m.messageUId);
+        const remainingUids = latestUnreadUids.filter(uid => !sentMessageUids.includes(uid));
+        this.localStore.set(UNREADMESSAGEUIDS_KEY, remainingUids);
+      } catch (error) {
+        console.error('发送已读回执失败:', error);
+        throw error;
+      }
+    }
+  }
+  let manager;
+  var MessageReceiptManager$1 = {
+    create(appkey, currentUserId) {
+      manager = new MessageReceiptManager(appkey, currentUserId);
+    },
+    get() {
+      return manager;
+    }
+  };
+
   class MessageLoader {
     watcher;
     pullingMsg = false;
@@ -19909,8 +20678,10 @@
           }
         });
         if (messages.length) {
-          this.watcher.batchMessage?.(messages);
+          let normalMessages = this.handleReceiptMessages(messages);
+          this.watcher.batchMessage?.(normalMessages);
         }
+        MessageReceiptManager$1.get()?.sendArrivalReceipts(messages);
         if (done) {
           if (seqno.ge(this.serverMsgSeqno)) {
             this.serverMsgSeqno = seqno;
@@ -19929,6 +20700,39 @@
         }
       });
     }
+    handleReceiptMessages(messages) {
+      const normalMessages = [];
+      const receiptnotificationMessages = [];
+      messages.forEach(msg => {
+        if (msg.messageType === NotiMessageTypes.GROUP_ARRIVAL_RECEIPT || msg.messageType === NotiMessageTypes.GROUP_READ_RECEIPT || msg.messageType === NotiMessageTypes.PRIVATE_ARRIVAL_RECEIPT || msg.messageType === NotiMessageTypes.PRIVATE_READ_RECEIPT) {
+          receiptnotificationMessages.push(msg);
+        } else {
+          normalMessages.push(msg);
+        }
+      });
+      const sentMessages = normalMessages.filter(m => m.messageDirection === exports.MessageDirection.SEND);
+      receiptnotificationMessages.forEach(notiMsg => {
+        const notiContent = notiMsg.content;
+        const isArrivalReceipt = notiMsg.messageType === NotiMessageTypes.GROUP_ARRIVAL_RECEIPT || notiMsg.messageType === NotiMessageTypes.PRIVATE_ARRIVAL_RECEIPT;
+        sentMessages.forEach(msg => {
+          if (notiContent.msgIdList.includes(msg.messageUId)) {
+            if (isArrivalReceipt) {
+              msg.receivedStatus = exports.ReceivedStatus.RECEIVED;
+            } else {
+              msg.receivedStatus = exports.ReceivedStatus.READ;
+            }
+          }
+        });
+        this.watcher.onReceiptReceived?.({
+          conversation: {
+            conversationType: notiMsg.conversationType,
+            targetId: notiMsg.targetId
+          },
+          messageUIdList: notiContent.msgIdList
+        }, notiMsg.messageType === NotiMessageTypes.GROUP_ARRIVAL_RECEIPT || notiMsg.messageType === NotiMessageTypes.PRIVATE_ARRIVAL_RECEIPT ? 0 : 1);
+      });
+      return normalMessages;
+    }
     isExistPersistedMessage(messageList) {
       return messageList.some(m => m.isPersited);
     }
@@ -19981,6 +20785,11 @@
 
   const RecallCommandMessage = registerMessageType$1(MessageTypes.RECALL, true, false, false);
 
+  const GroupArrivalReceiptMessage = registerMessageType$1(NotiMessageTypes.GROUP_ARRIVAL_RECEIPT, false, false, true);
+  const GroupReadReceiptMessage = registerMessageType$1(NotiMessageTypes.GROUP_READ_RECEIPT, false, false, true);
+  const PrivateArrivalReceiptMessage = registerMessageType$1(NotiMessageTypes.PRIVATE_ARRIVAL_RECEIPT, false, false, true);
+  const PrivateReadReceiptMessage = registerMessageType$1(NotiMessageTypes.PRIVATE_READ_RECEIPT, false, false, true);
+
   const DEFAULT_SOCKET_URI = 'wss://imweb.mp.net:6443';
   class LibLoader {
     options;
@@ -20009,7 +20818,8 @@
         batchMessage: undefined,
         conversationState: undefined,
         onPush: undefined,
-        onRecall: undefined
+        onRecall: undefined,
+        onReceiptReceived: undefined
       };
       webSocketServer.setServerInfo(this.getWebSocketUrl());
       webSocketServer.setCallback({
@@ -20042,6 +20852,10 @@
       registerMessage(MessageTypes.GROUP_INVITATION, InvitationMessage);
       registerMessage(MessageTypes.REDPACKET, RedEnvelopeMessage);
       registerMessage(MessageTypes.TRANSFER, TransferMessage);
+      registerMessage(NotiMessageTypes.GROUP_ARRIVAL_RECEIPT, GroupArrivalReceiptMessage);
+      registerMessage(NotiMessageTypes.GROUP_READ_RECEIPT, GroupReadReceiptMessage);
+      registerMessage(NotiMessageTypes.PRIVATE_ARRIVAL_RECEIPT, PrivateArrivalReceiptMessage);
+      registerMessage(NotiMessageTypes.PRIVATE_READ_RECEIPT, PrivateReadReceiptMessage);
     }
     async connect() {
       if (this.connectionStatus === exports.ConnectionStatus.CONNECTED) {
@@ -20059,6 +20873,7 @@
         this.isInternalConnected = true;
         ConversationManager$1.get().destroyed();
         ConversationManager$1.create(this.options.appkey, accountStore.uid.toString(), this.watcher.conversationState);
+        MessageReceiptManager$1.create(this.options.appkey, accountStore.uid.toString());
         this.messageLoader?.stop();
         this.messageLoader = new MessageLoader(this.watcher, this.options);
         synchronizeServerTime();
@@ -26739,7 +27554,7 @@
     sentStatus,
     receivedTime: '0',
     isStatusMessage: message.isStatusMessage,
-    receivedStatus: exports.ReceivedStatus.UNREAD,
+    receivedStatus: exports.ReceivedStatus.IDLE,
     disableNotification: true
   });
 
@@ -27472,6 +28287,13 @@
           messageUids.forEach(messageUId => {
             this.emit(exports.Events.RECALL, messageUId);
           });
+        },
+        onReceiptReceived: (event, type) => {
+          if (type === 0) {
+            this.emit(exports.Events.ARRIVAL_RECEIPT_RECEIVED, event);
+          } else {
+            this.emit(exports.Events.READ_RECEIPT_RECEIVED, event);
+          }
         }
       });
     }
@@ -27689,6 +28511,9 @@
     clearConversationMessageDraft(conversation) {
       ConversationManager$1.get().clearDraft(conversation);
     }
+    async sendReadReceipts(messages) {
+      await MessageReceiptManager$1.get()?.sendReadReceipts(messages);
+    }
     formatConversation(serverConversationData) {
       const {
         dialog,
@@ -28965,6 +29790,18 @@
   const parseChatRecordMsgDetails = (conversation, detailItems) => {
     return serverMessageParser.parseChatRecordMsgDetails(conversation, detailItems);
   };
+  const sendReadReceipts = async messages => {
+    try {
+      await imClient.sendReadReceipts(messages);
+      return {
+        code: exports.ErrorCode.SUCCESS
+      };
+    } catch (error) {
+      return {
+        code: exports.ErrorCode.UNKNOWN
+      };
+    }
+  };
   const mockLogin = config => {
     return login(config);
   };
@@ -29035,6 +29872,7 @@
   exports.sendHQVoiceMessage = sendHQVoiceMessage;
   exports.sendImageMessage = sendImageMessage;
   exports.sendMessage = sendMessage;
+  exports.sendReadReceipts = sendReadReceipts;
   exports.sendSightMessage = sendSightMessage;
   exports.sendTextMessage = sendTextMessage;
   exports.setConversationNotificationStatus = setConversationNotificationStatus;