@softtynet/zca-js 2.2.8 → 2.2.10

package/dist/apis/media/uploadAttachment.js

@@ -0,0 +1,209 @@
+import FormData from "form-data";
+import fs from "node:fs";
+import { ZaloApiError } from "../../Errors/ZaloApiError.js";
+import { ThreadType } from "../../models/index.js";
+import { apiFactory, getFileExtension, getFileName, getFileSize, getImageMetaData, getMd5LargeFileObject, resolveResponse, } from "../../utils.js";
+const urlType = {
+    image: "photo_original/upload",
+    video: "asyncfile/upload",
+    others: "asyncfile/upload",
+};
+export const uploadAttachmentFactory = apiFactory()((api, ctx, utils) => {
+    const serviceURL = `${api.zpwServiceMap.file[0]}/api`;
+    const { sharefile } = ctx.settings.features;
+    function isExceedMaxFile(totalFile) {
+        return totalFile > sharefile.max_file;
+    }
+    function isExceedMaxFileSize(fileSize) {
+        return fileSize > sharefile.max_size_share_file_v3 * 1024 * 1024;
+    }
+    function isExtensionValid(ext) {
+        return sharefile.restricted_ext_file.indexOf(ext) == -1;
+    }
+    /**
+     * Upload an attachment to a thread
+     *
+     * @param sources path to files or attachment sources
+     * @param threadId Group or User ID
+     * @param type Message type (User or Group)
+     *
+     * @throws {ZaloApiError | ZaloApiMissingImageMetadataGetter}
+     */
+    return async function uploadAttachment(sources, threadId, type = ThreadType.User) {
+        if (!sources)
+            throw new ZaloApiError("Missing sources");
+        if (!Array.isArray(sources))
+            sources = [sources];
+        if (sources.length == 0)
+            throw new ZaloApiError("Missing sources");
+        if (isExceedMaxFile(sources.length))
+            throw new ZaloApiError("Exceed maximum file of " + sharefile.max_file);
+        if (!threadId)
+            throw new ZaloApiError("Missing threadId");
+        const chunkSize = ctx.settings.features.sharefile.chunk_size_file;
+        const isGroupMessage = type == ThreadType.Group;
+        const attachmentsData = [];
+        const url = `${serviceURL}/${isGroupMessage ? "group" : "message"}/`;
+        const typeParam = isGroupMessage ? "11" : "2";
+        let clientId = Date.now();
+        for (const source of sources) {
+            const isFilePath = typeof source == "string";
+            const isBuffer = typeof source == "object" && source.data instanceof Buffer;
+            if (!isFilePath && !isBuffer)
+                throw new ZaloApiError("Invalid source type");
+            if (!isFilePath && !source.filename)
+                throw new ZaloApiError("Missing filename");
+            if (isFilePath && !fs.existsSync(source))
+                throw new ZaloApiError("File not found");
+            const extFile = getFileExtension(isFilePath ? source : source.filename).toLowerCase();
+            const fileName = isFilePath ? getFileName(source) : source.filename;
+            if (isExtensionValid(extFile) == false)
+                throw new ZaloApiError(`File extension "${extFile}" is not allowed`);
+            const data = {
+                filePath: isFilePath ? source : source.filename,
+                chunkContent: [],
+                params: {},
+                source,
+            };
+            if (isGroupMessage)
+                data.params.grid = threadId;
+            else
+                data.params.toid = threadId;
+            switch (extFile) {
+                case "jpg":
+                case "jpeg":
+                case "png":
+                case "webp": {
+                    const imageData = isFilePath ? await getImageMetaData(ctx, source) : { ...source.metadata, fileName };
+                    if (isExceedMaxFileSize(imageData.totalSize))
+                        throw new ZaloApiError(`File ${fileName} size exceed maximum size of ${sharefile.max_size_share_file_v3}MB`);
+                    data.fileData = imageData;
+                    data.fileType = "image";
+                    data.params.totalChunk = Math.ceil(data.fileData.totalSize / chunkSize);
+                    data.params.fileName = fileName;
+                    data.params.clientId = clientId++;
+                    data.params.totalSize = imageData.totalSize;
+                    data.params.imei = ctx.imei;
+                    data.params.isE2EE = 0;
+                    data.params.jxl = 0;
+                    data.params.chunkId = 1;
+                    break;
+                }
+                case "mp4": {
+                    const videoSize = isFilePath ? await getFileSize(source) : source.metadata.totalSize;
+                    if (isExceedMaxFileSize(videoSize))
+                        throw new ZaloApiError(`File ${fileName} size exceed maximum size of ${sharefile.max_size_share_file_v3}MB`);
+                    data.fileType = "video";
+                    data.fileData = {
+                        fileName,
+                        totalSize: videoSize,
+                    };
+                    data.params.totalChunk = Math.ceil(data.fileData.totalSize / chunkSize);
+                    data.params.fileName = fileName;
+                    data.params.clientId = clientId++;
+                    data.params.totalSize = videoSize;
+                    data.params.imei = ctx.imei;
+                    data.params.isE2EE = 0;
+                    data.params.jxl = 0;
+                    data.params.chunkId = 1;
+                    break;
+                }
+                default: {
+                    const fileSize = isFilePath ? await getFileSize(source) : source.metadata.totalSize;
+                    if (isExceedMaxFileSize(fileSize))
+                        throw new ZaloApiError(`File ${fileName} size exceed maximum size of ${sharefile.max_size_share_file_v3}MB`);
+                    data.fileType = "others";
+                    data.fileData = {
+                        fileName,
+                        totalSize: fileSize,
+                    };
+                    data.params.totalChunk = Math.ceil(data.fileData.totalSize / chunkSize);
+                    data.params.fileName = fileName;
+                    data.params.clientId = clientId++;
+                    data.params.totalSize = fileSize;
+                    data.params.imei = ctx.imei;
+                    data.params.isE2EE = 0;
+                    data.params.jxl = 0;
+                    data.params.chunkId = 1;
+                    break;
+                }
+            }
+            const fileBuffer = isFilePath ? await fs.promises.readFile(source) : source.data;
+            for (let i = 0; i < data.params.totalChunk; i++) {
+                const formData = new FormData();
+                const slicedBuffer = fileBuffer.subarray(i * chunkSize, (i + 1) * chunkSize);
+                formData.append("chunkContent", slicedBuffer, {
+                    filename: fileName,
+                    contentType: "application/octet-stream",
+                });
+                data.chunkContent[i] = formData;
+            }
+            attachmentsData.push(data);
+        }
+        const requests = [], results = [];
+        for (let atmIndex = 0; atmIndex < attachmentsData.length; atmIndex++) {
+            const data = attachmentsData[atmIndex];
+            for (let i = 0; i < data.params.totalChunk; i++) {
+                const encryptedParams = utils.encodeAES(JSON.stringify(data.params));
+                if (!encryptedParams)
+                    throw new ZaloApiError("Failed to encrypt message");
+                requests.push(utils
+                    .request(utils.makeURL(url + urlType[data.fileType], { type: typeParam, params: encryptedParams }), {
+                    method: "POST",
+                    headers: data.chunkContent[i].getHeaders(),
+                    body: data.chunkContent[i].getBuffer(),
+                })
+                    .then(async (response) => {
+                    /**
+                     * @TODO: better type rather than any
+                     */
+                    const resData = await resolveResponse(ctx, response);
+                    if (resData && resData.fileId != "-1" && resData.photoId != "-1")
+                        await new Promise((resolve, reject) => {
+                            if (data.fileType == "video" || data.fileType == "others") {
+                                const timeoutId = setTimeout(() => {
+                                    ctx.uploadCallbacks.delete(resData.fileId.toString());
+                                    reject(new ZaloApiError("Upload attachment timed out after 5 minutes"));
+                                }, 5 * 60 * 1000);
+                                const uploadCallback = async (wsData) => {
+                                    clearTimeout(timeoutId);
+                                    const result = {
+                                        fileType: data.fileType,
+                                        ...resData,
+                                        ...wsData,
+                                        totalSize: data.fileData.totalSize,
+                                        fileName: data.fileData.fileName,
+                                        checksum: (await getMd5LargeFileObject(data.source, data.fileData.totalSize)).data,
+                                    };
+                                    results[atmIndex] = result;
+                                    resolve();
+                                };
+                                ctx.uploadCallbacks.set(resData.fileId.toString(), uploadCallback);
+                            }
+                            if (data.fileType == "image") {
+                                const result = {
+                                    fileType: "image",
+                                    width: data.fileData.width,
+                                    height: data.fileData.height,
+                                    totalSize: data.fileData.totalSize,
+                                    hdSize: data.fileData.totalSize,
+                                    finished: resData.finished,
+                                    normalUrl: resData.normalUrl,
+                                    hdUrl: resData.hdUrl,
+                                    thumbUrl: resData.thumbUrl,
+                                    chunkId: resData.chunkId,
+                                    photoId: resData.photoId,
+                                    clientFileId: resData.clientFileId,
+                                };
+                                results[atmIndex] = result;
+                                resolve();
+                            }
+                        });
+                }));
+                data.params.chunkId++;
+            }
+        }
+        await Promise.all(requests);
+        return results;
+    };
+});

package/dist/apis/media/voiceToText.d.ts

@@ -0,0 +1,4 @@
+export type VoiceToTextResponse = {
+    req_id: string;
+};
+export declare const voiceToTextFactory: (ctx: import("../../context.js").ContextBase, api: import("../../apis.js").API) => (voiceUrl: string) => Promise<VoiceToTextResponse>;

package/dist/apis/media/voiceToText.js

@@ -0,0 +1,29 @@
+import { ZaloApiError } from "../../Errors/ZaloApiError.js";
+import { apiFactory, ZALO_DOMAINS } from "../../utils.js";
+export const voiceToTextFactory = apiFactory()((api, _ctx, utils) => {
+    const baseDomain = api.zpwServiceMap.ai_features?.[0] || ZALO_DOMAINS.AI_FEATURES_FALLBACK;
+    const serviceURL = utils.makeURL(`${baseDomain}/api/aifeatures/voice2text`);
+    /**
+     * Gửi yêu cầu chuyển đổi tin nhắn thoại sang văn bản bằng Zalo AI (command 13394).
+     * Kết quả văn bản sau khi xử lý xong sẽ được đẩy về qua sự kiện `api.listener.on("voice2text_event", ...)` khớp với `req_id`.
+     *
+     * @param voiceUrl Đường dẫn URL của tệp ghi âm tin nhắn thoại (`.aac` / `.mp3` / `.m4a`)
+     * @throws {ZaloApiError}
+     */
+    return async function voiceToText(voiceUrl) {
+        if (!voiceUrl) {
+            throw new ZaloApiError("Missing voiceUrl");
+        }
+        const encryptedParams = utils.encodeAES(JSON.stringify({ url: voiceUrl }));
+        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/changeAccountAvatar.d.ts

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

package/dist/apis/profile/changeAccountAvatar.js

@@ -0,0 +1,52 @@
+import FormData from "form-data";
+import fs from "node:fs";
+import { ZaloApiError } from "../../Errors/ZaloApiError.js";
+import { apiFactory, formatTime, getImageMetaData } from "../../utils.js";
+export const changeAccountAvatarFactory = apiFactory()((api, ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.file[0]}/api/profile/upavatar`);
+    /**
+     * Change account avatar
+     *
+     * @param avatarSource Attachment source, can be a file path or an Attachment object
+     *
+     * @throws {ZaloApiError | ZaloApiMissingImageMetadataGetter}
+     */
+    return async function changeAccountAvatar(avatarSource) {
+        const isSourceFilePath = typeof avatarSource == "string";
+        const imageMetaData = isSourceFilePath ? await getImageMetaData(ctx, avatarSource) : avatarSource.metadata;
+        const fileSize = imageMetaData.totalSize || 0;
+        const params = {
+            avatarSize: 120,
+            clientId: String(ctx.uid + formatTime("%H:%M %d/%m/%Y")),
+            language: ctx.language,
+            metaData: JSON.stringify({
+                origin: {
+                    width: imageMetaData.width || 1080,
+                    height: imageMetaData.height || 1080,
+                },
+                processed: {
+                    width: imageMetaData.width || 1080,
+                    height: imageMetaData.height || 1080,
+                    size: fileSize,
+                },
+            }),
+        };
+        const avatarData = isSourceFilePath ? fs.readFileSync(avatarSource) : avatarSource.data;
+        const formData = new FormData();
+        formData.append("fileContent", avatarData, {
+            filename: "blob",
+            contentType: "image/jpeg",
+        });
+        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",
+            headers: formData.getHeaders(),
+            body: formData.getBuffer(),
+        });
+        return utils.resolve(response);
+    };
+});

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

@@ -0,0 +1,9 @@
+export type DeleteAvatarResponse = {
+    delPhotoIds: string[];
+    errMap: {
+        [key: string]: {
+            err: number;
+        };
+    };
+};
+export declare const deleteAvatarFactory: (ctx: import("../../context.js").ContextBase, api: import("../../apis.js").API) => (photoId: string | string[]) => Promise<DeleteAvatarResponse>;

package/dist/apis/profile/deleteAvatar.js

@@ -0,0 +1,27 @@
+import { ZaloApiError } from "../../Errors/ZaloApiError.js";
+import { apiFactory } from "../../utils.js";
+export const deleteAvatarFactory = apiFactory()((api, ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.profile[0]}/api/social/del-avatars`);
+    /**
+     * Delete avatar from avatar list
+     *
+     * @param photoId avatar photo ID(s) to delete - can be a single string or array of strings
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function deleteAvatar(photoId) {
+        const photoIds = Array.isArray(photoId) ? photoId : [photoId];
+        const delPhotos = photoIds.map((id) => ({ photoId: id }));
+        const params = {
+            delPhotos: JSON.stringify(delPhotos),
+            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/fetchAccountInfo.d.ts

@@ -0,0 +1,5 @@
+import type { User } from "../../models/index.js";
+export type FetchAccountInfoResponse = {
+    profile: User;
+};
+export declare const fetchAccountInfoFactory: (ctx: import("../../context.js").ContextBase, api: import("../../apis.js").API) => () => Promise<FetchAccountInfoResponse>;

package/dist/apis/profile/fetchAccountInfo.js

@@ -0,0 +1,10 @@
+import { apiFactory } from "../../utils.js";
+export const fetchAccountInfoFactory = apiFactory()((api, _, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.profile[0]}/api/social/profile/me-v2`);
+    return async function fetchAccountInfo() {
+        const response = await utils.request(serviceURL, {
+            method: "GET",
+        });
+        return utils.resolve(response);
+    };
+});

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

@@ -0,0 +1,12 @@
+export type GetAvatarListResponse = {
+    albumId: string;
+    nextPhotoId: string;
+    hasMore: number;
+    photos: {
+        photoId: string;
+        thumbnail: string;
+        url: string;
+        bkUrl: string;
+    }[];
+};
+export declare const getAvatarListFactory: (ctx: import("../../context.js").ContextBase, api: import("../../apis.js").API) => (count?: number, page?: number) => Promise<GetAvatarListResponse>;

package/dist/apis/profile/getAvatarList.js

@@ -0,0 +1,28 @@
+import { ZaloApiError } from "../../Errors/ZaloApiError.js";
+import { apiFactory } from "../../utils.js";
+export const getAvatarListFactory = apiFactory()((api, ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.profile[0]}/api/social/avatar-list`);
+    /**
+     * Get avatar list
+     *
+     * @param count The number of avatars to fetch (default: 50)
+     * @param page The page number to fetch (default: 1)
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function getAvatarList(count = 50, page = 1) {
+        const params = {
+            page,
+            albumId: "0",
+            count,
+            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/getAvatarUrlProfile.d.ts

@@ -0,0 +1,7 @@
+import { AvatarSize } from "../../models/index.js";
+export type GetAvatarUrlProfileResponse = {
+    [userId: string]: {
+        avatar: string;
+    };
+};
+export declare const getAvatarUrlProfileFactory: (ctx: import("../../context.js").ContextBase, api: import("../../apis.js").API) => (friendIds: string | string[], avatarSize?: AvatarSize) => Promise<GetAvatarUrlProfileResponse>;

package/dist/apis/profile/getAvatarUrlProfile.js

@@ -0,0 +1,30 @@
+import { ZaloApiError } from "../../Errors/ZaloApiError.js";
+import { AvatarSize } from "../../models/index.js";
+import { apiFactory } from "../../utils.js";
+export const getAvatarUrlProfileFactory = apiFactory()((api, _ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.profile[0]}/api/social/profile/avatar-url`);
+    /**
+     * Get avatar url profile
+     *
+     * @param friendId friend id(s)
+     * @param avatarSize Avatar size (default: AvatarSize.Large)
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function getAvatarUrlProfile(friendIds, avatarSize = AvatarSize.Large) {
+        if (!Array.isArray(friendIds))
+            friendIds = [friendIds];
+        const params = {
+            friend_ids: friendIds,
+            avatar_size: avatarSize,
+            srcReq: -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/profile/getEmojiStatusConfig.d.ts

@@ -0,0 +1,17 @@
+export type EmojiStatusItem = {
+    id: number;
+    caption: {
+        vi: string;
+        en: string;
+    };
+    thumb: string;
+    full: string;
+};
+export type GetEmojiStatusConfigResponse = {
+    expireTime: number;
+    config: {
+        emojis: EmojiStatusItem[];
+        [key: string]: unknown;
+    };
+};
+export declare const getEmojiStatusConfigFactory: (ctx: import("../../context.js").ContextBase, api: import("../../apis.js").API) => (version?: number) => Promise<GetEmojiStatusConfigResponse>;

package/dist/apis/profile/getEmojiStatusConfig.js

@@ -0,0 +1,22 @@
+import { ZaloApiError } from "../../Errors/ZaloApiError.js";
+import { apiFactory, ZALO_DOMAINS } from "../../utils.js";
+export const getEmojiStatusConfigFactory = apiFactory()((api, _ctx, utils) => {
+    const baseDomain = api.zpwServiceMap.emoji_stt?.[0] || ZALO_DOMAINS.EMOJI_STATUS_FALLBACK;
+    const serviceURL = utils.makeURL(`${baseDomain}/api/v1/emoji-status/resource-config`);
+    /**
+     * Lấy cấu hình và danh sách bộ biểu tượng Trạng thái Emoji (Emoji Status - command 16300)
+     *
+     * @param version Phiên bản bộ nhớ đệm (mặc định: 0 để lấy đầy đủ danh sách)
+     * @throws {ZaloApiError}
+     */
+    return async function getEmojiStatusConfig(version = 0) {
+        const encryptedParams = utils.encodeAES(JSON.stringify({ version }));
+        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/getFullAvatar.d.ts

@@ -0,0 +1,5 @@
+export type GetFullAvatarResponse = {
+    bk_full_avatar: string;
+    full_avatar: string;
+};
+export declare const getFullAvatarFactory: (ctx: import("../../context.js").ContextBase, api: import("../../apis.js").API) => (friendId: string) => Promise<GetFullAvatarResponse>;

package/dist/apis/profile/getFullAvatar.js

@@ -0,0 +1,25 @@
+import { ZaloApiError } from "../../Errors/ZaloApiError.js";
+import { apiFactory } from "../../utils.js";
+export const getFullAvatarFactory = apiFactory()((api, ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.profile[0]}/api/social/profile/avatar`);
+    /**
+     * Get full avatar
+     *
+     * @param friendId friend id
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function getFullAvatar(friendId) {
+        const params = {
+            fid: friendId,
+            imei: ctx.imei,
+        };
+        const encryptedParams = utils.encodeAES(JSON.stringify(params));
+        if (!encryptedParams)
+            throw new ZaloApiError("Failed to encrypt params");
+        const response = await utils.request(utils.makeURL(serviceURL, { params: encryptedParams }), {
+            method: "GET",
+        });
+        return utils.resolve(response);
+    };
+});

package/dist/apis/profile/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/profile/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/profile/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/profile/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 ?? 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/profile/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/profile/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/profile/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/profile/getSettings.js

@@ -0,0 +1,20 @@
+import { ZaloApiError } from "../../Errors/ZaloApiError.js";
+import { apiFactory, ZALO_DOMAINS, ZALO_ENDPOINTS } from "../../utils.js";
+export const getSettingsFactory = apiFactory()((_api, _ctx, utils) => {
+    const serviceURL = utils.makeURL(`${ZALO_DOMAINS.WPA_CHAT}${ZALO_ENDPOINTS.WPA.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);
+    };
+});