@softtynet/zca-js 2.2.9 → 2.3.1

package/dist/apis/profile/getUserInfo.d.ts

@@ -0,0 +1,8 @@
+import { AvatarSize, type UnchangedProfileInfo, type User } from "../../models/index.js";
+export type ProfileInfo = User;
+export type UserInfoResponse = {
+    unchanged_profiles: Record<string, Partial<UnchangedProfileInfo>>;
+    phonebook_version: number;
+    changed_profiles: Record<string, ProfileInfo>;
+};
+export declare const getUserInfoFactory: (ctx: import("../../context.js").ContextBase, api: import("../../apis.js").API) => (userId: string | string[], avatarSize?: AvatarSize) => Promise<UserInfoResponse>;

package/dist/apis/profile/getUserInfo.js

@@ -0,0 +1,44 @@
+import { ZaloApiError } from "../../Errors/ZaloApiError.js";
+import { apiFactory } from "../../utils.js";
+import { AvatarSize } from "../../models/index.js";
+export const getUserInfoFactory = apiFactory()((api, ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.profile[0]}/api/social/friend/getprofiles/v2`);
+    /**
+     * Get user info using user id
+     *
+     * @param userId User id(s)
+     * @param avatarSize Avatar size (default: AvatarSize.Small)
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function getUserInfo(userId, avatarSize = AvatarSize.Small) {
+        if (!userId)
+            throw new ZaloApiError("Missing user id");
+        if (!Array.isArray(userId))
+            userId = [userId];
+        userId = userId.map((id) => {
+            if (id.split("_").length > 1) {
+                return id;
+            }
+            return `${id}_0`;
+        });
+        const params = {
+            phonebook_version: ctx.extraVer.phonebook,
+            friend_pversion_map: userId,
+            avatar_size: avatarSize,
+            language: ctx.language,
+            show_online_status: 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(serviceURL, {
+            method: "POST",
+            body: new URLSearchParams({
+                params: encryptedParams,
+            }),
+        });
+        return utils.resolve(response);
+    };
+});

package/dist/apis/profile/reuseAvatar.d.ts

@@ -0,0 +1,2 @@
+export type ReuseAvatarResponse = null;
+export declare const reuseAvatarFactory: (ctx: import("../../context.js").ContextBase, api: import("../../apis.js").API) => (photoId: string) => Promise<null>;

package/dist/apis/profile/reuseAvatar.js

@@ -0,0 +1,26 @@
+import { ZaloApiError } from "../../Errors/ZaloApiError.js";
+import { apiFactory } from "../../utils.js";
+export const reuseAvatarFactory = apiFactory()((api, ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.profile[0]}/api/social/reuse-avatar`);
+    /**
+     * Reuse avatar
+     *
+     * @param photoId photo id from getAvatarList api
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function reuseAvatar(photoId) {
+        const params = {
+            photoId: photoId,
+            isPostSocial: 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/profile/updateProfile.d.ts

@@ -0,0 +1,20 @@
+import type { BusinessCategory, Gender } from "../../models/index.js";
+export type UpdateProfilePayload = {
+    profile: {
+        name: string;
+        /**
+         * Date of birth in the format YYYY-MM-DD
+         */
+        dob: `${string}-${string}-${string}`;
+        gender: Gender;
+    };
+    biz?: Partial<{
+        cate: BusinessCategory;
+        description: string;
+        address: string;
+        website: string;
+        email: string;
+    }>;
+};
+export type UpdateProfileResponse = "";
+export declare const updateProfileFactory: (ctx: import("../../context.js").ContextBase, api: import("../../apis.js").API) => (payload: UpdateProfilePayload) => Promise<"">;

package/dist/apis/profile/updateProfile.js

@@ -0,0 +1,42 @@
+import { ZaloApiError } from "../../Errors/ZaloApiError.js";
+import { apiFactory } from "../../utils.js";
+export const updateProfileFactory = apiFactory()((api, ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.profile[0]}/api/social/profile/update`);
+    /**
+     * Change account setting information
+     *
+     * @param payload payload
+     *
+     * @note If your account is a Business Account, include the biz.cate field; otherwise the category will be removed.
+     * You may leave the other biz fields empty if you don’t want to change them.
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function updateProfile(payload) {
+        const params = {
+            profile: JSON.stringify({
+                name: payload.profile.name,
+                dob: payload.profile.dob,
+                gender: payload.profile.gender,
+            }),
+            biz: JSON.stringify({
+                desc: payload.biz?.description,
+                cate: payload.biz?.cate,
+                addr: payload.biz?.address,
+                website: payload.biz?.website,
+                email: payload.biz?.email,
+            }),
+            language: ctx.language,
+        };
+        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/profile/updateProfileBio.d.ts

@@ -0,0 +1,2 @@
+export type UpdateProfileBioResponse = "";
+export declare const updateProfileBioFactory: (ctx: import("../../context.js").ContextBase, api: import("../../apis.js").API) => (status: string) => Promise<"">;

package/dist/apis/profile/updateProfileBio.js

@@ -0,0 +1,27 @@
+import { ZaloApiError } from "../../Errors/ZaloApiError.js";
+import { apiFactory } from "../../utils.js";
+export const updateProfileBioFactory = apiFactory()((api, _ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.profile[0]}/api/social/profile/status`);
+    /**
+     * Update profile bio
+     *
+     * @param status status for update bio
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function updateProfileBio(status) {
+        const params = {
+            status: status,
+        };
+        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: "POST",
+            body: new URLSearchParams({
+                params: encryptedParams,
+            }),
+        });
+        return utils.resolve(response);
+    };
+});

package/dist/apis/profile/updateSettings.d.ts

@@ -0,0 +1,16 @@
+export type UpdateSettingsResponse = "";
+export declare enum UpdateSettingsType {
+    ViewBirthday = "view_birthday",
+    ShowOnlineStatus = "show_online_status",
+    DisplaySeenStatus = "display_seen_status",
+    ReceiveMessage = "receive_message",
+    AcceptCall = "accept_stranger_call",
+    AddFriendViaPhone = "add_friend_via_phone",
+    AddFriendViaQR = "add_friend_via_qr",
+    AddFriendViaGroup = "add_friend_via_group",
+    AddFriendViaContact = "add_friend_via_contact",
+    DisplayOnRecommendFriend = "display_on_recommend_friend",
+    ArchivedChat = "archivedChatStatus",
+    QuickMessage = "quickMessageStatus"
+}
+export declare const updateSettingsFactory: (ctx: import("../../context.js").ContextBase, api: import("../../apis.js").API) => (type: UpdateSettingsType, value: number) => Promise<"">;

package/dist/apis/profile/updateSettings.js

@@ -0,0 +1,90 @@
+import { ZaloApiError } from "../../Errors/ZaloApiError.js";
+import { apiFactory, ZALO_DOMAINS, ZALO_ENDPOINTS } from "../../utils.js";
+export var UpdateSettingsType;
+(function (UpdateSettingsType) {
+    UpdateSettingsType["ViewBirthday"] = "view_birthday";
+    UpdateSettingsType["ShowOnlineStatus"] = "show_online_status";
+    UpdateSettingsType["DisplaySeenStatus"] = "display_seen_status";
+    UpdateSettingsType["ReceiveMessage"] = "receive_message";
+    UpdateSettingsType["AcceptCall"] = "accept_stranger_call";
+    UpdateSettingsType["AddFriendViaPhone"] = "add_friend_via_phone";
+    UpdateSettingsType["AddFriendViaQR"] = "add_friend_via_qr";
+    UpdateSettingsType["AddFriendViaGroup"] = "add_friend_via_group";
+    UpdateSettingsType["AddFriendViaContact"] = "add_friend_via_contact";
+    UpdateSettingsType["DisplayOnRecommendFriend"] = "display_on_recommend_friend";
+    UpdateSettingsType["ArchivedChat"] = "archivedChatStatus";
+    UpdateSettingsType["QuickMessage"] = "quickMessageStatus";
+})(UpdateSettingsType || (UpdateSettingsType = {}));
+export const updateSettingsFactory = apiFactory()((_api, _ctx, utils) => {
+    const serviceURL = utils.makeURL(`${ZALO_DOMAINS.WPA_CHAT}${ZALO_ENDPOINTS.WPA.SETTING_UPDATE}`);
+    /**
+     * Set account settings
+     *
+     * @param type The type of setting to update
+     * @param value
+     *
+     * ViewBirthday
+     * * 0: hide
+     * * 1: show full day/month/year
+     * * 2: show day/month
+     *
+     * ShowOnlineStatus
+     * * 0: hide
+     * * 1: show
+     *
+     * DisplaySeenStatus
+     * * 0: hide
+     * * 1: show
+     *
+     * ReceiveMessage
+     * * 1: everyone
+     * * 2: only friends
+     *
+     * AcceptCall
+     * * 2: only friends
+     * * 3: everyone
+     * * 4: friends and person who contacted
+     *
+     * AddFriendViaPhone
+     * * 0: disable
+     * * 1: enable
+     *
+     * AddFriendViaQR
+     * * 0: disable
+     * * 1: enable
+     *
+     * AddFriendViaGroup
+     * * 0: disable
+     * * 1: enable
+     *
+     * AddFriendViaContact
+     * * 0: disable
+     * * 1: enable
+     *
+     * DisplayOnRecommendFriend
+     * * 0: disable
+     * * 1: enable
+     *
+     * ArchivedChat
+     * * 0: disable
+     * * 1: enable
+     *
+     * QuickMessage
+     * * 0: disable
+     * * 1: enable
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function updateSettings(type, value) {
+        const params = {
+            [type]: value,
+        };
+        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/sticker/getPersonalizedStickerList.d.ts

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

package/dist/apis/sticker/getPersonalizedStickerList.js

@@ -0,0 +1,24 @@
+import { ZaloApiError } from "../../Errors/ZaloApiError.js";
+import { apiFactory } from "../../utils.js";
+export const getPersonalizedStickerListFactory = apiFactory()((api, ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.sticker[0]}/api/message/sticker/personalized/list`);
+    /**
+     * Lấy danh sách Sticker cá nhân hóa của tài khoản (command 11745)
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function getPersonalizedStickerList() {
+        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/sticker/getStickerCategoriesV2.d.ts

@@ -0,0 +1,17 @@
+export type StickerCategoryV2Item = {
+    id: number;
+    name: string;
+    desc?: string;
+    totalImage?: number;
+    iconUrl?: string;
+    thumbUrl?: string;
+    previewUrl?: string;
+    status?: number;
+    type?: number;
+    [key: string]: unknown;
+};
+export type GetStickerCategoriesV2Response = {
+    categories: StickerCategoryV2Item[];
+    [key: string]: unknown;
+};
+export declare const getStickerCategoriesV2Factory: (ctx: import("../../context.js").ContextBase, api: import("../../apis.js").API) => () => Promise<GetStickerCategoriesV2Response>;

package/dist/apis/sticker/getStickerCategoriesV2.js

@@ -0,0 +1,21 @@
+import { ZaloApiError } from "../../Errors/ZaloApiError.js";
+import { apiFactory } from "../../utils.js";
+export const getStickerCategoriesV2Factory = apiFactory()((api, _ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.sticker[0]}/api/message/sticker/category/list/v2`);
+    /**
+     * Lấy danh sách danh mục bộ nhãn dán (Sticker Categories V2 - command 12020)
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function getStickerCategoriesV2() {
+        const encryptedParams = utils.encodeAES("");
+        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/sticker/getStickerCategoryData.d.ts

@@ -0,0 +1,3 @@
+import type { StickerCategoryV2Item } from "./getStickerCategoriesV2.js";
+export type GetStickerCategoryDataResponse = StickerCategoryV2Item;
+export declare const getStickerCategoryDataFactory: (ctx: import("../../context.js").ContextBase, api: import("../../apis.js").API) => (cid: number) => Promise<StickerCategoryV2Item>;

package/dist/apis/sticker/getStickerCategoryData.js

@@ -0,0 +1,25 @@
+import { ZaloApiError } from "../../Errors/ZaloApiError.js";
+import { apiFactory } from "../../utils.js";
+export const getStickerCategoryDataFactory = apiFactory()((api, _ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.sticker[0]}/api/message/sticker/category/detail`);
+    /**
+     * Lấy thông tin chi tiết một bộ nhãn dán theo `cid` (command 11156)
+     *
+     * @param cid ID bộ nhãn dán (Category ID)
+     * @throws {ZaloApiError}
+     */
+    return async function getStickerCategoryData(cid) {
+        const params = {
+            cid,
+        };
+        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/sticker/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/sticker/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/sticker/getStickerHello.d.ts

@@ -0,0 +1,16 @@
+export type StickerHelloItem = {
+    id: number;
+    cateId: number;
+    type: number;
+    text: string;
+    uri: string;
+    fkey: number;
+    status: number;
+    stickerUrl: string;
+    stickerSpriteUrl: string;
+    stickerWebpUrl?: string | null;
+    totalFrames: number;
+    duration: number;
+};
+export type GetStickerHelloResponse = Record<string, unknown> | StickerHelloItem[];
+export declare const getStickerHelloFactory: (ctx: import("../../context.js").ContextBase, api: import("../../apis.js").API) => () => Promise<GetStickerHelloResponse>;

package/dist/apis/sticker/getStickerHello.js

@@ -0,0 +1,34 @@
+import { ZaloApiError } from "../../Errors/ZaloApiError.js";
+import { apiFactory } from "../../utils.js";
+export const getStickerHelloFactory = apiFactory()((api, ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.sticker[0]}/api/message/sticker/suggestion`);
+    /**
+     * Lấy danh sách Sticker chào hỏi gợi ý khi bắt đầu trò chuyện mới (command 11751)
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function getStickerHello() {
+        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) => {
+            if (typeof result.data === "string") {
+                try {
+                    return JSON.parse(result.data);
+                }
+                catch {
+                    return result.data;
+                }
+            }
+            return result.data;
+        });
+    };
+});

package/dist/apis/sticker/getStickerSuggestKeywords.d.ts

@@ -0,0 +1,12 @@
+export type GetStickerSuggestKeywordsResponse = {
+    time: number;
+    suggest_data: {
+        version: number;
+        sdata: Array<{
+            keyword: string;
+            stickers?: number[];
+            [key: string]: unknown;
+        }>;
+    };
+};
+export declare const getStickerSuggestKeywordsFactory: (ctx: import("../../context.js").ContextBase, api: import("../../apis.js").API) => () => Promise<GetStickerSuggestKeywordsResponse>;

package/dist/apis/sticker/getStickerSuggestKeywords.js

@@ -0,0 +1,24 @@
+import { ZaloApiError } from "../../Errors/ZaloApiError.js";
+import { apiFactory } from "../../utils.js";
+export const getStickerSuggestKeywordsFactory = apiFactory()((api, ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.sticker[0]}/api/message/sticker/suggest/keywords`);
+    /**
+     * Lấy bộ từ khóa gợi ý Sticker tự động khi gõ tin nhắn (command 11740)
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function getStickerSuggestKeywords() {
+        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/sticker/getStickerSuggestion.d.ts

@@ -0,0 +1,12 @@
+export type GetStickerSuggestionOptions = {
+    keyword: string;
+    gif?: 0 | 1;
+    guggy?: 0 | 1;
+};
+export type GetStickerSuggestionResponse = {
+    sdata: unknown;
+    gif?: unknown;
+    guggy?: unknown;
+    [key: string]: unknown;
+};
+export declare const getStickerSuggestionFactory: (ctx: import("../../context.js").ContextBase, api: import("../../apis.js").API) => (options: GetStickerSuggestionOptions | string) => Promise<GetStickerSuggestionResponse>;

package/dist/apis/sticker/getStickerSuggestion.js

@@ -0,0 +1,29 @@
+import { ZaloApiError } from "../../Errors/ZaloApiError.js";
+import { apiFactory } from "../../utils.js";
+export const getStickerSuggestionFactory = apiFactory()((api, ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.sticker[0]}/api/message/sticker/suggest/stickers`);
+    /**
+     * Gợi ý Sticker/GIF theo từ khóa đang nhập (command 11741)
+     *
+     * @param options Từ khóa và tùy chọn kèm theo (`gif`, `guggy`)
+     * @throws {ZaloApiError}
+     */
+    return async function getStickerSuggestion(options) {
+        const normalized = typeof options === "string" ? { keyword: options } : options;
+        const params = {
+            keyword: normalized.keyword,
+            gif: normalized.gif ?? 1,
+            guggy: normalized.guggy ?? 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/sticker/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/sticker/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/sticker/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/sticker/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);
+    }
+});

package/dist/apis/sticker/searchSticker.d.ts

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