@softtynet/zca-js 2.3.2 → 2.3.4

package/dist/cjs/apis/group/checkQuotaCommunityMember.cjs

@@ -0,0 +1,39 @@
+'use strict';
+
+var ZaloApiError = require('../../Errors/ZaloApiError.cjs');
+var utils = require('../../utils.cjs');
+
+const checkQuotaCommunityMemberFactory = utils.apiFactory()((api, ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.group[0]}/api/group/quota/members-comm`);
+    /**
+     * Kiểm tra điều kiện/hạn mức thành viên Cộng đồng đối với một thành viên cụ thể trong nhóm (command 12182)
+     *
+     * @param groupId ID của nhóm
+     * @param uid UID của thành viên cần kiểm tra
+     * @throws {ZaloApiError}
+     */
+    return async function checkQuotaCommunityMember(groupId, uid) {
+        if (!groupId) {
+            throw new ZaloApiError.ZaloApiError("Missing groupId");
+        }
+        if (!uid) {
+            throw new ZaloApiError.ZaloApiError("Missing uid");
+        }
+        const cleanGroupId = groupId.startsWith("g") ? groupId.slice(1) : groupId;
+        const params = {
+            language: ctx.language || "vi",
+            grId: cleanGroupId,
+            uid: String(uid),
+        };
+        const encryptedParams = utils.encodeAES(JSON.stringify(params));
+        if (!encryptedParams) {
+            throw new ZaloApiError.ZaloApiError("Failed to encrypt params");
+        }
+        const response = await utils.request(utils.makeURL(serviceURL, { params: encryptedParams }), {
+            method: "GET",
+        });
+        return utils.resolve(response);
+    };
+});
+
+exports.checkQuotaCommunityMemberFactory = checkQuotaCommunityMemberFactory;

package/dist/cjs/apis/group/getE2eeGroupList.cjs

@@ -0,0 +1,20 @@
+'use strict';
+
+var utils = require('../../utils.cjs');
+
+const getE2eeGroupListFactory = utils.apiFactory()((api, _ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.group[0]}/api/group/getlg/e2ee`);
+    /**
+     * Lấy danh sách các nhóm đang bật mã hóa đầu cuối E2EE (command 12146)
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function getE2eeGroupList() {
+        const response = await utils.request(serviceURL, {
+            method: "GET",
+        });
+        return utils.resolve(response);
+    };
+});
+
+exports.getE2eeGroupListFactory = getE2eeGroupListFactory;

package/dist/cjs/apis/group/getGroupChatHistory.cjs

@@ -15,66 +15,89 @@ require('../../models/Reminder.cjs');
 require('../../models/ZBusiness.cjs');
 require('../../models/SyncEvent.cjs');
 require('../../models/CallEvent.cjs');
+var wsCipher = require('../../crypto/ws-cipher.cjs');
 
 const getGroupChatHistoryFactory = utils.apiFactory()((api, ctx, utils) => {
-    const serviceURL = utils.makeURL(`${api.zpwServiceMap.group_cloud_message[0]}/api/cm/getrecentv2`);
+    const recentServiceURL = utils.makeURL(`${api.zpwServiceMap.group_cloud_message[0]}/api/cm/getrecentv2`);
+    const oldServiceURL = utils.makeURL(`${api.zpwServiceMap.group_cloud_message[0]}/api/cm/getoldv2`);
     /**
-     * Get group chat history from Zalo Cloud Message (newest first)
+     * Lấy lịch sử tin nhắn nhóm từ Zalo Cloud Message (hỗ trợ cả `/api/cm/getrecentv2` cmd 12506 và `/api/cm/getoldv2` cmd 12507)
      *
-     * @param groupId group id
-     * @param count count of messages to return (default: 50, max safe limit: 200)
+     * @param groupId ID nhóm
+     * @param countOrOptions Số lượng tin nhắn cần tải (mặc định: `50`) hoặc đối tượng cấu hình phân trang `GetGroupChatHistoryOptions`
      *
      * @throws {ZaloApiError}
      */
-    return async function getGroupChatHistory(groupId, count = 50) {
+    return async function getGroupChatHistory(groupId, countOrOptions = 50) {
         if (!groupId)
             throw new ZaloApiError.ZaloApiError("Missing groupId");
         if (groupId.startsWith("g"))
             groupId = groupId.slice(1);
-        const safeCount = Math.min(Math.max(count, 1), 200);
+        const options = typeof countOrOptions === "number" ? { count: countOrOptions } : countOrOptions || {};
+        const requestedCount = Math.max(options.count ?? 50, 1);
+        const maxPages = options.maxPages ?? Math.max(10, Math.ceil(requestedCount / 50) + 2);
+        const targetServiceURL = options.useOldEndpoint ? oldServiceURL : recentServiceURL;
+        const msgIds = options.msgIds ?? [];
+        const src = options.src ?? 3;
         const messages = [];
-        let cursor = 0;
+        const seenMsgIds = new Set();
+        let cursor = options.cursor ?? 0;
         let lastPage = null;
         let pageCount = 0;
-        while (messages.length < safeCount && pageCount < 10) {
+        while (messages.length < requestedCount && pageCount < maxPages) {
             pageCount++;
             const params = {
                 groupId,
                 globalMsgId: cursor,
-                count: Math.min(50, safeCount - messages.length),
-                msgIds: [],
+                count: Math.min(50, requestedCount - messages.length),
+                msgIds,
                 imei: ctx.imei,
-                src: 3,
+                src,
             };
+            if (options.isOA) {
+                params.isOA = 1;
+            }
             const encryptedParams = utils.encodeAES(JSON.stringify(params));
             if (!encryptedParams)
                 throw new ZaloApiError.ZaloApiError("Failed to encrypt params");
-            const response = await utils.request(utils.makeURL(serviceURL, { params: encryptedParams, nretry: 0 }), {
+            const response = await utils.request(utils.makeURL(targetServiceURL, { params: encryptedParams, nretry: 0 }), {
                 method: "GET",
             });
             lastPage = await utils.resolve(response, (result) => {
                 let data = result.data;
                 if (typeof data === "string") {
-                    data = JSON.parse(data);
+                    data = JSON.parse(wsCipher.preParseJsonIds(data));
                 }
                 return data;
             });
             if (!lastPage || !Array.isArray(lastPage.groupMsgs))
                 break;
             for (const rawMsg of lastPage.groupMsgs) {
-                if (messages.length >= safeCount)
+                if (messages.length >= requestedCount)
                     break;
-                if (messages.some((m) => m.msgId === rawMsg.msgId))
+                const msgIdKey = String(rawMsg.msgId ?? rawMsg.cliMsgId ?? "");
+                if (msgIdKey && seenMsgIds.has(msgIdKey))
                     continue;
+                if (msgIdKey)
+                    seenMsgIds.add(msgIdKey);
                 messages.push(rawMsg);
             }
-            const nextCursor = Number(lastPage.lastMsgId);
-            if (!lastPage.hasMore || !nextCursor || nextCursor === cursor)
+            const nextCursor = lastPage.lastMsgId;
+            if (!lastPage.hasMore ||
+                nextCursor === undefined ||
+                nextCursor === null ||
+                nextCursor === "" ||
+                nextCursor === 0 ||
+                String(nextCursor) === String(cursor)) {
                 break;
+            }
             cursor = nextCursor;
         }
         const groupMsgs = messages.map((data) => new Message.GroupMessage(ctx.uid, data));
-        return Object.assign({}, lastPage || {}, { groupMsgs });
+        return Object.assign({}, lastPage || {}, {
+            groupMsgs,
+            nextCursor: lastPage?.lastMsgId,
+        });
     };
 });
 

package/dist/cjs/apis/group/getGroupCloudMessagePath.cjs

@@ -0,0 +1,69 @@
+'use strict';
+
+var ZaloApiError = require('../../Errors/ZaloApiError.cjs');
+require('../../models/AutoReply.cjs');
+require('../../models/Bank.cjs');
+require('../../models/Board.cjs');
+require('../../models/Enum.cjs');
+require('../../models/FriendEvent.cjs');
+require('../../models/Group.cjs');
+require('../../models/GroupEvent.cjs');
+var Message = require('../../models/Message.cjs');
+require('../../models/Reaction.cjs');
+require('../../models/Reminder.cjs');
+require('../../models/ZBusiness.cjs');
+require('../../models/SyncEvent.cjs');
+require('../../models/CallEvent.cjs');
+var utils = require('../../utils.cjs');
+var wsCipher = require('../../crypto/ws-cipher.cjs');
+
+const getGroupCloudMessagePathFactory = utils.apiFactory()((api, ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.group_cloud_message[0]}/api/cm/getpath`);
+    /**
+     * Lấy chuỗi tin nhắn nhóm theo đường dẫn nhảy tới một tin nhắn cụ thể (`globalMsgId` / `rGlobalMsgId`) qua `/api/cm/getpath` (command 12504)
+     *
+     * @param options Cấu hình truy vấn đường dẫn tin nhắn nhóm
+     * @throws {ZaloApiError}
+     */
+    return async function getGroupCloudMessagePath(options) {
+        if (!options?.groupId) {
+            throw new ZaloApiError.ZaloApiError("Missing groupId");
+        }
+        const cleanGroupId = options.groupId.startsWith("g") ? options.groupId.slice(1) : options.groupId;
+        const params = {
+            groupId: cleanGroupId,
+            globalMsgId: options.globalMsgId,
+            count: options.count ?? 50,
+            reverse: typeof options.reverse === "boolean" ? (options.reverse ? 1 : 0) : (options.reverse ?? 0),
+        };
+        if (options.rGlobalMsgId !== undefined && options.rOwnerId) {
+            params.rGlobalMsgId = options.rGlobalMsgId;
+            params.rOwnerId = options.rOwnerId;
+            if (options.rClientMsgId !== undefined) {
+                params.rClientMsgId = options.rClientMsgId;
+            }
+        }
+        const encryptedParams = utils.encodeAES(JSON.stringify(params));
+        if (!encryptedParams) {
+            throw new ZaloApiError.ZaloApiError("Failed to encrypt params");
+        }
+        const response = await utils.request(utils.makeURL(serviceURL, { params: encryptedParams, nretry: 0 }), {
+            method: "GET",
+        });
+        return utils.resolve(response, (result) => {
+            let data = result.data;
+            if (typeof data === "string") {
+                data = JSON.parse(wsCipher.preParseJsonIds(data));
+            }
+            const rawObj = (data && typeof data === "object" ? data : {});
+            const rawMsgs = Array.isArray(rawObj.groupMsgs) ? rawObj.groupMsgs : [];
+            const groupMsgs = rawMsgs.map((m) => new Message.GroupMessage(ctx.uid, m));
+            return {
+                ...rawObj,
+                groupMsgs,
+            };
+        });
+    };
+});
+
+exports.getGroupCloudMessagePathFactory = getGroupCloudMessagePathFactory;

package/dist/cjs/apis/group/getGroupHistoryLegacy.cjs

@@ -0,0 +1,80 @@
+'use strict';
+
+var ZaloApiError = require('../../Errors/ZaloApiError.cjs');
+require('../../models/AutoReply.cjs');
+require('../../models/Bank.cjs');
+require('../../models/Board.cjs');
+require('../../models/Enum.cjs');
+require('../../models/FriendEvent.cjs');
+require('../../models/Group.cjs');
+require('../../models/GroupEvent.cjs');
+var Message = require('../../models/Message.cjs');
+require('../../models/Reaction.cjs');
+require('../../models/Reminder.cjs');
+require('../../models/ZBusiness.cjs');
+require('../../models/SyncEvent.cjs');
+require('../../models/CallEvent.cjs');
+var utils = require('../../utils.cjs');
+var wsCipher = require('../../crypto/ws-cipher.cjs');
+
+const getGroupHistoryLegacyFactory = utils.apiFactory()((api, ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.group[0]}/api/group/history`);
+    /**
+     * Lấy lịch sử tin nhắn nhóm qua endpoint `/api/group/history` trên miền `group` (command 11240)
+     *
+     * @param groupId ID của nhóm
+     * @param count Số lượng tin nhắn cần tải (mặc định: `20`)
+     * @throws {ZaloApiError}
+     */
+    return async function getGroupHistoryLegacy(groupId, count = 20) {
+        if (!groupId) {
+            throw new ZaloApiError.ZaloApiError("Missing groupId");
+        }
+        const cleanGroupId = groupId.startsWith("g") ? groupId.slice(1) : groupId;
+        const params = {
+            grid: cleanGroupId,
+            count,
+        };
+        const encryptedParams = utils.encodeAES(JSON.stringify(params));
+        if (!encryptedParams) {
+            throw new ZaloApiError.ZaloApiError("Failed to encrypt params");
+        }
+        const response = await utils.request(utils.makeURL(serviceURL, { params: encryptedParams }), {
+            method: "GET",
+        });
+        return utils.resolve(response, (result) => {
+            let data = result.data;
+            if (typeof data === "string") {
+                try {
+                    data = JSON.parse(wsCipher.preParseJsonIds(data));
+                }
+                catch {
+                    data = {};
+                }
+            }
+            if (Array.isArray(data)) {
+                const groupMsgs = data.map((m) => new Message.GroupMessage(ctx.uid, m));
+                return { groupMsgs };
+            }
+            if (data && typeof data === "object") {
+                const obj = data;
+                const rawList = Array.isArray(obj.groupMsgs)
+                    ? obj.groupMsgs
+                    : Array.isArray(obj.msgs)
+                        ? obj.msgs
+                        : null;
+                if (rawList) {
+                    const groupMsgs = rawList.map((m) => new Message.GroupMessage(ctx.uid, m));
+                    return {
+                        ...obj,
+                        groupMsgs,
+                    };
+                }
+                return obj;
+            }
+            return { groupMsgs: [] };
+        });
+    };
+});
+
+exports.getGroupHistoryLegacyFactory = getGroupHistoryLegacyFactory;

package/dist/cjs/apis/group/getGroupInfoV2.cjs

@@ -0,0 +1,53 @@
+'use strict';
+
+var ZaloApiError = require('../../Errors/ZaloApiError.cjs');
+var utils = require('../../utils.cjs');
+
+const getGroupInfoV2Factory = utils.apiFactory()((api, ctx, utils) => {
+    const v2ServiceURL = utils.makeURL(`${api.zpwServiceMap.group[0]}/api/group/getgi/v2`);
+    const v1ServiceURL = utils.makeURL(`${api.zpwServiceMap.group[0]}/api/group/getgi`);
+    /**
+     * Lấy thông tin nhóm và danh sách thành viên theo trang qua `/api/group/getgi/v2` hoặc `/api/group/getgi` (command 11162)
+     *
+     * @param groupId ID của nhóm
+     * @param pageOrOptions Số trang `mpage` (mặc định: `1`) hoặc cấu hình `GetGroupInfoV2Options`
+     * @throws {ZaloApiError}
+     */
+    return async function getGroupInfoV2(groupId, pageOrOptions = 1) {
+        if (!groupId) {
+            throw new ZaloApiError.ZaloApiError("Missing groupId");
+        }
+        const cleanGroupId = groupId.startsWith("g") ? groupId.slice(1) : groupId;
+        const options = typeof pageOrOptions === "number" ? { mpage: pageOrOptions } : pageOrOptions || {};
+        const mpage = options.mpage ?? 1;
+        const mcount = options.mcount ?? 100;
+        const avatarSize = options.avatarSize ?? 120;
+        const memberAvatarSize = options.memberAvatarSize ?? 120;
+        const useV1 = Boolean(options.useV1Endpoint);
+        const targetURL = useV1 ? v1ServiceURL : v2ServiceURL;
+        const params = useV1
+            ? {
+                grid: cleanGroupId,
+                avatar_size: avatarSize,
+                member_avatar_size: memberAvatarSize,
+            }
+            : {
+                grid: cleanGroupId,
+                avatar_size: avatarSize,
+                member_avatar_size: memberAvatarSize,
+                mpage,
+                mcount,
+                imei: ctx.imei,
+            };
+        const encryptedParams = utils.encodeAES(JSON.stringify(params));
+        if (!encryptedParams) {
+            throw new ZaloApiError.ZaloApiError("Failed to encrypt params");
+        }
+        const response = await utils.request(utils.makeURL(targetURL, { params: encryptedParams }), {
+            method: "GET",
+        });
+        return utils.resolve(response);
+    };
+});
+
+exports.getGroupInfoV2Factory = getGroupInfoV2Factory;

package/dist/cjs/apis/group/getGroupListV3.cjs

@@ -0,0 +1,34 @@
+'use strict';
+
+var ZaloApiError = require('../../Errors/ZaloApiError.cjs');
+var utils = require('../../utils.cjs');
+
+const getGroupListV3Factory = utils.apiFactory()((api, ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.group[0]}/api/group/getlg/v3`);
+    /**
+     * Lấy danh sách nhóm theo trang kèm thông tin thành viên đại diện (`currentMems`) và gợi ý nhóm (`suggestGroup`) qua `/api/group/getlg/v3` (command 11161)
+     *
+     * @param pageOrOptions Số trang (mặc định: `1`) hoặc cấu hình `GetGroupListV3Options`
+     * @throws {ZaloApiError}
+     */
+    return async function getGroupListV3(pageOrOptions = 1) {
+        const options = typeof pageOrOptions === "number" ? { page: pageOrOptions } : pageOrOptions || {};
+        const params = {
+            page: options.page ?? 1,
+            count: options.count ?? 100,
+            avatar_size: 120,
+            member_avatar_size: 120,
+            imei: ctx.imei,
+        };
+        const encryptedParams = utils.encodeAES(JSON.stringify(params));
+        if (!encryptedParams) {
+            throw new ZaloApiError.ZaloApiError("Failed to encrypt params");
+        }
+        const response = await utils.request(utils.makeURL(serviceURL, { params: encryptedParams }), {
+            method: "GET",
+        });
+        return utils.resolve(response);
+    };
+});
+
+exports.getGroupListV3Factory = getGroupListV3Factory;

package/dist/cjs/apis/group/getGroupMessageStatus.cjs

@@ -0,0 +1,83 @@
+'use strict';
+
+var ZaloApiError = require('../../Errors/ZaloApiError.cjs');
+var utils = require('../../utils.cjs');
+var wsCipher = require('../../crypto/ws-cipher.cjs');
+
+const getGroupMessageStatusFactory = utils.apiFactory()((api, _ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.group[0]}/api/group/getStatusMsg`);
+    /**
+     * Truy vấn trạng thái Đã nhận (`deliver`) và Đã xem (`seen`) tin nhắn của danh sách thành viên trong nhóm (command 12017)
+     *
+     * @param groupIdOrItems ID nhóm (hoặc mảng cấu hình `{ tId, ids }`)
+     * @param memberIds Danh sách UID thành viên cần kiểm tra (khi tham số đầu là `groupId`)
+     * @throws {ZaloApiError}
+     */
+    return async function getGroupMessageStatus(groupIdOrItems, memberIds = []) {
+        let queryData;
+        if (Array.isArray(groupIdOrItems)) {
+            queryData = groupIdOrItems.map((item) => ({
+                tId: item.tId.startsWith("g") ? item.tId.slice(1) : item.tId,
+                ids: item.ids.map(String),
+            }));
+        }
+        else {
+            if (!groupIdOrItems) {
+                throw new ZaloApiError.ZaloApiError("Missing groupId");
+            }
+            const cleanGroupId = groupIdOrItems.startsWith("g") ? groupIdOrItems.slice(1) : groupIdOrItems;
+            queryData = [
+                {
+                    tId: cleanGroupId,
+                    ids: memberIds.map(String),
+                },
+            ];
+        }
+        const params = {
+            param: JSON.stringify({
+                data: queryData,
+            }),
+        };
+        const encryptedParams = utils.encodeAES(JSON.stringify(params));
+        if (!encryptedParams) {
+            throw new ZaloApiError.ZaloApiError("Failed to encrypt params");
+        }
+        const response = await utils.request(serviceURL, {
+            method: "POST",
+            body: new URLSearchParams({
+                params: encryptedParams,
+            }),
+        });
+        return utils.resolve(response, (result) => {
+            let rawData = result.data;
+            if (typeof rawData === "string" && rawData.length > 0) {
+                try {
+                    const parsed = JSON.parse(wsCipher.preParseJsonIds(rawData));
+                    if (parsed && typeof parsed === "object" && "data" in parsed && parsed.data) {
+                        rawData = parsed.data;
+                    }
+                    else {
+                        rawData = parsed;
+                    }
+                }
+                catch {
+                    // Giữ nguyên nếu không phải chuỗi JSON lồng
+                }
+            }
+            if (rawData && typeof rawData === "object") {
+                const obj = rawData;
+                if (Array.isArray(obj.statusInfos)) {
+                    return obj;
+                }
+                if (obj.data && typeof obj.data === "object" && Array.isArray(obj.data.statusInfos)) {
+                    return obj.data;
+                }
+            }
+            return {
+                statusInfos: Array.isArray(rawData) ? rawData : [],
+            };
+        });
+    };
+});
+
+exports.getGroupMessageStatusFactory = getGroupMessageStatusFactory;

package/dist/cjs/apis/group/getMultiGroupCloudMessages.cjs

@@ -0,0 +1,34 @@
+'use strict';
+
+var ZaloApiError = require('../../Errors/ZaloApiError.cjs');
+var utils = require('../../utils.cjs');
+
+const getMultiGroupCloudMessagesFactory = utils.apiFactory()((api, _ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.group_cloud_message[0]}/api/cm/mget`);
+    /**
+     * Đồng bộ nhanh tin nhắn Cloud của nhiều nhóm cùng lúc theo danh sách `groupIds` (command 12503 - `syncCloudMsgFirstLogin`)
+     *
+     * @param groupIds Danh sách ID nhóm cần tải tin nhắn Cloud
+     * @param nretry Số lần thử lại (mặc định: `0`)
+     * @throws {ZaloApiError}
+     */
+    return async function getMultiGroupCloudMessages(groupIds, nretry = 0) {
+        if (!Array.isArray(groupIds) || groupIds.length === 0) {
+            throw new ZaloApiError.ZaloApiError("Missing groupIds");
+        }
+        const cleanGroupIds = groupIds.map((gid) => (gid.startsWith("g") ? gid.slice(1) : gid));
+        const params = {
+            groupIds: cleanGroupIds,
+        };
+        const encryptedParams = utils.encodeAES(JSON.stringify(params));
+        if (!encryptedParams) {
+            throw new ZaloApiError.ZaloApiError("Failed to encrypt params");
+        }
+        const response = await utils.request(utils.makeURL(serviceURL, { params: encryptedParams, nretry }), {
+            method: "GET",
+        });
+        return utils.resolve(response);
+    };
+});
+
+exports.getMultiGroupCloudMessagesFactory = getMultiGroupCloudMessagesFactory;

package/dist/cjs/apis/media/getPersonalMedia.cjs

@@ -0,0 +1,36 @@
+'use strict';
+
+var ZaloApiError = require('../../Errors/ZaloApiError.cjs');
+var utils = require('../../utils.cjs');
+
+const getPersonalMediaFactory = utils.apiFactory()((api, _ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.media_store_send2me[0]}/api/media/oneone/list`);
+    /**
+     * Lấy danh sách Kho Lưu Trữ Ảnh/Video (`"media"`), File (`"file"`), hoặc Link (`"link"`) trong Cloud của tôi (Send2Me) (command 12220)
+     *
+     * @param options Tùy chọn truy vấn (`mediaType`, `limit`, `lastId`, `lastFetchId`)
+     * @throws {ZaloApiError}
+     */
+    return async function getPersonalMedia(options = {}) {
+        const params = {
+            media_type: options.mediaType ?? "media",
+            limit: options.limit ?? 20,
+        };
+        if (options.lastId !== undefined) {
+            params.last_id = options.lastId;
+        }
+        if (options.lastFetchId !== undefined && !Number.isNaN(options.lastFetchId)) {
+            params.lastFetchId = options.lastFetchId;
+        }
+        const encryptedParams = utils.encodeAES(JSON.stringify(params));
+        if (!encryptedParams) {
+            throw new ZaloApiError.ZaloApiError("Failed to encrypt params");
+        }
+        const response = await utils.request(utils.makeURL(serviceURL, { params: encryptedParams }), {
+            method: "GET",
+        });
+        return utils.resolve(response);
+    };
+});
+
+exports.getPersonalMediaFactory = getPersonalMediaFactory;

package/dist/cjs/apis/media/getPersonalMediaPreview.cjs

@@ -0,0 +1,29 @@
+'use strict';
+
+var ZaloApiError = require('../../Errors/ZaloApiError.cjs');
+var utils = require('../../utils.cjs');
+
+const getPersonalMediaPreviewFactory = utils.apiFactory()((api, _ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.media_store_send2me[0]}/api/media/oneone/preview`);
+    /**
+     * Lấy danh sách xem trước nhanh Kho Lưu Trữ trong Cloud của tôi (Send2Me) (command 12221)
+     *
+     * @param limit Số lượng mục tối đa (mặc định: `50`)
+     * @throws {ZaloApiError}
+     */
+    return async function getPersonalMediaPreview(limit = 50) {
+        const params = {
+            limit,
+        };
+        const encryptedParams = utils.encodeAES(JSON.stringify(params));
+        if (!encryptedParams) {
+            throw new ZaloApiError.ZaloApiError("Failed to encrypt params");
+        }
+        const response = await utils.request(utils.makeURL(serviceURL, { params: encryptedParams }), {
+            method: "POST",
+        });
+        return utils.resolve(response);
+    };
+});
+
+exports.getPersonalMediaPreviewFactory = getPersonalMediaPreviewFactory;

package/dist/cjs/apis/media/removePersonalMedia.cjs

@@ -0,0 +1,33 @@
+'use strict';
+
+var ZaloApiError = require('../../Errors/ZaloApiError.cjs');
+var utils = require('../../utils.cjs');
+
+const removePersonalMediaFactory = utils.apiFactory()((api, _ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.media_store_send2me[0]}/api/media/oneone/remove`);
+    /**
+     * Xóa mục lưu trữ trong Kho Lưu Trữ Cloud của tôi (Send2Me) (command 12222)
+     *
+     * @param options Thông tin mục cần xóa (`mediaType`, `mediaId`)
+     * @throws {ZaloApiError}
+     */
+    return async function removePersonalMedia(options) {
+        if (!options?.mediaType || options.mediaId === undefined) {
+            throw new ZaloApiError.ZaloApiError("Missing mediaType or mediaId");
+        }
+        const params = {
+            media_type: options.mediaType,
+            media_id: options.mediaId,
+        };
+        const encryptedParams = utils.encodeAES(JSON.stringify(params));
+        if (!encryptedParams) {
+            throw new ZaloApiError.ZaloApiError("Failed to encrypt params");
+        }
+        const response = await utils.request(utils.makeURL(serviceURL, { params: encryptedParams }), {
+            method: "POST",
+        });
+        return utils.resolve(response);
+    };
+});
+
+exports.removePersonalMediaFactory = removePersonalMediaFactory;