@softtynet/zca-js 2.2.9 → 2.3.1

package/dist/apis/group/getExtraGroupInfo.js

@@ -0,0 +1,32 @@
+import { ZaloApiError } from "../../Errors/ZaloApiError.js";
+import { apiFactory } from "../../utils.js";
+export const getExtraGroupInfoFactory = apiFactory()((api, ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.group[0]}/api/group/userctx/multiget`);
+    /**
+     * Lấy ngữ cảnh và vai trò mở rộng của người dùng đối với nhiều nhóm (command 12607)
+     *
+     * @param groupIds Mảng ID các nhóm cần truy vấn
+     * @throws {ZaloApiError}
+     */
+    return async function getExtraGroupInfo(groupIds) {
+        if (!Array.isArray(groupIds) || groupIds.length === 0) {
+            return {};
+        }
+        const cleanGroupIds = groupIds.map((g) => (g.startsWith("g") ? g.slice(1) : g));
+        const params = {
+            grids: cleanGroupIds,
+            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/group/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").API) => (payload: GetGroupBlockedMemberPayload, groupId: string) => Promise<GetGroupBlockedMemberResponse>;

package/dist/apis/group/getGroupBlockedMember.js

@@ -0,0 +1,28 @@
+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) {
+        const params = {
+            grid: groupId,
+            page: payload.page ?? 1,
+            count: payload.count ?? 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/group/getGroupChatHistory.d.ts

@@ -0,0 +1,18 @@
+import { GroupMessage } from "../../models/index.js";
+export type GetGroupChatHistoryResponse = {
+    error?: number;
+    lastMsgId?: number;
+    minMsgId?: number;
+    maxMsgId?: number;
+    msgJumpId?: number;
+    hasMore?: boolean;
+    isOld?: boolean;
+    isFiltered?: boolean;
+    rootMsgId?: number;
+    isRootDel?: boolean;
+    groupMsgs: GroupMessage[];
+    tsJoinGroup?: number;
+    isFilteredByPhase?: boolean;
+    isFilteredByTimeJoin?: boolean;
+};
+export declare const getGroupChatHistoryFactory: (ctx: import("../../context.js").ContextBase, api: import("../../apis.js").API) => (groupId: string, count?: number) => Promise<GetGroupChatHistoryResponse>;

package/dist/apis/group/getGroupChatHistory.js

@@ -0,0 +1,64 @@
+import { ZaloApiError } from "../../Errors/ZaloApiError.js";
+import { apiFactory } from "../../utils.js";
+import { GroupMessage } from "../../models/index.js";
+export const getGroupChatHistoryFactory = apiFactory()((api, ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.group_cloud_message[0]}/api/cm/getrecentv2`);
+    /**
+     * Get group chat history from Zalo Cloud Message (newest first)
+     *
+     * @param groupId group id
+     * @param count count of messages to return (default: 50, max safe limit: 200)
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function getGroupChatHistory(groupId, count = 50) {
+        if (!groupId)
+            throw new ZaloApiError("Missing groupId");
+        if (groupId.startsWith("g"))
+            groupId = groupId.slice(1);
+        const safeCount = Math.min(Math.max(count, 1), 200);
+        const messages = [];
+        let cursor = 0;
+        let lastPage = null;
+        let pageCount = 0;
+        while (messages.length < safeCount && pageCount < 10) {
+            pageCount++;
+            const params = {
+                groupId,
+                globalMsgId: cursor,
+                count: Math.min(50, safeCount - messages.length),
+                msgIds: [],
+                imei: ctx.imei,
+                src: 3,
+            };
+            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, nretry: 0 }), {
+                method: "GET",
+            });
+            lastPage = await utils.resolve(response, (result) => {
+                let data = result.data;
+                if (typeof data === "string") {
+                    data = JSON.parse(data);
+                }
+                return data;
+            });
+            if (!lastPage || !Array.isArray(lastPage.groupMsgs))
+                break;
+            for (const rawMsg of lastPage.groupMsgs) {
+                if (messages.length >= safeCount)
+                    break;
+                if (messages.some((m) => m.msgId === rawMsg.msgId))
+                    continue;
+                messages.push(rawMsg);
+            }
+            const nextCursor = Number(lastPage.lastMsgId);
+            if (!lastPage.hasMore || !nextCursor || nextCursor === cursor)
+                break;
+            cursor = nextCursor;
+        }
+        const groupMsgs = messages.map((data) => new GroupMessage(ctx.uid, data));
+        return Object.assign({}, lastPage || {}, { groupMsgs });
+    };
+});

package/dist/apis/group/getGroupCloudMessageJump.d.ts

@@ -0,0 +1,3 @@
+import type { GetGroupChatHistoryResponse } from "./getGroupChatHistory.js";
+export type GetGroupCloudMessageJumpResponse = GetGroupChatHistoryResponse;
+export declare const getGroupCloudMessageJumpFactory: (ctx: import("../../context.js").ContextBase, api: import("../../apis.js").API) => (groupId: string, globalMsgId: string | number, count?: number, msgJump?: number, msgIds?: Array<string | number>) => Promise<GetGroupChatHistoryResponse>;

package/dist/apis/group/getGroupCloudMessageJump.js

@@ -0,0 +1,46 @@
+import { ZaloApiError } from "../../Errors/ZaloApiError.js";
+import { GroupMessage } from "../../models/index.js";
+import { apiFactory } from "../../utils.js";
+export const getGroupCloudMessageJumpFactory = apiFactory()((api, ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.group_cloud_message[0]}/api/cm/rgetv2`);
+    /**
+     * Nhảy tới vị trí một tin nhắn nhóm cụ thể trên Zalo Cloud Message và lấy ngữ cảnh xung quanh (command 12508)
+     *
+     * @param groupId ID nhóm
+     * @param globalMsgId ID tin nhắn toàn cục cần nhảy tới
+     * @param count Số lượng tin nhắn ngữ cảnh cần tải (mặc định `20`)
+     * @param msgJump Cờ nhảy tin nhắn (mặc định `1`)
+     * @param msgIds Danh sách msgId bổ sung (mặc định `[]`)
+     * @throws {ZaloApiError}
+     */
+    return async function getGroupCloudMessageJump(groupId, globalMsgId, count = 20, msgJump = 1, msgIds = []) {
+        if (!groupId)
+            throw new ZaloApiError("Missing groupId");
+        if (groupId.startsWith("g"))
+            groupId = groupId.slice(1);
+        const params = {
+            groupId,
+            globalMsgId: String(globalMsgId),
+            count: Math.min(Math.max(count, 1), 50),
+            msgJump,
+            msgIds,
+            src: 3,
+        };
+        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, nretry: 0 }), {
+            method: "GET",
+        });
+        const page = await utils.resolve(response, (result) => {
+            let data = result.data;
+            if (typeof data === "string") {
+                data = JSON.parse(data);
+            }
+            return data;
+        });
+        const rawMsgs = Array.isArray(page?.groupMsgs) ? page.groupMsgs : [];
+        const groupMsgs = rawMsgs.map((data) => new GroupMessage(ctx.uid, data));
+        return Object.assign({}, page || {}, { groupMsgs });
+    };
+});

package/dist/apis/group/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").API) => (groupId: string | string[]) => Promise<GroupInfoResponse>;

package/dist/apis/group/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/group/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").API) => (payload: GetGroupInviteBoxInfoPayload) => Promise<GetGroupInviteBoxInfoResponse>;

package/dist/apis/group/getGroupInviteBoxInfo.js

@@ -0,0 +1,37 @@
+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) {
+        const params = {
+            grId: payload.groupId,
+            mcount: payload.mcount ?? 10,
+            mpage: payload.mpage ?? 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/group/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").API) => (payload?: GetGroupInviteBoxListPayload) => Promise<GetGroupInviteBoxListResponse>;

package/dist/apis/group/getGroupInviteBoxList.js

@@ -0,0 +1,30 @@
+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) {
+        const params = {
+            mpage: payload?.mpage ?? 1,
+            page: payload?.page ?? 0,
+            invPerPage: payload?.invPerPage ?? 12,
+            mcount: payload?.mcount ?? 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/group/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").API) => (groupId: string) => Promise<GetGroupLinkDetailResponse>;

package/dist/apis/group/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/group/getGroupLinkInfo.d.ts

@@ -0,0 +1,34 @@
+import type { GroupSetting, GroupType } from "../../models/index.js";
+export type GetGroupLinkInfoPayload = {
+    link: string;
+    /**
+     * Default: 1
+     */
+    memberPage?: number;
+};
+export type GetGroupLinkInfoResponse = {
+    groupId: string;
+    name: string;
+    desc: string;
+    type: GroupType;
+    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").API) => (payload: GetGroupLinkInfoPayload) => Promise<GetGroupLinkInfoResponse>;

package/dist/apis/group/getGroupLinkInfo.js

@@ -0,0 +1,27 @@
+import { ZaloApiError } from "../../Errors/ZaloApiError.js";
+import { apiFactory } from "../../utils.js";
+export const getGroupLinkInfoFactory = apiFactory()((api, _ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.group[0]}/api/group/link/ginfo`);
+    /**
+     * Get group link info
+     *
+     * @param payload - The payload of the request
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function getGroupLinkInfo(payload) {
+        const params = {
+            link: payload.link,
+            avatar_size: 120,
+            member_avatar_size: 120,
+            mpage: payload.memberPage ?? 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/group/getGroupMembersInfo.d.ts

@@ -0,0 +1,17 @@
+export type GroupMemberProfile = {
+    displayName: string;
+    zaloName: string;
+    avatar: string;
+    accountStatus: number;
+    type: number;
+    lastUpdateTime: number;
+    globalId: string;
+    id: string;
+};
+export type GetGroupMembersInfoResponse = {
+    profiles: {
+        [memberId: string]: GroupMemberProfile;
+    };
+    unchangeds_profile: unknown[];
+};
+export declare const getGroupMembersInfoFactory: (ctx: import("../../context.js").ContextBase, api: import("../../apis.js").API) => (memberId: string | string[]) => Promise<GetGroupMembersInfoResponse>;

package/dist/apis/group/getGroupMembersInfo.js

@@ -0,0 +1,24 @@
+import { ZaloApiError } from "../../Errors/ZaloApiError.js";
+import { apiFactory } from "../../utils.js";
+export const getGroupMembersInfoFactory = apiFactory()((api, _, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.profile[0]}/api/social/group/members`);
+    /**
+     * Get group information
+     *
+     * @param memberId member id or array of member ids
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function getGroupMembersInfo(memberId) {
+        if (!Array.isArray(memberId))
+            memberId = [memberId];
+        const params = {
+            friend_pversion_map: memberId.map((id) => (id.endsWith("_0") ? id : `${id}_0`)),
+        };
+        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 }));
+        return utils.resolve(response);
+    };
+});

package/dist/apis/group/getPendingGroupMembers.d.ts

@@ -0,0 +1,11 @@
+export type GetPendingGroupMembersUserInfo = {
+    uid: string;
+    dpn: string;
+    avatar: string;
+    user_submit: null;
+};
+export type GetPendingGroupMembersResponse = {
+    time: number;
+    users: GetPendingGroupMembersUserInfo[];
+};
+export declare const getPendingGroupMembersFactory: (ctx: import("../../context.js").ContextBase, api: import("../../apis.js").API) => (groupId: string) => Promise<GetPendingGroupMembersResponse>;

package/dist/apis/group/getPendingGroupMembers.js

@@ -0,0 +1,27 @@
+import { ZaloApiError } from "../../Errors/ZaloApiError.js";
+import { apiFactory } from "../../utils.js";
+export const getPendingGroupMembersFactory = apiFactory()((api, ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.group[0]}/api/group/pending-mems/list`);
+    /**
+     * Get pending group members
+     *
+     * @param groupId - The id of the group to get the pending members
+     *
+     * @note Only the group leader and deputy group leader can view
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function getPendingGroupMembers(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/group/getQuotaCommunity.d.ts

@@ -0,0 +1,8 @@
+export type GetQuotaCommunityResponse = {
+    canUpgr: boolean;
+    curComm: number;
+    quotaComm: number;
+    error_message_localize?: string;
+    [key: string]: unknown;
+};
+export declare const getQuotaCommunityFactory: (ctx: import("../../context.js").ContextBase, api: import("../../apis.js").API) => (groupId?: string | null, language?: string) => Promise<GetQuotaCommunityResponse>;

package/dist/apis/group/getQuotaCommunity.js

@@ -0,0 +1,27 @@
+import { ZaloApiError } from "../../Errors/ZaloApiError.js";
+import { apiFactory } from "../../utils.js";
+export const getQuotaCommunityFactory = apiFactory()((api, _ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.group[0]}/api/group/quota/community`);
+    /**
+     * Kiểm tra hạn mức nâng cấp nhóm lên Cộng đồng của tài khoản (command 12181)
+     *
+     * @param groupId (Tùy chọn) ID của nhóm cần kiểm tra
+     * @param language Ngôn ngữ thông báo (mặc định: `"vi"`)
+     * @throws {ZaloApiError}
+     */
+    return async function getQuotaCommunity(groupId = null, language = "vi") {
+        const cleanGroupId = groupId && groupId.startsWith("g") ? groupId.slice(1) : groupId;
+        const params = {
+            language,
+            grId: cleanGroupId,
+        };
+        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/group/getRelatedFriendGroup.d.ts

@@ -0,0 +1,6 @@
+export type GetRelatedFriendGroupResponse = {
+    groupRelateds: {
+        [friendId: string]: string[];
+    };
+};
+export declare const getRelatedFriendGroupFactory: (ctx: import("../../context.js").ContextBase, api: import("../../apis.js").API) => (friendId: string | string[]) => Promise<GetRelatedFriendGroupResponse>;