@ohos-ports/zca-js 2.2.0-beta.1

package/dist/apis/getListBankAccount.js

@@ -0,0 +1,27 @@
+import { ZaloApiError } from "../Errors/ZaloApiError.js";
+import { apiFactory } from "../utils.js";
+export const getListBankAccountFactory = apiFactory()((api, _ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.zimsg[0]}/api/transfer/list`);
+    /**
+     * Get list bank accounts
+     *
+     * @param page Page number (default: 0)
+     * @param limit Number of items to retrieve (default: 20)
+     *
+     * @throws {ZaloApiError} When something went wrong, with `error.code`
+     * - `114` - Invalid params
+     */
+    return async function getListBankAccount(page = 0, limit = 20) {
+        const params = {
+            page: page,
+            limit: limit,
+        };
+        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/getListBoard.d.ts

@@ -0,0 +1,21 @@
+import type { NoteDetail, PinnedMessageDetail, PollDetail } from "../models/index.js";
+import { BoardType } from "../models/index.js";
+export type ListBoardOptions = {
+    /**
+     * Page number (default: 1)
+     */
+    page?: number;
+    /**
+     * Number of items to retrieve (default: 20)
+     */
+    count?: number;
+};
+export type BoardItem = {
+    boardType: BoardType;
+    data: PollDetail | NoteDetail | PinnedMessageDetail;
+};
+export type GetListBoardResponse = {
+    items: BoardItem[];
+    count: number;
+};
+export declare const getListBoardFactory: (ctx: import("../context.js").ContextBase, api: import("../apis.js").API) => (options: ListBoardOptions, groupId: string) => Promise<GetListBoardResponse>;

package/dist/apis/getListBoard.js

@@ -0,0 +1,45 @@
+import { ZaloApiError } from "../Errors/ZaloApiError.js";
+import { BoardType } from "../models/index.js";
+import { apiFactory } from "../utils.js";
+export const getListBoardFactory = apiFactory()((api, ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.group_board[0]}/api/board/list`);
+    /**
+     * Get list board items in a group
+     *
+     * @param options - The options for the request
+     * @param groupId - The ID of the group
+     *
+     * @throws {ZaloApiError}
+     *
+     */
+    return async function getListBoard(options, groupId) {
+        var _a, _b;
+        const requestParams = {
+            group_id: groupId,
+            board_type: 0,
+            page: (_a = options.page) !== null && _a !== void 0 ? _a : 1,
+            count: (_b = options.count) !== null && _b !== void 0 ? _b : 20,
+            last_id: 0,
+            last_type: 0,
+            imei: ctx.imei,
+        };
+        const encryptedParams = utils.encodeAES(JSON.stringify(requestParams));
+        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;
+            data.items.forEach((item) => {
+                if (item.boardType != BoardType.Poll) {
+                    const detailData = item.data;
+                    if (typeof detailData.params === "string") {
+                        detailData.params = JSON.parse(detailData.params);
+                    }
+                }
+            });
+            return data;
+        });
+    };
+});

package/dist/apis/getListDevice.d.ts

@@ -0,0 +1,10 @@
+export type GetListDeviceResponse = {
+    devices: {
+        masterId: string;
+        encIdentity: string;
+        lastUpdateTs: number;
+        encSignature: string;
+        companions: unknown[];
+    };
+};
+export declare const getListDeviceFactory: (ctx: import("../context.js").ContextBase, api: import("../apis.js").API) => () => Promise<GetListDeviceResponse>;

package/dist/apis/getListDevice.js

@@ -0,0 +1,22 @@
+import { ZaloApiError } from "../Errors/ZaloApiError.js";
+import { apiFactory } from "../utils.js";
+export const getListDeviceFactory = apiFactory()((api, ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.aext[0]}/api/devices/linked`);
+    /**
+     * Get list device
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function getListDevice() {
+        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/getListReminder.d.ts

@@ -0,0 +1,28 @@
+import type { ReminderGroup, ReminderUser } from "../models/index.js";
+import { ThreadType } from "../models/index.js";
+export type ListReminderOptions = {
+    /**
+     * Page number (default: 1)
+     */
+    page?: number;
+    /**
+     * Number of items to retrieve (default: 20)
+     */
+    count?: number;
+};
+export type ReminderListUser = ReminderUser;
+export type ReminderListGroup = ReminderGroup & {
+    groupId: string;
+    eventType: number;
+    responseMem: {
+        rejectMember: number;
+        myResp: number;
+        acceptMember: number;
+    };
+    repeatInfo: {
+        list_ts: unknown[];
+    };
+    repeatData: unknown[];
+};
+export type GetListReminderResponse = (ReminderListUser & ReminderListGroup)[];
+export declare const getListReminderFactory: (ctx: import("../context.js").ContextBase, api: import("../apis.js").API) => (options: ListReminderOptions, threadId: string, type?: ThreadType) => Promise<GetListReminderResponse>;

package/dist/apis/getListReminder.js

@@ -0,0 +1,47 @@
+import { ZaloApiError } from "../Errors/ZaloApiError.js";
+import { ThreadType } from "../models/index.js";
+import { apiFactory } from "../utils.js";
+export const getListReminderFactory = apiFactory()((api, ctx, utils) => {
+    const serviceURL = {
+        [ThreadType.User]: utils.makeURL(`${api.zpwServiceMap.group_board[0]}/api/board/oneone/list`),
+        [ThreadType.Group]: utils.makeURL(`${api.zpwServiceMap.group_board[0]}/api/board/listReminder`),
+    };
+    /**
+     * Get list reminder
+     *
+     * @param options - The options for the request
+     * @param threadId - The ID of the thread
+     * @param type - The type of the thread (User or Group)
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function getListReminder(options, threadId, type = ThreadType.User) {
+        var _a, _b, _c, _d;
+        const requestParams = Object.assign({ objectData: JSON.stringify(type === ThreadType.User
+                ? {
+                    uid: threadId,
+                    board_type: 1,
+                    page: (_a = options.page) !== null && _a !== void 0 ? _a : 1,
+                    count: (_b = options.count) !== null && _b !== void 0 ? _b : 20,
+                    last_id: 0,
+                    last_type: 0,
+                }
+                : {
+                    group_id: threadId,
+                    board_type: 1,
+                    page: (_c = options.page) !== null && _c !== void 0 ? _c : 1,
+                    count: (_d = options.count) !== null && _d !== void 0 ? _d : 20,
+                    last_id: 0,
+                    last_type: 0,
+                }) }, (type === ThreadType.Group && { imei: ctx.imei }));
+        const encryptedParams = utils.encodeAES(JSON.stringify(requestParams));
+        if (!encryptedParams)
+            throw new ZaloApiError("Failed to encrypt params");
+        const response = await utils.request(utils.makeURL(serviceURL[type], { params: encryptedParams }), {
+            method: "GET",
+        });
+        return utils.resolve(response, (result) => {
+            return JSON.parse(result.data);
+        });
+    };
+});

package/dist/apis/getMultiUsersByPhones.d.ts

@@ -0,0 +1,5 @@
+import { AvatarSize, type UserBasic } from "../models/index.js";
+export type GetMultiUsersByPhonesResponse = {
+    [phoneNumber: string]: UserBasic;
+};
+export declare const getMultiUsersByPhonesFactory: (ctx: import("../context.js").ContextBase, api: import("../apis.js").API) => (phoneNumbers: string | string[], avatarSize?: AvatarSize) => Promise<GetMultiUsersByPhonesResponse>;

package/dist/apis/getMultiUsersByPhones.js

@@ -0,0 +1,39 @@
+import { ZaloApiError } from "../Errors/ZaloApiError.js";
+import { apiFactory } from "../utils.js";
+import { AvatarSize } from "../models/index.js";
+export const getMultiUsersByPhonesFactory = apiFactory()((api, ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.friend[0]}/api/friend/profile/multiget`);
+    /**
+     * Get multiple user(s) by their phone numbers.
+     *
+     * @param phoneNumbers Phone number(s)
+     * @param avatarSize Avatar size (default: AvatarSize.Large)
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function getMultiUsersByPhones(phoneNumbers, avatarSize = AvatarSize.Large) {
+        if (!phoneNumbers)
+            throw new ZaloApiError("Missing phoneNumbers");
+        if (!Array.isArray(phoneNumbers))
+            phoneNumbers = [phoneNumbers];
+        phoneNumbers = phoneNumbers.map((phone) => {
+            if (phone.startsWith("0")) {
+                if (ctx.language == "vi")
+                    phone = "84" + phone.slice(1);
+            }
+            return phone;
+        });
+        const params = {
+            phones: phoneNumbers,
+            avatar_size: avatarSize,
+            language: ctx.language,
+        };
+        const encryptedParams = utils.encodeAES(JSON.stringify(params));
+        if (!encryptedParams)
+            throw new ZaloApiError("Failed to encrypt params");
+        const response = await utils.request(utils.makeURL(serviceURL, { params: encryptedParams }), {
+            method: "GET",
+        });
+        return utils.resolve(response);
+    };
+});

package/dist/apis/getMute.d.ts

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

package/dist/apis/getMute.js

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

package/dist/apis/getOwnId.d.ts

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

package/dist/apis/getOwnId.js

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

package/dist/apis/getPendingGroupMembers.d.ts

@@ -0,0 +1,11 @@
+export type GetPendingGroupMembersUserInfo = {
+    uid: string;
+    dpn: string;
+    avatar: string;
+    user_submit: null;
+};
+export type GetPendingGroupMembersResponse = {
+    time: number;
+    users: GetPendingGroupMembersUserInfo[];
+};
+export declare const getPendingGroupMembersFactory: (ctx: import("../context.js").ContextBase, api: import("../apis.js").API) => (groupId: string) => Promise<GetPendingGroupMembersResponse>;

package/dist/apis/getPendingGroupMembers.js

@@ -0,0 +1,27 @@
+import { ZaloApiError } from "../Errors/ZaloApiError.js";
+import { apiFactory } from "../utils.js";
+export const getPendingGroupMembersFactory = apiFactory()((api, ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.group[0]}/api/group/pending-mems/list`);
+    /**
+     * Get pending group members
+     *
+     * @param groupId - The id of the group to get the pending members
+     *
+     * @note Only the group leader and deputy group leader can view
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function getPendingGroupMembers(groupId) {
+        const params = {
+            grid: groupId,
+            imei: ctx.imei,
+        };
+        const encryptedParams = utils.encodeAES(JSON.stringify(params));
+        if (!encryptedParams)
+            throw new ZaloApiError("Failed to encrypt params");
+        const response = await utils.request(utils.makeURL(serviceURL, { params: encryptedParams }), {
+            method: "GET",
+        });
+        return utils.resolve(response);
+    };
+});

package/dist/apis/getPinConversations.d.ts

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

package/dist/apis/getPinConversations.js

@@ -0,0 +1,22 @@
+import { ZaloApiError } from "../Errors/ZaloApiError.js";
+import { apiFactory } from "../utils.js";
+export const getPinConversationsFactory = apiFactory()((api, ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.conversation[0]}/api/pinconvers/list`);
+    /**
+     * Get pin conversations
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function getPinConversations() {
+        const params = {
+            imei: ctx.imei,
+        };
+        const encryptedParams = utils.encodeAES(JSON.stringify(params));
+        if (!encryptedParams)
+            throw new ZaloApiError("Failed to encrypt params");
+        const response = await utils.request(utils.makeURL(serviceURL, { params: encryptedParams }), {
+            method: "GET",
+        });
+        return utils.resolve(response);
+    };
+});

package/dist/apis/getPollDetail.d.ts

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

package/dist/apis/getPollDetail.js

@@ -0,0 +1,30 @@
+import { ZaloApiError } from "../Errors/ZaloApiError.js";
+import { apiFactory } from "../utils.js";
+export const getPollDetailFactory = apiFactory()((api, ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.group[0]}/api/poll/detail`);
+    /**
+     * Get poll detail
+     *
+     * @param pollId Poll ID
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function getPollDetail(pollId) {
+        if (!pollId)
+            throw new ZaloApiError("Missing poll id");
+        const params = {
+            poll_id: pollId,
+            imei: ctx.imei,
+        };
+        const encryptedParams = utils.encodeAES(JSON.stringify(params));
+        if (!encryptedParams)
+            throw new ZaloApiError("Failed to encrypt message");
+        const response = await utils.request(serviceURL, {
+            method: "POST",
+            body: new URLSearchParams({
+                params: encryptedParams,
+            }),
+        });
+        return utils.resolve(response);
+    };
+});

package/dist/apis/getProductCatalogList.d.ts

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

package/dist/apis/getProductCatalogList.js

@@ -0,0 +1,33 @@
+import { ZaloApiError } from "../Errors/ZaloApiError.js";
+import { apiFactory } from "../utils.js";
+export const getProductCatalogListFactory = apiFactory()((api, _, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.catalog[0]}/api/prodcatalog/product/list`);
+    /**
+     * Get product catalog list?
+     *
+     * @param payload payload
+     *
+     * @note this API is used for zBusiness
+     * @throws {ZaloApiError}
+     */
+    return async function getProductCatalogList(payload) {
+        var _a, _b, _c, _d;
+        const params = {
+            catalog_id: payload.catalogId,
+            limit: (_a = payload.limit) !== null && _a !== void 0 ? _a : 100,
+            version_catalog: (_b = payload.versionCatalog) !== null && _b !== void 0 ? _b : 0,
+            last_product_id: (_c = payload.lastProductId) !== null && _c !== void 0 ? _c : -1,
+            page: (_d = payload.page) !== null && _d !== void 0 ? _d : 0,
+        };
+        const encryptedParams = utils.encodeAES(JSON.stringify(params));
+        if (!encryptedParams)
+            throw new ZaloApiError("Failed to encrypt params");
+        const response = await utils.request(serviceURL, {
+            method: "POST",
+            body: new URLSearchParams({
+                params: encryptedParams,
+            }),
+        });
+        return utils.resolve(response);
+    };
+});

package/dist/apis/getQR.d.ts

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

package/dist/apis/getQR.js

@@ -0,0 +1,29 @@
+import { ZaloApiError } from "../Errors/ZaloApiError.js";
+import { apiFactory } from "../utils.js";
+export const getQRFactory = apiFactory()((api, _, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.friend[0]}/api/friend/mget-qr`);
+    /**
+     * Get QR code for users
+     *
+     * @param userId User ID or list of user IDs
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function getQR(userId) {
+        if (typeof userId == "string")
+            userId = [userId];
+        const params = {
+            fids: userId,
+        };
+        const encryptedParams = utils.encodeAES(JSON.stringify(params));
+        if (!encryptedParams)
+            throw new ZaloApiError("Failed to encrypt params");
+        const response = await utils.request(serviceURL, {
+            method: "POST",
+            body: new URLSearchParams({
+                params: encryptedParams,
+            }),
+        });
+        return utils.resolve(response);
+    };
+});

package/dist/apis/getQuickMessageList.d.ts

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

package/dist/apis/getQuickMessageList.js

@@ -0,0 +1,24 @@
+import { ZaloApiError } from "../Errors/ZaloApiError.js";
+import { apiFactory } from "../utils.js";
+export const getQuickMessageListFactory = apiFactory()((api, ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.quick_message[0]}/api/quickmessage/list`);
+    /**
+     * Get quick message list
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function getQuickMessageList() {
+        const params = {
+            version: 0,
+            lang: 0,
+            imei: ctx.imei,
+        };
+        const encryptedParams = utils.encodeAES(JSON.stringify(params));
+        if (!encryptedParams)
+            throw new ZaloApiError("Failed to encrypt params");
+        const response = await utils.request(utils.makeURL(serviceURL, { params: encryptedParams }), {
+            method: "GET",
+        });
+        return utils.resolve(response);
+    };
+});

package/dist/apis/getRelatedFriendGroup.d.ts

@@ -0,0 +1,6 @@
+export type GetRelatedFriendGroupResponse = {
+    groupRelateds: {
+        [friendId: string]: string[];
+    };
+};
+export declare const getRelatedFriendGroupFactory: (ctx: import("../context.js").ContextBase, api: import("../apis.js").API) => (friendId: string | string[]) => Promise<GetRelatedFriendGroupResponse>;

package/dist/apis/getRelatedFriendGroup.js

@@ -0,0 +1,30 @@
+import { ZaloApiError } from "../Errors/ZaloApiError.js";
+import { apiFactory } from "../utils.js";
+export const getRelatedFriendGroupFactory = apiFactory()((api, ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.friend[0]}/api/friend/group/related`);
+    /**
+     * Get related friend group
+     *
+     * @param friendId friend ids
+     *
+     * @note this API is used for zBusiness
+     * @throws {ZaloApiError}
+     */
+    return async function getRelatedFriendGroup(friendId) {
+        const friendIds = Array.isArray(friendId) ? friendId : [friendId];
+        const params = {
+            friend_ids: JSON.stringify(friendIds),
+            imei: ctx.imei,
+        };
+        const encryptedParams = utils.encodeAES(JSON.stringify(params));
+        if (!encryptedParams)
+            throw new ZaloApiError("Failed to encrypt params");
+        const response = await utils.request(serviceURL, {
+            method: "POST",
+            body: new URLSearchParams({
+                params: encryptedParams,
+            }),
+        });
+        return utils.resolve(response);
+    };
+});

package/dist/apis/getReminder.d.ts

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

package/dist/apis/getReminder.js

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

package/dist/apis/getReminderResponses.d.ts

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

package/dist/apis/getReminderResponses.js

@@ -0,0 +1,24 @@
+import { ZaloApiError } from "../Errors/ZaloApiError.js";
+import { apiFactory } from "../utils.js";
+export const getReminderResponsesFactory = apiFactory()((api, _ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.group_board[0]}/api/board/topic/listResponseEvent`);
+    /**
+     * Get reminder responses
+     *
+     * @param reminderId reminder id
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function getReminderResponses(reminderId) {
+        const params = {
+            eventId: reminderId,
+        };
+        const encryptedParams = utils.encodeAES(JSON.stringify(params));
+        if (!encryptedParams)
+            throw new ZaloApiError("Failed to encrypt params");
+        const response = await utils.request(utils.makeURL(serviceURL, { params: encryptedParams }), {
+            method: "GET",
+        });
+        return utils.resolve(response);
+    };
+});

package/dist/apis/getSentFriendRequest.d.ts

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