@openclaw/zalouser 2026.5.20 → 2026.5.22

package/node_modules/zca-js/dist/cjs/apis/updateAutoDeleteChat.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');
+require('../models/Reaction.cjs');
+require('../models/Reminder.cjs');
+require('../models/ZBusiness.cjs');
+var utils = require('../utils.cjs');
+
+exports.ChatTTL = void 0;
+(function (ChatTTL) {
+    ChatTTL[ChatTTL["NO_DELETE"] = 0] = "NO_DELETE";
+    ChatTTL[ChatTTL["ONE_DAY"] = 86400000] = "ONE_DAY";
+    ChatTTL[ChatTTL["SEVEN_DAYS"] = 604800000] = "SEVEN_DAYS";
+    ChatTTL[ChatTTL["FOURTEEN_DAYS"] = 1209600000] = "FOURTEEN_DAYS";
+})(exports.ChatTTL || (exports.ChatTTL = {}));
+const updateAutoDeleteChatFactory = utils.apiFactory()((api, ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.conversation[0]}/api/conv/autodelete/updateConvers`);
+    /**
+     * Auto delete chat
+     *
+     * @param ttl The time to live of the chat
+     * @param threadId The thread ID to auto delete chat
+     * @param type Type of thread (User or Group)
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function updateAutoDeleteChat(ttl, threadId, type = Enum.ThreadType.User) {
+        const params = {
+            threadId: threadId,
+            isGroup: type === Enum.ThreadType.Group ? 1 : 0,
+            ttl: ttl,
+            clientLang: ctx.language,
+        };
+        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.updateAutoDeleteChatFactory = updateAutoDeleteChatFactory;

package/node_modules/zca-js/dist/cjs/apis/updateAutoReply.cjs

@@ -0,0 +1,43 @@
+'use strict';
+
+var ZaloApiError = require('../Errors/ZaloApiError.cjs');
+var utils = require('../utils.cjs');
+
+const updateAutoReplyFactory = utils.apiFactory()((api, ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.auto_reply[0]}/api/autoreply/update`);
+    /**
+     * Update auto reply
+     *
+     * @param payload payload
+     *
+     * @note this API used for zBusiness
+     * @throws {ZaloApiError}
+     */
+    return async function updateAutoReply(payload) {
+        const uids = Array.isArray(payload.uids) ? payload.uids : [payload.uids];
+        const resultUids = payload.scope === 2 || payload.scope === 3 ? uids : [];
+        const params = {
+            cliLang: ctx.language,
+            id: payload.id,
+            enable: payload.isEnable,
+            content: payload.content,
+            startTime: payload.startTime,
+            endTime: payload.endTime,
+            recurrence: ["RRULE:FREQ=DAILY;"],
+            scope: payload.scope,
+            uids: resultUids,
+        };
+        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.updateAutoReplyFactory = updateAutoReplyFactory;

package/node_modules/zca-js/dist/cjs/apis/updateCatalog.cjs

@@ -0,0 +1,35 @@
+'use strict';
+
+var ZaloApiError = require('../Errors/ZaloApiError.cjs');
+var utils = require('../utils.cjs');
+
+const updateCatalogFactory = utils.apiFactory()((api, _, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.catalog[0]}/api/prodcatalog/catalog/update`);
+    /**
+     * Update catalog?
+     *
+     * @param payload payload
+     *
+     * @note this API is used for zBusiness
+     * @throws {ZaloApiError}
+     */
+    return async function updateCatalog(payload) {
+        const params = {
+            catalog_id: payload.catalogId,
+            catalog_name: payload.catalogName,
+            catalog_photo: "", // "" is defaut don't upload photo
+        };
+        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.updateCatalogFactory = updateCatalogFactory;

package/node_modules/zca-js/dist/cjs/apis/updateGroupSettings.cjs

@@ -0,0 +1,48 @@
+'use strict';
+
+var ZaloApiError = require('../Errors/ZaloApiError.cjs');
+var utils = require('../utils.cjs');
+
+const updateGroupSettingsFactory = utils.apiFactory()((api, ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.group[0]}/api/group/setting/update`);
+    /**
+     * Update group settings
+     *
+     * @param options Options
+     * @param groupId Group ID
+     *
+     * @note Zalo might throw an error with code 166 if you don't have enough permissions to change the settings.
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function updateGroupSettings(options, groupId) {
+        const params = {
+            blockName: options.blockName ? 1 : 0,
+            signAdminMsg: options.signAdminMsg ? 1 : 0,
+            // addMemberOnly: 0, // very tricky, any idea?
+            setTopicOnly: options.setTopicOnly ? 1 : 0,
+            enableMsgHistory: options.enableMsgHistory ? 1 : 0,
+            joinAppr: options.joinAppr ? 1 : 0,
+            lockCreatePost: options.lockCreatePost ? 1 : 0,
+            lockCreatePoll: options.lockCreatePoll ? 1 : 0,
+            lockSendMsg: options.lockSendMsg ? 1 : 0,
+            lockViewMember: options.lockViewMember ? 1 : 0,
+            // default values for not implemented options
+            bannFeature: 0,
+            dirtyMedia: 0,
+            banDuration: 0,
+            blocked_members: [],
+            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.updateGroupSettingsFactory = updateGroupSettingsFactory;

package/node_modules/zca-js/dist/cjs/apis/updateHiddenConversPin.cjs

@@ -0,0 +1,35 @@
+'use strict';
+
+var ZaloApiError = require('../Errors/ZaloApiError.cjs');
+var utils = require('../utils.cjs');
+
+const updateHiddenConversPinFactory = utils.apiFactory()((api, ctx, utils$1) => {
+    const serviceURL = utils$1.makeURL(`${api.zpwServiceMap.conversation[0]}/api/hiddenconvers/update-pin`);
+    const pinRegex = /^\d{4}$/;
+    /**
+     * Update hidden conversation pin
+     *
+     * @param pin The pin to update (must be a 4-digit number between 0000-9999)
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function updateHiddenConversPin(pin) {
+        if (!pinRegex.test(pin)) {
+            throw new ZaloApiError.ZaloApiError("Pin must be a 4-digit number between 0000-9999");
+        }
+        const encryptedPin = utils.encryptPin(pin);
+        const params = {
+            new_pin: encryptedPin,
+            imei: ctx.imei,
+        };
+        const encryptedParams = utils$1.encodeAES(JSON.stringify(params));
+        if (!encryptedParams)
+            throw new ZaloApiError.ZaloApiError("Failed to encrypt params");
+        const response = await utils$1.request(utils$1.makeURL(serviceURL, { params: encryptedParams }), {
+            method: "GET",
+        });
+        return utils$1.resolve(response);
+    };
+});
+
+exports.updateHiddenConversPinFactory = updateHiddenConversPinFactory;

package/node_modules/zca-js/dist/cjs/apis/updateLabels.cjs

@@ -0,0 +1,39 @@
+'use strict';
+
+var ZaloApiError = require('../Errors/ZaloApiError.cjs');
+var utils = require('../utils.cjs');
+
+const updateLabelsFactory = utils.apiFactory()((api, ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.label[0]}/api/convlabel/update`);
+    /**
+     * Update labels
+     *
+     * @param label label data
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function updateLabels(payload) {
+        const params = {
+            labelData: JSON.stringify(payload.labelData),
+            version: payload.version,
+            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,
+            }),
+        });
+        const unFormatted = (await utils.resolve(response));
+        return {
+            labelData: JSON.parse(unFormatted.labelData),
+            version: unFormatted.version,
+            lastUpdateTime: unFormatted.lastUpdateTime,
+        };
+    };
+});
+
+exports.updateLabelsFactory = updateLabelsFactory;

package/node_modules/zca-js/dist/cjs/apis/updateLang.cjs

@@ -0,0 +1,35 @@
+'use strict';
+
+var ZaloApiError = require('../Errors/ZaloApiError.cjs');
+var utils = require('../utils.cjs');
+
+exports.UpdateLangAvailableLanguages = void 0;
+(function (UpdateLangAvailableLanguages) {
+    UpdateLangAvailableLanguages["VI"] = "VI";
+    UpdateLangAvailableLanguages["EN"] = "EN";
+})(exports.UpdateLangAvailableLanguages || (exports.UpdateLangAvailableLanguages = {}));
+const updateLangFactory = utils.apiFactory()((api, _, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.profile[0]}/api/social/profile/updatelang`);
+    /**
+     * Update language?
+     *
+     * @param language language to update (VI, EN)
+     *
+     * @note Calling this API alone will not update the user's language.
+     * @throws {ZaloApiError}
+     */
+    return async function updateLang(language = exports.UpdateLangAvailableLanguages.VI) {
+        const params = {
+            language: 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.updateLangFactory = updateLangFactory;

package/node_modules/zca-js/dist/cjs/apis/updateProductCatalog.cjs

@@ -0,0 +1,56 @@
+'use strict';
+
+var ZaloApiError = require('../Errors/ZaloApiError.cjs');
+var utils = require('../utils.cjs');
+
+const updateProductCatalogFactory = utils.apiFactory()((api, _, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.catalog[0]}/api/prodcatalog/product/update`);
+    /**
+     * Update product catalog?
+     *
+     * @param payload payload
+     *
+     * @note this API is used for zBusiness - Maximum 5 media files are supported
+     * @throws {ZaloApiError}
+     */
+    return async function updateProductCatalog(payload) {
+        const productPhoto = payload.product_photos || [];
+        if (payload.files && payload.files.length == 0) {
+            if (payload.files.length > 5) {
+                throw new ZaloApiError.ZaloApiError("Maximum 5 media files are allowed");
+            }
+            for (const mediaFile of payload.files) {
+                const uploadMedia = await api.uploadProductPhoto({
+                    file: mediaFile,
+                });
+                const url = uploadMedia.normalUrl || uploadMedia.hdUrl;
+                productPhoto.push(url);
+            }
+        }
+        if (productPhoto.length > 5) {
+            throw new ZaloApiError.ZaloApiError("Maximum 5 media files are allowed");
+        }
+        const params = {
+            product_id: payload.productId,
+            product_name: payload.productName,
+            price: payload.price,
+            description: payload.description,
+            product_photos: productPhoto,
+            catalog_id: payload.catalogId,
+            currency_unit: "₫",
+            create_time: payload.createTime,
+        };
+        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.updateProductCatalogFactory = updateProductCatalogFactory;

package/node_modules/zca-js/dist/cjs/apis/updateProfile.cjs

@@ -0,0 +1,48 @@
+'use strict';
+
+var ZaloApiError = require('../Errors/ZaloApiError.cjs');
+var utils = require('../utils.cjs');
+
+const updateProfileFactory = utils.apiFactory()((api, ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.profile[0]}/api/social/profile/update`);
+    /**
+     * Change account setting information
+     *
+     * @param payload payload
+     *
+     * @note If your account is a Business Account, include the biz.cate field; otherwise the category will be removed.
+     * You may leave the other biz fields empty if you don’t want to change them.
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function updateProfile(payload) {
+        var _a, _b, _c, _d, _e;
+        const params = {
+            profile: JSON.stringify({
+                name: payload.profile.name,
+                dob: payload.profile.dob,
+                gender: payload.profile.gender,
+            }),
+            biz: JSON.stringify({
+                desc: (_a = payload.biz) === null || _a === void 0 ? void 0 : _a.description,
+                cate: (_b = payload.biz) === null || _b === void 0 ? void 0 : _b.cate,
+                addr: (_c = payload.biz) === null || _c === void 0 ? void 0 : _c.address,
+                website: (_d = payload.biz) === null || _d === void 0 ? void 0 : _d.website,
+                email: (_e = payload.biz) === null || _e === void 0 ? void 0 : _e.email,
+            }),
+            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(serviceURL, {
+            method: "POST",
+            body: new URLSearchParams({
+                params: encryptedParams,
+            }),
+        });
+        return utils.resolve(response);
+    };
+});
+
+exports.updateProfileFactory = updateProfileFactory;

package/node_modules/zca-js/dist/cjs/apis/updateProfileBio.cjs

@@ -0,0 +1,32 @@
+'use strict';
+
+var ZaloApiError = require('../Errors/ZaloApiError.cjs');
+var utils = require('../utils.cjs');
+
+const updateProfileBioFactory = utils.apiFactory()((api, _ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.profile[0]}/api/social/profile/status`);
+    /**
+     * Update profile bio
+     *
+     * @param status status for update bio
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function updateProfileBio(status) {
+        const params = {
+            status: status,
+        };
+        const encryptedParams = utils.encodeAES(JSON.stringify(params));
+        if (!encryptedParams)
+            throw new ZaloApiError.ZaloApiError("Failed to encrypt params");
+        const response = await utils.request(utils.makeURL(serviceURL, { params: encryptedParams }), {
+            method: "POST",
+            body: new URLSearchParams({
+                params: encryptedParams,
+            }),
+        });
+        return utils.resolve(response);
+    };
+});
+
+exports.updateProfileBioFactory = updateProfileBioFactory;

package/node_modules/zca-js/dist/cjs/apis/updateQuickMessage.cjs

@@ -0,0 +1,66 @@
+'use strict';
+
+var ZaloApiError = require('../Errors/ZaloApiError.cjs');
+var utils = require('../utils.cjs');
+
+const updateQuickMessageFactory = utils.apiFactory()((api, _ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.quick_message[0]}/api/quickmessage/update`);
+    /**
+     * Update quick message
+     *
+     * @param updatePayload - The payload containing data to update the quick message
+     * @param itemId - The id of the quick message to update
+     *
+     * @note Zalo might throw an error with code 212 if the itemId does not exist.
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function updateQuickMessage(updatePayload, itemId) {
+        const isType = !updatePayload.media ? 0 : 1;
+        const params = {
+            itemId: itemId,
+            keyword: updatePayload.keyword,
+            message: {
+                title: updatePayload.title,
+                params: "",
+            },
+            type: isType,
+        };
+        if (isType === 1) {
+            if (!updatePayload.media)
+                throw new ZaloApiError.ZaloApiError("Media is required");
+            const uploadMedia = await api.uploadProductPhoto({
+                file: updatePayload.media,
+            });
+            const photoId = uploadMedia.photoId;
+            const thumbUrl = uploadMedia.thumbUrl;
+            const normalUrl = uploadMedia.normalUrl;
+            const hdUrl = uploadMedia.hdUrl;
+            params.media = {
+                items: [
+                    {
+                        type: 0,
+                        photoId: photoId,
+                        title: "",
+                        width: "",
+                        height: "",
+                        previewThumb: thumbUrl,
+                        rawUrl: normalUrl || hdUrl,
+                        thumbUrl: thumbUrl,
+                        normalUrl: normalUrl || hdUrl,
+                        hdUrl: hdUrl || normalUrl,
+                    },
+                ],
+            };
+        }
+        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.updateQuickMessageFactory = updateQuickMessageFactory;

package/node_modules/zca-js/dist/cjs/apis/updateSettings.cjs

@@ -0,0 +1,95 @@
+'use strict';
+
+var ZaloApiError = require('../Errors/ZaloApiError.cjs');
+var utils = require('../utils.cjs');
+
+exports.UpdateSettingsType = void 0;
+(function (UpdateSettingsType) {
+    UpdateSettingsType["ViewBirthday"] = "view_birthday";
+    UpdateSettingsType["ShowOnlineStatus"] = "show_online_status";
+    UpdateSettingsType["DisplaySeenStatus"] = "display_seen_status";
+    UpdateSettingsType["ReceiveMessage"] = "receive_message";
+    UpdateSettingsType["AcceptCall"] = "accept_stranger_call";
+    UpdateSettingsType["AddFriendViaPhone"] = "add_friend_via_phone";
+    UpdateSettingsType["AddFriendViaQR"] = "add_friend_via_qr";
+    UpdateSettingsType["AddFriendViaGroup"] = "add_friend_via_group";
+    UpdateSettingsType["AddFriendViaContact"] = "add_friend_via_contact";
+    UpdateSettingsType["DisplayOnRecommendFriend"] = "display_on_recommend_friend";
+    UpdateSettingsType["ArchivedChat"] = "archivedChatStatus";
+    UpdateSettingsType["QuickMessage"] = "quickMessageStatus";
+})(exports.UpdateSettingsType || (exports.UpdateSettingsType = {}));
+const updateSettingsFactory = utils.apiFactory()((_api, _ctx, utils) => {
+    const serviceURL = utils.makeURL(`https://wpa.chat.zalo.me/api/setting/update`);
+    /**
+     * Set account settings
+     *
+     * @param type The type of setting to update
+     * @param value
+     *
+     * ViewBirthday
+     * * 0: hide
+     * * 1: show full day/month/year
+     * * 2: show day/month
+     *
+     * ShowOnlineStatus
+     * * 0: hide
+     * * 1: show
+     *
+     * DisplaySeenStatus
+     * * 0: hide
+     * * 1: show
+     *
+     * ReceiveMessage
+     * * 1: everyone
+     * * 2: only friends
+     *
+     * AcceptCall
+     * * 2: only friends
+     * * 3: everyone
+     * * 4: friends and person who contacted
+     *
+     * AddFriendViaPhone
+     * * 0: disable
+     * * 1: enable
+     *
+     * AddFriendViaQR
+     * * 0: disable
+     * * 1: enable
+     *
+     * AddFriendViaGroup
+     * * 0: disable
+     * * 1: enable
+     *
+     * AddFriendViaContact
+     * * 0: disable
+     * * 1: enable
+     *
+     * DisplayOnRecommendFriend
+     * * 0: disable
+     * * 1: enable
+     *
+     * ArchivedChat
+     * * 0: disable
+     * * 1: enable
+     *
+     * QuickMessage
+     * * 0: disable
+     * * 1: enable
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function updateSettings(type, value) {
+        const params = {
+            [type]: value,
+        };
+        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.updateSettingsFactory = updateSettingsFactory;

package/node_modules/zca-js/dist/cjs/apis/upgradeGroupToCommunity.cjs

@@ -0,0 +1,32 @@
+'use strict';
+
+var ZaloApiError = require('../Errors/ZaloApiError.cjs');
+var utils = require('../utils.cjs');
+
+const upgradeGroupToCommunityFactory = utils.apiFactory()((api, ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.group[0]}/api/group/upgrade/community`);
+    /**
+     * Upgrade group to community
+     *
+     * @param groupId Group ID upgrade
+     *
+     * @note Zalo account identity must be verified and the account must be over 18 to use
+     * @code 185 The limit on the number of communities that can own has been reached
+     * @throws {ZaloApiError}
+     */
+    return async function upgradeGroupToCommunity(groupId) {
+        const params = {
+            grId: groupId,
+            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.upgradeGroupToCommunityFactory = upgradeGroupToCommunityFactory;