zalo-toolkit 1.0.0

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").ZaloAPI) => (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").ZaloAPI) => (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/getContext.d.ts

@@ -0,0 +1 @@
+export declare const getContextFactory: (ctx: import("../context.js").ContextBase, api: import("../apis.js").ZaloAPI) => () => 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").ZaloAPI) => () => 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").ZaloAPI) => (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").ZaloAPI) => () => 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").ZaloAPI) => () => Promise<GetFriendRecommendationsResponse>;

package/dist/apis/getFriendRecommendations.js

@@ -0,0 +1,27 @@
+import { ZaloApiError } from '../Errors/ZaloApiError.js';
+import { apiFactory } from '../utils.js';
+export var FriendRecommendationsType;
+(function (FriendRecommendationsType) {
+    FriendRecommendationsType[FriendRecommendationsType["RecommendedFriend"] = 1] = "RecommendedFriend";
+    FriendRecommendationsType[FriendRecommendationsType["ReceivedFriendRequest"] = 2] = "ReceivedFriendRequest";
+})(FriendRecommendationsType || (FriendRecommendationsType = {}));
+export const getFriendRecommendationsFactory = apiFactory()((api, ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.friend[0]}/api/friend/recommendsv2/list`);
+    /**
+     * Get friend recommendations/received friend requests
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function getFriendRecommendations() {
+        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);
+    };
+});

package/dist/apis/getFriendRequestStatus.d.ts

@@ -0,0 +1,8 @@
+export type GetFriendRequestStatusResponse = {
+    addFriendPrivacy: number;
+    isSeenFriendReq: boolean;
+    is_friend: number;
+    is_requested: number;
+    is_requesting: number;
+};
+export declare const getFriendRequestStatusFactory: (ctx: import("../context.js").ContextBase, api: import("../apis.js").ZaloAPI) => (friendId: string) => Promise<GetFriendRequestStatusResponse>;

package/dist/apis/getFriendRequestStatus.js

@@ -0,0 +1,25 @@
+import { ZaloApiError } from '../Errors/ZaloApiError.js';
+import { apiFactory } from '../utils.js';
+export const getFriendRequestStatusFactory = apiFactory()((api, ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.friend[0]}/api/friend/reqstatus`);
+    /**
+     * Get friend request status
+     *
+     * @param friendId friend id
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function getFriendRequestStatus(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(utils.makeURL(serviceURL, { params: encryptedParams }), {
+            method: 'GET',
+        });
+        return utils.resolve(response);
+    };
+});

package/dist/apis/getGroupBlockedMember.d.ts

@@ -0,0 +1,23 @@
+export type GetGroupBlockedMemberPayload = {
+    /**
+     * Page number (default: 1)
+     */
+    page?: number;
+    /**
+     * Number of items to retrieve (default: 50)
+     */
+    count?: number;
+};
+export type GetGroupBlockedMemberResponse = {
+    blocked_members: {
+        id: string;
+        dName: string;
+        zaloName: string;
+        avatar: string;
+        avatar_25: string;
+        accountStatus: number;
+        type: number;
+    }[];
+    has_more: number;
+};
+export declare const getGroupBlockedMemberFactory: (ctx: import("../context.js").ContextBase, api: import("../apis.js").ZaloAPI) => (payload: GetGroupBlockedMemberPayload, groupId: string) => Promise<GetGroupBlockedMemberResponse>;

package/dist/apis/getGroupBlockedMember.js

@@ -0,0 +1,29 @@
+import { ZaloApiError } from '../Errors/ZaloApiError.js';
+import { apiFactory } from '../utils.js';
+export const getGroupBlockedMemberFactory = apiFactory()((api, ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.group[0]}/api/group/blockedmems/list`);
+    /**
+     * Get group blocked member
+     *
+     * @param payload payload
+     * @param groupId group id
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function getGroupBlockedMember(payload, groupId) {
+        var _a, _b;
+        const params = {
+            grid: groupId,
+            page: (_a = payload.page) !== null && _a !== void 0 ? _a : 1,
+            count: (_b = payload.count) !== null && _b !== void 0 ? _b : 50,
+            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/getGroupInfo.d.ts

@@ -0,0 +1,16 @@
+import type { GroupInfo } from '../models/index.js';
+export type GroupInfoResponse = {
+    removedsGroup: string[];
+    unchangedsGroup: string[];
+    gridInfoMap: {
+        [groupId: string]: GroupInfo & {
+            memVerList: string[];
+            pendingApprove: GroupInfoPendingApprove;
+        };
+    };
+};
+export type GroupInfoPendingApprove = {
+    time: number;
+    uids: string[] | null;
+};
+export declare const getGroupInfoFactory: (ctx: import("../context.js").ContextBase, api: import("../apis.js").ZaloAPI) => (groupId: string | string[]) => Promise<GroupInfoResponse>;

package/dist/apis/getGroupInfo.js

@@ -0,0 +1,32 @@
+import { ZaloApiError } from '../Errors/ZaloApiError.js';
+import { apiFactory } from '../utils.js';
+export const getGroupInfoFactory = apiFactory()((api, _, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.group[0]}/api/group/getmg-v2`);
+    /**
+     * Get group information
+     *
+     * @param groupId Group ID or list of group IDs
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function getGroupInfo(groupId) {
+        if (!Array.isArray(groupId))
+            groupId = [groupId];
+        const params = {
+            gridVerMap: JSON.stringify(groupId.reduce((acc, id) => {
+                acc[id] = 0;
+                return acc;
+            }, {})),
+        };
+        const encryptedParams = utils.encodeAES(JSON.stringify(params));
+        if (!encryptedParams)
+            throw new ZaloApiError('Failed to encrypt message');
+        const response = await utils.request(serviceURL, {
+            method: 'POST',
+            body: new URLSearchParams({
+                params: encryptedParams,
+            }),
+        });
+        return utils.resolve(response);
+    };
+});

package/dist/apis/getGroupInviteBoxInfo.d.ts

@@ -0,0 +1,32 @@
+import type { GroupInfo, GroupTopic } from '../models/index.js';
+export type GetGroupInviteBoxInfoPayload = {
+    groupId: string;
+    mpage?: number;
+    mcount?: number;
+};
+export type GetGroupInviteBoxInfoResponse = {
+    groupInfo: GroupInfo & {
+        topic?: Omit<GroupTopic, 'action'>;
+    };
+    inviterInfo: {
+        id: string;
+        dName: string;
+        zaloName: string;
+        avatar: string;
+        avatar_25: string;
+        accountStatus: number;
+        type: number;
+    };
+    grCreatorInfo: {
+        id: string;
+        dName: string;
+        zaloName: string;
+        avatar: string;
+        avatar_25: string;
+        accountStatus: number;
+        type: number;
+    };
+    expiredTs: string;
+    type: number;
+};
+export declare const getGroupInviteBoxInfoFactory: (ctx: import("../context.js").ContextBase, api: import("../apis.js").ZaloAPI) => (payload: GetGroupInviteBoxInfoPayload) => Promise<GetGroupInviteBoxInfoResponse>;

package/dist/apis/getGroupInviteBoxInfo.js

@@ -0,0 +1,38 @@
+import { ZaloApiError } from '../Errors/ZaloApiError.js';
+import { apiFactory } from '../utils.js';
+export const getGroupInviteBoxInfoFactory = apiFactory()((api, _, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.group[0]}/api/group/inv-box/inv-info`);
+    /**
+     * Get group invite box info
+     *
+     * @param payload - The payload of the request
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function getGroupInviteBoxInfo(payload) {
+        var _a, _b;
+        const params = {
+            grId: payload.groupId,
+            mcount: (_a = payload.mcount) !== null && _a !== void 0 ? _a : 10,
+            mpage: (_b = payload.mpage) !== null && _b !== void 0 ? _b : 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, (result) => {
+            const data = result.data;
+            const topic = data.groupInfo.topic;
+            if (typeof topic.params == 'string') {
+                const params = JSON.parse(topic.params);
+                if (typeof params.extra == 'string') {
+                    params.extra = JSON.parse(params.extra);
+                }
+                topic.params = params;
+            }
+            return data;
+        });
+    };
+});

package/dist/apis/getGroupInviteBoxList.d.ts

@@ -0,0 +1,38 @@
+import type { GroupInfo } from '../models/index.js';
+export type GetGroupInviteBoxListPayload = {
+    mpage?: number;
+    page?: number;
+    invPerPage?: number;
+    mcount?: number;
+};
+export type GetGroupInviteBoxListResponse = {
+    invitations: {
+        groupInfo: GroupInfo;
+        inviterInfo: {
+            id: string;
+            dName: string;
+            zaloName: string;
+            avatar: string;
+            avatar_25: string;
+            accountStatus: number;
+            type: number;
+        };
+        grCreatorInfo: {
+            id: string;
+            dName: string;
+            zaloName: string;
+            avatar: string;
+            avatar_25: string;
+            accountStatus: number;
+            type: number;
+        };
+        /**
+         * Expired timestamp max 7 days
+         */
+        expiredTs: string;
+        type: number;
+    }[];
+    total: number;
+    hasMore: boolean;
+};
+export declare const getGroupInviteBoxListFactory: (ctx: import("../context.js").ContextBase, api: import("../apis.js").ZaloAPI) => (payload?: GetGroupInviteBoxListPayload) => Promise<GetGroupInviteBoxListResponse>;

package/dist/apis/getGroupInviteBoxList.js

@@ -0,0 +1,31 @@
+import { ZaloApiError } from '../Errors/ZaloApiError.js';
+import { apiFactory } from '../utils.js';
+export const getGroupInviteBoxListFactory = apiFactory()((api, _, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.group[0]}/api/group/inv-box/list`);
+    /**
+     * Get group invite box list
+     *
+     * @param payload - The payload of the request
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function getGroupInviteBoxList(payload) {
+        var _a, _b, _c, _d;
+        const params = {
+            mpage: (_a = payload === null || payload === void 0 ? void 0 : payload.mpage) !== null && _a !== void 0 ? _a : 1,
+            page: (_b = payload === null || payload === void 0 ? void 0 : payload.page) !== null && _b !== void 0 ? _b : 0,
+            invPerPage: (_c = payload === null || payload === void 0 ? void 0 : payload.invPerPage) !== null && _c !== void 0 ? _c : 12,
+            mcount: (_d = payload === null || payload === void 0 ? void 0 : payload.mcount) !== null && _d !== void 0 ? _d : 10,
+            lastGroupId: null, // @TODO: check type
+            avatar_size: 120,
+            member_avatar_size: 120,
+        };
+        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/getGroupLinkDetail.d.ts

@@ -0,0 +1,9 @@
+export type GetGroupLinkDetailResponse = {
+    link?: string;
+    expiration_date?: number;
+    /**
+     * 1: enabled, 0: disabled
+     */
+    enabled: number;
+};
+export declare const getGroupLinkDetailFactory: (ctx: import("../context.js").ContextBase, api: import("../apis.js").ZaloAPI) => (groupId: string) => Promise<GetGroupLinkDetailResponse>;

package/dist/apis/getGroupLinkDetail.js

@@ -0,0 +1,25 @@
+import { ZaloApiError } from '../Errors/ZaloApiError.js';
+import { apiFactory } from '../utils.js';
+export const getGroupLinkDetailFactory = apiFactory()((api, ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.group[0]}/api/group/link/detail`);
+    /**
+     * Get group link detail
+     *
+     * @param groupId The group id
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function getGroupLinkDetail(groupId) {
+        const params = {
+            grid: groupId,
+            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/getGroupLinkInfo.d.ts

@@ -0,0 +1,34 @@
+import type { GroupSetting } from '../models/index.js';
+export type GetGroupLinkInfoPayload = {
+    link: string;
+    /**
+     * Default: 1
+     */
+    memberPage?: number;
+};
+export type GetGroupLinkInfoResponse = {
+    groupId: string;
+    name: string;
+    desc: string;
+    type: number;
+    creatorId: string;
+    avt: string;
+    fullAvt: string;
+    adminIds: string[];
+    currentMems: {
+        id: string;
+        dName: string;
+        zaloName: string;
+        avatar: string;
+        avatar_25: string;
+        accountStatus: number;
+        type: number;
+    }[];
+    admins: unknown[];
+    hasMoreMember: number;
+    subType: number;
+    totalMember: number;
+    setting: GroupSetting;
+    globalId: string;
+};
+export declare const getGroupLinkInfoFactory: (ctx: import("../context.js").ContextBase, api: import("../apis.js").ZaloAPI) => (payload: GetGroupLinkInfoPayload) => Promise<GetGroupLinkInfoResponse>;