@phuquy2203/n8n-nodes-zl-sumo 2.0.15

package/dist/src/apis/findUser.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findUserFactory = void 0;
+const ZaloApiError_js_1 = require("../Errors/ZaloApiError.js");
+const utils_js_1 = require("../utils.js");
+exports.findUserFactory = (0, utils_js_1.apiFactory)()((api, ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.friend[0]}/api/friend/profile/get`);
+    /**
+     * Find user by phone number
+     *
+     * @param phoneNumber Phone number
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function findUser(phoneNumber) {
+        if (!phoneNumber)
+            throw new ZaloApiError_js_1.ZaloApiError("Missing phoneNumber");
+        if (phoneNumber.startsWith("0")) {
+            if (ctx.language == "vi")
+                phoneNumber = "84" + phoneNumber.slice(1);
+        }
+        const params = {
+            phone: phoneNumber,
+            avatar_size: 240,
+            language: ctx.language,
+            imei: ctx.imei,
+            reqSrc: 40,
+        };
+        const encryptedParams = utils.encodeAES(JSON.stringify(params));
+        if (!encryptedParams)
+            throw new ZaloApiError_js_1.ZaloApiError("Failed to encrypt message");
+        const finalServiceUrl = new URL(serviceURL);
+        finalServiceUrl.searchParams.append("params", encryptedParams);
+        const response = await utils.request(utils.makeURL(finalServiceUrl.toString(), {
+            params: encryptedParams,
+        }));
+        return utils.resolve(response, (result) => {
+            if (result.error && result.error.code != 216)
+                throw new ZaloApiError_js_1.ZaloApiError(result.error.message, result.error.code);
+            return result.data;
+        });
+    };
+});

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

@@ -0,0 +1,24 @@
+import { ThreadType } from "../models/index.js";
+export type ForwardMessagePayload = {
+    message: string;
+    ttl?: number;
+    reference?: {
+        id: string;
+        ts: number;
+        logSrcType: number;
+        fwLvl: number;
+    };
+};
+export type ForwardMessageSuccess = {
+    clientId: string;
+    msgId: string;
+};
+export type ForwardMessageFail = {
+    clientId: string;
+    error_code: string;
+};
+export type ForwardMessageResponse = {
+    success: ForwardMessageSuccess[];
+    fail: ForwardMessageFail[];
+};
+export declare const forwardMessageFactory: (ctx: import("../context.js").ContextBase, api: import("../apis.js").API) => (payload: ForwardMessagePayload, threadIds: string[], type?: ThreadType) => Promise<ForwardMessageResponse>;

package/dist/src/apis/forwardMessage.js

@@ -0,0 +1,102 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.forwardMessageFactory = void 0;
+const ZaloApiError_js_1 = require("../Errors/ZaloApiError.js");
+const index_js_1 = require("../models/index.js");
+const utils_js_1 = require("../utils.js");
+exports.forwardMessageFactory = (0, utils_js_1.apiFactory)()((api, ctx, utils) => {
+    const serviceURL = {
+        [index_js_1.ThreadType.User]: utils.makeURL(`${api.zpwServiceMap.file[0]}/api/message/mforward`),
+        [index_js_1.ThreadType.Group]: utils.makeURL(`${api.zpwServiceMap.file[0]}/api/group/mforward`),
+    };
+    /**
+     * Forward message to multiple threads
+     *
+     * @param payload Forward message payload
+     * @param threadId Thread ID(s)
+     * @param type Thread type (User/Group)
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function forwardMessage(payload, threadIds, type = index_js_1.ThreadType.User) {
+        var _a, _b;
+        if (!payload.message)
+            throw new ZaloApiError_js_1.ZaloApiError("Missing message content");
+        if (!threadIds || threadIds.length === 0)
+            throw new ZaloApiError_js_1.ZaloApiError("Missing thread IDs");
+        const timestamp = Date.now();
+        const clientId = timestamp.toString();
+        const msgInfo = {
+            message: payload.message,
+            reference: payload.reference
+                ? JSON.stringify({
+                    type: 3,
+                    data: JSON.stringify(payload.reference),
+                })
+                : undefined,
+        };
+        const decorLog = payload.reference
+            ? {
+                fw: {
+                    pmsg: {
+                        st: 1,
+                        ts: payload.reference.ts,
+                        id: payload.reference.id,
+                    },
+                    rmsg: {
+                        st: 1,
+                        ts: payload.reference.ts,
+                        id: payload.reference.id,
+                    },
+                    fwLvl: payload.reference.fwLvl,
+                },
+            }
+            : null;
+        let params;
+        if (type === index_js_1.ThreadType.User) {
+            params = {
+                toIds: threadIds.map((threadId) => {
+                    var _a;
+                    return ({
+                        clientId,
+                        toUid: threadId,
+                        ttl: (_a = payload.ttl) !== null && _a !== void 0 ? _a : 0,
+                    });
+                }),
+                imei: ctx.imei,
+                ttl: (_a = payload.ttl) !== null && _a !== void 0 ? _a : 0,
+                msgType: "1",
+                totalIds: threadIds.length,
+                msgInfo: JSON.stringify(msgInfo),
+                decorLog: JSON.stringify(decorLog),
+            };
+        }
+        else {
+            params = {
+                grids: threadIds.map((threadId) => {
+                    var _a;
+                    return ({
+                        clientId,
+                        grid: threadId,
+                        ttl: (_a = payload.ttl) !== null && _a !== void 0 ? _a : 0,
+                    });
+                }),
+                ttl: (_b = payload.ttl) !== null && _b !== void 0 ? _b : 0,
+                msgType: "1",
+                totalIds: threadIds.length,
+                msgInfo: JSON.stringify(msgInfo),
+                decorLog: JSON.stringify(decorLog),
+            };
+        }
+        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[type], {
+            method: "POST",
+            body: new URLSearchParams({
+                params: encryptedParams,
+            }),
+        });
+        return utils.resolve(response);
+    };
+});

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

@@ -0,0 +1,8 @@
+export type GetAliasListResponse = {
+    items: {
+        userId: string;
+        alias: string;
+    }[];
+    updateTime: string;
+};
+export declare const getAliasListFactory: (ctx: import("../context.js").ContextBase, api: import("../apis.js").API) => (count?: number, page?: number) => Promise<GetAliasListResponse>;

package/dist/src/apis/getAliasList.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAliasListFactory = void 0;
+const ZaloApiError_js_1 = require("../Errors/ZaloApiError.js");
+const utils_js_1 = require("../utils.js");
+exports.getAliasListFactory = (0, utils_js_1.apiFactory)()((api, ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.alias[0]}/api/alias/list`);
+    /**
+     * Get alias list
+     *
+     * @param count Page size (default: 100)
+     * @param page Page number (default: 1)
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function getAliasList(count = 100, page = 1) {
+        const params = {
+            page,
+            count,
+            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);
+    };
+});

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

@@ -0,0 +1,3 @@
+import type { User } from "../models/index.js";
+export type GetAllFriendsResponse = User[];
+export declare const getAllFriendsFactory: (ctx: import("../context.js").ContextBase, api: import("../apis.js").API) => (count?: number, page?: number) => Promise<GetAllFriendsResponse>;

package/dist/src/apis/getAllFriends.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAllFriendsFactory = void 0;
+const ZaloApiError_js_1 = require("../Errors/ZaloApiError.js");
+const utils_js_1 = require("../utils.js");
+exports.getAllFriendsFactory = (0, utils_js_1.apiFactory)()((api, ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.profile[0]}/api/social/friend/getfriends`);
+    /**
+     * Get all friends
+     *
+     * @param count Page size (default: 20000)
+     * @param page Page number (default: 1)
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function getAllFriends(count = 20000, page = 1) {
+        const params = {
+            incInvalid: 1,
+            page,
+            count,
+            avatar_size: 120,
+            actiontime: 0,
+            imei: ctx.imei,
+        };
+        const encryptedParams = utils.encodeAES(JSON.stringify(params));
+        if (!encryptedParams)
+            throw new ZaloApiError_js_1.ZaloApiError("Failed to encrypt message");
+        const response = await utils.request(utils.makeURL(serviceURL, {
+            params: encryptedParams,
+        }), {
+            method: "GET",
+        });
+        return utils.resolve(response);
+    };
+});

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

@@ -0,0 +1,7 @@
+export type GetAllGroupsResponse = {
+    version: string;
+    gridVerMap: {
+        [groupId: string]: string;
+    };
+};
+export declare const getAllGroupsFactory: (ctx: import("../context.js").ContextBase, api: import("../apis.js").API) => () => Promise<GetAllGroupsResponse>;

package/dist/src/apis/getAllGroups.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAllGroupsFactory = void 0;
+const utils_js_1 = require("../utils.js");
+exports.getAllGroupsFactory = (0, utils_js_1.apiFactory)()((api, _, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.group_poll[0]}/api/group/getlg/v4`);
+    return async function getAllGroups() {
+        const response = await utils.request(serviceURL, {
+            method: "GET",
+        });
+        return utils.resolve(response);
+    };
+});

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

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

package/dist/src/apis/getArchivedChatList.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getArchivedChatListFactory = void 0;
+const ZaloApiError_js_1 = require("../Errors/ZaloApiError.js");
+const utils_js_1 = require("../utils.js");
+exports.getArchivedChatListFactory = (0, utils_js_1.apiFactory)()((api, ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.label[0]}/api/archivedchat/list`);
+    /**
+     * Get arcnived chat list
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function getArchivedChatList() {
+        const params = {
+            version: 1,
+            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);
+    };
+});

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

@@ -0,0 +1,9 @@
+export type GetAutoDeleteChatResponse = {
+    convers: {
+        destId: string;
+        isGroup: boolean;
+        ttl: number;
+        createdAt: number;
+    }[];
+};
+export declare const getAutoDeleteChatFactory: (ctx: import("../context.js").ContextBase, api: import("../apis.js").API) => () => Promise<GetAutoDeleteChatResponse>;

package/dist/src/apis/getAutoDeleteChat.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAutoDeleteChatFactory = void 0;
+const ZaloApiError_js_1 = require("../Errors/ZaloApiError.js");
+const utils_js_1 = require("../utils.js");
+exports.getAutoDeleteChatFactory = (0, utils_js_1.apiFactory)()((api, _ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.conversation[0]}/api/conv/autodelete/getConvers`);
+    /**
+     * Get auto delete chat
+     *
+     * @throws {ZaloApiError}
+     *
+     */
+    return async function getAutoDeleteChat() {
+        const params = {};
+        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/getAutoReplyList.d.ts

@@ -0,0 +1,6 @@
+import type { AutoReplyItem } from "../models/index.js";
+export type GetAutoReplyListResponse = {
+    item: AutoReplyItem[];
+    version: number;
+};
+export declare const getAutoReplyListFactory: (ctx: import("../context.js").ContextBase, api: import("../apis.js").API) => () => Promise<GetAutoReplyListResponse>;

package/dist/src/apis/getAutoReplyList.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAutoReplyListFactory = void 0;
+const ZaloApiError_js_1 = require("../Errors/ZaloApiError.js");
+const utils_js_1 = require("../utils.js");
+exports.getAutoReplyListFactory = (0, utils_js_1.apiFactory)()((api, ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.auto_reply[0]}/api/autoreply/list`);
+    /**
+     * Get auto reply list
+     *
+     * @note this API used for zBusiness
+     * @throws {ZaloApiError}
+     */
+    return async function getAutoReplyList() {
+        const params = {
+            version: 0,
+            cliLang: 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(utils.makeURL(serviceURL, { params: encryptedParams }), {
+            method: "GET",
+        });
+        return utils.resolve(response);
+    };
+});

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

@@ -0,0 +1,12 @@
+export type GetAvatarListResponse = {
+    albumId: string;
+    nextPhotoId: string;
+    hasMore: number;
+    photos: {
+        photoId: string;
+        thumbnail: string;
+        url: string;
+        bkUrl: string;
+    }[];
+};
+export declare const getAvatarListFactory: (ctx: import("../context.js").ContextBase, api: import("../apis.js").API) => (count?: number, page?: number) => Promise<GetAvatarListResponse>;

package/dist/src/apis/getAvatarList.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAvatarListFactory = void 0;
+const ZaloApiError_js_1 = require("../Errors/ZaloApiError.js");
+const utils_js_1 = require("../utils.js");
+exports.getAvatarListFactory = (0, utils_js_1.apiFactory)()((api, ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.profile[0]}/api/social/avatar-list`);
+    /**
+     * Get avatar list
+     *
+     * @param count The number of avatars to fetch (default: 50)
+     * @param page The page number to fetch (default: 1)
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function getAvatarList(count = 50, page = 1) {
+        const params = {
+            page,
+            albumId: "0",
+            count,
+            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);
+    };
+});

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

@@ -0,0 +1,24 @@
+import type { BusinessCategory } from "../models/index.js";
+export type GetBizAccountResponse = {
+    biz?: {
+        desc: string | null;
+        cate: BusinessCategory;
+        addr: string;
+        website: string;
+        email: string;
+    };
+    setting_start_page?: {
+        enable_biz_label: number;
+        enable_cate: number;
+        enable_add: number;
+        cta_profile: number;
+        /**
+         * Relative path used to build the catalog URL.
+         *
+         * Example: https://catalog.zalo.me/${cta_catalog}
+         */
+        cta_catalog: string | null;
+    } | null;
+    pkgId: number;
+};
+export declare const getBizAccountFactory: (ctx: import("../context.js").ContextBase, api: import("../apis.js").API) => (friendId: string) => Promise<GetBizAccountResponse>;

package/dist/src/apis/getBizAccount.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getBizAccountFactory = void 0;
+const ZaloApiError_js_1 = require("../Errors/ZaloApiError.js");
+const utils_js_1 = require("../utils.js");
+exports.getBizAccountFactory = (0, utils_js_1.apiFactory)()((api, _ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.profile[0]}/api/social/friend/get-bizacc`);
+    /**
+     * Get biz account
+     *
+     * @param friendId The friend ID to get biz account
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function getBizAccount(friendId) {
+        const params = {
+            fid: friendId,
+        };
+        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/getCatalogList.d.ts

@@ -0,0 +1,18 @@
+import type { CatalogItem } from "../models/index.js";
+export type GetCatalogListPayload = {
+    /**
+     * Number of items to retrieve (default: 20)
+     */
+    limit?: number;
+    lastProductId?: number;
+    /**
+     * Page number (default: 0)
+     */
+    page?: number;
+};
+export type GetCatalogListResponse = {
+    items: CatalogItem[];
+    version: number;
+    has_more: number;
+};
+export declare const getCatalogListFactory: (ctx: import("../context.js").ContextBase, api: import("../apis.js").API) => (payload?: GetCatalogListPayload) => Promise<GetCatalogListResponse>;

package/dist/src/apis/getCatalogList.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCatalogListFactory = void 0;
+const ZaloApiError_js_1 = require("../Errors/ZaloApiError.js");
+const utils_js_1 = require("../utils.js");
+exports.getCatalogListFactory = (0, utils_js_1.apiFactory)()((api, _, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.catalog[0]}/api/prodcatalog/catalog/list`);
+    /**
+     * Get catalog list?
+     *
+     * @param payload payload
+     *
+     * @note this API is used for zBusiness
+     * @throws {ZaloApiError}
+     */
+    return async function getCatalogList(payload) {
+        var _a, _b, _c;
+        const params = {
+            version_list_catalog: 0,
+            limit: (_a = payload === null || payload === void 0 ? void 0 : payload.limit) !== null && _a !== void 0 ? _a : 20,
+            last_product_id: (_b = payload === null || payload === void 0 ? void 0 : payload.lastProductId) !== null && _b !== void 0 ? _b : -1,
+            page: (_c = payload === null || payload === void 0 ? void 0 : payload.page) !== null && _c !== void 0 ? _c : 0,
+        };
+        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/getContext.d.ts

@@ -0,0 +1 @@
+export declare const getContextFactory: (ctx: import("../context.js").ContextBase, api: import("../apis.js").API) => () => import("../context.js").ContextSession;

package/dist/src/apis/getContext.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getContextFactory = void 0;
+const utils_js_1 = require("../utils.js");
+exports.getContextFactory = (0, utils_js_1.apiFactory)()((_, ctx) => {
+    return () => ctx;
+});

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

@@ -0,0 +1 @@
+export declare const getCookieFactory: (ctx: import("../context.js").ContextBase, api: import("../apis.js").API) => () => import("tough-cookie").CookieJar;

package/dist/src/apis/getCookie.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCookieFactory = void 0;
+const utils_js_1 = require("../utils.js");
+exports.getCookieFactory = (0, utils_js_1.apiFactory)()((_, ctx) => {
+    /**
+     * Get the current cookie string
+     */
+    return function getCookie() {
+        return ctx.cookie;
+    };
+});

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

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

package/dist/src/apis/getFriendBoardList.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getFriendBoardListFactory = void 0;
+const ZaloApiError_js_1 = require("../Errors/ZaloApiError.js");
+const utils_js_1 = require("../utils.js");
+exports.getFriendBoardListFactory = (0, utils_js_1.apiFactory)()((api, ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.friend_board[0]}/api/friendboard/list`);
+    /**
+     * Get friend board list
+     *
+     * @param conversationId conversation id
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function getFriendBoardList(conversationId) {
+        const params = {
+            conversationId: conversationId,
+            version: 0,
+            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);
+    };
+});

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

@@ -0,0 +1,10 @@
+export type GetFriendOnlinesStatus = {
+    userId: string;
+    status: string;
+};
+export type GetFriendOnlinesResponse = {
+    predefine: string[];
+    ownerStatus: string;
+    onlines: GetFriendOnlinesStatus[];
+};
+export declare const getFriendOnlinesFactory: (ctx: import("../context.js").ContextBase, api: import("../apis.js").API) => () => Promise<GetFriendOnlinesResponse>;

package/dist/src/apis/getFriendOnlines.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getFriendOnlinesFactory = void 0;
+const ZaloApiError_js_1 = require("../Errors/ZaloApiError.js");
+const utils_js_1 = require("../utils.js");
+exports.getFriendOnlinesFactory = (0, utils_js_1.apiFactory)()((api, ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.profile[0]}/api/social/friend/onlines`);
+    /**
+     * Get friend onlines?
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function getFriendOnlines() {
+        const params = {
+            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, (result) => {
+            const data = result.data;
+            if (Array.isArray(data.onlines)) {
+                for (const online of data.onlines) {
+                    if (typeof online.status === "string") {
+                        const parsed = JSON.parse(online.status);
+                        if (parsed && typeof parsed.status === "string") {
+                            online.status = parsed.status;
+                        }
+                    }
+                }
+            }
+            return data;
+        });
+    };
+});