@softtynet/zca-js 2.2.9 → 2.2.10

package/dist/cjs/apis/friend/getBlockFriends.cjs

@@ -0,0 +1,33 @@
+'use strict';
+
+var ZaloApiError = require('../../Errors/ZaloApiError.cjs');
+var utils = require('../../utils.cjs');
+
+const getBlockFriendsFactory = utils.apiFactory()((api, _ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.friend[0]}/api/friend/blocklistv2`);
+    /**
+     * Lấy danh sách người dùng đang bị chặn chuẩn V2 (command 11429)
+     *
+     * @param page Trang cần lấy (mặc định: 1)
+     * @param count Số lượng mỗi trang (mặc định: 50)
+     * @param avatarSize Kích thước ảnh đại diện (mặc định: 120)
+     * @throws {ZaloApiError}
+     */
+    return async function getBlockFriends(page = 1, count = 50, avatarSize = 120) {
+        const params = {
+            page,
+            count,
+            avatar: avatarSize,
+        };
+        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.getBlockFriendsFactory = getBlockFriendsFactory;

package/dist/cjs/apis/friend/getCloseFriends.cjs

@@ -0,0 +1,25 @@
+'use strict';
+
+var ZaloApiError = require('../../Errors/ZaloApiError.cjs');
+var utils = require('../../utils.cjs');
+
+const getCloseFriendsFactory = utils.apiFactory()((api, _ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.profile[0]}/api/social/friend/getclosedfriends`);
+    /**
+     * Get close friends
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function getCloseFriends() {
+        const params = {};
+        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.getCloseFriendsFactory = getCloseFriendsFactory;

package/dist/cjs/apis/friend/getExtraFriendInfo.cjs

@@ -0,0 +1,36 @@
+'use strict';
+
+var ZaloApiError = require('../../Errors/ZaloApiError.cjs');
+var utils = require('../../utils.cjs');
+
+const getExtraFriendInfoFactory = utils.apiFactory()((api, ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.friend[0]}/api/friend/context/multiget`);
+    /**
+     * Lấy ngữ cảnh và vai trò mở rộng (ví dụ `role: ["boss"]`) của danh sách bạn bè (command 11442)
+     *
+     * @param friendIds Mảng UID cần truy vấn
+     * @throws {ZaloApiError}
+     */
+    return async function getExtraFriendInfo(friendIds) {
+        if (!Array.isArray(friendIds) || friendIds.length === 0) {
+            return {};
+        }
+        const params = {
+            fids: friendIds,
+            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(serviceURL, {
+            method: "POST",
+            body: new URLSearchParams({
+                params: encryptedParams,
+            }),
+        });
+        return utils.resolve(response);
+    };
+});
+
+exports.getExtraFriendInfoFactory = getExtraFriendInfoFactory;

package/dist/cjs/apis/friend/getFriendBoardList.cjs

@@ -0,0 +1,31 @@
+'use strict';
+
+var ZaloApiError = require('../../Errors/ZaloApiError.cjs');
+var utils = require('../../utils.cjs');
+
+const getFriendBoardListFactory = utils.apiFactory()((api, ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.friend_board[0]}/api/friendboard/list`);
+    /**
+     * Get friend board list
+     *
+     * @param conversationId conversation id
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function getFriendBoardList(conversationId) {
+        const params = {
+            conversationId: conversationId,
+            version: 0,
+            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.getFriendBoardListFactory = getFriendBoardListFactory;

package/dist/cjs/apis/friend/getFriendOnlines.cjs

@@ -0,0 +1,40 @@
+'use strict';
+
+var ZaloApiError = require('../../Errors/ZaloApiError.cjs');
+var utils = require('../../utils.cjs');
+
+const getFriendOnlinesFactory = utils.apiFactory()((api, ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.profile[0]}/api/social/friend/onlines`);
+    /**
+     * Get friend onlines?
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function getFriendOnlines() {
+        const params = {
+            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, (result) => {
+            const data = result.data;
+            if (Array.isArray(data.onlines)) {
+                for (const online of data.onlines) {
+                    if (typeof online.status === "string") {
+                        const parsed = JSON.parse(online.status);
+                        if (parsed && typeof parsed.status === "string") {
+                            online.status = parsed.status;
+                        }
+                    }
+                }
+            }
+            return data;
+        });
+    };
+});
+
+exports.getFriendOnlinesFactory = getFriendOnlinesFactory;

package/dist/cjs/apis/friend/getFriendRecommendations.cjs

@@ -0,0 +1,32 @@
+'use strict';
+
+var ZaloApiError = require('../../Errors/ZaloApiError.cjs');
+var utils = require('../../utils.cjs');
+
+exports.FriendRecommendationsType = void 0;
+(function (FriendRecommendationsType) {
+    FriendRecommendationsType[FriendRecommendationsType["RecommendedFriend"] = 1] = "RecommendedFriend";
+    FriendRecommendationsType[FriendRecommendationsType["ReceivedFriendRequest"] = 2] = "ReceivedFriendRequest";
+})(exports.FriendRecommendationsType || (exports.FriendRecommendationsType = {}));
+const getFriendRecommendationsFactory = utils.apiFactory()((api, ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.friend[0]}/api/friend/recommendsv2/list`);
+    /**
+     * Get friend recommendations/received friend requests
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function getFriendRecommendations() {
+        const params = {
+            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.getFriendRecommendationsFactory = getFriendRecommendationsFactory;

package/dist/cjs/apis/friend/getFriendRequestStatus.cjs

@@ -0,0 +1,30 @@
+'use strict';
+
+var ZaloApiError = require('../../Errors/ZaloApiError.cjs');
+var utils = require('../../utils.cjs');
+
+const getFriendRequestStatusFactory = utils.apiFactory()((api, ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.friend[0]}/api/friend/reqstatus`);
+    /**
+     * Get friend request status
+     *
+     * @param friendId friend id
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function getFriendRequestStatus(friendId) {
+        const params = {
+            fid: friendId,
+            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.getFriendRequestStatusFactory = getFriendRequestStatusFactory;

package/dist/cjs/apis/friend/getFriendsEmojiStatus.cjs

@@ -0,0 +1,34 @@
+'use strict';
+
+var ZaloApiError = require('../../Errors/ZaloApiError.cjs');
+var utils = require('../../utils.cjs');
+var domains = require('../../constants/domains.cjs');
+
+const getFriendsEmojiStatusFactory = utils.apiFactory()((api, _ctx, utils) => {
+    const baseDomain = api.zpwServiceMap.emoji_stt?.[0] || domains.ZALO_DOMAINS.EMOJI_STATUS_FALLBACK;
+    const serviceURL = utils.makeURL(`${baseDomain}/api/v1/emoji-status/friends`);
+    /**
+     * Lấy danh sách trạng thái Emoji (Emoji Status) hiện tại của bạn bè (command 16301)
+     *
+     * @param options Tùy chọn phân trang (`version`, `fromUid`, `maxEmojiStatusId`, `page`)
+     * @throws {ZaloApiError}
+     */
+    return async function getFriendsEmojiStatus(options = {}) {
+        const params = {
+            version: options.version ?? 0,
+            fromUid: options.fromUid ?? "0",
+            maxEmojiStatusId: String(options.maxEmojiStatusId ?? "0"),
+            page: options.page ?? 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 }), {
+            method: "GET",
+        });
+        return utils.resolve(response);
+    };
+});
+
+exports.getFriendsEmojiStatusFactory = getFriendsEmojiStatusFactory;

package/dist/cjs/apis/friend/getLastReadContactTab.cjs

@@ -0,0 +1,20 @@
+'use strict';
+
+var utils = require('../../utils.cjs');
+
+const getLastReadContactTabFactory = utils.apiFactory()((api, _ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.friend[0]}/api/friend/last-read-contact-tab`);
+    /**
+     * Lấy dấu thời gian lần cuối đọc tab Danh bạ (command 12230)
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function getLastReadContactTab() {
+        const response = await utils.request(serviceURL, {
+            method: "GET",
+        });
+        return utils.resolve(response);
+    };
+});
+
+exports.getLastReadContactTabFactory = getLastReadContactTabFactory;

package/dist/cjs/apis/friend/getMultiUsersByPhones.cjs

@@ -0,0 +1,55 @@
+'use strict';
+
+var ZaloApiError = require('../../Errors/ZaloApiError.cjs');
+var utils = require('../../utils.cjs');
+require('../../models/AutoReply.cjs');
+require('../../models/Bank.cjs');
+require('../../models/Board.cjs');
+var Enum = require('../../models/Enum.cjs');
+require('../../models/FriendEvent.cjs');
+require('../../models/Group.cjs');
+require('../../models/GroupEvent.cjs');
+require('../../models/Reaction.cjs');
+require('../../models/Reminder.cjs');
+require('../../models/ZBusiness.cjs');
+require('../../models/SyncEvent.cjs');
+require('../../models/CallEvent.cjs');
+
+const getMultiUsersByPhonesFactory = utils.apiFactory()((api, ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.friend[0]}/api/friend/profile/multiget`);
+    /**
+     * Get multiple user(s) by their phone numbers.
+     *
+     * @param phoneNumbers Phone number(s)
+     * @param avatarSize Avatar size (default: AvatarSize.Large)
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function getMultiUsersByPhones(phoneNumbers, avatarSize = Enum.AvatarSize.Large) {
+        if (!phoneNumbers)
+            throw new ZaloApiError.ZaloApiError("Missing phoneNumbers");
+        if (!Array.isArray(phoneNumbers))
+            phoneNumbers = [phoneNumbers];
+        phoneNumbers = phoneNumbers.map((phone) => {
+            if (phone.startsWith("0")) {
+                if (ctx.language == "vi")
+                    phone = "84" + phone.slice(1);
+            }
+            return phone;
+        });
+        const params = {
+            phones: phoneNumbers,
+            avatar_size: avatarSize,
+            language: ctx.language,
+        };
+        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.getMultiUsersByPhonesFactory = getMultiUsersByPhonesFactory;

package/dist/cjs/apis/friend/getPhonebookV2.cjs

@@ -0,0 +1,26 @@
+'use strict';
+
+var ZaloApiError = require('../../Errors/ZaloApiError.cjs');
+var utils = require('../../utils.cjs');
+
+const getPhonebookV2Factory = utils.apiFactory()((api, _ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.profile[0]}/api/social/friend/phonebook/v2`);
+    /**
+     * Lấy danh bạ bạn bè đồng bộ từ số điện thoại chuẩn V2 (command 12428)
+     *
+     * @param phonebookVersion Phiên bản danh bạ (mặc định: 0 để lấy toàn bộ)
+     * @throws {ZaloApiError}
+     */
+    return async function getPhonebookV2(phonebookVersion = 0) {
+        const encryptedParams = utils.encodeAES(JSON.stringify({ phonebook_version: phonebookVersion }));
+        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.getPhonebookV2Factory = getPhonebookV2Factory;

package/dist/cjs/apis/friend/getSentFriendRequest.cjs

@@ -0,0 +1,29 @@
+'use strict';
+
+var ZaloApiError = require('../../Errors/ZaloApiError.cjs');
+var utils = require('../../utils.cjs');
+
+const getSentFriendRequestFactory = utils.apiFactory()((api, ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.friend[0]}/api/friend/requested/list`);
+    /**
+     * Get friend requested
+     *
+     * @note Zalo might throw an error with code 112 if you have no friend requests.
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function getSentFriendRequest() {
+        const params = {
+            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.getSentFriendRequestFactory = getSentFriendRequestFactory;

package/dist/cjs/apis/friend/lastOnline.cjs

@@ -0,0 +1,31 @@
+'use strict';
+
+var ZaloApiError = require('../../Errors/ZaloApiError.cjs');
+var utils = require('../../utils.cjs');
+
+const lastOnlineFactory = utils.apiFactory()((api, ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.profile[0]}/api/social/profile/lastOnline`);
+    /**
+     * Get last online
+     *
+     * @param uid User ID
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function lastOnline(uid) {
+        const params = {
+            uid: uid,
+            conv_type: 1,
+            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.lastOnlineFactory = lastOnlineFactory;

package/dist/cjs/apis/friend/readContactTab.cjs

@@ -0,0 +1,31 @@
+'use strict';
+
+var ZaloApiError = require('../../Errors/ZaloApiError.cjs');
+var utils = require('../../utils.cjs');
+
+const readContactTabFactory = utils.apiFactory()((api, _ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.friend[0]}/api/friend/read-contact-tab`);
+    /**
+     * Đánh dấu đã đọc tab Danh bạ (command 12231)
+     *
+     * @param ts Dấu thời gian (mặc định: `Date.now()`)
+     * @throws {ZaloApiError}
+     */
+    return async function readContactTab(ts = Date.now()) {
+        const params = {
+            ts,
+        };
+        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);
+    };
+});
+
+exports.readContactTabFactory = readContactTabFactory;

package/dist/cjs/apis/friend/rejectFriendRequest.cjs

@@ -0,0 +1,32 @@
+'use strict';
+
+var ZaloApiError = require('../../Errors/ZaloApiError.cjs');
+var utils = require('../../utils.cjs');
+
+const rejectFriendRequestFactory = utils.apiFactory()((api, _ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.friend[0]}/api/friend/reject`);
+    /**
+     * Reject a friend request from a User
+     *
+     * @param friendId
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function rejectFriendRequest(friendId) {
+        const params = {
+            fid: friendId,
+        };
+        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);
+    };
+});
+
+exports.rejectFriendRequestFactory = rejectFriendRequestFactory;

package/dist/cjs/apis/friend/removeFriend.cjs

@@ -0,0 +1,33 @@
+'use strict';
+
+var ZaloApiError = require('../../Errors/ZaloApiError.cjs');
+var utils = require('../../utils.cjs');
+
+const removeFriendFactory = utils.apiFactory()((api, ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.friend[0]}/api/friend/remove`);
+    /**
+     * Remove friend
+     *
+     * @param friendId - ID of the friend to remove
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function removeFriend(friendId) {
+        const params = {
+            fid: friendId,
+            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(serviceURL, {
+            method: "POST",
+            body: new URLSearchParams({
+                params: encryptedParams,
+            }),
+        });
+        return utils.resolve(response);
+    };
+});
+
+exports.removeFriendFactory = removeFriendFactory;

package/dist/cjs/apis/friend/removeFriendAlias.cjs

@@ -0,0 +1,29 @@
+'use strict';
+
+var ZaloApiError = require('../../Errors/ZaloApiError.cjs');
+var utils = require('../../utils.cjs');
+
+const removeFriendAliasFactory = utils.apiFactory()((api, _ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.alias[0]}/api/alias/remove`);
+    /**
+     * Remove friend's alias
+     *
+     * @param friendId friend id
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function removeFriendAlias(friendId) {
+        const params = {
+            friendId: friendId,
+        };
+        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.removeFriendAliasFactory = removeFriendAliasFactory;

package/dist/cjs/apis/friend/sendFriendRequest.cjs

@@ -0,0 +1,44 @@
+'use strict';
+
+var ZaloApiError = require('../../Errors/ZaloApiError.cjs');
+var utils = require('../../utils.cjs');
+
+const sendFriendRequestFactory = utils.apiFactory()((api, ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.friend[0]}/api/friend/sendreq`);
+    /**
+     * Send a friend request to a user.
+     *
+     * @param msg message sent with friend request
+     * @param userId User ID to send friend request to
+     *
+     * @note Zalo might throw an error with code 225 if the user is already friends with you,
+     *          215 if the user might have blocked you,
+     *          222 if user has already sent you a friend request, your request will be treated as acceptance instead.
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function sendFriendRequest(msg, userId) {
+        const params = {
+            toid: userId,
+            msg: msg,
+            reqsrc: 30,
+            imei: ctx.imei,
+            language: ctx.language,
+            srcParams: JSON.stringify({
+                uidTo: userId,
+            }),
+        };
+        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);
+    };
+});
+
+exports.sendFriendRequestFactory = sendFriendRequestFactory;

package/dist/cjs/apis/friend/unblockUser.cjs

@@ -0,0 +1,33 @@
+'use strict';
+
+var ZaloApiError = require('../../Errors/ZaloApiError.cjs');
+var utils = require('../../utils.cjs');
+
+const unblockUserFactory = utils.apiFactory()((api, ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.friend[0]}/api/friend/unblock`);
+    /**
+     * Unblock a User
+     *
+     * @param userId The ID of the User to unblock
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function unblockUser(userId) {
+        const params = {
+            fid: userId,
+            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(serviceURL, {
+            method: "POST",
+            body: new URLSearchParams({
+                params: encryptedParams,
+            }),
+        });
+        return utils.resolve(response);
+    };
+});
+
+exports.unblockUserFactory = unblockUserFactory;