@ohos-ports/zca-js 2.2.0-beta.1

package/dist/cjs/apis/removeReminder.cjs

@@ -0,0 +1,54 @@
+'use strict';
+
+var ZaloApiError = require('../Errors/ZaloApiError.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');
+var utils = require('../utils.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,64 @@
+'use strict';
+
+var ZaloApiError = require('../Errors/ZaloApiError.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');
+var utils = require('../utils.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

@@ -0,0 +1,43 @@
+'use strict';
+
+var ZaloApiError = require('../Errors/ZaloApiError.cjs');
+var utils = require('../utils.cjs');
+
+exports.ReviewPendingMemberRequestStatus = void 0;
+(function (ReviewPendingMemberRequestStatus) {
+    ReviewPendingMemberRequestStatus[ReviewPendingMemberRequestStatus["SUCCESS"] = 0] = "SUCCESS";
+    ReviewPendingMemberRequestStatus[ReviewPendingMemberRequestStatus["NOT_IN_PENDING_LIST"] = 170] = "NOT_IN_PENDING_LIST";
+    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/scanURL.cjs

@@ -0,0 +1,33 @@
+'use strict';
+
+var ZaloApiError = require('../Errors/ZaloApiError.cjs');
+var utils = require('../utils.cjs');
+
+const scanURLFactory = utils.apiFactory()((api, _ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.file[0]}/api/message/scanurl`);
+    /**
+     * Scan URL to check if it is safe?
+     *
+     * @param url URL to scan
+     *
+     * @throws {ZaloApiError} When something went wrong, with `error.code`
+     * - `114` - Invalid params
+     */
+    return async function scanURL(url) {
+        const params = {
+            url: url,
+        };
+        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.scanURLFactory = scanURLFactory;

package/dist/cjs/apis/searchSticker.cjs

@@ -0,0 +1,33 @@
+'use strict';
+
+var ZaloApiError = require('../Errors/ZaloApiError.cjs');
+var utils = require('../utils.cjs');
+
+const searchStickerFactory = utils.apiFactory()((api, ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.sticker[0]}/api/message/sticker/search`);
+    /**
+     * Search stickers
+     *
+     * @param keyword Keyword to search stickers
+     * @param limit Limit of stickers to return (default: 50)
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function searchSticker(keyword, limit = 50) {
+        const params = {
+            keyword: keyword,
+            limit: limit,
+            srcType: 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.searchStickerFactory = searchStickerFactory;

package/dist/cjs/apis/sendBankCard.cjs

@@ -0,0 +1,51 @@
+'use strict';
+
+var ZaloApiError = require('../Errors/ZaloApiError.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');
+var utils = require('../utils.cjs');
+
+const sendBankCardFactory = utils.apiFactory()((api, _, 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,73 @@
+'use strict';
+
+var ZaloApiError = require('../Errors/ZaloApiError.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');
+var utils = require('../utils.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,69 @@
+'use strict';
+
+var ZaloApiError = require('../Errors/ZaloApiError.cjs');
+var context = require('../context.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');
+var utils = require('../utils.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;

package/dist/cjs/apis/sendLink.cjs

@@ -0,0 +1,75 @@
+'use strict';
+
+var ZaloApiError = require('../Errors/ZaloApiError.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');
+var utils = require('../utils.cjs');
+
+const sendLinkFactory = utils.apiFactory()((api, ctx, utils) => {
+    const serviceURL = {
+        [Enum.ThreadType.User]: utils.makeURL(`${api.zpwServiceMap.chat[0]}/api/message/link`, {
+            nretry: 0,
+        }),
+        [Enum.ThreadType.Group]: utils.makeURL(`${api.zpwServiceMap.group[0]}/api/group/sendlink`, {
+            nretry: 0,
+        }),
+    };
+    /**
+     * Send link
+     *
+     * @param options Link and ttl
+     * @param threadId Thread ID
+     * @param type Thread type
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function sendLink(options, threadId, type = Enum.ThreadType.User) {
+        var _a;
+        const res = await api.parseLink(options.link);
+        const params = {
+            msg: options.msg && options.msg.trim()
+                ? options.msg.includes(options.link)
+                    ? options.msg
+                    : options.msg + " " + options.link
+                : options.link,
+            href: res.data.href,
+            src: res.data.src,
+            title: res.data.title,
+            desc: res.data.desc,
+            thumb: res.data.thumb,
+            type: 2, // 0
+            media: JSON.stringify(res.data.media),
+            ttl: (_a = options.ttl) !== null && _a !== void 0 ? _a : 0,
+            clientId: Date.now(),
+        };
+        if (type == Enum.ThreadType.Group) {
+            params.grid = threadId;
+            params.imei = ctx.imei;
+            // params.mentionInfo = "[]"; @TODO: implement this
+        }
+        else {
+            params.toId = threadId;
+            params.mentionInfo = "";
+        }
+        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.sendLinkFactory = sendLinkFactory;