@trungdlp/zca-js 1.0.0

package/dist/apis/getMultiUsersByPhone.js

@@ -0,0 +1,38 @@
+import { ZaloApiError } from "../Errors/ZaloApiError.js";
+import { apiFactory } from "../utils.js";
+export const getMultiUsersByPhoneFactory = apiFactory()((api, ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.friend[0]}/api/friend/profile/multiget`);
+    /**
+     * Get multiple user(s) by phone number
+     *
+     * @param phoneNumber Phone(s) number
+     * @param isAvatarSizeMax Is avatar size max (default: true)
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function getMultiUsersByPhone(phoneNumbers, isAvatarSizeMax = true) {
+        if (!phoneNumbers)
+            throw new ZaloApiError("Missing phoneNumber");
+        if (!Array.isArray(phoneNumbers))
+            phoneNumbers = [phoneNumbers];
+        phoneNumbers = phoneNumbers.map((phone) => {
+            if (phone.startsWith("0")) {
+                if (ctx.language == "vi")
+                    phone = "84" + phone.slice(1);
+            }
+            return phone;
+        });
+        const params = {
+            phones: phoneNumbers,
+            avatar_size: isAvatarSizeMax ? 240 : 120,
+            language: 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/getMute.d.ts

@@ -0,0 +1,13 @@
+export type MuteEntriesInfo = {
+    id: string;
+    duration: number;
+    startTime: number;
+    systemTime: number;
+    currentTime: number;
+    muteMode: number;
+};
+export type GetMuteResponse = {
+    chatEntries: MuteEntriesInfo[];
+    groupChatEntries: MuteEntriesInfo[];
+};
+export declare const getMuteFactory: (ctx: import("../context.js").ContextBase, api: import("../apis.js").API) => () => Promise<GetMuteResponse>;

package/dist/apis/getMute.js

@@ -0,0 +1,22 @@
+import { ZaloApiError } from "../Errors/ZaloApiError.js";
+import { apiFactory } from "../utils.js";
+export const getMuteFactory = apiFactory()((api, ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.profile[0]}/api/social/profile/getmute`);
+    /**
+     * Get mute
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function getMute() {
+        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/getOwnId.d.ts

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

package/dist/apis/getOwnId.js

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

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

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

package/dist/apis/getPinConversations.js

@@ -0,0 +1,22 @@
+import { ZaloApiError } from "../Errors/ZaloApiError.js";
+import { apiFactory } from "../utils.js";
+export const getPinConversationsFactory = apiFactory()((api, ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.conversation[0]}/api/pinconvers/list`);
+    /**
+     * Get pin conversations
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function getPinConversations() {
+        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/getPollDetail.d.ts

@@ -0,0 +1,3 @@
+import type { PollDetail } from "../models/index.js";
+export type PollDetailResponse = PollDetail;
+export declare const getPollDetailFactory: (ctx: import("../context.js").ContextBase, api: import("../apis.js").API) => (pollId: number) => Promise<PollDetail>;

package/dist/apis/getPollDetail.js

@@ -0,0 +1,30 @@
+import { ZaloApiError } from "../Errors/ZaloApiError.js";
+import { apiFactory } from "../utils.js";
+export const getPollDetailFactory = apiFactory()((api, ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.group[0]}/api/poll/detail`);
+    /**
+     * Get poll detail
+     *
+     * @param pollId Poll ID
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function getPollDetail(pollId) {
+        if (!pollId)
+            throw new ZaloApiError("Missing poll id");
+        const params = {
+            poll_id: pollId,
+            imei: ctx.imei,
+        };
+        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/getProductCatalogList.d.ts

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

package/dist/apis/getProductCatalogList.js

@@ -0,0 +1,33 @@
+import { ZaloApiError } from "../Errors/ZaloApiError.js";
+import { apiFactory } from "../utils.js";
+export const getProductCatalogListFactory = apiFactory()((api, _, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.catalog[0]}/api/prodcatalog/product/list`);
+    /**
+     * Get product catalog list?
+     *
+     * @param payload payload
+     *
+     * @note this API is used for zBusiness
+     * @throws {ZaloApiError}
+     */
+    return async function getProductCatalogList(payload) {
+        var _a, _b, _c, _d;
+        const params = {
+            catalog_id: payload.catalogId,
+            limit: (_a = payload.limit) !== null && _a !== void 0 ? _a : 100,
+            version_catalog: (_b = payload.versionCatalog) !== null && _b !== void 0 ? _b : 0,
+            last_product_id: (_c = payload.lastProductId) !== null && _c !== void 0 ? _c : -1,
+            page: (_d = payload.page) !== null && _d !== void 0 ? _d : 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/getQR.d.ts

@@ -0,0 +1,4 @@
+export type GetQRResponse = {
+    [userId: string]: string;
+};
+export declare const getQRFactory: (ctx: import("../context.js").ContextBase, api: import("../apis.js").API) => (userId: string | string[]) => Promise<GetQRResponse>;

package/dist/apis/getQR.js

@@ -0,0 +1,29 @@
+import { ZaloApiError } from "../Errors/ZaloApiError.js";
+import { apiFactory } from "../utils.js";
+export const getQRFactory = apiFactory()((api, _, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.friend[0]}/api/friend/mget-qr`);
+    /**
+     * Get QR code for users
+     *
+     * @param userId User ID or list of user IDs
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function getQR(userId) {
+        if (typeof userId == "string")
+            userId = [userId];
+        const params = {
+            fids: userId,
+        };
+        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/getQuickMessageList.d.ts

@@ -0,0 +1,7 @@
+import type { QuickMessage } from "../models/index.js";
+export type GetQuickMessageListResponse = {
+    cursor: number;
+    version: number;
+    items: QuickMessage[];
+};
+export declare const getQuickMessageListFactory: (ctx: import("../context.js").ContextBase, api: import("../apis.js").API) => () => Promise<GetQuickMessageListResponse>;

package/dist/apis/getQuickMessageList.js

@@ -0,0 +1,24 @@
+import { ZaloApiError } from "../Errors/ZaloApiError.js";
+import { apiFactory } from "../utils.js";
+export const getQuickMessageListFactory = apiFactory()((api, ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.quick_message[0]}/api/quickmessage/list`);
+    /**
+     * Get quick message list
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function getQuickMessageList() {
+        const params = {
+            version: 0,
+            lang: 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/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>;

package/dist/apis/getRelatedFriendGroup.js

@@ -0,0 +1,30 @@
+import { ZaloApiError } from "../Errors/ZaloApiError.js";
+import { apiFactory } from "../utils.js";
+export const getRelatedFriendGroupFactory = apiFactory()((api, ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.friend[0]}/api/friend/group/related`);
+    /**
+     * Get related friend group
+     *
+     * @param friendId friend ids
+     *
+     * @note this API is used for zBusiness
+     * @throws {ZaloApiError}
+     */
+    return async function getRelatedFriendGroup(friendId) {
+        const friendIds = Array.isArray(friendId) ? friendId : [friendId];
+        const params = {
+            friend_ids: JSON.stringify(friendIds),
+            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/getReminder.d.ts

@@ -0,0 +1,3 @@
+import type { ReminderGroup } from "../models/index.js";
+export type GetReminderResponse = ReminderGroup;
+export declare const getReminderFactory: (ctx: import("../context.js").ContextBase, api: import("../apis.js").API) => (reminderId: string) => Promise<ReminderGroup>;

package/dist/apis/getReminder.js

@@ -0,0 +1,25 @@
+import { ZaloApiError } from "../Errors/ZaloApiError.js";
+import { apiFactory } from "../utils.js";
+export const getReminderFactory = apiFactory()((api, ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.group_board[0]}/api/board/topic/getReminder`);
+    /**
+     * Get reminder details from a group
+     *
+     * @param reminderId Reminder ID
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function getReminder(reminderId) {
+        const params = {
+            eventId: reminderId,
+            imei: ctx.imei,
+        };
+        const encryptedParams = utils.encodeAES(JSON.stringify(params));
+        if (!encryptedParams)
+            throw new ZaloApiError("Failed to encrypt params");
+        const response = await utils.request(utils.makeURL(serviceURL, { params: encryptedParams }), {
+            method: "GET",
+        });
+        return utils.resolve(response);
+    };
+});

package/dist/apis/getReminderResponses.d.ts

@@ -0,0 +1,5 @@
+export type GetReminderResponsesResponse = {
+    rejectMember: string[];
+    acceptMember: string[];
+};
+export declare const getReminderResponsesFactory: (ctx: import("../context.js").ContextBase, api: import("../apis.js").API) => (reminderId: string) => Promise<GetReminderResponsesResponse>;

package/dist/apis/getReminderResponses.js

@@ -0,0 +1,24 @@
+import { ZaloApiError } from "../Errors/ZaloApiError.js";
+import { apiFactory } from "../utils.js";
+export const getReminderResponsesFactory = apiFactory()((api, _ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.group_board[0]}/api/board/topic/listResponseEvent`);
+    /**
+     * Get reminder responses
+     *
+     * @param reminderId reminder id
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function getReminderResponses(reminderId) {
+        const params = {
+            eventId: reminderId,
+        };
+        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/getSearchSticker.d.ts

@@ -0,0 +1,3 @@
+import type { StickerBasic } from "../models/index.js";
+export type GetSearchStickerResponse = StickerBasic[];
+export declare const getSearchStickerFactory: (ctx: import("../context.js").ContextBase, api: import("../apis.js").API) => (keyword: string, limit?: number) => Promise<GetSearchStickerResponse>;

package/dist/apis/getSearchSticker.js

@@ -0,0 +1,28 @@
+import { ZaloApiError } from "../Errors/ZaloApiError.js";
+import { apiFactory } from "../utils.js";
+export const getSearchStickerFactory = apiFactory()((api, ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.sticker[0]}/api/message/sticker/search`);
+    /**
+     * Get search sticker
+     *
+     * @param keyword Keyword to search sticker
+     * @param limit Limit of stickers to return (default: 50)
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function getSearchSticker(keyword, limit = 50) {
+        const params = {
+            keyword: keyword,
+            limit: limit,
+            srcType: 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/getSentFriendRequest.d.ts

@@ -0,0 +1,18 @@
+import type { ZBusinessPackage } from "../models/ZBusiness.js";
+export type SentFriendRequestInfo = {
+    userId: string;
+    zaloName: string;
+    displayName: string;
+    avatar: string;
+    globalId: string;
+    bizPkg: ZBusinessPackage;
+    fReqInfo: {
+        message: string;
+        src: number;
+        time: number;
+    };
+};
+export type GetSentFriendRequestResponse = {
+    [userId: string]: SentFriendRequestInfo;
+};
+export declare const getSentFriendRequestFactory: (ctx: import("../context.js").ContextBase, api: import("../apis.js").API) => () => Promise<GetSentFriendRequestResponse>;

package/dist/apis/getSentFriendRequest.js

@@ -0,0 +1,24 @@
+import { ZaloApiError } from "../Errors/ZaloApiError.js";
+import { apiFactory } from "../utils.js";
+export const getSentFriendRequestFactory = apiFactory()((api, ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.friend[0]}/api/friend/requested/list`);
+    /**
+     * Get friend requested
+     *
+     * @note Zalo might throw an error with code 112 if you have no friend requests.
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function getSentFriendRequest() {
+        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/getSettings.d.ts

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

package/dist/apis/getSettings.js

@@ -0,0 +1,20 @@
+import { ZaloApiError } from "../Errors/ZaloApiError.js";
+import { apiFactory } from "../utils.js";
+export const getSettingsFactory = apiFactory()((_api, _ctx, utils) => {
+    const serviceURL = utils.makeURL(`https://wpa.chat.zalo.me/api/setting/me`);
+    /**
+     * Get my account settings
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function getSettings() {
+        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/getStickerCategoryDetail.d.ts

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

package/dist/apis/getStickerCategoryDetail.js

@@ -0,0 +1,24 @@
+import { ZaloApiError } from "../Errors/ZaloApiError.js";
+import { apiFactory } from "../utils.js";
+export const getStickerCategoryDetailFactory = apiFactory()((api, ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.sticker[0]}/api/message/sticker/category/sticker_detail`);
+    /**
+     * Get sticker category detail
+     *
+     * @param cateId Sticker category ID
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function getStickerCategoryDetail(cateId) {
+        const params = {
+            cid: cateId,
+        };
+        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/getStickers.d.ts

@@ -0,0 +1 @@
+export declare const getStickersFactory: (ctx: import("../context.js").ContextBase, api: import("../apis.js").API) => (keyword: string) => Promise<number[]>;

package/dist/apis/getStickers.js

@@ -0,0 +1,40 @@
+import { ZaloApiError } from "../Errors/ZaloApiError.js";
+import { apiFactory } from "../utils.js";
+export const getStickersFactory = apiFactory()((api, ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.sticker}/api/message/sticker`);
+    /**
+     * Get stickers by keyword
+     *
+     * @param keyword Keyword to search for
+     * @returns Sticker IDs
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function getStickers(keyword) {
+        if (!keyword)
+            throw new ZaloApiError("Missing keyword");
+        const params = {
+            keyword: keyword,
+            gif: 1,
+            guggy: 0,
+            imei: ctx.imei,
+        };
+        const encryptedParams = utils.encodeAES(JSON.stringify(params));
+        if (!encryptedParams)
+            throw new ZaloApiError("Failed to encrypt message");
+        const finalServiceUrl = new URL(serviceURL);
+        finalServiceUrl.pathname = finalServiceUrl.pathname + "/suggest/stickers";
+        const response = await utils.request(utils.makeURL(finalServiceUrl.toString(), {
+            params: encryptedParams,
+        }));
+        return utils.resolve(response, (result) => {
+            const suggestions = result.data;
+            const stickerIds = [];
+            // @TODO: Implement these
+            // suggestions.sugg_guggy, suggestions.sugg_gif
+            if (suggestions.sugg_sticker)
+                suggestions.sugg_sticker.forEach((sticker) => stickerIds.push(sticker.sticker_id));
+            return stickerIds;
+        });
+    };
+});

package/dist/apis/getStickersDetail.d.ts

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

package/dist/apis/getStickersDetail.js

@@ -0,0 +1,40 @@
+import { ZaloApiError } from "../Errors/ZaloApiError.js";
+import { apiFactory, resolveResponse } from "../utils.js";
+export const getStickersDetailFactory = apiFactory()((api, ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.sticker}/api/message/sticker/sticker_detail`);
+    /**
+     * Get stickers detail by sticker IDs
+     *
+     * @param stickerIds Sticker IDs to search for
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function getStickersDetail(stickerIds) {
+        if (!stickerIds)
+            throw new ZaloApiError("Missing sticker id");
+        if (!Array.isArray(stickerIds))
+            stickerIds = [stickerIds];
+        if (stickerIds.length == 0)
+            throw new ZaloApiError("Missing sticker id");
+        const stickers = [];
+        const tasks = stickerIds.map((stickerId) => getStickerDetail(stickerId));
+        const tasksResult = await Promise.allSettled(tasks);
+        tasksResult.forEach((result) => {
+            if (result.status === "fulfilled")
+                stickers.push(result.value);
+        });
+        return stickers;
+    };
+    async function getStickerDetail(stickerId) {
+        const params = {
+            sid: stickerId,
+        };
+        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 resolveResponse(ctx, response);
+    }
+});