zalo-toolkit 1.0.0 → 1.0.2

package/dist/cjs/apis/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/removeGroupBlockedMember.cjs

@@ -0,0 +1,33 @@
+'use strict';
+
+var ZaloApiError = require('../Errors/ZaloApiError.cjs');
+var utils = require('../utils.cjs');
+
+const removeGroupBlockedMemberFactory = utils.apiFactory()((api, _, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.group[0]}/api/group/blockedmems/remove`);
+    /**
+     * Remove group blocked member
+     *
+     * @param memberId member id(s)
+     * @param groupId group id
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function removeGroupBlockedMember(memberId, groupId) {
+        if (!Array.isArray(memberId))
+            memberId = [memberId];
+        const params = {
+            grid: groupId,
+            members: memberId,
+        };
+        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.removeGroupBlockedMemberFactory = removeGroupBlockedMemberFactory;

package/dist/cjs/apis/removeGroupDeputy.cjs

@@ -0,0 +1,35 @@
+'use strict';
+
+var ZaloApiError = require('../Errors/ZaloApiError.cjs');
+var utils = require('../utils.cjs');
+
+const removeGroupDeputyFactory = utils.apiFactory()((api, ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.group[0]}/api/group/admins/remove`);
+    /**
+     * Remove group deputy
+     *
+     * @param memberId user Id or list of user Ids
+     * @param groupId group Id
+     *
+     * @throws {ZaloApiError}
+     *
+     */
+    return async function removeGroupDeputy(memberId, groupId) {
+        if (!Array.isArray(memberId))
+            memberId = [memberId];
+        const params = {
+            grid: groupId,
+            members: memberId,
+            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.removeGroupDeputyFactory = removeGroupDeputyFactory;

package/dist/cjs/apis/removeQuickMessage.cjs

@@ -0,0 +1,32 @@
+'use strict';
+
+var ZaloApiError = require('../Errors/ZaloApiError.cjs');
+var utils = require('../utils.cjs');
+
+const removeQuickMessageFactory = utils.apiFactory()((api, _ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.quick_message[0]}/api/quickmessage/delete`);
+    /**
+     * Remove quick message
+     *
+     * @param itemIds - The id(s) of the quick message(s) to remove (number or number[])
+     *
+     * @note Zalo might throw an error with code 212 if the item does not exist
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function removeQuickMessage(itemIds) {
+        const idsArray = Array.isArray(itemIds) ? itemIds : [itemIds];
+        const params = {
+            itemIds: idsArray,
+        };
+        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.removeQuickMessageFactory = removeQuickMessageFactory;

package/dist/cjs/apis/removeReminder.cjs

@@ -0,0 +1,53 @@
+'use strict';
+
+var ZaloApiError = require('../Errors/ZaloApiError.cjs');
+require('../models/AutoReply.cjs');
+require('../models/Board.cjs');
+var Enum = require('../models/Enum.cjs');
+require('../models/FriendEvent.cjs');
+require('../models/Group.cjs');
+require('../models/GroupEvent.cjs');
+var utils = require('../utils.cjs');
+require('../models/Reaction.cjs');
+require('../models/Reminder.cjs');
+require('../models/ZBusiness.cjs');
+
+const removeReminderFactory = utils.apiFactory()((api, ctx, utils) => {
+    const serviceURL = {
+        [Enum.ThreadType.User]: utils.makeURL(`${api.zpwServiceMap.group_board[0]}/api/board/oneone/remove`),
+        [Enum.ThreadType.Group]: utils.makeURL(`${api.zpwServiceMap.group_board[0]}/api/board/topic/remove`),
+    };
+    /**
+     * Remove a reminder in a (user/group)
+     *
+     * @param reminderId Reminder ID to remove reminder from
+     * @param threadId (User/Group) ID to remove reminder from
+     * @param type Thread type (User or Group)
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function removeReminder(reminderId, threadId, type = Enum.ThreadType.User) {
+        const params = type === Enum.ThreadType.User
+            ? {
+                uid: threadId,
+                reminderId: reminderId,
+            }
+            : {
+                grid: threadId,
+                topicId: reminderId,
+                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[type], {
+            method: 'POST',
+            body: new URLSearchParams({
+                params: encryptedParams,
+            }),
+        });
+        return utils.resolve(response);
+    };
+});
+
+exports.removeReminderFactory = removeReminderFactory;

package/dist/cjs/apis/removeUnreadMark.cjs

@@ -0,0 +1,63 @@
+'use strict';
+
+var ZaloApiError = require('../Errors/ZaloApiError.cjs');
+require('../models/AutoReply.cjs');
+require('../models/Board.cjs');
+var Enum = require('../models/Enum.cjs');
+require('../models/FriendEvent.cjs');
+require('../models/Group.cjs');
+require('../models/GroupEvent.cjs');
+var utils = require('../utils.cjs');
+require('../models/Reaction.cjs');
+require('../models/Reminder.cjs');
+require('../models/ZBusiness.cjs');
+
+const removeUnreadMarkFactory = utils.apiFactory()((api, ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.conversation[0]}/api/conv/removeUnreadMark`);
+    /**
+     * Remove unread mark from conversation
+     *
+     * @param threadId Thread ID
+     * @param type Thread type (User/Group)
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function removeUnreadMark(threadId, type = Enum.ThreadType.User) {
+        const timestamp = Date.now();
+        const isGroup = type === Enum.ThreadType.Group;
+        const requestParams = {
+            param: JSON.stringify({
+                [isGroup ? 'convsGroup' : 'convsUser']: [threadId],
+                [isGroup ? 'convsUser' : 'convsGroup']: [],
+                [isGroup ? 'convsGroupData' : 'convsUserData']: [
+                    {
+                        id: threadId,
+                        ts: timestamp,
+                    },
+                ],
+                [isGroup ? 'convsUserData' : 'convsGroupData']: [],
+            }),
+        };
+        const encryptedParams = utils.encodeAES(JSON.stringify(requestParams));
+        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) => {
+            const data = result.data;
+            if (typeof data.data === 'string') {
+                return {
+                    data: JSON.parse(data.data),
+                    status: data.status,
+                };
+            }
+            return result.data;
+        });
+    };
+});
+
+exports.removeUnreadMarkFactory = removeUnreadMarkFactory;

package/dist/cjs/apis/removeUserFromGroup.cjs

@@ -0,0 +1,39 @@
+'use strict';
+
+var ZaloApiError = require('../Errors/ZaloApiError.cjs');
+var utils = require('../utils.cjs');
+
+const removeUserFromGroupFactory = utils.apiFactory()((api, ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.group[0]}/api/group/kickout`);
+    /**
+     * Remove user from existing group
+     *
+     * @param memberId User ID or list of user IDs to remove
+     * @param groupId Group ID
+     *
+     * @note Zalo might throw an error with code 165 if the user is not in the group, 166 if you don't have enough permissions or is not in the group
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function removeUserFromGroup(memberId, groupId) {
+        if (!Array.isArray(memberId))
+            memberId = [memberId];
+        const params = {
+            grid: groupId,
+            members: memberId,
+            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.removeUserFromGroupFactory = removeUserFromGroupFactory;

package/dist/cjs/apis/resetHiddenConversPin.cjs

@@ -0,0 +1,25 @@
+'use strict';
+
+var ZaloApiError = require('../Errors/ZaloApiError.cjs');
+var utils = require('../utils.cjs');
+
+const resetHiddenConversPinFactory = utils.apiFactory()((api, _ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.conversation[0]}/api/hiddenconvers/reset`);
+    /**
+     * Reset hidden conversation pin
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function resetHiddenConversPin() {
+        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.resetHiddenConversPinFactory = resetHiddenConversPinFactory;

package/dist/cjs/apis/reuseAvatar.cjs

@@ -0,0 +1,31 @@
+'use strict';
+
+var ZaloApiError = require('../Errors/ZaloApiError.cjs');
+var utils = require('../utils.cjs');
+
+const reuseAvatarFactory = utils.apiFactory()((api, ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.profile[0]}/api/social/reuse-avatar`);
+    /**
+     * Reuse avatar
+     *
+     * @param photoId photo id from getAvatarList api
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function reuseAvatar(photoId) {
+        const params = {
+            photoId: photoId,
+            isPostSocial: 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.reuseAvatarFactory = reuseAvatarFactory;

package/dist/cjs/apis/reviewPendingMemberRequest.cjs

@@ -1,16 +1,7 @@
 'use strict';
 
-require('crypto-js');
-require('json-bigint');
-require('node:crypto');
-require('node:fs');
-require('node:path');
-require('pako');
-require('spark-md5');
-require('tough-cookie');
-require('sharp');
-require('../models/FriendEvent.cjs');
-require('../models/GroupEvent.cjs');
+var ZaloApiError = require('../Errors/ZaloApiError.cjs');
+var utils = require('../utils.cjs');
 
 exports.ReviewPendingMemberRequestStatus = void 0;
 (function (ReviewPendingMemberRequestStatus) {
@@ -19,3 +10,34 @@ exports.ReviewPendingMemberRequestStatus = void 0;
     ReviewPendingMemberRequestStatus[ReviewPendingMemberRequestStatus["ALREADY_IN_GROUP"] = 178] = "ALREADY_IN_GROUP";
     ReviewPendingMemberRequestStatus[ReviewPendingMemberRequestStatus["INSUFFICIENT_PERMISSION"] = 166] = "INSUFFICIENT_PERMISSION";
 })(exports.ReviewPendingMemberRequestStatus || (exports.ReviewPendingMemberRequestStatus = {}));
+const reviewPendingMemberRequestFactory = utils.apiFactory()((api, _, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.group[0]}/api/group/pending-mems/review`);
+    /**
+     * Review pending member(s) request
+     *
+     * @param payload - The payload containing data to review the pending member(s) request
+     * @param groupId - The id of the group to review the pending member(s) request
+     *
+     * @note Only the group leader and deputy group leader can review
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function reviewPendingMemberRequest(payload, groupId) {
+        if (!Array.isArray(payload.members))
+            payload.members = [payload.members];
+        const params = {
+            grid: groupId,
+            members: payload.members,
+            isApprove: payload.isApprove ? 1 : 0, // 1: approve, 0: reject
+        };
+        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.reviewPendingMemberRequestFactory = reviewPendingMemberRequestFactory;

package/dist/cjs/apis/sendBankCard.cjs

@@ -0,0 +1,50 @@
+'use strict';
+
+var ZaloApiError = require('../Errors/ZaloApiError.cjs');
+require('../models/AutoReply.cjs');
+require('../models/Board.cjs');
+var Enum = require('../models/Enum.cjs');
+require('../models/FriendEvent.cjs');
+require('../models/Group.cjs');
+require('../models/GroupEvent.cjs');
+var utils = require('../utils.cjs');
+require('../models/Reaction.cjs');
+require('../models/Reminder.cjs');
+require('../models/ZBusiness.cjs');
+
+const sendBankCardFactory = utils.apiFactory()((api, ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.zimsg[0]}/api/transfer/card`);
+    /**
+     * Send bank card
+     *
+     * @param payload The payload containing the bank card information
+     * @param threadId The ID of the thread to send the bank card to
+     * @param type The type of thread to send the bank card to
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function sendBankCard(payload, threadId, type = Enum.ThreadType.User) {
+        var _a;
+        const params = {
+            binBank: payload.binBank,
+            numAccBank: payload.numAccBank,
+            nameAccBank: ((_a = payload.nameAccBank) === null || _a === void 0 ? void 0 : _a.toUpperCase()) || '---',
+            cliMsgId: Date.now().toString(),
+            tsMsg: Date.now(),
+            destUid: threadId,
+            destType: type === Enum.ThreadType.Group ? 1 : 0,
+        };
+        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.sendBankCardFactory = sendBankCardFactory;

package/dist/cjs/apis/sendCard.cjs

@@ -0,0 +1,72 @@
+'use strict';
+
+var ZaloApiError = require('../Errors/ZaloApiError.cjs');
+require('../models/AutoReply.cjs');
+require('../models/Board.cjs');
+var Enum = require('../models/Enum.cjs');
+require('../models/FriendEvent.cjs');
+require('../models/Group.cjs');
+require('../models/GroupEvent.cjs');
+var utils = require('../utils.cjs');
+require('../models/Reaction.cjs');
+require('../models/Reminder.cjs');
+require('../models/ZBusiness.cjs');
+
+const sendCardFactory = utils.apiFactory()((api, ctx, utils) => {
+    const serviceURL = {
+        [Enum.ThreadType.User]: utils.makeURL(`${api.zpwServiceMap.file[0]}/api/message/forward`),
+        [Enum.ThreadType.Group]: utils.makeURL(`${api.zpwServiceMap.file[0]}/api/group/forward`),
+    };
+    /**
+     * Send a card to a User - Group
+     *
+     * @param userId Unique ID for Card
+     * @param phoneNumber Optional phone number for sending card to a User
+     * @param ttl Time to live in milliseconds (default: 0)
+     * @param threadId ID of the conversation
+     * @param type Message type (User or GroupMessage)
+     *
+     * @throws {ZaloApiError}
+     *
+     */
+    return async function sendCard(options, threadId, type = Enum.ThreadType.User) {
+        var _a;
+        const data = await api.getQR(options.userId);
+        const QRCodeURL = data[options.userId];
+        const clientId = Date.now().toString();
+        const params = {
+            ttl: (_a = options.ttl) !== null && _a !== void 0 ? _a : 0,
+            msgType: 6,
+            clientId: clientId,
+            msgInfo: {
+                contactUid: options.userId,
+                qrCodeUrl: QRCodeURL,
+            },
+        };
+        if (options.phoneNumber) {
+            params.msgInfo.phone = options.phoneNumber;
+        }
+        if (type == Enum.ThreadType.Group) {
+            params.visibility = 0;
+            params.grid = threadId;
+        }
+        else {
+            params.toId = threadId;
+            params.imei = ctx.imei;
+        }
+        const msgInfoStringified = JSON.stringify(params.msgInfo);
+        params.msgInfo = msgInfoStringified;
+        const encryptedParams = utils.encodeAES(JSON.stringify(params));
+        if (!encryptedParams)
+            throw new ZaloApiError.ZaloApiError('Failed to encrypt params');
+        const response = await utils.request(serviceURL[type], {
+            method: 'POST',
+            body: new URLSearchParams({
+                params: encryptedParams,
+            }),
+        });
+        return utils.resolve(response);
+    };
+});
+
+exports.sendCardFactory = sendCardFactory;

package/dist/cjs/apis/sendDeliveredEvent.cjs

@@ -0,0 +1,68 @@
+'use strict';
+
+var ZaloApiError = require('../Errors/ZaloApiError.cjs');
+var context = require('../context.cjs');
+require('../models/AutoReply.cjs');
+require('../models/Board.cjs');
+var Enum = require('../models/Enum.cjs');
+require('../models/FriendEvent.cjs');
+require('../models/Group.cjs');
+require('../models/GroupEvent.cjs');
+var utils = require('../utils.cjs');
+require('../models/Reaction.cjs');
+require('../models/Reminder.cjs');
+require('../models/ZBusiness.cjs');
+
+const sendDeliveredEventFactory = utils.apiFactory()((api, ctx, utils) => {
+    const serviceURL = {
+        [Enum.ThreadType.User]: utils.makeURL(`${api.zpwServiceMap.chat[0]}/api/message/deliveredv2`),
+        [Enum.ThreadType.Group]: utils.makeURL(`${api.zpwServiceMap.group[0]}/api/group/deliveredv2`),
+    };
+    /**
+     * Send message delivered event
+     *
+     * @param isSeen Whether the message is seen or not
+     * @param messages List of messages to send delivered event
+     * @param type Messages type (User or Group), defaults to User
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function sendDeliveredEvent(isSeen, messages, type = Enum.ThreadType.User) {
+        if (!messages)
+            throw new ZaloApiError.ZaloApiError('messages are missing or not in a valid array format.');
+        if (!Array.isArray(messages))
+            messages = [messages];
+        if (messages.length === 0 || messages.length > context.MAX_MESSAGES_PER_SEND)
+            throw new ZaloApiError.ZaloApiError('messages must contain between 1 and 50 messages.');
+        // 27/02/2025
+        // This can send messages from multiple groups, but to prevent potential issues,
+        // we will restrict it to sending messages only within the same group.
+        const idTo = messages[0].idTo;
+        if (type === Enum.ThreadType.Group && !messages.every((msg) => msg.idTo === idTo))
+            throw new ZaloApiError.ZaloApiError('All messages must have the same idTo for Group thread');
+        const msgInfos = Object.assign({ seen: isSeen ? 1 : 0, data: messages.map((msg) => ({
+                cmi: msg.cliMsgId,
+                gmi: msg.msgId,
+                si: msg.uidFrom,
+                di: msg.idTo === ctx.uid ? '0' : msg.idTo,
+                mt: msg.msgType,
+                st: msg.st || 0 === msg.st ? 0 : -1,
+                at: msg.at || 0 === msg.at ? 0 : -1,
+                cmd: msg.cmd || 0 === msg.cmd ? 0 : -1,
+                ts: parseInt(`${msg.ts}`) || 0 === parseInt(`${msg.ts}`) ? 0 : -1,
+            })) }, (type === Enum.ThreadType.User ? {} : { grid: idTo }));
+        const params = Object.assign({ msgInfos: JSON.stringify(msgInfos) }, (type === Enum.ThreadType.User ? {} : { 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[type], {
+            method: 'POST',
+            body: new URLSearchParams({
+                params: encryptedParams,
+            }),
+        });
+        return utils.resolve(response);
+    };
+});
+
+exports.sendDeliveredEventFactory = sendDeliveredEventFactory;

package/dist/cjs/apis/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;