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

package/dist/apis/forwardMessage.js

@@ -0,0 +1,99 @@
+import { ZaloApiError } from "../Errors/ZaloApiError.js";
+import { ThreadType } from "../models/index.js";
+import { apiFactory } from "../utils.js";
+export const forwardMessageFactory = apiFactory()((api, ctx, utils) => {
+    const serviceURL = {
+        [ThreadType.User]: utils.makeURL(`${api.zpwServiceMap.file[0]}/api/message/mforward`),
+        [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 = ThreadType.User) {
+        var _a, _b;
+        if (!payload.message)
+            throw new ZaloApiError("Missing message content");
+        if (!threadIds || threadIds.length === 0)
+            throw new 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 === 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("Failed to encrypt params");
+        const response = await utils.request(serviceURL[type], {
+            method: "POST",
+            body: new URLSearchParams({
+                params: encryptedParams,
+            }),
+        });
+        return utils.resolve(response);
+    };
+});

package/dist/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/apis/getAliasList.js

@@ -0,0 +1,27 @@
+import { ZaloApiError } from "../Errors/ZaloApiError.js";
+import { apiFactory } from "../utils.js";
+export const getAliasListFactory = 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("Failed to encrypt params");
+        const response = await utils.request(utils.makeURL(serviceURL, { params: encryptedParams }), {
+            method: "GET",
+        });
+        return utils.resolve(response);
+    };
+});

package/dist/apis/getAllFriends.d.ts

@@ -0,0 +1,3 @@
+import { AvatarSize, 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, avatarSize?: AvatarSize) => Promise<GetAllFriendsResponse>;

package/dist/apis/getAllFriends.js

@@ -0,0 +1,34 @@
+import { ZaloApiError } from "../Errors/ZaloApiError.js";
+import { apiFactory } from "../utils.js";
+import { AvatarSize } from "../models/index.js";
+export const getAllFriendsFactory = 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)
+     * @param avatarSize Avatar size (default: AvatarSize.Small)
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function getAllFriends(count = 20000, page = 1, avatarSize = AvatarSize.Small) {
+        const params = {
+            incInvalid: 1,
+            page,
+            count,
+            avatar_size: avatarSize,
+            actiontime: 0,
+            imei: ctx.imei,
+        };
+        const encryptedParams = utils.encodeAES(JSON.stringify(params));
+        if (!encryptedParams)
+            throw new ZaloApiError("Failed to encrypt message");
+        const response = await utils.request(utils.makeURL(serviceURL, {
+            params: encryptedParams,
+        }), {
+            method: "GET",
+        });
+        return utils.resolve(response);
+    };
+});

package/dist/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/apis/getAllGroups.js

@@ -0,0 +1,10 @@
+import { apiFactory } from "../utils.js";
+export const getAllGroupsFactory = 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/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/apis/getArchivedChatList.js

@@ -0,0 +1,23 @@
+import { ZaloApiError } from "../Errors/ZaloApiError.js";
+import { apiFactory } from "../utils.js";
+export const getArchivedChatListFactory = 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("Failed to encrypt params");
+        const response = await utils.request(utils.makeURL(serviceURL, { params: encryptedParams }), {
+            method: "GET",
+        });
+        return utils.resolve(response);
+    };
+});

package/dist/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/apis/getAutoDeleteChat.js

@@ -0,0 +1,21 @@
+import { ZaloApiError } from "../Errors/ZaloApiError.js";
+import { apiFactory } from "../utils.js";
+export const getAutoDeleteChatFactory = 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("Failed to encrypt params");
+        const response = await utils.request(utils.makeURL(serviceURL, { params: encryptedParams }), {
+            method: "GET",
+        });
+        return utils.resolve(response);
+    };
+});

package/dist/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/apis/getAutoReplyList.js

@@ -0,0 +1,24 @@
+import { ZaloApiError } from "../Errors/ZaloApiError.js";
+import { apiFactory } from "../utils.js";
+export const getAutoReplyListFactory = 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("Failed to encrypt params");
+        const response = await utils.request(utils.makeURL(serviceURL, { params: encryptedParams }), {
+            method: "GET",
+        });
+        return utils.resolve(response);
+    };
+});

package/dist/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/apis/getAvatarList.js

@@ -0,0 +1,28 @@
+import { ZaloApiError } from "../Errors/ZaloApiError.js";
+import { apiFactory } from "../utils.js";
+export const getAvatarListFactory = 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("Failed to encrypt params");
+        const response = await utils.request(utils.makeURL(serviceURL, { params: encryptedParams }), {
+            method: "GET",
+        });
+        return utils.resolve(response);
+    };
+});

package/dist/apis/getAvatarUrlProfile.d.ts

@@ -0,0 +1,7 @@
+import { AvatarSize } from "../models/index.js";
+export type GetAvatarUrlProfileResponse = {
+    [userId: string]: {
+        avatar: string;
+    };
+};
+export declare const getAvatarUrlProfileFactory: (ctx: import("../context.js").ContextBase, api: import("../apis.js").API) => (friendIds: string | string[], avatarSize?: AvatarSize) => Promise<GetAvatarUrlProfileResponse>;

package/dist/apis/getAvatarUrlProfile.js

@@ -0,0 +1,30 @@
+import { ZaloApiError } from "../Errors/ZaloApiError.js";
+import { AvatarSize } from "../models/index.js";
+import { apiFactory } from "../utils.js";
+export const getAvatarUrlProfileFactory = apiFactory()((api, _ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.profile[0]}/api/social/profile/avatar-url`);
+    /**
+     * Get avatar url profile
+     *
+     * @param friendId friend id(s)
+     * @param avatarSize Avatar size (default: AvatarSize.Large)
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function getAvatarUrlProfile(friendIds, avatarSize = AvatarSize.Large) {
+        if (!Array.isArray(friendIds))
+            friendIds = [friendIds];
+        const params = {
+            friend_ids: friendIds,
+            avatar_size: avatarSize,
+            srcReq: -1,
+        };
+        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/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/apis/getBizAccount.js

@@ -0,0 +1,27 @@
+import { ZaloApiError } from "../Errors/ZaloApiError.js";
+import { apiFactory } from "../utils.js";
+export const getBizAccountFactory = 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("Failed to encrypt params");
+        const response = await utils.request(serviceURL, {
+            method: "POST",
+            body: new URLSearchParams({
+                params: encryptedParams,
+            }),
+        });
+        return utils.resolve(response);
+    };
+});

package/dist/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/apis/getCatalogList.js

@@ -0,0 +1,32 @@
+import { ZaloApiError } from "../Errors/ZaloApiError.js";
+import { apiFactory } from "../utils.js";
+export const getCatalogListFactory = 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("Failed to encrypt params");
+        const response = await utils.request(serviceURL, {
+            method: "POST",
+            body: new URLSearchParams({
+                params: encryptedParams,
+            }),
+        });
+        return utils.resolve(response);
+    };
+});

package/dist/apis/getCloseFriends.d.ts

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

package/dist/apis/getCloseFriends.js

@@ -0,0 +1,20 @@
+import { ZaloApiError } from "../Errors/ZaloApiError.js";
+import { apiFactory } from "../utils.js";
+export const getCloseFriendsFactory = apiFactory()((api, _ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.profile[0]}/api/social/friend/getclosedfriends`);
+    /**
+     * Get close friends
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function getCloseFriends() {
+        const params = {};
+        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/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/apis/getContext.js

@@ -0,0 +1,4 @@
+import { apiFactory } from "../utils.js";
+export const getContextFactory = apiFactory()((_, ctx) => {
+    return () => ctx;
+});

package/dist/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/apis/getCookie.js

@@ -0,0 +1,9 @@
+import { apiFactory } from "../utils.js";
+export const getCookieFactory = apiFactory()((_, ctx) => {
+    /**
+     * Get the current cookie string
+     */
+    return function getCookie() {
+        return ctx.cookie;
+    };
+});

package/dist/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/apis/getFriendBoardList.js

@@ -0,0 +1,26 @@
+import { ZaloApiError } from "../Errors/ZaloApiError.js";
+import { apiFactory } from "../utils.js";
+export const getFriendBoardListFactory = 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("Failed to encrypt params");
+        const response = await utils.request(utils.makeURL(serviceURL, { params: encryptedParams }), {
+            method: "GET",
+        });
+        return utils.resolve(response);
+    };
+});

package/dist/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/apis/getFriendOnlines.js

@@ -0,0 +1,35 @@
+import { ZaloApiError } from "../Errors/ZaloApiError.js";
+import { apiFactory } from "../utils.js";
+export const getFriendOnlinesFactory = 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("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;
+        });
+    };
+});

package/dist/apis/getFriendRecommendations.d.ts

@@ -0,0 +1,42 @@
+import type { Gender, ZBusinessPackage } from "../models/index.js";
+export declare enum FriendRecommendationsType {
+    RecommendedFriend = 1,
+    ReceivedFriendRequest = 2
+}
+export type FriendRecommendationsCollapseMsgListConfig = {
+    collapseId: number;
+    collapseXItem: number;
+    collapseYItem: number;
+};
+export type FriendRecommendationsDataInfo = {
+    userId: string;
+    zaloName: string;
+    displayName: string;
+    avatar: string;
+    phoneNumber: string;
+    status: string;
+    gender: Gender;
+    dob: number;
+    type: number;
+    recommType: FriendRecommendationsType;
+    recommSrc: number;
+    recommTime: number;
+    recommInfo: {
+        suggestWay: number;
+        source: number;
+        message: string;
+        customText: string | null;
+    };
+    bizPkg: ZBusinessPackage;
+    isSeenFriendReq: boolean;
+};
+export type FriendRecommendationsRecommItem = {
+    recommItemType: number;
+    dataInfo: FriendRecommendationsDataInfo;
+};
+export type GetFriendRecommendationsResponse = {
+    expiredDuration: number;
+    collapseMsgListConfig: FriendRecommendationsCollapseMsgListConfig;
+    recommItems: FriendRecommendationsRecommItem[];
+};
+export declare const getFriendRecommendationsFactory: (ctx: import("../context.js").ContextBase, api: import("../apis.js").API) => () => Promise<GetFriendRecommendationsResponse>;