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

package/dist/apis/getFriendRecommendations.js

@@ -0,0 +1,27 @@
+import { ZaloApiError } from "../Errors/ZaloApiError.js";
+import { apiFactory } from "../utils.js";
+export var FriendRecommendationsType;
+(function (FriendRecommendationsType) {
+    FriendRecommendationsType[FriendRecommendationsType["RecommendedFriend"] = 1] = "RecommendedFriend";
+    FriendRecommendationsType[FriendRecommendationsType["ReceivedFriendRequest"] = 2] = "ReceivedFriendRequest";
+})(FriendRecommendationsType || (FriendRecommendationsType = {}));
+export const getFriendRecommendationsFactory = apiFactory()((api, ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.friend[0]}/api/friend/recommendsv2/list`);
+    /**
+     * Get friend recommendations/received friend requests
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function getFriendRecommendations() {
+        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/getFriendRequestStatus.d.ts

@@ -0,0 +1,8 @@
+export type GetFriendRequestStatusResponse = {
+    addFriendPrivacy: number;
+    isSeenFriendReq: boolean;
+    is_friend: number;
+    is_requested: number;
+    is_requesting: number;
+};
+export declare const getFriendRequestStatusFactory: (ctx: import("../context.js").ContextBase, api: import("../apis.js").API) => (friendId: string) => Promise<GetFriendRequestStatusResponse>;

package/dist/apis/getFriendRequestStatus.js

@@ -0,0 +1,25 @@
+import { ZaloApiError } from "../Errors/ZaloApiError.js";
+import { apiFactory } from "../utils.js";
+export const getFriendRequestStatusFactory = apiFactory()((api, ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.friend[0]}/api/friend/reqstatus`);
+    /**
+     * Get friend request status
+     *
+     * @param friendId friend id
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function getFriendRequestStatus(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/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/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/getGroupBlockedMember.d.ts

@@ -0,0 +1,23 @@
+export type GetGroupBlockedMemberPayload = {
+    /**
+     * Page number (default: 1)
+     */
+    page?: number;
+    /**
+     * Number of items to retrieve (default: 50)
+     */
+    count?: number;
+};
+export type GetGroupBlockedMemberResponse = {
+    blocked_members: {
+        id: string;
+        dName: string;
+        zaloName: string;
+        avatar: string;
+        avatar_25: string;
+        accountStatus: number;
+        type: number;
+    }[];
+    has_more: number;
+};
+export declare const getGroupBlockedMemberFactory: (ctx: import("../context.js").ContextBase, api: import("../apis.js").API) => (payload: GetGroupBlockedMemberPayload, groupId: string) => Promise<GetGroupBlockedMemberResponse>;

package/dist/apis/getGroupBlockedMember.js

@@ -0,0 +1,29 @@
+import { ZaloApiError } from "../Errors/ZaloApiError.js";
+import { apiFactory } from "../utils.js";
+export const getGroupBlockedMemberFactory = apiFactory()((api, ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.group[0]}/api/group/blockedmems/list`);
+    /**
+     * Get group blocked member
+     *
+     * @param payload payload
+     * @param groupId group id
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function getGroupBlockedMember(payload, groupId) {
+        var _a, _b;
+        const params = {
+            grid: groupId,
+            page: (_a = payload.page) !== null && _a !== void 0 ? _a : 1,
+            count: (_b = payload.count) !== null && _b !== void 0 ? _b : 50,
+            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/getGroupChatHistory.d.ts

@@ -0,0 +1,8 @@
+import { GroupMessage } from "../models/index.js";
+export type GetGroupChatHistoryResponse = {
+    lastActionId: string;
+    lastActionIdOther: string;
+    more: number;
+    groupMsgs: GroupMessage[];
+};
+export declare const getGroupChatHistoryFactory: (ctx: import("../context.js").ContextBase, api: import("../apis.js").API) => (groupId: string, count?: number) => Promise<GetGroupChatHistoryResponse>;

package/dist/apis/getGroupChatHistory.js

@@ -0,0 +1,36 @@
+import { ZaloApiError } from "../Errors/ZaloApiError.js";
+import { apiFactory } from "../utils.js";
+import { GroupMessage } from "../models/index.js";
+export const getGroupChatHistoryFactory = apiFactory()((api, ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.group[0]}/api/group/history`);
+    /**
+     * Get group chat history
+     *
+     * @param groupId group id
+     * @param count count of messages to return (default: 50)
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function getGroupChatHistory(groupId, count = 50) {
+        const params = {
+            grid: groupId,
+            count: count,
+        };
+        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);
+            }
+            for (let i = 0; i < data.groupMsgs.length; i++) {
+                data.groupMsgs[i] = new GroupMessage(ctx.uid, data.groupMsgs[i]);
+            }
+            return data;
+        });
+    };
+});

package/dist/apis/getGroupInfo.d.ts

@@ -0,0 +1,16 @@
+import type { GroupInfo } from "../models/index.js";
+export type GroupInfoResponse = {
+    removedsGroup: string[];
+    unchangedsGroup: string[];
+    gridInfoMap: {
+        [groupId: string]: GroupInfo & {
+            memVerList: string[];
+            pendingApprove: GroupInfoPendingApprove;
+        };
+    };
+};
+export type GroupInfoPendingApprove = {
+    time: number;
+    uids: string[] | null;
+};
+export declare const getGroupInfoFactory: (ctx: import("../context.js").ContextBase, api: import("../apis.js").API) => (groupId: string | string[]) => Promise<GroupInfoResponse>;

package/dist/apis/getGroupInfo.js

@@ -0,0 +1,32 @@
+import { ZaloApiError } from "../Errors/ZaloApiError.js";
+import { apiFactory } from "../utils.js";
+export const getGroupInfoFactory = apiFactory()((api, _, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.group[0]}/api/group/getmg-v2`);
+    /**
+     * Get group information
+     *
+     * @param groupId Group ID or list of group IDs
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function getGroupInfo(groupId) {
+        if (!Array.isArray(groupId))
+            groupId = [groupId];
+        const params = {
+            gridVerMap: JSON.stringify(groupId.reduce((acc, id) => {
+                acc[id] = 0;
+                return acc;
+            }, {})),
+        };
+        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/getGroupInviteBoxInfo.d.ts

@@ -0,0 +1,32 @@
+import type { GroupInfo, GroupTopic } from "../models/index.js";
+export type GetGroupInviteBoxInfoPayload = {
+    groupId: string;
+    mpage?: number;
+    mcount?: number;
+};
+export type GetGroupInviteBoxInfoResponse = {
+    groupInfo: GroupInfo & {
+        topic?: Omit<GroupTopic, "action">;
+    };
+    inviterInfo: {
+        id: string;
+        dName: string;
+        zaloName: string;
+        avatar: string;
+        avatar_25: string;
+        accountStatus: number;
+        type: number;
+    };
+    grCreatorInfo: {
+        id: string;
+        dName: string;
+        zaloName: string;
+        avatar: string;
+        avatar_25: string;
+        accountStatus: number;
+        type: number;
+    };
+    expiredTs: string;
+    type: number;
+};
+export declare const getGroupInviteBoxInfoFactory: (ctx: import("../context.js").ContextBase, api: import("../apis.js").API) => (payload: GetGroupInviteBoxInfoPayload) => Promise<GetGroupInviteBoxInfoResponse>;

package/dist/apis/getGroupInviteBoxInfo.js

@@ -0,0 +1,38 @@
+import { ZaloApiError } from "../Errors/ZaloApiError.js";
+import { apiFactory } from "../utils.js";
+export const getGroupInviteBoxInfoFactory = apiFactory()((api, _, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.group[0]}/api/group/inv-box/inv-info`);
+    /**
+     * Get group invite box info
+     *
+     * @param payload - The payload of the request
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function getGroupInviteBoxInfo(payload) {
+        var _a, _b;
+        const params = {
+            grId: payload.groupId,
+            mcount: (_a = payload.mcount) !== null && _a !== void 0 ? _a : 10,
+            mpage: (_b = payload.mpage) !== null && _b !== void 0 ? _b : 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, (result) => {
+            const data = result.data;
+            const topic = data.groupInfo.topic;
+            if (typeof topic.params == "string") {
+                const params = JSON.parse(topic.params);
+                if (typeof params.extra == "string") {
+                    params.extra = JSON.parse(params.extra);
+                }
+                topic.params = params;
+            }
+            return data;
+        });
+    };
+});

package/dist/apis/getGroupInviteBoxList.d.ts

@@ -0,0 +1,38 @@
+import type { GroupInfo } from "../models/index.js";
+export type GetGroupInviteBoxListPayload = {
+    mpage?: number;
+    page?: number;
+    invPerPage?: number;
+    mcount?: number;
+};
+export type GetGroupInviteBoxListResponse = {
+    invitations: {
+        groupInfo: GroupInfo;
+        inviterInfo: {
+            id: string;
+            dName: string;
+            zaloName: string;
+            avatar: string;
+            avatar_25: string;
+            accountStatus: number;
+            type: number;
+        };
+        grCreatorInfo: {
+            id: string;
+            dName: string;
+            zaloName: string;
+            avatar: string;
+            avatar_25: string;
+            accountStatus: number;
+            type: number;
+        };
+        /**
+         * Expired timestamp max 7 days
+         */
+        expiredTs: string;
+        type: number;
+    }[];
+    total: number;
+    hasMore: boolean;
+};
+export declare const getGroupInviteBoxListFactory: (ctx: import("../context.js").ContextBase, api: import("../apis.js").API) => (payload?: GetGroupInviteBoxListPayload) => Promise<GetGroupInviteBoxListResponse>;

package/dist/apis/getGroupInviteBoxList.js

@@ -0,0 +1,31 @@
+import { ZaloApiError } from "../Errors/ZaloApiError.js";
+import { apiFactory } from "../utils.js";
+export const getGroupInviteBoxListFactory = apiFactory()((api, _, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.group[0]}/api/group/inv-box/list`);
+    /**
+     * Get group invite box list
+     *
+     * @param payload - The payload of the request
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function getGroupInviteBoxList(payload) {
+        var _a, _b, _c, _d;
+        const params = {
+            mpage: (_a = payload === null || payload === void 0 ? void 0 : payload.mpage) !== null && _a !== void 0 ? _a : 1,
+            page: (_b = payload === null || payload === void 0 ? void 0 : payload.page) !== null && _b !== void 0 ? _b : 0,
+            invPerPage: (_c = payload === null || payload === void 0 ? void 0 : payload.invPerPage) !== null && _c !== void 0 ? _c : 12,
+            mcount: (_d = payload === null || payload === void 0 ? void 0 : payload.mcount) !== null && _d !== void 0 ? _d : 10,
+            lastGroupId: null, // @TODO: check type
+            avatar_size: 120,
+            member_avatar_size: 120,
+        };
+        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/getGroupLinkDetail.d.ts

@@ -0,0 +1,9 @@
+export type GetGroupLinkDetailResponse = {
+    link?: string;
+    expiration_date?: number;
+    /**
+     * 1: enabled, 0: disabled
+     */
+    enabled: number;
+};
+export declare const getGroupLinkDetailFactory: (ctx: import("../context.js").ContextBase, api: import("../apis.js").API) => (groupId: string) => Promise<GetGroupLinkDetailResponse>;

package/dist/apis/getGroupLinkDetail.js

@@ -0,0 +1,25 @@
+import { ZaloApiError } from "../Errors/ZaloApiError.js";
+import { apiFactory } from "../utils.js";
+export const getGroupLinkDetailFactory = apiFactory()((api, ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.group[0]}/api/group/link/detail`);
+    /**
+     * Get group link detail
+     *
+     * @param groupId The group id
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function getGroupLinkDetail(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/getGroupLinkInfo.d.ts

@@ -0,0 +1,34 @@
+import type { GroupSetting, GroupType } from "../models/index.js";
+export type GetGroupLinkInfoPayload = {
+    link: string;
+    /**
+     * Default: 1
+     */
+    memberPage?: number;
+};
+export type GetGroupLinkInfoResponse = {
+    groupId: string;
+    name: string;
+    desc: string;
+    type: GroupType;
+    creatorId: string;
+    avt: string;
+    fullAvt: string;
+    adminIds: string[];
+    currentMems: {
+        id: string;
+        dName: string;
+        zaloName: string;
+        avatar: string;
+        avatar_25: string;
+        accountStatus: number;
+        type: number;
+    }[];
+    admins: unknown[];
+    hasMoreMember: number;
+    subType: number;
+    totalMember: number;
+    setting: GroupSetting;
+    globalId: string;
+};
+export declare const getGroupLinkInfoFactory: (ctx: import("../context.js").ContextBase, api: import("../apis.js").API) => (payload: GetGroupLinkInfoPayload) => Promise<GetGroupLinkInfoResponse>;

package/dist/apis/getGroupLinkInfo.js

@@ -0,0 +1,28 @@
+import { ZaloApiError } from "../Errors/ZaloApiError.js";
+import { apiFactory } from "../utils.js";
+export const getGroupLinkInfoFactory = apiFactory()((api, _ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.group[0]}/api/group/link/ginfo`);
+    /**
+     * Get group link info
+     *
+     * @param payload - The payload of the request
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function getGroupLinkInfo(payload) {
+        var _a;
+        const params = {
+            link: payload.link,
+            avatar_size: 120,
+            member_avatar_size: 120,
+            mpage: (_a = payload.memberPage) !== null && _a !== void 0 ? _a : 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/getGroupMembersInfo.d.ts

@@ -0,0 +1,17 @@
+export type GroupMemberProfile = {
+    displayName: string;
+    zaloName: string;
+    avatar: string;
+    accountStatus: number;
+    type: number;
+    lastUpdateTime: number;
+    globalId: string;
+    id: string;
+};
+export type GetGroupMembersInfoResponse = {
+    profiles: {
+        [memberId: string]: GroupMemberProfile;
+    };
+    unchangeds_profile: unknown[];
+};
+export declare const getGroupMembersInfoFactory: (ctx: import("../context.js").ContextBase, api: import("../apis.js").API) => (memberId: string | string[]) => Promise<GetGroupMembersInfoResponse>;

package/dist/apis/getGroupMembersInfo.js

@@ -0,0 +1,24 @@
+import { ZaloApiError } from "../Errors/ZaloApiError.js";
+import { apiFactory } from "../utils.js";
+export const getGroupMembersInfoFactory = apiFactory()((api, _, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.profile[0]}/api/social/group/members`);
+    /**
+     * Get group information
+     *
+     * @param memberId member id or array of member ids
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function getGroupMembersInfo(memberId) {
+        if (!Array.isArray(memberId))
+            memberId = [memberId];
+        const params = {
+            friend_pversion_map: memberId.map((id) => (id.endsWith("_0") ? id : `${id}_0`)),
+        };
+        const encryptedParams = utils.encodeAES(JSON.stringify(params));
+        if (!encryptedParams)
+            throw new ZaloApiError("Failed to encrypt message");
+        const response = await utils.request(utils.makeURL(serviceURL, { params: encryptedParams }));
+        return utils.resolve(response);
+    };
+});

package/dist/apis/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/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/getLabels.d.ts

@@ -0,0 +1,7 @@
+import type { LabelData } from "../models/index.js";
+export type GetLabelsResponse = {
+    labelData: LabelData[];
+    version: number;
+    lastUpdateTime: number;
+};
+export declare const getLabelsFactory: (ctx: import("../context.js").ContextBase, api: import("../apis.js").API) => () => Promise<GetLabelsResponse>;

package/dist/apis/getLabels.js

@@ -0,0 +1,28 @@
+import { ZaloApiError } from "../Errors/ZaloApiError.js";
+import { apiFactory } from "../utils.js";
+export const getLabelsFactory = apiFactory()((api, ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.label[0]}/api/convlabel/get`);
+    /**
+     * Get all labels
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function getLabels() {
+        const params = {
+            imei: ctx.imei,
+        };
+        const encryptedParams = utils.encodeAES(JSON.stringify(params));
+        if (!encryptedParams)
+            throw new ZaloApiError("Failed to encrypt message");
+        const response = await utils.request(utils.makeURL(serviceURL, { params: encryptedParams }));
+        return utils.resolve(response, (result) => {
+            const data = result.data;
+            const formattedData = {
+                labelData: JSON.parse(data.labelData),
+                version: data.version,
+                lastUpdateTime: data.lastUpdateTime,
+            };
+            return formattedData;
+        });
+    };
+});

package/dist/apis/getListBank.d.ts

@@ -0,0 +1,5 @@
+import type { BankInfo } from "../models/index.js";
+export type GetListBankResponse = {
+    banks: BankInfo[];
+};
+export declare const getListBankFactory: (ctx: import("../context.js").ContextBase, api: import("../apis.js").API) => () => Promise<GetListBankResponse>;

package/dist/apis/getListBank.js

@@ -0,0 +1,20 @@
+import { ZaloApiError } from "../Errors/ZaloApiError.js";
+import { apiFactory } from "../utils.js";
+export const getListBankFactory = apiFactory()((api, _ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.zimsg[0]}/api/transfer/conf`);
+    /**
+     * Get list bank
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function getListBank() {
+        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/getListBankAccount.d.ts

@@ -0,0 +1,7 @@
+import type { BankAccount } from "../models/index.js";
+export type GetListBankAccountResponse = {
+    hasMore: boolean;
+    total: number;
+    myBanks: BankAccount[];
+};
+export declare const getListBankAccountFactory: (ctx: import("../context.js").ContextBase, api: import("../apis.js").API) => (page?: number, limit?: number) => Promise<GetListBankAccountResponse>;