@softtynet/zca-js 2.2.1 → 2.2.2

package/dist/cjs/index.cjs

@@ -19,6 +19,9 @@ var SeenMessage = require('./models/SeenMessage.cjs');
 var Typing = require('./models/Typing.cjs');
 var Undo = require('./models/Undo.cjs');
 var ZBusiness = require('./models/ZBusiness.cjs');
+var ClearUnread = require('./models/ClearUnread.cjs');
+var SyncEvent = require('./models/SyncEvent.cjs');
+var CallEvent = require('./models/CallEvent.cjs');
 var zalo = require('./zalo.cjs');
 var listen = require('./apis/listen.cjs');
 var loginQR = require('./apis/loginQR.cjs');
@@ -30,6 +33,8 @@ var setMute = require('./apis/setMute.cjs');
 var updateAutoDeleteChat = require('./apis/updateAutoDeleteChat.cjs');
 var updateLang = require('./apis/updateLang.cjs');
 var updateSettings = require('./apis/updateSettings.cjs');
+var sendVoiceCall = require('./apis/sendVoiceCall.cjs');
+var utils = require('./utils.cjs');
 var apis = require('./apis.cjs');
 
 
@@ -107,6 +112,17 @@ Object.defineProperty(exports, "BusinessCategory", {
 	get: function () { return ZBusiness.BusinessCategory; }
 });
 exports.BusinessCategoryName = ZBusiness.BusinessCategoryName;
+exports.ClearUnread = ClearUnread.ClearUnread;
+Object.defineProperty(exports, "SyncEventType", {
+	enumerable: true,
+	get: function () { return SyncEvent.SyncEventType; }
+});
+exports.initializeSyncEvent = SyncEvent.initializeSyncEvent;
+Object.defineProperty(exports, "CallEventType", {
+	enumerable: true,
+	get: function () { return CallEvent.CallEventType; }
+});
+exports.initializeCallEvent = CallEvent.initializeCallEvent;
 exports.Zalo = zalo.Zalo;
 Object.defineProperty(exports, "CloseReason", {
 	enumerable: true,
@@ -156,4 +172,12 @@ Object.defineProperty(exports, "UpdateSettingsType", {
 	enumerable: true,
 	get: function () { return updateSettings.UpdateSettingsType; }
 });
+Object.defineProperty(exports, "CallType", {
+	enumerable: true,
+	get: function () { return sendVoiceCall.CallType; }
+});
+exports.decryptWithPrivateKey = utils.decryptWithPrivateKey;
+exports.decryptZdbBuffer = utils.decryptZdbBuffer;
+exports.deriveZdbAesKey = utils.deriveZdbAesKey;
+exports.generateRSAKeyPair = utils.generateRSAKeyPair;
 exports.API = apis.API;

package/dist/cjs/models/CallEvent.cjs

@@ -0,0 +1,51 @@
+'use strict';
+
+exports.CallEventType = void 0;
+(function (CallEventType) {
+    CallEventType["REQUEST"] = "request";
+    CallEventType["ANSWER"] = "answer";
+    CallEventType["CANCEL"] = "cancel";
+    CallEventType["END"] = "end";
+    CallEventType["RINGRING"] = "ringring";
+    CallEventType["GROUP_REQUEST"] = "group_request";
+    CallEventType["GROUP_ANSWER"] = "group_answer";
+    CallEventType["UNKNOWN"] = "unknown";
+})(exports.CallEventType || (exports.CallEventType = {}));
+function initializeCallEvent(data, act, act_type) {
+    let type = exports.CallEventType.UNKNOWN;
+    switch (act) {
+        case "request":
+            type = exports.CallEventType.REQUEST;
+            break;
+        case "answer":
+            type = exports.CallEventType.ANSWER;
+            break;
+        case "cancel":
+            type = exports.CallEventType.CANCEL;
+            break;
+        case "end":
+        case "endcall":
+            type = exports.CallEventType.END;
+            break;
+        case "ringring":
+            type = exports.CallEventType.RINGRING;
+            break;
+        case "group_request":
+            type = exports.CallEventType.GROUP_REQUEST;
+            break;
+        case "group_answer":
+            type = exports.CallEventType.GROUP_ANSWER;
+            break;
+        default:
+            type = exports.CallEventType.UNKNOWN;
+            break;
+    }
+    return {
+        type,
+        act,
+        act_type,
+        data,
+    };
+}
+
+exports.initializeCallEvent = initializeCallEvent;

package/dist/cjs/models/ClearUnread.cjs

@@ -0,0 +1,17 @@
+'use strict';
+
+var Enum = require('./Enum.cjs');
+
+class ClearUnread {
+    constructor(data) {
+        this.idTo = data.idTo;
+        this.userName = data.userName;
+        this.lastMsgId = data.lastMsgId;
+        this.isGroup = data.isGroup === 1;
+        this.threadType = data.isGroup === 1 ? Enum.ThreadType.Group : Enum.ThreadType.User;
+        this.ts = data.ts;
+        this.type = data.type;
+    }
+}
+
+exports.ClearUnread = ClearUnread;

package/dist/cjs/models/SyncEvent.cjs

@@ -0,0 +1,54 @@
+'use strict';
+
+exports.SyncEventType = void 0;
+(function (SyncEventType) {
+    SyncEventType["USER_CONFIRM"] = "user_confirm";
+    SyncEventType["SYNCMSG_INFO"] = "syncmsg_info";
+    SyncEventType["TRANSFER_ERROR"] = "transfer_error";
+    SyncEventType["TRANSFER_AFTER_LOGIN"] = "transfer_after_login";
+    SyncEventType["UNKNOWN"] = "unknown";
+})(exports.SyncEventType || (exports.SyncEventType = {}));
+function initializeSyncEvent(data, act, act_type) {
+    if (act === "user_confirm") {
+        return {
+            type: exports.SyncEventType.USER_CONFIRM,
+            data: data,
+            act,
+            act_type,
+        };
+    }
+    else if (act === "syncmsg_info") {
+        return {
+            type: exports.SyncEventType.SYNCMSG_INFO,
+            data: data,
+            act,
+            act_type,
+        };
+    }
+    else if (act === "transfer_error") {
+        return {
+            type: exports.SyncEventType.TRANSFER_ERROR,
+            data: data,
+            act,
+            act_type,
+        };
+    }
+    else if (act === "transfer_after_login") {
+        return {
+            type: exports.SyncEventType.TRANSFER_AFTER_LOGIN,
+            data: data,
+            act,
+            act_type,
+        };
+    }
+    else {
+        return {
+            type: exports.SyncEventType.UNKNOWN,
+            data,
+            act,
+            act_type,
+        };
+    }
+}
+
+exports.initializeSyncEvent = initializeSyncEvent;

package/dist/cjs/utils.cjs

@@ -683,7 +683,16 @@ async function handleZaloResponse(ctx, response, isEncrypted = true) {
             };
             return result;
         }
-        const decodedData = isEncrypted ? JSON.parse(decodeAES(ctx.secretKey, jsonData.data)) : jsonData;
+        if (isEncrypted && (!jsonData.data || jsonData.data.length === 0)) {
+            result.data = {};
+            return result;
+        }
+        const decodedStr = isEncrypted ? decodeAES(ctx.secretKey, jsonData.data) : null;
+        if (isEncrypted && (!decodedStr || decodedStr.length === 0)) {
+            result.data = {};
+            return result;
+        }
+        const decodedData = isEncrypted ? JSON.parse(decodedStr) : jsonData;
         if (decodedData.error_code != 0) {
             result.error = {
                 message: decodedData.error_message,
@@ -754,6 +763,144 @@ function normalizeHolderName(input) {
         .trim();
     return normalized.length >= 5 ? normalized : undefined;
 }
+/**
+ * Generates an RSA 2048-bit key pair for mobile message synchronization (`pull_mobile_msg`)
+ * @returns Object containing public and private keys in both PEM and Base64 formats
+ */
+function generateRSAKeyPair() {
+    const { publicKey, privateKey } = crypto.generateKeyPairSync("rsa", {
+        modulusLength: 2048,
+        publicKeyEncoding: { type: "spki", format: "pem" },
+        privateKeyEncoding: { type: "pkcs8", format: "pem" },
+    });
+    const publicKeyBase64 = publicKey
+        .toString()
+        .replace(/-----BEGIN PUBLIC KEY-----/g, "")
+        .replace(/-----END PUBLIC KEY-----/g, "")
+        .replace(/\s+/g, "");
+    const privateKeyBase64 = privateKey
+        .toString()
+        .replace(/-----BEGIN PRIVATE KEY-----/g, "")
+        .replace(/-----END PRIVATE KEY-----/g, "")
+        .replace(/\s+/g, "");
+    return { publicKeyBase64, privateKeyBase64, publicKey: publicKey.toString(), privateKey: privateKey.toString() };
+}
+function b64urlToBigInt(value) {
+    return BigInt("0x" + Buffer.from(value, "base64url").toString("hex"));
+}
+function modPow(base, exp, mod) {
+    const zero = BigInt(0);
+    const one = BigInt(1);
+    let result = one;
+    base %= mod;
+    while (exp > zero) {
+        if (exp & one)
+            result = (result * base) % mod;
+        base = (base * base) % mod;
+        exp >>= one;
+    }
+    return result;
+}
+/**
+ * Pure-BigInt RSA CRT PKCS#1 v1.5 decryption fallback for Node.js environments
+ * where OpenSSL blocks `RSA_PKCS1_PADDING` in `crypto.privateDecrypt` (CVE-2023-46809).
+ */
+function rsaDecryptPkcs1Manual(privateKeyPem, cipher) {
+    const jwk = crypto.createPrivateKey(privateKeyPem).export({ format: "jwk" });
+    const n = b64urlToBigInt(jwk.n);
+    const p = b64urlToBigInt(jwk.p);
+    const q = b64urlToBigInt(jwk.q);
+    const dp = b64urlToBigInt(jwk.dp);
+    const dq = b64urlToBigInt(jwk.dq);
+    const qi = b64urlToBigInt(jwk.qi);
+    const c = BigInt("0x" + cipher.toString("hex"));
+    const m1 = modPow(c, dp, p);
+    const m2 = modPow(c, dq, q);
+    const h = (qi * (((m1 - m2) % p) + p)) % p;
+    const m = m2 + h * q;
+    const k = Math.ceil(n.toString(16).length / 2);
+    const em = Buffer.from(m.toString(16).padStart(k * 2, "0"), "hex");
+    if (em[0] !== 0x00 || em[1] !== 0x02)
+        throw new ZaloApiError.ZaloApiError("Invalid RSA PKCS#1 v1.5 padding");
+    const sep = em.indexOf(0x00, 2);
+    if (sep < 10)
+        throw new ZaloApiError.ZaloApiError("Invalid RSA PKCS#1 v1.5 padding separator");
+    return em.subarray(sep + 1);
+}
+/**
+ * Decrypt `encrypted_key` from `syncmsg_info` using RSA private key with PKCS#1 v1.5 scheme.
+ * Automatically falls back to pure-BigInt CRT decryption if OpenSSL disables `RSA_PKCS1_PADDING`.
+ *
+ * @param privateKey - RSA private key in PEM format
+ * @param encryptedBase64 - Base64 encoded `encrypted_key` from `syncmsg_info`
+ * @returns Raw decrypted bytes (typically 16-32 bytes; use `deriveZdbAesKey` for ZDB4.0 AES-256-CBC key)
+ */
+function decryptWithPrivateKey(privateKey, encryptedBase64) {
+    const cleanKey = privateKey.replace(/\\n/g, "\n");
+    const encryptedBuffer = Buffer.from(encryptedBase64, "base64");
+    try {
+        return crypto.privateDecrypt({
+            key: cleanKey,
+            padding: crypto.constants.RSA_PKCS1_PADDING,
+        }, encryptedBuffer);
+    }
+    catch (err) {
+        const errorObj = err;
+        const code = String((errorObj === null || errorObj === void 0 ? void 0 : errorObj.code) || "");
+        const msg = String((errorObj === null || errorObj === void 0 ? void 0 : errorObj.message) || "");
+        if (code.includes("INVALID_ARG") || /RSA_PKCS1_PADDING|security-revert|not supported/i.test(msg)) {
+            return rsaDecryptPkcs1Manual(cleanKey, encryptedBuffer);
+        }
+        throw err;
+    }
+}
+/**
+ * Derives the 32-byte AES-256-CBC key for Zalo ZDB4.0 (`.db.crypt`) backup files
+ * from the raw RSA-decrypted bytes: first 32 uppercase hex characters as ASCII bytes.
+ */
+function deriveZdbAesKey(decryptedRsaBytes) {
+    const upperHex = decryptedRsaBytes.toString("hex").toUpperCase();
+    if (upperHex.length < 32) {
+        throw new ZaloApiError.ZaloApiError(`Decrypted RSA key hex is too short (${upperHex.length} chars, expected >= 32)`);
+    }
+    return Buffer.from(upperHex.slice(0, 32), "ascii");
+}
+/**
+ * Decrypts a Zalo ZDB4.0 (`.db.crypt`) backup buffer into its plaintext ZDB4.0 container
+ * (header + table of contents + XZ stream) using 64KB independent AES-256-CBC chunks (`IV = 0`).
+ */
+function decryptZdbBuffer(zdbBuffer, aesKey) {
+    const ZDB_MAGIC = Buffer.from("ZDB4.0", "ascii");
+    const CHUNK_SIZE = 0x10000;
+    const zeroIv = Buffer.alloc(16, 0);
+    for (const startOffset of [0, 4]) {
+        const encryptedLength = Math.floor((zdbBuffer.length - startOffset) / 16) * 16;
+        if (encryptedLength < 16)
+            continue;
+        const firstChunkLen = Math.min(CHUNK_SIZE, encryptedLength);
+        const firstDecipher = crypto.createDecipheriv("aes-256-cbc", aesKey, zeroIv);
+        firstDecipher.setAutoPadding(false);
+        const firstPlain = Buffer.concat([
+            firstDecipher.update(zdbBuffer.subarray(startOffset, startOffset + firstChunkLen)),
+            firstDecipher.final(),
+        ]);
+        if (!firstPlain.subarray(0, ZDB_MAGIC.length).equals(ZDB_MAGIC)) {
+            continue;
+        }
+        const chunks = [firstPlain];
+        for (let offset = CHUNK_SIZE; offset < encryptedLength; offset += CHUNK_SIZE) {
+            const len = Math.min(CHUNK_SIZE, encryptedLength - offset);
+            const decipher = crypto.createDecipheriv("aes-256-cbc", aesKey, zeroIv);
+            decipher.setAutoPadding(false);
+            chunks.push(Buffer.concat([
+                decipher.update(zdbBuffer.subarray(startOffset + offset, startOffset + offset + len)),
+                decipher.final(),
+            ]));
+        }
+        return Buffer.concat(chunks);
+    }
+    throw new ZaloApiError.ZaloApiError("Invalid AES key or buffer is not in ZDB4.0 format");
+}
 
 exports.ParamsEncryptor = ParamsEncryptor;
 exports.apiFactory = apiFactory;
@@ -762,9 +909,13 @@ exports.decodeBase64ToBuffer = decodeBase64ToBuffer;
 exports.decodeEventData = decodeEventData;
 exports.decodeUnit8Array = decodeUnit8Array;
 exports.decryptResp = decryptResp;
+exports.decryptWithPrivateKey = decryptWithPrivateKey;
+exports.decryptZdbBuffer = decryptZdbBuffer;
+exports.deriveZdbAesKey = deriveZdbAesKey;
 exports.encodeAES = encodeAES;
 exports.encryptPin = encryptPin;
 exports.formatTime = formatTime;
+exports.generateRSAKeyPair = generateRSAKeyPair;
 exports.generateZaloUUID = generateZaloUUID;
 exports.getBrowserLanguage = getBrowserLanguage;
 exports.getChromeVersionFromUA = getChromeVersionFromUA;
@@ -791,4 +942,5 @@ exports.normalizeHolderName = normalizeHolderName;
 exports.removeUndefinedKeys = removeUndefinedKeys;
 exports.request = request;
 exports.resolveResponse = resolveResponse;
+exports.rsaDecryptPkcs1Manual = rsaDecryptPkcs1Manual;
 exports.strPadLeft = strPadLeft;

package/dist/index.d.ts

@@ -12,6 +12,8 @@ export type { AddUnreadMarkResponse } from "./apis/addUnreadMark.js";
 export type { AddUserToGroupResponse } from "./apis/addUserToGroup.js";
 export type { BlockUserResponse } from "./apis/blockUser.js";
 export type { BlockViewFeedResponse } from "./apis/blockViewFeed.js";
+export type { CancelPullMobileParams, CancelPullMobileResponse } from "./apis/cancelPullMobile.js";
+export type { CancelVoiceCallOptions, CancelVoiceCallResponse } from "./apis/cancelVoiceCall.js";
 export type { ChangeAccountAvatarResponse } from "./apis/changeAccountAvatar.js";
 export type { ChangeFriendAliasResponse } from "./apis/changeFriendAlias.js";
 export type { ChangeGroupAvatarResponse } from "./apis/changeGroupAvatar.js";
@@ -40,6 +42,7 @@ export type { DisperseGroupResponse } from "./apis/disperseGroup.js";
 export type { EditNoteOptions, EditNoteResponse } from "./apis/editNote.js";
 export type { EditReminderGroup, EditReminderUser, EditReminderOptions, EditReminderResponse } from "./apis/editReminder.js";
 export type { EnableGroupLinkResponse } from "./apis/enableGroupLink.js";
+export type { EndVoiceCallOptions, EndVoiceCallResponse } from "./apis/endVoiceCall.js";
 export type { FetchAccountInfoResponse } from "./apis/fetchAccountInfo.js";
 export type { FindUserResponse } from "./apis/findUser.js";
 export type { FindUserByUsernameResponse } from "./apis/findUserByUsername.js";
@@ -77,6 +80,7 @@ export type { GetListDeviceResponse } from "./apis/getListDevice.js";
 export type { GetListReminderResponse, ListReminderOptions, ReminderListGroup, ReminderListUser } from "./apis/getListReminder.js";
 export type { GetMultiUsersByPhonesResponse } from "./apis/getMultiUsersByPhones.js";
 export type { GetMuteResponse, MuteEntriesInfo } from "./apis/getMute.js";
+export type { GetNoisedIdsParams, GetNoisedIdsResponse } from "./apis/getNoisedIds.js";
 export type { GetPendingGroupMembersResponse, GetPendingGroupMembersUserInfo } from "./apis/getPendingGroupMembers.js";
 export type { GetPinConversationsResponse } from "./apis/getPinConversations.js";
 export type { PollDetailResponse } from "./apis/getPollDetail.js";
@@ -90,6 +94,7 @@ export type { GetSentFriendRequestResponse, SentFriendRequestInfo } from "./apis
 export type { GetSettingsResponse } from "./apis/getSettings.js";
 export type { GetStickerCategoryDetailResponse } from "./apis/getStickerCategoryDetail.js";
 export type { StickerDetailResponse } from "./apis/getStickersDetail.js";
+export type { GetSyncDataParams } from "./apis/getSyncData.js";
 export type { GetUnreadMarkResponse, UnreadMark } from "./apis/getUnreadMark.js";
 export type { ProfileInfo, UserInfoResponse } from "./apis/getUserInfo.js";
 export type { InviteUserToGroupsResponse } from "./apis/inviteUserToGroups.js";
@@ -102,6 +107,8 @@ export type { LockPollResponse } from "./apis/lockPoll.js";
 export type { LoginQRCallback, LoginQRCallbackEvent } from "./apis/loginQR.js";
 export type { LostFocusResponse } from "./apis/lostFocus.js";
 export type { ParseLinkErrorMaps, ParseLinkResponse } from "./apis/parseLink.js";
+export type { PreloadConversationsRawResponse, PreloadConversationsResponse } from "./apis/preloadConversations.js";
+export type { PullMobileParams, PullMobileResponse } from "./apis/pullMobile.js";
 export type { RegisterCatalogResponse } from "./apis/registerCatalog.js";
 export type { RejectFriendRequestResponse } from "./apis/rejectFriendRequest.js";
 export type { RemoveFriendResponse } from "./apis/removeFriend.js";
@@ -112,7 +119,7 @@ export type { RemoveQuickMessageResponse } from "./apis/removeQuickMessage.js";
 export type { RemoveReminderResponse } from "./apis/removeReminder.js";
 export type { RemoveUnreadMarkResponse } from "./apis/removeUnreadMark.js";
 export type { RemoveUserFromGroupResponse } from "./apis/removeUserFromGroup.js";
-export type { RequestSyncFromPhoneResponse } from "./apis/requestSyncFromPhone.js";
+export type { RequestSyncFromPhoneOptions, RequestSyncFromPhoneResponse } from "./apis/requestSyncFromPhone.js";
 export type { ResetHiddenConversPinResponse } from "./apis/resetHiddenConversPin.js";
 export type { ReuseAvatarResponse } from "./apis/reuseAvatar.js";
 export type { ReviewPendingMemberRequestPayload, ReviewPendingMemberRequestResponse } from "./apis/reviewPendingMemberRequest.js";
@@ -130,6 +137,7 @@ export type { SendStickerResponse, SendStickerPayload } from "./apis/sendSticker
 export type { SendTypingEventResponse } from "./apis/sendTypingEvent.js";
 export type { SendVideoOptions, SendVideoResponse } from "./apis/sendVideo.js";
 export type { SendVoiceOptions, SendVoiceResponse } from "./apis/sendVoice.js";
+export type { RequestCallServerInfo, SendVoiceCallOptions, SendVoiceCallResponse } from "./apis/sendVoiceCall.js";
 export type { SetHiddenConversationsResponse } from "./apis/setHiddenConversations.js";
 export type { SetMuteParams, SetMuteResponse } from "./apis/setMute.js";
 export type { SetPinnedConversationsResponse } from "./apis/setPinnedConversations.js";
@@ -167,3 +175,5 @@ export { MuteAction, MuteDuration } from "./apis/setMute.js";
 export { ChatTTL } from "./apis/updateAutoDeleteChat.js";
 export { UpdateLangAvailableLanguages } from "./apis/updateLang.js";
 export { UpdateSettingsType } from "./apis/updateSettings.js";
+export { CallType } from "./apis/sendVoiceCall.js";
+export { generateRSAKeyPair, decryptWithPrivateKey, deriveZdbAesKey, decryptZdbBuffer } from "./utils.js";

package/dist/index.js

@@ -12,3 +12,5 @@ export { MuteAction, MuteDuration } from "./apis/setMute.js";
 export { ChatTTL } from "./apis/updateAutoDeleteChat.js";
 export { UpdateLangAvailableLanguages } from "./apis/updateLang.js";
 export { UpdateSettingsType } from "./apis/updateSettings.js";
+export { CallType } from "./apis/sendVoiceCall.js";
+export { generateRSAKeyPair, decryptWithPrivateKey, deriveZdbAesKey, decryptZdbBuffer } from "./utils.js";

package/dist/models/CallEvent.d.ts

@@ -0,0 +1,30 @@
+export declare enum CallEventType {
+    REQUEST = "request",
+    ANSWER = "answer",
+    CANCEL = "cancel",
+    END = "end",
+    RINGRING = "ringring",
+    GROUP_REQUEST = "group_request",
+    GROUP_ANSWER = "group_answer",
+    UNKNOWN = "unknown"
+}
+export type TCallEventData = {
+    callId?: number;
+    call_id?: number;
+    uidN?: string | number;
+    callerId?: string | number;
+    calleeId?: string | number;
+    session?: string;
+    sessId?: string;
+    status?: number;
+    callType?: number;
+    ts?: number | string;
+    [key: string]: unknown;
+};
+export type CallEvent = {
+    type: CallEventType;
+    act: string;
+    act_type: string;
+    data: TCallEventData;
+};
+export declare function initializeCallEvent(data: TCallEventData, act: string, act_type: string): CallEvent;

package/dist/models/CallEvent.js

@@ -0,0 +1,47 @@
+export var CallEventType;
+(function (CallEventType) {
+    CallEventType["REQUEST"] = "request";
+    CallEventType["ANSWER"] = "answer";
+    CallEventType["CANCEL"] = "cancel";
+    CallEventType["END"] = "end";
+    CallEventType["RINGRING"] = "ringring";
+    CallEventType["GROUP_REQUEST"] = "group_request";
+    CallEventType["GROUP_ANSWER"] = "group_answer";
+    CallEventType["UNKNOWN"] = "unknown";
+})(CallEventType || (CallEventType = {}));
+export function initializeCallEvent(data, act, act_type) {
+    let type = CallEventType.UNKNOWN;
+    switch (act) {
+        case "request":
+            type = CallEventType.REQUEST;
+            break;
+        case "answer":
+            type = CallEventType.ANSWER;
+            break;
+        case "cancel":
+            type = CallEventType.CANCEL;
+            break;
+        case "end":
+        case "endcall":
+            type = CallEventType.END;
+            break;
+        case "ringring":
+            type = CallEventType.RINGRING;
+            break;
+        case "group_request":
+            type = CallEventType.GROUP_REQUEST;
+            break;
+        case "group_answer":
+            type = CallEventType.GROUP_ANSWER;
+            break;
+        default:
+            type = CallEventType.UNKNOWN;
+            break;
+    }
+    return {
+        type,
+        act,
+        act_type,
+        data,
+    };
+}

package/dist/models/ClearUnread.d.ts

@@ -0,0 +1,22 @@
+import { ThreadType } from "./Enum.js";
+export type TClearUnreadItem = {
+    idTo: string;
+    userName?: string;
+    lastMsgId: string;
+    isGroup: number;
+    ts?: number;
+    type?: number;
+};
+export type TClearUnreads = {
+    clearUnreads: TClearUnreadItem[];
+};
+export declare class ClearUnread {
+    idTo: string;
+    userName?: string;
+    lastMsgId: string;
+    isGroup: boolean;
+    threadType: ThreadType;
+    ts?: number;
+    type?: number;
+    constructor(data: TClearUnreadItem);
+}

package/dist/models/ClearUnread.js

@@ -0,0 +1,12 @@
+import { ThreadType } from "./Enum.js";
+export class ClearUnread {
+    constructor(data) {
+        this.idTo = data.idTo;
+        this.userName = data.userName;
+        this.lastMsgId = data.lastMsgId;
+        this.isGroup = data.isGroup === 1;
+        this.threadType = data.isGroup === 1 ? ThreadType.Group : ThreadType.User;
+        this.ts = data.ts;
+        this.type = data.type;
+    }
+}

package/dist/models/SyncData.d.ts

@@ -0,0 +1,35 @@
+export type SyncData = {
+    file_path: string;
+    encrypted_key: string;
+    metadata: {
+        file_name: string;
+        file_size: number;
+        checksum_code: string;
+        from_seq_id: number;
+        is_full_transfer: number;
+    };
+};
+export type SyncDataStream = {
+    stream: ReadableStream<Uint8Array> | null;
+    metadata: {
+        file_name: string;
+        file_size: number;
+        checksum_code: string;
+        from_seq_id: number;
+        is_full_transfer: number;
+        encrypted_key: string;
+    };
+    response?: {
+        status: number;
+        statusText: string;
+        url: string;
+        contentType: string | null;
+        contentLength: string | null;
+    };
+};
+export type SyncDataResponse = {
+    success: boolean;
+    data?: SyncData;
+    stream?: SyncDataStream;
+    error?: string;
+};

package/dist/models/SyncData.js

@@ -0,0 +1 @@
+export {};

package/dist/models/SyncEvent.d.ts

@@ -0,0 +1,83 @@
+export declare enum SyncEventType {
+    USER_CONFIRM = "user_confirm",
+    SYNCMSG_INFO = "syncmsg_info",
+    TRANSFER_ERROR = "transfer_error",
+    TRANSFER_AFTER_LOGIN = "transfer_after_login",
+    UNKNOWN = "unknown"
+}
+export type DatabaseBackupInfo = {
+    backup_db?: {
+        msg_total: number;
+        msg_thread: number;
+    };
+    origin_db?: {
+        msg_total: number;
+        msg_thread: number;
+    };
+    db_format?: number;
+};
+export type TSyncEventUserConfirm = {
+    user_action: number;
+    public_key: string;
+    pc_name: string;
+};
+export type TSyncEventSyncMsgInfo = {
+    uid: number;
+    url: string;
+    time: number;
+    device_type: number;
+    device_name: string;
+    client_version: number;
+    file_name: string;
+    checksum_code: string;
+    checksum?: string;
+    file_size: number;
+    client_time: number;
+    from_seq_id: number;
+    public_key: string;
+    encrypted_key: string;
+    trigger_reason: number;
+    is_full_transfer: number;
+    db_info: string | DatabaseBackupInfo;
+};
+export type TSyncEventTransferError = {
+    public_key: string;
+    pc_name: string;
+    can_retry?: number;
+    status?: number;
+    error_msg?: string;
+    error_code?: number;
+};
+export type TSyncEventTransferAfterLogin = {
+    temp_key: string;
+    imei: string;
+    [key: string]: unknown;
+};
+export type TSyncEvent = TSyncEventUserConfirm | TSyncEventSyncMsgInfo | TSyncEventTransferError | TSyncEventTransferAfterLogin;
+export type SyncEvent = {
+    type: SyncEventType.USER_CONFIRM;
+    data: TSyncEventUserConfirm;
+    act: string;
+    act_type: string;
+} | {
+    type: SyncEventType.SYNCMSG_INFO;
+    data: TSyncEventSyncMsgInfo;
+    act: string;
+    act_type: string;
+} | {
+    type: SyncEventType.TRANSFER_ERROR;
+    data: TSyncEventTransferError;
+    act: string;
+    act_type: string;
+} | {
+    type: SyncEventType.TRANSFER_AFTER_LOGIN;
+    data: TSyncEventTransferAfterLogin;
+    act: string;
+    act_type: string;
+} | {
+    type: SyncEventType.UNKNOWN;
+    data: unknown;
+    act: string;
+    act_type: string;
+};
+export declare function initializeSyncEvent(data: TSyncEvent, act: string, act_type: string): SyncEvent;