@softtynet/zca-js 2.2.9 → 2.3.1

package/dist/apis/chat/getHiddenConversations.d.ts

@@ -0,0 +1,11 @@
+export type GetHiddenConversationsResponse = {
+    pin: string;
+    threads: {
+        /**
+         * 1: true, 0: false
+         */
+        is_group: number;
+        thread_id: string;
+    }[];
+};
+export declare const getHiddenConversationsFactory: (ctx: import("../../context.js").ContextBase, api: import("../../apis.js").API) => () => Promise<GetHiddenConversationsResponse>;

package/dist/apis/chat/getHiddenConversations.js

@@ -0,0 +1,23 @@
+import { ZaloApiError } from "../../Errors/ZaloApiError.js";
+import { apiFactory } from "../../utils.js";
+export const getHiddenConversationsFactory = apiFactory()((api, ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.conversation[0]}/api/hiddenconvers/get-all`);
+    /**
+     * Get hidden conversations
+     *
+     * @throws {ZaloApiError}
+     *
+     */
+    return async function getHiddenConversations() {
+        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/chat/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/chat/getLastSeen.js

@@ -0,0 +1,38 @@
+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 = {}) {
+        const group = (options.groupIds ?? []).map((g) => (g.startsWith("g") ? g.slice(1) : g));
+        const oneone = options.userIds ?? [];
+        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) => {
+            const raw = result.data;
+            if (raw && typeof raw.data === "string") {
+                try {
+                    const inner = JSON.parse(raw.data);
+                    return (inner?.data ?? inner);
+                }
+                catch {
+                    return raw;
+                }
+            }
+            return raw;
+        });
+    };
+});

package/dist/apis/chat/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/chat/getLastSeenReaction.js

@@ -0,0 +1,27 @@
+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 = {}) {
+        const group = (options.groupIds ?? []).map((g) => (g.startsWith("g") ? g.slice(1) : g));
+        const oneone = options.userIds ?? [];
+        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/chat/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/chat/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/chat/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/chat/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/chat/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/chat/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/chat/getUnreadMark.d.ts

@@ -0,0 +1,14 @@
+export type UnreadMark = {
+    id: number;
+    cliMsgId: number;
+    fromUid: number;
+    ts: number;
+};
+export type GetUnreadMarkResponse = {
+    data: {
+        convsGroup: UnreadMark[];
+        convsUser: UnreadMark[];
+    };
+    status: number;
+};
+export declare const getUnreadMarkFactory: (ctx: import("../../context.js").ContextBase, api: import("../../apis.js").API) => () => Promise<GetUnreadMarkResponse>;

package/dist/apis/chat/getUnreadMark.js

@@ -0,0 +1,30 @@
+import { ZaloApiError } from "../../Errors/ZaloApiError.js";
+import { apiFactory } from "../../utils.js";
+export const getUnreadMarkFactory = apiFactory()((api, _, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.conversation[0]}/api/conv/getUnreadMark`);
+    /**
+     * Get unread mark
+     *
+     * @throws {ZaloApiError}
+     *
+     */
+    return async function getUnreadMark() {
+        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, (result) => {
+            const data = result.data;
+            if (typeof data.data === "string") {
+                return {
+                    data: JSON.parse(data.data),
+                    status: data.status,
+                };
+            }
+            return data;
+        });
+    };
+});

package/dist/apis/chat/parseLink.d.ts

@@ -0,0 +1,21 @@
+export type ParseLinkErrorMaps = Record<string, number>;
+export type ParseLinkResponse = {
+    data: {
+        thumb: string;
+        title: string;
+        desc: string;
+        src: string;
+        href: string;
+        media: {
+            type: number;
+            count: number;
+            mediaTitle: string;
+            artist: string;
+            streamUrl: string;
+            stream_icon: string;
+        };
+        stream_icon: string;
+    };
+    error_maps: ParseLinkErrorMaps;
+};
+export declare const parseLinkFactory: (ctx: import("../../context.js").ContextBase, api: import("../../apis.js").API) => (link: string) => Promise<ParseLinkResponse>;

package/dist/apis/chat/parseLink.js

@@ -0,0 +1,27 @@
+import { ZaloApiError } from "../../Errors/ZaloApiError.js";
+import { apiFactory } from "../../utils.js";
+export const parseLinkFactory = apiFactory()((api, ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.file[0]}/api/message/parselink`);
+    /**
+     * Parse link
+     *
+     * @param link link to parse
+     *
+     * @throws {ZaloApiError}
+     *
+     */
+    return async function parseLink(link) {
+        const params = {
+            link,
+            version: 1, // version 0 is not available errorMaps || version 1 is errorMaps (for response)
+            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/chat/preloadConversations.d.ts

@@ -0,0 +1,28 @@
+import { ClearUnread, type Message, type TClearUnreadItem, type TGroupMessage, type TMessage } from "../../models/index.js";
+export type PreloadConversationsRawResponse = {
+    msgs?: TMessage[];
+    groupMsgs?: TGroupMessage[];
+    allmsgs?: Array<TMessage | (TGroupMessage & {
+        isGroup?: boolean | number;
+    })>;
+    eeMsgs?: unknown[];
+    pageMsgs?: unknown[];
+    clearUnreads?: TClearUnreadItem[];
+    clearUnreadsReact?: TClearUnreadItem[];
+    seens?: unknown[];
+    lastActionId?: string;
+    lastActionIdOther?: string;
+    more?: number;
+    conversations?: Array<{
+        conv_id: string;
+        last_msgs?: unknown[];
+        unread_count?: number;
+        [key: string]: unknown;
+    }>;
+    [key: string]: unknown;
+};
+export type PreloadConversationsResponse = PreloadConversationsRawResponse & {
+    messages: Message[];
+    unreadCleared: ClearUnread[];
+};
+export declare const preloadConversationsFactory: (ctx: import("../../context.js").ContextBase, api: import("../../apis.js").API) => (threadIdLocalMsgId?: Record<string, string | number>) => Promise<PreloadConversationsResponse>;

package/dist/apis/chat/preloadConversations.js

@@ -0,0 +1,78 @@
+import { ZaloApiError } from "../../Errors/ZaloApiError.js";
+import { ClearUnread, GroupMessage, UserMessage, } from "../../models/index.js";
+import { apiFactory } from "../../utils.js";
+export const preloadConversationsFactory = apiFactory()((api, ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.conversation[0]}/api/preloadconvers/get-last-msgs`);
+    /**
+     * Preload last messages and unread-cleared states across active conversations.
+     * Useful for initial state loading and catching up missed messages after reconnect.
+     *
+     * @param threadIdLocalMsgId Optional map of `{ [threadId]: lastLocalMsgId }` (defaults to `{}`)
+     * @throws {ZaloApiError}
+     */
+    return async function preloadConversations(threadIdLocalMsgId = {}) {
+        const params = {
+            threadIdLocalMsgId: JSON.stringify(threadIdLocalMsgId ?? {}),
+            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) => {
+            let data = (result.data ?? {});
+            if (typeof data === "string") {
+                data = JSON.parse(data);
+            }
+            const messages = [];
+            const seenMsgIds = new Set();
+            if (Array.isArray(data.msgs)) {
+                for (const msg of data.msgs) {
+                    const id = String(msg.msgId ?? "");
+                    if (id && seenMsgIds.has(id))
+                        continue;
+                    if (id)
+                        seenMsgIds.add(id);
+                    messages.push(new UserMessage(ctx.uid, msg));
+                }
+            }
+            if (Array.isArray(data.groupMsgs)) {
+                for (const msg of data.groupMsgs) {
+                    const id = String(msg.msgId ?? "");
+                    if (id && seenMsgIds.has(id))
+                        continue;
+                    if (id)
+                        seenMsgIds.add(id);
+                    messages.push(new GroupMessage(ctx.uid, msg));
+                }
+            }
+            if (Array.isArray(data.allmsgs)) {
+                for (const msg of data.allmsgs) {
+                    const id = String(msg.msgId ?? "");
+                    if (id && seenMsgIds.has(id))
+                        continue;
+                    if (id)
+                        seenMsgIds.add(id);
+                    const isGroup = ("isGroup" in msg && Boolean(msg.isGroup)) ||
+                        (typeof msg.idTo === "string" && msg.idTo.startsWith("g"));
+                    if (isGroup) {
+                        messages.push(new GroupMessage(ctx.uid, msg));
+                    }
+                    else {
+                        messages.push(new UserMessage(ctx.uid, msg));
+                    }
+                }
+            }
+            const unreadCleared = Array.isArray(data.clearUnreads)
+                ? data.clearUnreads.map((item) => new ClearUnread(item))
+                : [];
+            return {
+                ...data,
+                messages,
+                unreadCleared,
+            };
+        });
+    };
+});

package/dist/apis/chat/removeUnreadMark.d.ts

@@ -0,0 +1,8 @@
+import { ThreadType } from "../../models/index.js";
+export type RemoveUnreadMarkResponse = {
+    data: {
+        updateId: number;
+    };
+    status: number;
+};
+export declare const removeUnreadMarkFactory: (ctx: import("../../context.js").ContextBase, api: import("../../apis.js").API) => (threadId: string, type?: ThreadType) => Promise<RemoveUnreadMarkResponse>;

package/dist/apis/chat/removeUnreadMark.js

@@ -0,0 +1,50 @@
+import { ZaloApiError } from "../../Errors/ZaloApiError.js";
+import { ThreadType } from "../../models/index.js";
+import { apiFactory } from "../../utils.js";
+export const removeUnreadMarkFactory = apiFactory()((api, ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.conversation[0]}/api/conv/removeUnreadMark`);
+    /**
+     * Remove unread mark from conversation
+     *
+     * @param threadId Thread ID
+     * @param type Thread type (User/Group)
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function removeUnreadMark(threadId, type = ThreadType.User) {
+        const timestamp = Date.now();
+        const isGroup = type === ThreadType.Group;
+        const requestParams = {
+            param: JSON.stringify({
+                [isGroup ? "convsGroup" : "convsUser"]: [threadId],
+                [isGroup ? "convsUser" : "convsGroup"]: [],
+                [isGroup ? "convsGroupData" : "convsUserData"]: [
+                    {
+                        id: threadId,
+                        ts: timestamp,
+                    },
+                ],
+                [isGroup ? "convsUserData" : "convsGroupData"]: [],
+            }),
+        };
+        const encryptedParams = utils.encodeAES(JSON.stringify(requestParams));
+        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, (result) => {
+            const data = result.data;
+            if (typeof data.data === "string") {
+                return {
+                    data: JSON.parse(data.data),
+                    status: data.status,
+                };
+            }
+            return result.data;
+        });
+    };
+});

package/dist/apis/chat/resetHiddenConversPin.d.ts

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

package/dist/apis/chat/resetHiddenConversPin.js

@@ -0,0 +1,20 @@
+import { ZaloApiError } from "../../Errors/ZaloApiError.js";
+import { apiFactory } from "../../utils.js";
+export const resetHiddenConversPinFactory = apiFactory()((api, _ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.conversation[0]}/api/hiddenconvers/reset`);
+    /**
+     * Reset hidden conversation pin
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function resetHiddenConversPin() {
+        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/chat/sendBankCard.d.ts

@@ -0,0 +1,9 @@
+import type { BinBankCard } from "../../models/index.js";
+import { ThreadType } from "../../models/index.js";
+export type SendBankCardPayload = {
+    binBank: BinBankCard;
+    numAccBank: string;
+    nameAccBank?: string;
+};
+export type SendBankCardResponse = "";
+export declare const sendBankCardFactory: (ctx: import("../../context.js").ContextBase, api: import("../../apis.js").API) => (payload: SendBankCardPayload, threadId: string, type?: ThreadType) => Promise<"">;

package/dist/apis/chat/sendBankCard.js

@@ -0,0 +1,36 @@
+import { ZaloApiError } from "../../Errors/ZaloApiError.js";
+import { ThreadType } from "../../models/index.js";
+import { apiFactory } from "../../utils.js";
+export const sendBankCardFactory = apiFactory()((api, _, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.zimsg[0]}/api/transfer/card`);
+    /**
+     * Send bank card
+     *
+     * @param payload The payload containing the bank card information
+     * @param threadId The ID of the thread to send the bank card to
+     * @param type The type of thread to send the bank card to
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function sendBankCard(payload, threadId, type = ThreadType.User) {
+        const params = {
+            binBank: payload.binBank,
+            numAccBank: payload.numAccBank,
+            nameAccBank: payload.nameAccBank?.toUpperCase() || "---",
+            cliMsgId: Date.now().toString(),
+            tsMsg: Date.now(),
+            destUid: threadId,
+            destType: type === ThreadType.Group ? 1 : 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/chat/sendCard.d.ts

@@ -0,0 +1,10 @@
+import { ThreadType } from "../../models/index.js";
+export type SendCardOptions = {
+    userId: string;
+    phoneNumber?: string;
+    ttl?: number;
+};
+export type SendCardResponse = {
+    msgId: number;
+};
+export declare const sendCardFactory: (ctx: import("../../context.js").ContextBase, api: import("../../apis.js").API) => (options: SendCardOptions, threadId: string, type?: ThreadType) => Promise<SendCardResponse>;

package/dist/apis/chat/sendCard.js

@@ -0,0 +1,58 @@
+import { ZaloApiError } from "../../Errors/ZaloApiError.js";
+import { ThreadType } from "../../models/index.js";
+import { apiFactory } from "../../utils.js";
+export const sendCardFactory = apiFactory()((api, ctx, utils) => {
+    const serviceURL = {
+        [ThreadType.User]: utils.makeURL(`${api.zpwServiceMap.file[0]}/api/message/forward`),
+        [ThreadType.Group]: utils.makeURL(`${api.zpwServiceMap.file[0]}/api/group/forward`),
+    };
+    /**
+     * Send a card to a User - Group
+     *
+     * @param userId Unique ID for Card
+     * @param phoneNumber Optional phone number for sending card to a User
+     * @param ttl Time to live in milliseconds (default: 0)
+     * @param threadId ID of the conversation
+     * @param type Message type (User or GroupMessage)
+     *
+     * @throws {ZaloApiError}
+     *
+     */
+    return async function sendCard(options, threadId, type = ThreadType.User) {
+        const data = await api.getQR(options.userId);
+        const QRCodeURL = data[options.userId];
+        const clientId = Date.now().toString();
+        const params = {
+            ttl: options.ttl ?? 0,
+            msgType: 6,
+            clientId: clientId,
+            msgInfo: {
+                contactUid: options.userId,
+                qrCodeUrl: QRCodeURL,
+            },
+        };
+        if (options.phoneNumber) {
+            params.msgInfo.phone = options.phoneNumber;
+        }
+        if (type == ThreadType.Group) {
+            params.visibility = 0;
+            params.grid = threadId;
+        }
+        else {
+            params.toId = threadId;
+            params.imei = ctx.imei;
+        }
+        const msgInfoStringified = JSON.stringify(params.msgInfo);
+        params.msgInfo = msgInfoStringified;
+        const encryptedParams = utils.encodeAES(JSON.stringify(params));
+        if (!encryptedParams)
+            throw new ZaloApiError("Failed to encrypt params");
+        const response = await utils.request(serviceURL[type], {
+            method: "POST",
+            body: new URLSearchParams({
+                params: encryptedParams,
+            }),
+        });
+        return utils.resolve(response);
+    };
+});

package/dist/apis/chat/sendDeliveredEvent.d.ts

@@ -0,0 +1,16 @@
+import { ThreadType } from "../../models/index.js";
+export type SendDeliveredEventResponse = "" | {
+    status: number;
+};
+export type SendDeliveredEventMessageParams = {
+    msgId: string;
+    cliMsgId: string;
+    uidFrom: string;
+    idTo: string;
+    msgType: string;
+    st: number;
+    at: number;
+    cmd: number;
+    ts: string | number;
+};
+export declare const sendDeliveredEventFactory: (ctx: import("../../context.js").ContextBase, api: import("../../apis.js").API) => (isSeen: boolean, messages: SendDeliveredEventMessageParams | SendDeliveredEventMessageParams[], type?: ThreadType) => Promise<SendDeliveredEventResponse>;