@trungdlp/zca-js 1.0.0

package/dist/apis/loginQR.js

@@ -0,0 +1,365 @@
+import { CookieJar } from "tough-cookie";
+import { writeFile } from "node:fs/promises";
+import { ZaloApiError } from "../Errors/ZaloApiError.js";
+import { logger, request } from "../utils.js";
+import { ZaloApiLoginQRAborted } from "../Errors/ZaloApiLoginQRAborted.js";
+import { ZaloApiLoginQRDeclined } from "../Errors/ZaloApiLoginQRDeclined.js";
+export var LoginQRCallbackEventType;
+(function (LoginQRCallbackEventType) {
+    LoginQRCallbackEventType[LoginQRCallbackEventType["QRCodeGenerated"] = 0] = "QRCodeGenerated";
+    LoginQRCallbackEventType[LoginQRCallbackEventType["QRCodeExpired"] = 1] = "QRCodeExpired";
+    LoginQRCallbackEventType[LoginQRCallbackEventType["QRCodeScanned"] = 2] = "QRCodeScanned";
+    LoginQRCallbackEventType[LoginQRCallbackEventType["QRCodeDeclined"] = 3] = "QRCodeDeclined";
+    LoginQRCallbackEventType[LoginQRCallbackEventType["GotLoginInfo"] = 4] = "GotLoginInfo";
+})(LoginQRCallbackEventType || (LoginQRCallbackEventType = {}));
+async function loadLoginPage(ctx) {
+    const response = await request(ctx, "https://id.zalo.me/account?continue=https%3A%2F%2Fchat.zalo.me%2F", {
+        headers: {
+            accept: "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7",
+            "accept-language": "vi-VN,vi;q=0.9,fr-FR;q=0.8,fr;q=0.7,en-US;q=0.6,en;q=0.5",
+            "cache-control": "max-age=0",
+            priority: "u=0, i",
+            "sec-ch-ua": '"Chromium";v="130", "Google Chrome";v="130", "Not?A_Brand";v="99"',
+            "sec-ch-ua-mobile": "?0",
+            "sec-ch-ua-platform": '"Windows"',
+            "sec-fetch-dest": "document",
+            "sec-fetch-mode": "navigate",
+            "sec-fetch-site": "same-site",
+            "sec-fetch-user": "?1",
+            "upgrade-insecure-requests": "1",
+            Referer: "https://chat.zalo.me/",
+            "Referrer-Policy": "strict-origin-when-cross-origin",
+        },
+        method: "GET",
+    });
+    const html = await response.text();
+    const regex = /https:\/\/stc-zlogin\.zdn\.vn\/main-([\d.]+)\.js/;
+    const match = html.match(regex);
+    return match === null || match === void 0 ? void 0 : match[1];
+}
+async function getLoginInfo(ctx, version) {
+    const form = new URLSearchParams();
+    form.append("continue", "https://zalo.me/pc");
+    form.append("v", version);
+    return await request(ctx, "https://id.zalo.me/account/logininfo", {
+        headers: {
+            accept: "*/*",
+            "accept-language": "vi-VN,vi;q=0.9,fr-FR;q=0.8,fr;q=0.7,en-US;q=0.6,en;q=0.5",
+            "content-type": "application/x-www-form-urlencoded",
+            priority: "u=1, i",
+            "sec-ch-ua": '"Chromium";v="130", "Google Chrome";v="130", "Not?A_Brand";v="99"',
+            "sec-ch-ua-mobile": "?0",
+            "sec-ch-ua-platform": '"Windows"',
+            "sec-fetch-dest": "empty",
+            "sec-fetch-mode": "cors",
+            "sec-fetch-site": "same-origin",
+            Referer: "https://id.zalo.me/account?continue=https%3A%2F%2Fzalo.me%2Fpc",
+            "Referrer-Policy": "strict-origin-when-cross-origin",
+        },
+        body: form,
+        method: "POST",
+    })
+        .then((res) => res.json())
+        .catch(logger(ctx).error);
+}
+async function verifyClient(ctx, version) {
+    const form = new URLSearchParams();
+    form.append("type", "device");
+    form.append("continue", "https://zalo.me/pc");
+    form.append("v", version);
+    return await request(ctx, "https://id.zalo.me/account/verify-client", {
+        headers: {
+            accept: "*/*",
+            "accept-language": "vi-VN,vi;q=0.9,fr-FR;q=0.8,fr;q=0.7,en-US;q=0.6,en;q=0.5",
+            "content-type": "application/x-www-form-urlencoded",
+            priority: "u=1, i",
+            "sec-ch-ua": '"Chromium";v="130", "Google Chrome";v="130", "Not?A_Brand";v="99"',
+            "sec-ch-ua-mobile": "?0",
+            "sec-ch-ua-platform": '"Windows"',
+            "sec-fetch-dest": "empty",
+            "sec-fetch-mode": "cors",
+            "sec-fetch-site": "same-origin",
+            Referer: "https://id.zalo.me/account?continue=https%3A%2F%2Fzalo.me%2Fpc",
+            "Referrer-Policy": "strict-origin-when-cross-origin",
+        },
+        body: form,
+        method: "POST",
+    })
+        .then((res) => res.json())
+        .catch(logger(ctx).error);
+}
+async function generate(ctx, version) {
+    const form = new URLSearchParams();
+    form.append("continue", "https://zalo.me/pc");
+    form.append("v", version);
+    return await request(ctx, "https://id.zalo.me/account/authen/qr/generate", {
+        headers: {
+            accept: "*/*",
+            "accept-language": "vi-VN,vi;q=0.9,fr-FR;q=0.8,fr;q=0.7,en-US;q=0.6,en;q=0.5",
+            "content-type": "application/x-www-form-urlencoded",
+            priority: "u=1, i",
+            "sec-ch-ua": '"Chromium";v="130", "Google Chrome";v="130", "Not?A_Brand";v="99"',
+            "sec-ch-ua-mobile": "?0",
+            "sec-ch-ua-platform": '"Windows"',
+            "sec-fetch-dest": "empty",
+            "sec-fetch-mode": "cors",
+            "sec-fetch-site": "same-origin",
+            Referer: "https://id.zalo.me/account?continue=https%3A%2F%2Fzalo.me%2Fpc",
+            "Referrer-Policy": "strict-origin-when-cross-origin",
+        },
+        body: form,
+        method: "POST",
+    })
+        .then((res) => res.json())
+        .catch(logger(ctx).error);
+}
+async function saveQRCodeToFile(filepath, imageData) {
+    await writeFile(filepath, imageData, "base64");
+}
+async function waitingScan(ctx, version, code, signal) {
+    const form = new URLSearchParams();
+    form.append("code", code);
+    form.append("continue", "https://chat.zalo.me/");
+    form.append("v", version);
+    return await request(ctx, "https://id.zalo.me/account/authen/qr/waiting-scan", {
+        headers: {
+            accept: "*/*",
+            "accept-language": "vi-VN,vi;q=0.9,fr-FR;q=0.8,fr;q=0.7,en-US;q=0.6,en;q=0.5",
+            "content-type": "application/x-www-form-urlencoded",
+            priority: "u=1, i",
+            "sec-ch-ua": '"Chromium";v="130", "Google Chrome";v="130", "Not?A_Brand";v="99"',
+            "sec-ch-ua-mobile": "?0",
+            "sec-ch-ua-platform": '"Windows"',
+            "sec-fetch-dest": "empty",
+            "sec-fetch-mode": "cors",
+            "sec-fetch-site": "same-origin",
+            Referer: "https://id.zalo.me/account?continue=https%3A%2F%2Fchat.zalo.me%2F",
+            "Referrer-Policy": "strict-origin-when-cross-origin",
+        },
+        body: form,
+        method: "POST",
+        signal,
+    })
+        .then((res) => res.json())
+        .then((data) => {
+        if (data.error_code == 8) {
+            return waitingScan(ctx, version, code, signal);
+        }
+        return data;
+    })
+        .catch((e) => {
+        if (!signal.aborted)
+            logger(ctx).error(e);
+    });
+}
+async function waitingConfirm(ctx, version, code, signal) {
+    const form = new URLSearchParams();
+    form.append("code", code);
+    form.append("gToken", "");
+    form.append("gAction", "CONFIRM_QR");
+    form.append("continue", "https://chat.zalo.me/");
+    form.append("v", version);
+    logger(ctx).info("Please confirm on your phone");
+    return await request(ctx, "https://id.zalo.me/account/authen/qr/waiting-confirm", {
+        headers: {
+            accept: "*/*",
+            "accept-language": "vi-VN,vi;q=0.9,fr-FR;q=0.8,fr;q=0.7,en-US;q=0.6,en;q=0.5",
+            "content-type": "application/x-www-form-urlencoded",
+            priority: "u=1, i",
+            "sec-ch-ua": '"Chromium";v="130", "Google Chrome";v="130", "Not?A_Brand";v="99"',
+            "sec-ch-ua-mobile": "?0",
+            "sec-ch-ua-platform": '"Windows"',
+            "sec-fetch-dest": "empty",
+            "sec-fetch-mode": "cors",
+            "sec-fetch-site": "same-origin",
+            Referer: "https://id.zalo.me/account?continue=https%3A%2F%2Fchat.zalo.me%2F",
+            "Referrer-Policy": "strict-origin-when-cross-origin",
+        },
+        body: form,
+        method: "POST",
+        signal,
+    })
+        .then((res) => res.json())
+        .then((data) => {
+        if (data.error_code == 8) {
+            return waitingConfirm(ctx, version, code, signal);
+        }
+        return data;
+    })
+        .catch((e) => {
+        if (!signal.aborted)
+            logger(ctx).error(e);
+    });
+}
+async function checkSession(ctx) {
+    return await request(ctx, "https://id.zalo.me/account/checksession?continue=https%3A%2F%2Fchat.zalo.me%2Findex.html", {
+        headers: {
+            accept: "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7",
+            "accept-language": "vi-VN,vi;q=0.9,fr-FR;q=0.8,fr;q=0.7,en-US;q=0.6,en;q=0.5",
+            priority: "u=0, i",
+            "sec-ch-ua": '"Chromium";v="130", "Google Chrome";v="130", "Not?A_Brand";v="99"',
+            "sec-ch-ua-mobile": "?0",
+            "sec-ch-ua-platform": '"Windows"',
+            "sec-fetch-dest": "document",
+            "sec-fetch-mode": "navigate",
+            "sec-fetch-site": "same-origin",
+            "upgrade-insecure-requests": "1",
+            Referer: "https://id.zalo.me/account?continue=https%3A%2F%2Fchat.zalo.me%2F",
+            "Referrer-Policy": "strict-origin-when-cross-origin",
+        },
+        redirect: "manual",
+        method: "GET",
+    }).catch(logger(ctx).error);
+}
+async function getUserInfo(ctx) {
+    return await request(ctx, "https://jr.chat.zalo.me/jr/userinfo", {
+        headers: {
+            accept: "*/*",
+            "accept-language": "vi-VN,vi;q=0.9,fr-FR;q=0.8,fr;q=0.7,en-US;q=0.6,en;q=0.5",
+            priority: "u=1, i",
+            "sec-ch-ua": '"Chromium";v="130", "Google Chrome";v="130", "Not?A_Brand";v="99"',
+            "sec-ch-ua-mobile": "?0",
+            "sec-ch-ua-platform": '"Windows"',
+            "sec-fetch-dest": "empty",
+            "sec-fetch-mode": "cors",
+            "sec-fetch-site": "same-site",
+            Referer: "https://chat.zalo.me/",
+            "Referrer-Policy": "strict-origin-when-cross-origin",
+        },
+        method: "GET",
+    })
+        .then((res) => res.json())
+        .catch(logger(ctx).error);
+}
+export async function loginQR(ctx, options, callback) {
+    ctx.cookie = new CookieJar();
+    ctx.userAgent = options.userAgent;
+    return new Promise(async (resolve, reject) => {
+        var _a;
+        const controller = new AbortController();
+        let qrTimeout = null;
+        function cleanUp() {
+            controller.abort();
+            if (qrTimeout) {
+                clearTimeout(qrTimeout);
+                qrTimeout = null;
+            }
+        }
+        try {
+            function retry() {
+                cleanUp();
+                return resolve(loginQR(ctx, options, callback));
+            }
+            function abort() {
+                cleanUp();
+                return reject(new ZaloApiLoginQRAborted());
+            }
+            if (ctx.options.logging)
+                console.log();
+            const loginVersion = await loadLoginPage(ctx);
+            if (!loginVersion)
+                throw new ZaloApiError("Cannot get API login version");
+            logger(ctx).info("Got login version:", loginVersion);
+            await getLoginInfo(ctx, loginVersion);
+            await verifyClient(ctx, loginVersion);
+            const qrGenResult = await generate(ctx, loginVersion);
+            if (!qrGenResult || !qrGenResult.data)
+                throw new ZaloApiError(`Unable to generate QRCode\nResponse: ${JSON.stringify(qrGenResult, null, 2)}`);
+            const qrData = qrGenResult.data;
+            if (callback) {
+                callback({
+                    type: LoginQRCallbackEventType.QRCodeGenerated,
+                    data: Object.assign(Object.assign({}, qrGenResult.data), { image: qrGenResult.data.image.replace(/^data:image\/png;base64,/, "") }),
+                    actions: {
+                        async saveToFile(qrPath) {
+                            var _a;
+                            if (qrPath === void 0) { qrPath = (_a = options.qrPath) !== null && _a !== void 0 ? _a : "qr.png"; }
+                            await saveQRCodeToFile(qrPath, qrData.image.replace(/^data:image\/png;base64,/, ""));
+                            logger(ctx).info("Scan the QR code at", `'${qrPath}'`, "to proceed with login");
+                        },
+                        retry,
+                        abort,
+                    },
+                });
+            }
+            else {
+                const qrPath = (_a = options.qrPath) !== null && _a !== void 0 ? _a : "qr.png";
+                await saveQRCodeToFile(qrPath, qrData.image.replace(/^data:image\/png;base64,/, ""));
+                logger(ctx).info("Scan the QR code at", `'${qrPath}'`, "to proceed with login");
+            }
+            qrTimeout = setTimeout(() => {
+                cleanUp();
+                logger(ctx).info("QR expired!");
+                if (callback) {
+                    callback({
+                        type: LoginQRCallbackEventType.QRCodeExpired,
+                        data: null,
+                        actions: {
+                            retry,
+                            abort,
+                        },
+                    });
+                }
+                else {
+                    retry();
+                }
+            }, 100000);
+            const scanResult = await waitingScan(ctx, loginVersion, qrGenResult.data.code, controller.signal);
+            if (!scanResult || !scanResult.data)
+                throw new ZaloApiError("Cannot get scan result");
+            if (callback) {
+                callback({
+                    type: LoginQRCallbackEventType.QRCodeScanned,
+                    data: scanResult.data,
+                    actions: {
+                        retry,
+                        abort,
+                    },
+                });
+            }
+            const confirmResult = await waitingConfirm(ctx, loginVersion, qrGenResult.data.code, controller.signal);
+            if (!confirmResult)
+                throw new ZaloApiError("Cannot get confirm result");
+            clearTimeout(qrTimeout);
+            if (confirmResult.error_code == -13) {
+                if (callback) {
+                    callback({
+                        type: LoginQRCallbackEventType.QRCodeDeclined,
+                        data: {
+                            code: qrData.code,
+                        },
+                        actions: {
+                            retry,
+                            abort,
+                        },
+                    });
+                }
+                else {
+                    logger(ctx).error("QRCode login declined");
+                    throw new ZaloApiLoginQRDeclined();
+                }
+                return;
+            }
+            else if (confirmResult.error_code != 0) {
+                throw new ZaloApiError(`An error has occurred.\nResponse: ${JSON.stringify(confirmResult, null, 2)}`);
+            }
+            const checkSessionResult = await checkSession(ctx);
+            if (!checkSessionResult)
+                throw new ZaloApiError("Cannot get session, login failed");
+            logger(ctx).info("Successfully logged into the account", scanResult.data.display_name);
+            const userInfo = await getUserInfo(ctx);
+            if (!userInfo || !userInfo.data)
+                throw new ZaloApiError("Can't get account info");
+            if (!userInfo.data.logged)
+                throw new ZaloApiError("Can't login");
+            resolve({
+                cookies: ctx.cookie.toJSON().cookies,
+                userInfo: userInfo.data.info,
+            });
+        }
+        catch (error) {
+            cleanUp();
+            reject(error);
+        }
+    });
+}

package/dist/apis/parseLink.d.ts

@@ -0,0 +1,21 @@
+export type ParseLinkErrorMaps = Record<string, number>;
+export type ParseLinkResponse = {
+    data: {
+        thumb: string;
+        title: string;
+        desc: string;
+        src: string;
+        href: string;
+        media: {
+            type: number;
+            count: number;
+            mediaTitle: string;
+            artist: string;
+            streamUrl: string;
+            stream_icon: string;
+        };
+        stream_icon: string;
+    };
+    error_maps: ParseLinkErrorMaps;
+};
+export declare const parseLinkFactory: (ctx: import("../context.js").ContextBase, api: import("../apis.js").API) => (link: string) => Promise<ParseLinkResponse>;

package/dist/apis/parseLink.js

@@ -0,0 +1,27 @@
+import { ZaloApiError } from "../Errors/ZaloApiError.js";
+import { apiFactory } from "../utils.js";
+export const parseLinkFactory = apiFactory()((api, ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.file[0]}/api/message/parselink`);
+    /**
+     * Parse link
+     *
+     * @param link link to parse
+     *
+     * @throws {ZaloApiError}
+     *
+     */
+    return async function parseLink(link) {
+        const params = {
+            link,
+            version: 1, // version 0 is not available errorMaps || version 1 is errorMaps (for response)
+            imei: ctx.imei,
+        };
+        const encryptedParams = utils.encodeAES(JSON.stringify(params));
+        if (!encryptedParams)
+            throw new ZaloApiError("Failed to encrypt params");
+        const response = await utils.request(utils.makeURL(serviceURL, { params: encryptedParams }), {
+            method: "GET",
+        });
+        return utils.resolve(response);
+    };
+});

package/dist/apis/rejectFriendRequest.d.ts

@@ -0,0 +1,2 @@
+export type RejectFriendRequestResponse = "";
+export declare const rejectFriendRequestFactory: (ctx: import("../context.js").ContextBase, api: import("../apis.js").API) => (friendId: string) => Promise<"">;

package/dist/apis/rejectFriendRequest.js

@@ -0,0 +1,27 @@
+import { ZaloApiError } from "../Errors/ZaloApiError.js";
+import { apiFactory } from "../utils.js";
+export const rejectFriendRequestFactory = apiFactory()((api, _ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.friend[0]}/api/friend/reject`);
+    /**
+     * Reject a friend request from a User
+     *
+     * @param friendId
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function rejectFriendRequest(friendId) {
+        const params = {
+            fid: friendId,
+        };
+        const encryptedParams = utils.encodeAES(JSON.stringify(params));
+        if (!encryptedParams)
+            throw new ZaloApiError("Failed to encrypt params");
+        const response = await utils.request(serviceURL, {
+            method: "POST",
+            body: new URLSearchParams({
+                params: encryptedParams,
+            }),
+        });
+        return utils.resolve(response);
+    };
+});

package/dist/apis/removeFriend.d.ts

@@ -0,0 +1,2 @@
+export type RemoveFriendResponse = "";
+export declare const removeFriendFactory: (ctx: import("../context.js").ContextBase, api: import("../apis.js").API) => (friendId: string) => Promise<"">;

package/dist/apis/removeFriend.js

@@ -0,0 +1,28 @@
+import { ZaloApiError } from "../Errors/ZaloApiError.js";
+import { apiFactory } from "../utils.js";
+export const removeFriendFactory = apiFactory()((api, ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.friend[0]}/api/friend/remove`);
+    /**
+     * Remove friend
+     *
+     * @param friendId - ID of the friend to remove
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function removeFriend(friendId) {
+        const params = {
+            fid: friendId,
+            imei: ctx.imei,
+        };
+        const encryptedParams = utils.encodeAES(JSON.stringify(params));
+        if (!encryptedParams)
+            throw new ZaloApiError("Failed to encrypt params");
+        const response = await utils.request(serviceURL, {
+            method: "POST",
+            body: new URLSearchParams({
+                params: encryptedParams,
+            }),
+        });
+        return utils.resolve(response);
+    };
+});

package/dist/apis/removeFriendAlias.d.ts

@@ -0,0 +1,2 @@
+export type RemoveFriendAliasResponse = "";
+export declare const removeFriendAliasFactory: (ctx: import("../context.js").ContextBase, api: import("../apis.js").API) => (friendId: string) => Promise<"">;

package/dist/apis/removeFriendAlias.js

@@ -0,0 +1,24 @@
+import { ZaloApiError } from "../Errors/ZaloApiError.js";
+import { apiFactory } from "../utils.js";
+export const removeFriendAliasFactory = apiFactory()((api, _ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.alias[0]}/api/alias/remove`);
+    /**
+     * Remove friend's alias
+     *
+     * @param friendId friend id
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function removeFriendAlias(friendId) {
+        const params = {
+            friendId: friendId,
+        };
+        const encryptedParams = utils.encodeAES(JSON.stringify(params));
+        if (!encryptedParams)
+            throw new ZaloApiError("Failed to encrypt params");
+        const response = await utils.request(utils.makeURL(serviceURL, { params: encryptedParams }), {
+            method: "GET",
+        });
+        return utils.resolve(response);
+    };
+});

package/dist/apis/removeGroupBlockedMember.d.ts

@@ -0,0 +1,2 @@
+export type RemoveGroupBlockedMemberResponse = "";
+export declare const removeGroupBlockedMemberFactory: (ctx: import("../context.js").ContextBase, api: import("../apis.js").API) => (memberId: string | string[], groupId: string) => Promise<"">;

package/dist/apis/removeGroupBlockedMember.js

@@ -0,0 +1,28 @@
+import { ZaloApiError } from "../Errors/ZaloApiError.js";
+import { apiFactory } from "../utils.js";
+export const removeGroupBlockedMemberFactory = apiFactory()((api, _, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.group[0]}/api/group/blockedmems/remove`);
+    /**
+     * Remove group blocked member
+     *
+     * @param memberId member id(s)
+     * @param groupId group id
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function removeGroupBlockedMember(memberId, groupId) {
+        if (!Array.isArray(memberId))
+            memberId = [memberId];
+        const params = {
+            grid: groupId,
+            members: memberId,
+        };
+        const encryptedParams = utils.encodeAES(JSON.stringify(params));
+        if (!encryptedParams)
+            throw new ZaloApiError("Failed to encrypt params");
+        const response = await utils.request(utils.makeURL(serviceURL, { params: encryptedParams }), {
+            method: "GET",
+        });
+        return utils.resolve(response);
+    };
+});

package/dist/apis/removeGroupDeputy.d.ts

@@ -0,0 +1,2 @@
+export type RemoveGroupDeputyResponse = "";
+export declare const removeGroupDeputyFactory: (ctx: import("../context.js").ContextBase, api: import("../apis.js").API) => (memberId: string | string[], groupId: string) => Promise<"">;

package/dist/apis/removeGroupDeputy.js

@@ -0,0 +1,30 @@
+import { ZaloApiError } from "../Errors/ZaloApiError.js";
+import { apiFactory } from "../utils.js";
+export const removeGroupDeputyFactory = apiFactory()((api, ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.group[0]}/api/group/admins/remove`);
+    /**
+     * Remove group deputy
+     *
+     * @param memberId user Id or list of user Ids
+     * @param groupId group Id
+     *
+     * @throws {ZaloApiError}
+     *
+     */
+    return async function removeGroupDeputy(memberId, groupId) {
+        if (!Array.isArray(memberId))
+            memberId = [memberId];
+        const params = {
+            grid: groupId,
+            members: memberId,
+            imei: ctx.imei,
+        };
+        const encryptedParams = utils.encodeAES(JSON.stringify(params));
+        if (!encryptedParams)
+            throw new ZaloApiError("Failed to encrypt params");
+        const response = await utils.request(utils.makeURL(serviceURL, { params: encryptedParams }), {
+            method: "GET",
+        });
+        return utils.resolve(response);
+    };
+});

package/dist/apis/removeQuickMessage.d.ts

@@ -0,0 +1,5 @@
+export type RemoveQuickMessageResponse = {
+    itemIds: number[];
+    version: number;
+};
+export declare const removeQuickMessageFactory: (ctx: import("../context.js").ContextBase, api: import("../apis.js").API) => (itemIds: number | number[]) => Promise<RemoveQuickMessageResponse>;

package/dist/apis/removeQuickMessage.js

@@ -0,0 +1,27 @@
+import { ZaloApiError } from "../Errors/ZaloApiError.js";
+import { apiFactory } from "../utils.js";
+export const removeQuickMessageFactory = apiFactory()((api, _ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.quick_message[0]}/api/quickmessage/delete`);
+    /**
+     * Remove quick message
+     *
+     * @param itemIds - The id(s) of the quick message(s) to remove (number or number[])
+     *
+     * @note Zalo might throw an error with code 212 if the item does not exist
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function removeQuickMessage(itemIds) {
+        const idsArray = Array.isArray(itemIds) ? itemIds : [itemIds];
+        const params = {
+            itemIds: idsArray,
+        };
+        const encryptedParams = utils.encodeAES(JSON.stringify(params));
+        if (!encryptedParams)
+            throw new ZaloApiError("Failed to encrypt params");
+        const response = await utils.request(utils.makeURL(serviceURL, { params: encryptedParams }), {
+            method: "GET",
+        });
+        return utils.resolve(response);
+    };
+});

package/dist/apis/removeReminder.d.ts

@@ -0,0 +1,3 @@
+import { ThreadType } from "../models/index.js";
+export type RemoveReminderResponse = "" | number;
+export declare const removeReminderFactory: (ctx: import("../context.js").ContextBase, api: import("../apis.js").API) => (reminderId: string, threadId: string, type?: ThreadType) => Promise<RemoveReminderResponse>;

package/dist/apis/removeReminder.js

@@ -0,0 +1,40 @@
+import { ZaloApiError } from "../Errors/ZaloApiError.js";
+import { ThreadType } from "../models/index.js";
+import { apiFactory } from "../utils.js";
+export const removeReminderFactory = apiFactory()((api, ctx, utils) => {
+    const serviceURL = {
+        [ThreadType.User]: utils.makeURL(`${api.zpwServiceMap.group_board[0]}/api/board/oneone/remove`),
+        [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 = ThreadType.User) {
+        const params = type === 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("Failed to encrypt params");
+        const response = await utils.request(serviceURL[type], {
+            method: "POST",
+            body: new URLSearchParams({
+                params: encryptedParams,
+            }),
+        });
+        return utils.resolve(response);
+    };
+});