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

package/dist/cjs/apis/getGroupInviteBoxList.cjs

@@ -0,0 +1,36 @@
+'use strict';
+
+var ZaloApiError = require('../Errors/ZaloApiError.cjs');
+var utils = require('../utils.cjs');
+
+const getGroupInviteBoxListFactory = utils.apiFactory()((api, _, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.group[0]}/api/group/inv-box/list`);
+    /**
+     * Get group invite box list
+     *
+     * @param payload - The payload of the request
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function getGroupInviteBoxList(payload) {
+        var _a, _b, _c, _d;
+        const params = {
+            mpage: (_a = payload === null || payload === void 0 ? void 0 : payload.mpage) !== null && _a !== void 0 ? _a : 1,
+            page: (_b = payload === null || payload === void 0 ? void 0 : payload.page) !== null && _b !== void 0 ? _b : 0,
+            invPerPage: (_c = payload === null || payload === void 0 ? void 0 : payload.invPerPage) !== null && _c !== void 0 ? _c : 12,
+            mcount: (_d = payload === null || payload === void 0 ? void 0 : payload.mcount) !== null && _d !== void 0 ? _d : 10,
+            lastGroupId: null, // @TODO: check type
+            avatar_size: 120,
+            member_avatar_size: 120,
+        };
+        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.getGroupInviteBoxListFactory = getGroupInviteBoxListFactory;

package/dist/cjs/apis/getGroupLinkDetail.cjs

@@ -0,0 +1,30 @@
+'use strict';
+
+var ZaloApiError = require('../Errors/ZaloApiError.cjs');
+var utils = require('../utils.cjs');
+
+const getGroupLinkDetailFactory = utils.apiFactory()((api, ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.group[0]}/api/group/link/detail`);
+    /**
+     * Get group link detail
+     *
+     * @param groupId The group id
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function getGroupLinkDetail(groupId) {
+        const params = {
+            grid: groupId,
+            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.getGroupLinkDetailFactory = getGroupLinkDetailFactory;

package/dist/cjs/apis/getGroupLinkInfo.cjs

@@ -0,0 +1,33 @@
+'use strict';
+
+var ZaloApiError = require('../Errors/ZaloApiError.cjs');
+var utils = require('../utils.cjs');
+
+const getGroupLinkInfoFactory = utils.apiFactory()((api, _ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.group[0]}/api/group/link/ginfo`);
+    /**
+     * Get group link info
+     *
+     * @param payload - The payload of the request
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function getGroupLinkInfo(payload) {
+        var _a;
+        const params = {
+            link: payload.link,
+            avatar_size: 120,
+            member_avatar_size: 120,
+            mpage: (_a = payload.memberPage) !== null && _a !== void 0 ? _a : 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.getGroupLinkInfoFactory = getGroupLinkInfoFactory;

package/dist/cjs/apis/getGroupMembersInfo.cjs

@@ -0,0 +1,29 @@
+'use strict';
+
+var ZaloApiError = require('../Errors/ZaloApiError.cjs');
+var utils = require('../utils.cjs');
+
+const getGroupMembersInfoFactory = utils.apiFactory()((api, _, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.profile[0]}/api/social/group/members`);
+    /**
+     * Get group information
+     *
+     * @param memberId member id or array of member ids
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function getGroupMembersInfo(memberId) {
+        if (!Array.isArray(memberId))
+            memberId = [memberId];
+        const params = {
+            friend_pversion_map: memberId.map((id) => (id.endsWith("_0") ? id : `${id}_0`)),
+        };
+        const encryptedParams = utils.encodeAES(JSON.stringify(params));
+        if (!encryptedParams)
+            throw new ZaloApiError.ZaloApiError("Failed to encrypt message");
+        const response = await utils.request(utils.makeURL(serviceURL, { params: encryptedParams }));
+        return utils.resolve(response);
+    };
+});
+
+exports.getGroupMembersInfoFactory = getGroupMembersInfoFactory;

package/dist/cjs/apis/getHiddenConversations.cjs

@@ -0,0 +1,28 @@
+'use strict';
+
+var ZaloApiError = require('../Errors/ZaloApiError.cjs');
+var utils = require('../utils.cjs');
+
+const getHiddenConversationsFactory = utils.apiFactory()((api, ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.conversation[0]}/api/hiddenconvers/get-all`);
+    /**
+     * Get hidden conversations
+     *
+     * @throws {ZaloApiError}
+     *
+     */
+    return async function getHiddenConversations() {
+        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.getHiddenConversationsFactory = getHiddenConversationsFactory;

package/dist/cjs/apis/getLabels.cjs

@@ -0,0 +1,33 @@
+'use strict';
+
+var ZaloApiError = require('../Errors/ZaloApiError.cjs');
+var utils = require('../utils.cjs');
+
+const getLabelsFactory = utils.apiFactory()((api, ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.label[0]}/api/convlabel/get`);
+    /**
+     * Get all labels
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function getLabels() {
+        const params = {
+            imei: ctx.imei,
+        };
+        const encryptedParams = utils.encodeAES(JSON.stringify(params));
+        if (!encryptedParams)
+            throw new ZaloApiError.ZaloApiError("Failed to encrypt message");
+        const response = await utils.request(utils.makeURL(serviceURL, { params: encryptedParams }));
+        return utils.resolve(response, (result) => {
+            const data = result.data;
+            const formattedData = {
+                labelData: JSON.parse(data.labelData),
+                version: data.version,
+                lastUpdateTime: data.lastUpdateTime,
+            };
+            return formattedData;
+        });
+    };
+});
+
+exports.getLabelsFactory = getLabelsFactory;

package/dist/cjs/apis/getListBank.cjs

@@ -0,0 +1,25 @@
+'use strict';
+
+var ZaloApiError = require('../Errors/ZaloApiError.cjs');
+var utils = require('../utils.cjs');
+
+const getListBankFactory = utils.apiFactory()((api, _ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.zimsg[0]}/api/transfer/conf`);
+    /**
+     * Get list bank
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function getListBank() {
+        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.getListBankFactory = getListBankFactory;

package/dist/cjs/apis/getListBankAccount.cjs

@@ -0,0 +1,32 @@
+'use strict';
+
+var ZaloApiError = require('../Errors/ZaloApiError.cjs');
+var utils = require('../utils.cjs');
+
+const getListBankAccountFactory = utils.apiFactory()((api, _ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.zimsg[0]}/api/transfer/list`);
+    /**
+     * Get list bank accounts
+     *
+     * @param page Page number (default: 0)
+     * @param limit Number of items to retrieve (default: 20)
+     *
+     * @throws {ZaloApiError} When something went wrong, with `error.code`
+     * - `114` - Invalid params
+     */
+    return async function getListBankAccount(page = 0, limit = 20) {
+        const params = {
+            page: page,
+            limit: 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: "GET",
+        });
+        return utils.resolve(response);
+    };
+});
+
+exports.getListBankAccountFactory = getListBankAccountFactory;

package/dist/cjs/apis/getListBoard.cjs

@@ -0,0 +1,59 @@
+'use strict';
+
+var ZaloApiError = require('../Errors/ZaloApiError.cjs');
+require('../models/AutoReply.cjs');
+require('../models/Bank.cjs');
+var Board = require('../models/Board.cjs');
+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 getListBoardFactory = utils.apiFactory()((api, ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.group_board[0]}/api/board/list`);
+    /**
+     * Get list board items in a group
+     *
+     * @param options - The options for the request
+     * @param groupId - The ID of the group
+     *
+     * @throws {ZaloApiError}
+     *
+     */
+    return async function getListBoard(options, groupId) {
+        var _a, _b;
+        const requestParams = {
+            group_id: groupId,
+            board_type: 0,
+            page: (_a = options.page) !== null && _a !== void 0 ? _a : 1,
+            count: (_b = options.count) !== null && _b !== void 0 ? _b : 20,
+            last_id: 0,
+            last_type: 0,
+            imei: ctx.imei,
+        };
+        const encryptedParams = utils.encodeAES(JSON.stringify(requestParams));
+        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;
+            data.items.forEach((item) => {
+                if (item.boardType != Board.BoardType.Poll) {
+                    const detailData = item.data;
+                    if (typeof detailData.params === "string") {
+                        detailData.params = JSON.parse(detailData.params);
+                    }
+                }
+            });
+            return data;
+        });
+    };
+});
+
+exports.getListBoardFactory = getListBoardFactory;

package/dist/cjs/apis/getListDevice.cjs

@@ -0,0 +1,27 @@
+'use strict';
+
+var ZaloApiError = require('../Errors/ZaloApiError.cjs');
+var utils = require('../utils.cjs');
+
+const getListDeviceFactory = utils.apiFactory()((api, ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.aext[0]}/api/devices/linked`);
+    /**
+     * Get list device
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function getListDevice() {
+        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.getListDeviceFactory = getListDeviceFactory;

package/dist/cjs/apis/getListReminder.cjs

@@ -0,0 +1,61 @@
+'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 getListReminderFactory = utils.apiFactory()((api, ctx, utils) => {
+    const serviceURL = {
+        [Enum.ThreadType.User]: utils.makeURL(`${api.zpwServiceMap.group_board[0]}/api/board/oneone/list`),
+        [Enum.ThreadType.Group]: utils.makeURL(`${api.zpwServiceMap.group_board[0]}/api/board/listReminder`),
+    };
+    /**
+     * Get list reminder
+     *
+     * @param options - The options for the request
+     * @param threadId - The ID of the thread
+     * @param type - The type of the thread (User or Group)
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function getListReminder(options, threadId, type = Enum.ThreadType.User) {
+        var _a, _b, _c, _d;
+        const requestParams = Object.assign({ objectData: JSON.stringify(type === Enum.ThreadType.User
+                ? {
+                    uid: threadId,
+                    board_type: 1,
+                    page: (_a = options.page) !== null && _a !== void 0 ? _a : 1,
+                    count: (_b = options.count) !== null && _b !== void 0 ? _b : 20,
+                    last_id: 0,
+                    last_type: 0,
+                }
+                : {
+                    group_id: threadId,
+                    board_type: 1,
+                    page: (_c = options.page) !== null && _c !== void 0 ? _c : 1,
+                    count: (_d = options.count) !== null && _d !== void 0 ? _d : 20,
+                    last_id: 0,
+                    last_type: 0,
+                }) }, (type === Enum.ThreadType.Group && { imei: ctx.imei }));
+        const encryptedParams = utils.encodeAES(JSON.stringify(requestParams));
+        if (!encryptedParams)
+            throw new ZaloApiError.ZaloApiError("Failed to encrypt params");
+        const response = await utils.request(utils.makeURL(serviceURL[type], { params: encryptedParams }), {
+            method: "GET",
+        });
+        return utils.resolve(response, (result) => {
+            return JSON.parse(result.data);
+        });
+    };
+});
+
+exports.getListReminderFactory = getListReminderFactory;

package/dist/cjs/apis/getMultiUsersByPhones.cjs

@@ -0,0 +1,53 @@
+'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');
+
+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/getMute.cjs

@@ -0,0 +1,27 @@
+'use strict';
+
+var ZaloApiError = require('../Errors/ZaloApiError.cjs');
+var utils = require('../utils.cjs');
+
+const getMuteFactory = utils.apiFactory()((api, ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.profile[0]}/api/social/profile/getmute`);
+    /**
+     * Get mute
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function getMute() {
+        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.getMuteFactory = getMuteFactory;

package/dist/cjs/apis/getOwnId.cjs

@@ -0,0 +1,9 @@
+'use strict';
+
+var utils = require('../utils.cjs');
+
+const getOwnIdFactory = utils.apiFactory()((_, ctx) => {
+    return () => ctx.uid;
+});
+
+exports.getOwnIdFactory = getOwnIdFactory;

package/dist/cjs/apis/getPendingGroupMembers.cjs

@@ -0,0 +1,32 @@
+'use strict';
+
+var ZaloApiError = require('../Errors/ZaloApiError.cjs');
+var utils = require('../utils.cjs');
+
+const getPendingGroupMembersFactory = utils.apiFactory()((api, ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.group[0]}/api/group/pending-mems/list`);
+    /**
+     * Get pending group members
+     *
+     * @param groupId - The id of the group to get the pending members
+     *
+     * @note Only the group leader and deputy group leader can view
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function getPendingGroupMembers(groupId) {
+        const params = {
+            grid: groupId,
+            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.getPendingGroupMembersFactory = getPendingGroupMembersFactory;

package/dist/cjs/apis/getPinConversations.cjs

@@ -0,0 +1,27 @@
+'use strict';
+
+var ZaloApiError = require('../Errors/ZaloApiError.cjs');
+var utils = require('../utils.cjs');
+
+const getPinConversationsFactory = utils.apiFactory()((api, ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.conversation[0]}/api/pinconvers/list`);
+    /**
+     * Get pin conversations
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function getPinConversations() {
+        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.getPinConversationsFactory = getPinConversationsFactory;

package/dist/cjs/apis/getPollDetail.cjs

@@ -0,0 +1,35 @@
+'use strict';
+
+var ZaloApiError = require('../Errors/ZaloApiError.cjs');
+var utils = require('../utils.cjs');
+
+const getPollDetailFactory = utils.apiFactory()((api, ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.group[0]}/api/poll/detail`);
+    /**
+     * Get poll detail
+     *
+     * @param pollId Poll ID
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function getPollDetail(pollId) {
+        if (!pollId)
+            throw new ZaloApiError.ZaloApiError("Missing poll id");
+        const params = {
+            poll_id: pollId,
+            imei: ctx.imei,
+        };
+        const encryptedParams = utils.encodeAES(JSON.stringify(params));
+        if (!encryptedParams)
+            throw new ZaloApiError.ZaloApiError("Failed to encrypt message");
+        const response = await utils.request(serviceURL, {
+            method: "POST",
+            body: new URLSearchParams({
+                params: encryptedParams,
+            }),
+        });
+        return utils.resolve(response);
+    };
+});
+
+exports.getPollDetailFactory = getPollDetailFactory;

package/dist/cjs/apis/getProductCatalogList.cjs

@@ -0,0 +1,38 @@
+'use strict';
+
+var ZaloApiError = require('../Errors/ZaloApiError.cjs');
+var utils = require('../utils.cjs');
+
+const getProductCatalogListFactory = utils.apiFactory()((api, _, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.catalog[0]}/api/prodcatalog/product/list`);
+    /**
+     * Get product catalog list?
+     *
+     * @param payload payload
+     *
+     * @note this API is used for zBusiness
+     * @throws {ZaloApiError}
+     */
+    return async function getProductCatalogList(payload) {
+        var _a, _b, _c, _d;
+        const params = {
+            catalog_id: payload.catalogId,
+            limit: (_a = payload.limit) !== null && _a !== void 0 ? _a : 100,
+            version_catalog: (_b = payload.versionCatalog) !== null && _b !== void 0 ? _b : 0,
+            last_product_id: (_c = payload.lastProductId) !== null && _c !== void 0 ? _c : -1,
+            page: (_d = payload.page) !== null && _d !== void 0 ? _d : 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.getProductCatalogListFactory = getProductCatalogListFactory;

package/dist/cjs/apis/getQR.cjs

@@ -0,0 +1,34 @@
+'use strict';
+
+var ZaloApiError = require('../Errors/ZaloApiError.cjs');
+var utils = require('../utils.cjs');
+
+const getQRFactory = utils.apiFactory()((api, _, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.friend[0]}/api/friend/mget-qr`);
+    /**
+     * Get QR code for users
+     *
+     * @param userId User ID or list of user IDs
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function getQR(userId) {
+        if (typeof userId == "string")
+            userId = [userId];
+        const params = {
+            fids: 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.getQRFactory = getQRFactory;