@softtynet/zca-js 2.1.3

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 } from "../models/index.js";
+export type GetGroupLinkInfoPayload = {
+    link: string;
+    /**
+     * Default: 1
+     */
+    memberPage?: number;
+};
+export type GetGroupLinkInfoResponse = {
+    groupId: string;
+    name: string;
+    desc: string;
+    type: number;
+    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/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/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>;