@softtynet/zca-js 2.2.8 → 2.2.9

package/dist/apis/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 === null || page === void 0 ? void 0 : page.groupMsgs) ? page.groupMsgs : [];
+        const groupMsgs = rawMsgs.map((data) => new GroupMessage(ctx.uid, data));
+        return Object.assign({}, page || {}, { groupMsgs });
+    };
+});

package/dist/apis/getLastReadContactTab.d.ts

@@ -0,0 +1,4 @@
+export type GetLastReadContactTabResponse = {
+    ts: number;
+};
+export declare const getLastReadContactTabFactory: (ctx: import("../context.js").ContextBase, api: import("../apis.js").API) => () => Promise<GetLastReadContactTabResponse>;

package/dist/apis/getLastReadContactTab.js

@@ -0,0 +1,15 @@
+import { apiFactory } from "../utils.js";
+export const getLastReadContactTabFactory = apiFactory()((api, _ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.friend[0]}/api/friend/last-read-contact-tab`);
+    /**
+     * Lấy dấu thời gian lần cuối đọc tab Danh bạ (command 12230)
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function getLastReadContactTab() {
+        const response = await utils.request(serviceURL, {
+            method: "GET",
+        });
+        return utils.resolve(response);
+    };
+});

package/dist/apis/getLastSeen.d.ts

@@ -0,0 +1,11 @@
+export type GetLastSeenOptions = {
+    groupIds?: string[];
+    userIds?: string[];
+};
+export type GetLastSeenResponse = {
+    clearUnreadInfo?: Record<string, unknown>[];
+    data?: string;
+    status?: number;
+    [key: string]: unknown;
+};
+export declare const getLastSeenFactory: (ctx: import("../context.js").ContextBase, api: import("../apis.js").API) => (options?: GetLastSeenOptions) => Promise<GetLastSeenResponse>;

package/dist/apis/getLastSeen.js

@@ -0,0 +1,40 @@
+import { ZaloApiError } from "../Errors/ZaloApiError.js";
+import { apiFactory } from "../utils.js";
+export const getLastSeenFactory = apiFactory()((api, _ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.chat[0]}/api/preloadconvers/get-last-seen`);
+    /**
+     * Lấy thông tin trạng thái đã xem cuối cùng của danh sách nhóm và cá nhân (command 12009)
+     *
+     * @param options Danh sách ID nhóm (`groupIds`) và UID cá nhân (`userIds`)
+     * @throws {ZaloApiError}
+     */
+    return async function getLastSeen(options = {}) {
+        var _a, _b;
+        const group = ((_a = options.groupIds) !== null && _a !== void 0 ? _a : []).map((g) => (g.startsWith("g") ? g.slice(1) : g));
+        const oneone = (_b = options.userIds) !== null && _b !== void 0 ? _b : [];
+        const params = {
+            param: JSON.stringify({ group, oneone }),
+        };
+        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) => {
+            var _a;
+            const raw = result.data;
+            if (raw && typeof raw.data === "string") {
+                try {
+                    const inner = JSON.parse(raw.data);
+                    return ((_a = inner === null || inner === void 0 ? void 0 : inner.data) !== null && _a !== void 0 ? _a : inner);
+                }
+                catch (_b) {
+                    return raw;
+                }
+            }
+            return raw;
+        });
+    };
+});

package/dist/apis/getLastSeenReaction.d.ts

@@ -0,0 +1,9 @@
+export type GetLastSeenReactionOptions = {
+    groupIds?: string[];
+    userIds?: string[];
+};
+export type GetLastSeenReactionResponse = {
+    clearUnreadInfo: Record<string, unknown>[];
+    [key: string]: unknown;
+};
+export declare const getLastSeenReactionFactory: (ctx: import("../context.js").ContextBase, api: import("../apis.js").API) => (options?: GetLastSeenReactionOptions) => Promise<GetLastSeenReactionResponse>;

package/dist/apis/getLastSeenReaction.js

@@ -0,0 +1,28 @@
+import { ZaloApiError } from "../Errors/ZaloApiError.js";
+import { apiFactory } from "../utils.js";
+export const getLastSeenReactionFactory = apiFactory()((api, _ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.reaction[0]}/api/react/gLastSn`);
+    /**
+     * Lấy trạng thái đã xem cảm xúc (Reaction) cuối cùng của danh sách nhóm và cá nhân (command 12450)
+     *
+     * @param options Danh sách ID nhóm (`groupIds`) và UID cá nhân (`userIds`)
+     * @throws {ZaloApiError}
+     */
+    return async function getLastSeenReaction(options = {}) {
+        var _a, _b;
+        const group = ((_a = options.groupIds) !== null && _a !== void 0 ? _a : []).map((g) => (g.startsWith("g") ? g.slice(1) : g));
+        const oneone = (_b = options.userIds) !== null && _b !== void 0 ? _b : [];
+        const params = {
+            group,
+            oneone,
+        };
+        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/getListPinTopics.d.ts

@@ -0,0 +1,5 @@
+export type GetListPinTopicsResponse = {
+    items: unknown[];
+    version: number;
+};
+export declare const getListPinTopicsFactory: (ctx: import("../context.js").ContextBase, api: import("../apis.js").API) => (groupId: string, boardVersion?: number) => Promise<GetListPinTopicsResponse>;

package/dist/apis/getListPinTopics.js

@@ -0,0 +1,28 @@
+import { ZaloApiError } from "../Errors/ZaloApiError.js";
+import { apiFactory } from "../utils.js";
+export const getListPinTopicsFactory = apiFactory()((api, ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.group_board[0]}/api/board/pin/list`);
+    /**
+     * Lấy danh sách chủ đề / tin nhắn đã ghim trong bảng tin nhóm (command 12001)
+     *
+     * @param groupId ID nhóm
+     * @param boardVersion Phiên bản bảng ghim hiện tại (mặc định `0`)
+     * @throws {ZaloApiError}
+     */
+    return async function getListPinTopics(groupId, boardVersion = 0) {
+        const params = {
+            groupId,
+            boardVersion,
+            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/getMediaStorePreview.d.ts

@@ -0,0 +1,3 @@
+import type { MediaStoreItem } from "./getConversationMedia.js";
+export type GetMediaStorePreviewResponse = MediaStoreItem[];
+export declare const getMediaStorePreviewFactory: (ctx: import("../context.js").ContextBase, api: import("../apis.js").API) => (groupId: string, limit?: number) => Promise<GetMediaStorePreviewResponse>;

package/dist/apis/getMediaStorePreview.js

@@ -0,0 +1,31 @@
+import { ZaloApiError } from "../Errors/ZaloApiError.js";
+import { apiFactory } from "../utils.js";
+export const getMediaStorePreviewFactory = apiFactory()((api, ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.media_store[0]}/api/mediastore/preview`);
+    /**
+     * Lấy danh sách xem trước nhanh Kho Lưu Trữ (Ảnh/Video, File, Link) của nhóm (command 11843)
+     *
+     * @param groupId ID của nhóm
+     * @param limit Số lượng mục tối đa (mặc định: 50)
+     * @throws {ZaloApiError}
+     */
+    return async function getMediaStorePreview(groupId, limit = 50) {
+        if (!groupId) {
+            throw new ZaloApiError("Missing groupId");
+        }
+        const cleanGroupId = groupId.startsWith("g") ? groupId.slice(1) : groupId;
+        const params = {
+            limit,
+            group_id: cleanGroupId,
+            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: "POST",
+        });
+        return utils.resolve(response);
+    };
+});

package/dist/apis/getMiniProfile.d.ts

@@ -0,0 +1,13 @@
+export type MiniProfileItem = {
+    userId: string;
+    avatar: string;
+    globalId: string;
+    type: number;
+    bizPkg?: {
+        label: string | null;
+        pkgId: number;
+    };
+    [key: string]: unknown;
+};
+export type GetMiniProfileResponse = Record<string, MiniProfileItem>;
+export declare const getMiniProfileFactory: (ctx: import("../context.js").ContextBase, api: import("../apis.js").API) => (friendIds: string[], avatarSize?: number) => Promise<GetMiniProfileResponse>;

package/dist/apis/getMiniProfile.js

@@ -0,0 +1,34 @@
+import { ZaloApiError } from "../Errors/ZaloApiError.js";
+import { apiFactory } from "../utils.js";
+export const getMiniProfileFactory = apiFactory()((api, _ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.profile[0]}/api/social/friend/getminiprofiles`);
+    /**
+     * Lấy nhanh thông tin hồ sơ rút gọn (Avatar, Global ID, gói Biz) của danh sách người dùng (command 12134)
+     *
+     * @param friendIds Mảng UID cần lấy thông tin
+     * @param avatarSize Kích thước ảnh đại diện (mặc định: 120)
+     * @throws {ZaloApiError}
+     */
+    return async function getMiniProfile(friendIds, avatarSize = 120) {
+        if (!Array.isArray(friendIds) || friendIds.length === 0) {
+            return {};
+        }
+        const params = {
+            friend_ids: friendIds,
+            avatar_size: avatarSize,
+            incInvalid: 1,
+            srcReq: -1,
+        };
+        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/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/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/getPhonebookV2.d.ts

@@ -0,0 +1,6 @@
+export type GetPhonebookV2Response = {
+    phonebook: Record<string, string>;
+    version?: number;
+    [key: string]: unknown;
+};
+export declare const getPhonebookV2Factory: (ctx: import("../context.js").ContextBase, api: import("../apis.js").API) => (phonebookVersion?: number) => Promise<GetPhonebookV2Response>;

package/dist/apis/getPhonebookV2.js

@@ -0,0 +1,21 @@
+import { ZaloApiError } from "../Errors/ZaloApiError.js";
+import { apiFactory } from "../utils.js";
+export const getPhonebookV2Factory = apiFactory()((api, _ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.profile[0]}/api/social/friend/phonebook/v2`);
+    /**
+     * Lấy danh bạ bạn bè đồng bộ từ số điện thoại chuẩn V2 (command 12428)
+     *
+     * @param phonebookVersion Phiên bản danh bạ (mặc định: 0 để lấy toàn bộ)
+     * @throws {ZaloApiError}
+     */
+    return async function getPhonebookV2(phonebookVersion = 0) {
+        const encryptedParams = utils.encodeAES(JSON.stringify({ phonebook_version: phonebookVersion }));
+        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/getProfileRank.d.ts

@@ -0,0 +1,5 @@
+export type GetProfileRankResponse = {
+    userRank: string;
+    [key: string]: unknown;
+};
+export declare const getProfileRankFactory: (ctx: import("../context.js").ContextBase, api: import("../apis.js").API) => (profileId?: string) => Promise<GetProfileRankResponse>;

package/dist/apis/getProfileRank.js

@@ -0,0 +1,25 @@
+import { ZaloApiError } from "../Errors/ZaloApiError.js";
+import { apiFactory } from "../utils.js";
+export const getProfileRankFactory = apiFactory()((api, ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.profile[0]}/api/social/profile/getrank`);
+    /**
+     * Lấy hạng tài khoản Zalo của một người dùng (ví dụ `"WHITE"`, `"GOLD"` - command 12012)
+     *
+     * @param profileId UID của người dùng cần kiểm tra (mặc định: UID của tài khoản đang đăng nhập)
+     * @throws {ZaloApiError}
+     */
+    return async function getProfileRank(profileId) {
+        const params = {
+            profile_id: profileId !== null && profileId !== void 0 ? profileId : ctx.uid,
+            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/getProfileVerificationStatus.d.ts

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

package/dist/apis/getProfileVerificationStatus.js

@@ -0,0 +1,20 @@
+import { ZaloApiError } from "../Errors/ZaloApiError.js";
+import { apiFactory } from "../utils.js";
+export const getProfileVerificationStatusFactory = apiFactory()((api, ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.profile[0]}/api/social/profile/verification/status`);
+    /**
+     * Kiểm tra trạng thái xác thực định danh (eKYC) của tài khoản Zalo (command 12150)
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function getProfileVerificationStatus() {
+        const encryptedParams = utils.encodeAES(JSON.stringify({ imei: ctx.imei }));
+        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/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/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/getRecentSearchList.d.ts

@@ -0,0 +1,6 @@
+export type GetRecentSearchListResponse = {
+    version: number;
+    list_recent: Record<string, unknown>[];
+    list_keyword: string[];
+};
+export declare const getRecentSearchListFactory: (ctx: import("../context.js").ContextBase, api: import("../apis.js").API) => (version?: number) => Promise<GetRecentSearchListResponse>;

package/dist/apis/getRecentSearchList.js

@@ -0,0 +1,25 @@
+import { ZaloApiError } from "../Errors/ZaloApiError.js";
+import { apiFactory } from "../utils.js";
+export const getRecentSearchListFactory = apiFactory()((api, ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.recent_search[0]}/api/recentsearch/list`);
+    /**
+     * Lấy danh sách lịch sử tìm kiếm gần đây trên Zalo (command 12125)
+     *
+     * @param version Phiên bản lịch sử tìm kiếm (mặc định: 0)
+     * @throws {ZaloApiError}
+     */
+    return async function getRecentSearchList(version = 0) {
+        const params = {
+            version,
+            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/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/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/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/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/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/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 (_a) {
+                    return result.data;
+                }
+            }
+            return result.data;
+        });
+    };
+});

package/dist/apis/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/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);
+    };
+});