@phuquy2203/n8n-nodes-zl-sumo 2.0.15

package/dist/src/apis/updateProfile.d.ts

@@ -0,0 +1,20 @@
+import type { BusinessCategory, Gender } from "../models/index.js";
+export type UpdateProfilePayload = {
+    profile: {
+        name: string;
+        /**
+         * Date of birth in the format YYYY-MM-DD
+         */
+        dob: `${string}-${string}-${string}`;
+        gender: Gender;
+    };
+    biz?: Partial<{
+        cate: BusinessCategory;
+        description: string;
+        address: string;
+        website: string;
+        email: string;
+    }>;
+};
+export type UpdateProfileResponse = "";
+export declare const updateProfileFactory: (ctx: import("../context.js").ContextBase, api: import("../apis.js").API) => (payload: UpdateProfilePayload) => Promise<"">;

package/dist/src/apis/updateProfile.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.updateProfileFactory = void 0;
+const ZaloApiError_js_1 = require("../Errors/ZaloApiError.js");
+const utils_js_1 = require("../utils.js");
+exports.updateProfileFactory = (0, utils_js_1.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_js_1.ZaloApiError("Failed to encrypt params");
+        const response = await utils.request(serviceURL, {
+            method: "POST",
+            body: new URLSearchParams({
+                params: encryptedParams,
+            }),
+        });
+        return utils.resolve(response);
+    };
+});

package/dist/src/apis/updateQuickMessage.d.ts

@@ -0,0 +1,11 @@
+import type { QuickMessage, AttachmentSource } from "../models/index.js";
+export type UpdateQuickMessagePayload = {
+    keyword: string;
+    title: string;
+    media?: AttachmentSource;
+};
+export type UpdateQuickMessageResponse = {
+    item: QuickMessage;
+    version: number;
+};
+export declare const updateQuickMessageFactory: (ctx: import("../context.js").ContextBase, api: import("../apis.js").API) => (updatePayload: UpdateQuickMessagePayload, itemId: number) => Promise<UpdateQuickMessageResponse>;

package/dist/src/apis/updateQuickMessage.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.updateQuickMessageFactory = void 0;
+const ZaloApiError_js_1 = require("../Errors/ZaloApiError.js");
+const utils_js_1 = require("../utils.js");
+exports.updateQuickMessageFactory = (0, utils_js_1.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_js_1.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_js_1.ZaloApiError("Failed to encrypt params");
+        const response = await utils.request(utils.makeURL(serviceURL, { params: encryptedParams }), {
+            method: "GET",
+        });
+        return utils.resolve(response);
+    };
+});

package/dist/src/apis/updateSettings.d.ts

@@ -0,0 +1,16 @@
+export type UpdateSettingsResponse = "";
+export declare enum UpdateSettingsType {
+    ViewBirthday = "view_birthday",
+    ShowOnlineStatus = "show_online_status",
+    DisplaySeenStatus = "display_seen_status",
+    ReceiveMessage = "receive_message",
+    AcceptCall = "accept_stranger_call",
+    AddFriendViaPhone = "add_friend_via_phone",
+    AddFriendViaQR = "add_friend_via_qr",
+    AddFriendViaGroup = "add_friend_via_group",
+    AddFriendViaContact = "add_friend_via_contact",
+    DisplayOnRecommendFriend = "display_on_recommend_friend",
+    ArchivedChat = "archivedChatStatus",
+    QuickMessage = "quickMessageStatus"
+}
+export declare const updateSettingsFactory: (ctx: import("../context.js").ContextBase, api: import("../apis.js").API) => (type: UpdateSettingsType, value: number) => Promise<"">;

package/dist/src/apis/updateSettings.js

@@ -0,0 +1,93 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.updateSettingsFactory = exports.UpdateSettingsType = void 0;
+const ZaloApiError_js_1 = require("../Errors/ZaloApiError.js");
+const utils_js_1 = require("../utils.js");
+var UpdateSettingsType;
+(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";
+})(UpdateSettingsType || (exports.UpdateSettingsType = UpdateSettingsType = {}));
+exports.updateSettingsFactory = (0, utils_js_1.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_js_1.ZaloApiError("Failed to encrypt params");
+        const response = await utils.request(utils.makeURL(serviceURL, { params: encryptedParams }), {
+            method: "GET",
+        });
+        return utils.resolve(response);
+    };
+});

package/dist/src/apis/uploadAttachment.d.ts

@@ -0,0 +1,50 @@
+import { ThreadType, type AttachmentSource } from "../models/index.js";
+export type UploadAttachmentImageResponse = {
+    normalUrl: string;
+    photoId: string;
+    finished: number | boolean;
+    hdUrl: string;
+    thumbUrl: string;
+    clientFileId: number;
+    chunkId: number;
+    fileType: "image";
+    width: number;
+    height: number;
+    totalSize: number;
+    hdSize: number;
+};
+export type UploadAttachmentVideoResponse = {
+    finished: number | boolean;
+    clientFileId: number;
+    chunkId: number;
+    fileType: "video";
+    fileUrl: string;
+    fileId: string;
+    checksum: string;
+    totalSize: number;
+    fileName: string;
+};
+export type UploadAttachmentFileResponse = {
+    finished: number | boolean;
+    clientFileId: number;
+    chunkId: number;
+    fileType: "others";
+    fileUrl: string;
+    fileId: string;
+    checksum: string;
+    totalSize: number;
+    fileName: string;
+};
+export type ImageData = {
+    fileName: string;
+    totalSize: number | undefined;
+    width: number | undefined;
+    height: number | undefined;
+};
+export type FileData = {
+    fileName: string;
+    totalSize: number;
+};
+export type UploadAttachmentType = UploadAttachmentImageResponse | UploadAttachmentVideoResponse | UploadAttachmentFileResponse;
+export type UploadAttachmentResponse = UploadAttachmentType[];
+export declare const uploadAttachmentFactory: (ctx: import("../context.js").ContextBase, api: import("../apis.js").API) => (sources: AttachmentSource | AttachmentSource[], threadId: string, type?: ThreadType) => Promise<UploadAttachmentType[]>;

package/dist/src/apis/uploadAttachment.js

@@ -0,0 +1,202 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.uploadAttachmentFactory = void 0;
+const form_data_1 = __importDefault(require("form-data"));
+const node_fs_1 = __importDefault(require("node:fs"));
+const ZaloApiError_js_1 = require("../Errors/ZaloApiError.js");
+const index_js_1 = require("../models/index.js");
+const utils_js_1 = require("../utils.js");
+const urlType = {
+    image: "photo_original/upload",
+    video: "asyncfile/upload",
+    others: "asyncfile/upload",
+};
+exports.uploadAttachmentFactory = (0, utils_js_1.apiFactory)()((api, ctx, utils) => {
+    const serviceURL = `${api.zpwServiceMap.file[0]}/api`;
+    const { sharefile } = ctx.settings.features;
+    function isExceedMaxFile(totalFile) {
+        return totalFile > sharefile.max_file;
+    }
+    function isExceedMaxFileSize(fileSize) {
+        return fileSize > sharefile.max_size_share_file_v3 * 1024 * 1024;
+    }
+    function isExtensionValid(ext) {
+        return sharefile.restricted_ext_file.indexOf(ext) == -1;
+    }
+    /**
+     * Upload an attachment to a thread
+     *
+     * @param sources path to files or attachment sources
+     * @param threadId Group or User ID
+     * @param type Message type (User or Group)
+     *
+     * @throws {ZaloApiError | ZaloApiMissingImageMetadataGetter}
+     */
+    return async function uploadAttachment(sources, threadId, type = index_js_1.ThreadType.User) {
+        if (!sources)
+            throw new ZaloApiError_js_1.ZaloApiError("Missing sources");
+        if (!Array.isArray(sources))
+            sources = [sources];
+        if (sources.length == 0)
+            throw new ZaloApiError_js_1.ZaloApiError("Missing sources");
+        if (isExceedMaxFile(sources.length))
+            throw new ZaloApiError_js_1.ZaloApiError("Exceed maximum file of " + sharefile.max_file);
+        if (!threadId)
+            throw new ZaloApiError_js_1.ZaloApiError("Missing threadId");
+        const chunkSize = ctx.settings.features.sharefile.chunk_size_file;
+        const isGroupMessage = type == index_js_1.ThreadType.Group;
+        const attachmentsData = [];
+        const url = `${serviceURL}/${isGroupMessage ? "group" : "message"}/`;
+        const typeParam = isGroupMessage ? "11" : "2";
+        let clientId = Date.now();
+        for (const source of sources) {
+            const isFilePath = typeof source == "string";
+            const isBuffer = typeof source == "object" && source.data instanceof Buffer;
+            if (!isFilePath && !isBuffer)
+                throw new ZaloApiError_js_1.ZaloApiError("Invalid source type");
+            if (!isFilePath && !source.filename)
+                throw new ZaloApiError_js_1.ZaloApiError("Missing filename");
+            if (isFilePath && !node_fs_1.default.existsSync(source))
+                throw new ZaloApiError_js_1.ZaloApiError("File not found");
+            const extFile = (0, utils_js_1.getFileExtension)(isFilePath ? source : source.filename).toLowerCase();
+            const fileName = isFilePath ? (0, utils_js_1.getFileName)(source) : source.filename;
+            if (isExtensionValid(extFile) == false)
+                throw new ZaloApiError_js_1.ZaloApiError(`File extension "${extFile}" is not allowed`);
+            const data = {
+                filePath: isFilePath ? source : source.filename,
+                chunkContent: [],
+                params: {},
+                source,
+            };
+            if (isGroupMessage)
+                data.params.grid = threadId;
+            else
+                data.params.toid = threadId;
+            switch (extFile) {
+                case "jpg":
+                case "jpeg":
+                case "png":
+                case "webp": {
+                    const imageData = isFilePath ? await (0, utils_js_1.getImageMetaData)(ctx, source) : Object.assign(Object.assign({}, source.metadata), { fileName });
+                    if (isExceedMaxFileSize(imageData.totalSize))
+                        throw new ZaloApiError_js_1.ZaloApiError(`File ${fileName} size exceed maximum size of ${sharefile.max_size_share_file_v3}MB`);
+                    data.fileData = imageData;
+                    data.fileType = "image";
+                    data.params.totalChunk = Math.ceil(data.fileData.totalSize / chunkSize);
+                    data.params.fileName = fileName;
+                    data.params.clientId = clientId++;
+                    data.params.totalSize = imageData.totalSize;
+                    data.params.imei = ctx.imei;
+                    data.params.isE2EE = 0;
+                    data.params.jxl = 0;
+                    data.params.chunkId = 1;
+                    break;
+                }
+                case "mp4": {
+                    const videoSize = isFilePath ? await (0, utils_js_1.getFileSize)(source) : source.metadata.totalSize;
+                    if (isExceedMaxFileSize(videoSize))
+                        throw new ZaloApiError_js_1.ZaloApiError(`File ${fileName} size exceed maximum size of ${sharefile.max_size_share_file_v3}MB`);
+                    data.fileType = "video";
+                    data.fileData = {
+                        fileName,
+                        totalSize: videoSize,
+                    };
+                    data.params.totalChunk = Math.ceil(data.fileData.totalSize / chunkSize);
+                    data.params.fileName = fileName;
+                    data.params.clientId = clientId++;
+                    data.params.totalSize = videoSize;
+                    data.params.imei = ctx.imei;
+                    data.params.isE2EE = 0;
+                    data.params.jxl = 0;
+                    data.params.chunkId = 1;
+                    break;
+                }
+                default: {
+                    const fileSize = isFilePath ? await (0, utils_js_1.getFileSize)(source) : source.metadata.totalSize;
+                    if (isExceedMaxFileSize(fileSize))
+                        throw new ZaloApiError_js_1.ZaloApiError(`File ${fileName} size exceed maximum size of ${sharefile.max_size_share_file_v3}MB`);
+                    data.fileType = "others";
+                    data.fileData = {
+                        fileName,
+                        totalSize: fileSize,
+                    };
+                    data.params.totalChunk = Math.ceil(data.fileData.totalSize / chunkSize);
+                    data.params.fileName = fileName;
+                    data.params.clientId = clientId++;
+                    data.params.totalSize = fileSize;
+                    data.params.imei = ctx.imei;
+                    data.params.isE2EE = 0;
+                    data.params.jxl = 0;
+                    data.params.chunkId = 1;
+                    break;
+                }
+            }
+            const fileBuffer = isFilePath ? await node_fs_1.default.promises.readFile(source) : source.data;
+            for (let i = 0; i < data.params.totalChunk; i++) {
+                const formData = new form_data_1.default();
+                const slicedBuffer = fileBuffer.subarray(i * chunkSize, (i + 1) * chunkSize);
+                formData.append("chunkContent", slicedBuffer, {
+                    filename: fileName,
+                    contentType: "application/octet-stream",
+                });
+                data.chunkContent[i] = formData;
+            }
+            attachmentsData.push(data);
+        }
+        const requests = [], results = [];
+        for (const data of attachmentsData) {
+            for (let i = 0; i < data.params.totalChunk; i++) {
+                const encryptedParams = utils.encodeAES(JSON.stringify(data.params));
+                if (!encryptedParams)
+                    throw new ZaloApiError_js_1.ZaloApiError("Failed to encrypt message");
+                requests.push(utils
+                    .request(utils.makeURL(url + urlType[data.fileType], { type: typeParam, params: encryptedParams }), {
+                    method: "POST",
+                    headers: data.chunkContent[i].getHeaders(),
+                    body: data.chunkContent[i].getBuffer(),
+                })
+                    .then(async (response) => {
+                    /**
+                     * @TODO: better type rather than any
+                     */
+                    const resData = await (0, utils_js_1.resolveResponse)(ctx, response);
+                    if (resData && resData.fileId != "-1" && resData.photoId != "-1")
+                        await new Promise((resolve) => {
+                            if (data.fileType == "video" || data.fileType == "others") {
+                                const uploadCallback = async (wsData) => {
+                                    const result = Object.assign(Object.assign(Object.assign({ fileType: data.fileType }, resData), wsData), { totalSize: data.fileData.totalSize, fileName: data.fileData.fileName, checksum: (await (0, utils_js_1.getMd5LargeFileObject)(data.source, data.fileData.totalSize)).data });
+                                    results.push(result);
+                                    resolve();
+                                };
+                                ctx.uploadCallbacks.set(resData.fileId.toString(), uploadCallback);
+                            }
+                            if (data.fileType == "image") {
+                                const result = {
+                                    fileType: "image",
+                                    width: data.fileData.width,
+                                    height: data.fileData.height,
+                                    totalSize: data.fileData.totalSize,
+                                    hdSize: data.fileData.totalSize,
+                                    finished: resData.finished,
+                                    normalUrl: resData.normalUrl,
+                                    hdUrl: resData.hdUrl,
+                                    thumbUrl: resData.thumbUrl,
+                                    chunkId: resData.chunkId,
+                                    photoId: resData.photoId,
+                                    clientFileId: resData.clientFileId,
+                                };
+                                results.push(result);
+                                resolve();
+                            }
+                        });
+                }));
+                data.params.chunkId++;
+            }
+        }
+        await Promise.all(requests);
+        return results;
+    };
+});

package/dist/src/apis/uploadProductPhoto.d.ts

@@ -0,0 +1,14 @@
+import type { AttachmentSource } from "../models/index.js";
+export type UploadProductPhotoPayload = {
+    file: AttachmentSource;
+};
+export type UploadProductPhotoResponse = {
+    normalUrl: string;
+    photoId: string;
+    finished: number;
+    hdUrl: string;
+    thumbUrl: string;
+    clientFileId: number;
+    chunkId: number;
+};
+export declare const uploadProductPhotoFactory: (ctx: import("../context.js").ContextBase, api: import("../apis.js").API) => (payload: UploadProductPhotoPayload) => Promise<UploadProductPhotoResponse>;

package/dist/src/apis/uploadProductPhoto.js

@@ -0,0 +1,56 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.uploadProductPhotoFactory = void 0;
+const node_fs_1 = __importDefault(require("node:fs"));
+const form_data_1 = __importDefault(require("form-data"));
+const ZaloApiError_js_1 = require("../Errors/ZaloApiError.js");
+const utils_js_1 = require("../utils.js");
+exports.uploadProductPhotoFactory = (0, utils_js_1.apiFactory)()((api, ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.file[0]}/api/product/upload/photo`);
+    /**
+     * Upload product photo for api quick message, product catalog or custom local storage
+     *
+     * @param payload file path or attachment source
+     *
+     * @throws {ZaloApiError | ZaloApiMissingImageMetadataGetter}
+     */
+    return async function uploadProductPhoto(payload) {
+        const isSourceFilePath = typeof payload.file == "string";
+        const fileMetaData = isSourceFilePath
+            ? await (0, utils_js_1.getImageMetaData)(ctx, payload.file)
+            : payload.file.metadata;
+        const fileSize = fileMetaData.totalSize || 0;
+        const fileBuffer = isSourceFilePath
+            ? await node_fs_1.default.promises.readFile(payload.file)
+            : payload.file.data;
+        const formData = new form_data_1.default();
+        formData.append("chunkContent", fileBuffer, {
+            filename: "undefined",
+            contentType: "application/octet-stream",
+        });
+        const params = {
+            totalChunk: 1,
+            fileName: `Base64_Img_Picker_${Date.now()}.jpg`,
+            clientId: Date.now(),
+            totalSize: fileSize,
+            imei: ctx.imei,
+            chunkId: 1,
+            toid: ctx.loginInfo.send2me_id,
+            featureId: 1,
+        };
+        const encryptedParams = utils.encodeAES(JSON.stringify(params));
+        if (!encryptedParams)
+            throw new ZaloApiError_js_1.ZaloApiError("Failed to encrypt params");
+        const response = await utils.request(utils.makeURL(serviceURL, {
+            params: encryptedParams,
+        }), {
+            method: "POST",
+            headers: formData.getHeaders(),
+            body: formData.getBuffer(),
+        });
+        return utils.resolve(response);
+    };
+});

package/dist/src/apis/votePoll.d.ts

@@ -0,0 +1,5 @@
+import type { PollOptions } from "../models/index.js";
+export type VotePollResponse = {
+    options: PollOptions[];
+};
+export declare const votePollFactory: (ctx: import("../context.js").ContextBase, api: import("../apis.js").API) => (pollId: number, optionId: number | number[]) => Promise<VotePollResponse>;

package/dist/src/apis/votePoll.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.votePollFactory = void 0;
+const ZaloApiError_js_1 = require("../Errors/ZaloApiError.js");
+const utils_js_1 = require("../utils.js");
+exports.votePollFactory = (0, utils_js_1.apiFactory)()((api, ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.group[0]}/api/poll/vote`);
+    /**
+     * Vote on a poll
+     *
+     * @param pollId The ID of the poll to vote on
+     * @param optionId The ID(s) of the option to vote on
+     *
+     * @throws ZaloApiError
+     */
+    return async function votePoll(pollId, optionId) {
+        if (!Array.isArray(optionId))
+            optionId = [optionId];
+        const params = {
+            poll_id: pollId,
+            option_ids: optionId, // unvote = empty array
+            imei: ctx.imei,
+        };
+        const encryptedParams = utils.encodeAES(JSON.stringify(params));
+        if (!encryptedParams)
+            throw new ZaloApiError_js_1.ZaloApiError("Failed to encrypt params");
+        const response = await utils.request(utils.makeURL(serviceURL, { params: encryptedParams }), {
+            method: "GET",
+        });
+        return utils.resolve(response);
+    };
+});