@trungdlp/zca-js 1.0.0

package/dist/apis/createAutoReply.d.ts

@@ -0,0 +1,14 @@
+import type { AutoReplyItem, AutoReplyScope } from "../models/index.js";
+export type CreateAutoReplyPayload = {
+    content: string;
+    isEnable: boolean;
+    startTime: number;
+    endTime: number;
+    scope: AutoReplyScope;
+    uids?: string | string[];
+};
+export type CreateAutoReplyResponse = {
+    item: AutoReplyItem;
+    version: number;
+};
+export declare const createAutoReplyFactory: (ctx: import("../context.js").ContextBase, api: import("../apis.js").API) => (payload: CreateAutoReplyPayload) => Promise<CreateAutoReplyResponse>;

package/dist/apis/createAutoReply.js

@@ -0,0 +1,37 @@
+import { ZaloApiError } from "../Errors/ZaloApiError.js";
+import { apiFactory } from "../utils.js";
+export const createAutoReplyFactory = apiFactory()((api, ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.auto_reply[0]}/api/autoreply/create`);
+    /**
+     * Create auto reply
+     *
+     * @param payload payload
+     *
+     * @note this API used for zBusiness
+     * @throws {ZaloApiError}
+     */
+    return async function createAutoReply(payload) {
+        const uids = Array.isArray(payload.uids) ? payload.uids : [payload.uids];
+        const resultUids = (payload.scope === 2 || payload.scope === 3) ? uids : [];
+        const params = {
+            cliLang: ctx.language,
+            enable: payload.isEnable,
+            content: payload.content,
+            startTime: payload.startTime,
+            endTime: payload.endTime,
+            recurrence: ["RRULE:FREQ=DAILY;"],
+            scope: payload.scope,
+            uids: resultUids,
+        };
+        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/createCatalog.d.ts

@@ -0,0 +1,7 @@
+import type { CatalogItem } from "../models/index.js";
+export type CreateCatalogResponse = {
+    item: CatalogItem;
+    version_ls_catalog: number;
+    version_catalog: number;
+};
+export declare const createCatalogFactory: (ctx: import("../context.js").ContextBase, api: import("../apis.js").API) => (catalogName: string) => Promise<CreateCatalogResponse>;

package/dist/apis/createCatalog.js

@@ -0,0 +1,29 @@
+import { ZaloApiError } from "../Errors/ZaloApiError.js";
+import { apiFactory } from "../utils.js";
+export const createCatalogFactory = apiFactory()((api, _, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.catalog[0]}/api/prodcatalog/catalog/create`);
+    /**
+     * Create catalog?
+     *
+     * @param catalogName catalog name
+     *
+     * @note this API is used for zBusiness
+     * @throws {ZaloApiError}
+     */
+    return async function createCatalog(catalogName) {
+        const params = {
+            catalog_name: catalogName,
+            catalog_photo: "",
+        };
+        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/createGroup.d.ts

@@ -0,0 +1,28 @@
+import type { AttachmentSource } from "../models/index.js";
+export type CreateGroupResponse = {
+    groupType: number;
+    sucessMembers: string[];
+    groupId: string;
+    errorMembers: string[];
+    error_data: Record<string, unknown>;
+};
+export type CreateGroupOptions = {
+    /**
+     * Group name
+     */
+    name?: string;
+    /**
+     * List of member IDs to add to the group
+     */
+    members: string[];
+    /**
+     * Avatar source, can be a file path or an Attachment object
+     */
+    avatarSource?: AttachmentSource;
+    /**
+     * Path to the avatar image file
+     * @deprecated Use `avatarSource` instead
+     */
+    avatarPath?: string;
+};
+export declare const createGroupFactory: (ctx: import("../context.js").ContextBase, api: import("../apis.js").API) => (options: CreateGroupOptions) => Promise<CreateGroupResponse>;

package/dist/apis/createGroup.js

@@ -0,0 +1,43 @@
+import { ZaloApiError } from "../Errors/ZaloApiError.js";
+import { apiFactory } from "../utils.js";
+export const createGroupFactory = apiFactory()((api, ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.group[0]}/api/group/create/v2`);
+    /**
+     * Create a new group
+     *
+     * @param options Group options
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function createGroup(options) {
+        if (options.members.length == 0)
+            throw new ZaloApiError("Group must have at least one member");
+        const params = {
+            clientId: Date.now(),
+            gname: String(Date.now()),
+            gdesc: null,
+            members: options.members,
+            membersTypes: options.members.map(() => -1),
+            nameChanged: 0,
+            createLink: 1,
+            clientLang: ctx.language,
+            imei: ctx.imei,
+            zsource: 601,
+        };
+        if (options.name && options.name.length > 0) {
+            params.gname = options.name;
+            params.nameChanged = 1;
+        }
+        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 }), {
+            method: "POST",
+        });
+        const data = await utils.resolve(response);
+        options.avatarSource = options.avatarSource || options.avatarPath;
+        if (options.avatarSource)
+            await api.changeGroupAvatar(options.avatarSource, data.groupId).catch(utils.logger.error);
+        return data;
+    };
+});

package/dist/apis/createNote.d.ts

@@ -0,0 +1,7 @@
+import type { NoteDetail } from "../models/index.js";
+export type CreateNoteOptions = {
+    title: string;
+    pinAct?: boolean;
+};
+export type CreateNoteResponse = NoteDetail;
+export declare const createNoteFactory: (ctx: import("../context.js").ContextBase, api: import("../apis.js").API) => (options: CreateNoteOptions, groupId: string) => Promise<NoteDetail>;

package/dist/apis/createNote.js

@@ -0,0 +1,47 @@
+import { ZaloApiError } from "../Errors/ZaloApiError.js";
+import { apiFactory } from "../utils.js";
+export const createNoteFactory = apiFactory()((api, ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.group_board[0]}/api/board/topic/createv2`);
+    /**
+     * Create a note in a group
+     *
+     * @param options note options
+     * @param options.title note title
+     * @param options.pinAct pin action (pin note)
+     * @param groupId group id
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function createNote(options, groupId) {
+        const params = {
+            grid: groupId,
+            type: 0,
+            color: -16777216,
+            emoji: "",
+            startTime: -1,
+            duration: -1,
+            params: JSON.stringify({
+                title: options.title,
+            }),
+            repeat: 0,
+            src: 1,
+            imei: ctx.imei,
+            pinAct: options.pinAct ? 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, (result) => {
+            if (typeof result.data.params === "string") {
+                result.data.params = JSON.parse(result.data.params);
+            }
+            return result.data;
+        });
+    };
+});

package/dist/apis/createPoll.d.ts

@@ -0,0 +1,36 @@
+import type { PollDetail } from "../models/index.js";
+/**
+ * Options for creating a poll.
+ */
+export type CreatePollOptions = {
+    /**
+     * Question for the poll.
+     */
+    question: string;
+    /**
+     * List of options for the poll.
+     */
+    options: string[];
+    /**
+     * Poll expiration time in milliseconds (0 = no expiration).
+     */
+    expiredTime?: number;
+    /**
+     * Allows multiple choices in the poll.
+     */
+    allowMultiChoices?: boolean;
+    /**
+     * Allows members to add new options to the poll.
+     */
+    allowAddNewOption?: boolean;
+    /**
+     * Hides voting results until the user has voted.
+     */
+    hideVotePreview?: boolean;
+    /**
+     * Hides poll voters (anonymous poll).
+     */
+    isAnonymous?: boolean;
+};
+export type CreatePollResponse = PollDetail;
+export declare const createPollFactory: (ctx: import("../context.js").ContextBase, api: import("../apis.js").API) => (options: CreatePollOptions, groupId: string) => Promise<PollDetail>;

package/dist/apis/createPoll.js

@@ -0,0 +1,40 @@
+import { ZaloApiError } from "../Errors/ZaloApiError.js";
+import { apiFactory } from "../utils.js";
+export const createPollFactory = apiFactory()((api, ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.group[0]}/api/poll/create`);
+    /**
+     * Create a poll in a group.
+     *
+     * @param options Poll options
+     * @param groupId Group ID to create poll from
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function createPoll(options, groupId) {
+        var _a;
+        const params = {
+            group_id: groupId,
+            question: options.question,
+            options: options.options,
+            expired_time: (_a = options.expiredTime) !== null && _a !== void 0 ? _a : 0,
+            pinAct: false,
+            allow_multi_choices: !!options.allowMultiChoices,
+            allow_add_new_option: !!options.allowAddNewOption,
+            is_hide_vote_preview: !!options.hideVotePreview,
+            is_anonymous: !!options.isAnonymous,
+            poll_type: 0,
+            src: 1,
+            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/createProductCatalog.d.ts

@@ -0,0 +1,23 @@
+import type { AttachmentSource, ProductCatalogItem } from "../models/index.js";
+export type CreateProductCatalogPayload = {
+    catalogId: string;
+    productName: string;
+    price: string;
+    description: string;
+    /**
+     * Upto 5 media files are allowed, will be ignored if product_photos is provided
+     */
+    files?: AttachmentSource[];
+    /**
+     * List of product photo URLs, upto 5
+     *
+     * You can manually get the URL using `uploadProductPhoto` api
+     */
+    product_photos?: string[];
+};
+export type CreateProductCatalogResponse = {
+    item: ProductCatalogItem;
+    version_ls_catalog: number;
+    version_catalog: number;
+};
+export declare const createProductCatalogFactory: (ctx: import("../context.js").ContextBase, api: import("../apis.js").API) => (payload: CreateProductCatalogPayload) => Promise<CreateProductCatalogResponse>;

package/dist/apis/createProductCatalog.js

@@ -0,0 +1,50 @@
+import { ZaloApiError } from "../Errors/ZaloApiError.js";
+import { apiFactory } from "../utils.js";
+export const createProductCatalogFactory = apiFactory()((api, _, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.catalog[0]}/api/prodcatalog/product/create`);
+    /**
+     * Create product catalog?
+     *
+     * @param payload payload
+     *
+     * @note this API is used for zBussiness - Maximum 5 media files are supported
+     * @throws {ZaloApiError}
+     */
+    return async function createProductCatalog(payload) {
+        const productPhoto = payload.product_photos || [];
+        if (payload.files && payload.files.length == 0) {
+            if (payload.files.length > 5) {
+                throw new ZaloApiError("Maximum 5 media files are allowed");
+            }
+            for (const mediaFile of payload.files) {
+                const uploadMedia = await api.uploadProductPhoto({
+                    file: mediaFile,
+                });
+                const url = uploadMedia.normalUrl || uploadMedia.hdUrl;
+                productPhoto.push(url);
+            }
+        }
+        if (productPhoto.length > 5) {
+            throw new ZaloApiError("Maximum 5 media files are allowed");
+        }
+        const params = {
+            product_name: payload.productName,
+            price: payload.price,
+            description: payload.description,
+            product_photos: productPhoto,
+            catalog_id: payload.catalogId,
+            currency_unit: "₫", // $
+            create_time: Date.now(),
+        };
+        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/createReminder.d.ts

@@ -0,0 +1,12 @@
+import type { ReminderGroup, ReminderUser } from "../models/index.js";
+import { ReminderRepeatMode, ThreadType } from "../models/index.js";
+export type CreateReminderOptions = {
+    title: string;
+    emoji?: string;
+    startTime?: number;
+    repeat?: ReminderRepeatMode;
+};
+export type CreateReminderUser = ReminderUser;
+export type CreateReminderGroup = Omit<ReminderGroup, "responseMem">;
+export type CreateReminderResponse = CreateReminderUser | CreateReminderGroup;
+export declare const createReminderFactory: (ctx: import("../context.js").ContextBase, api: import("../apis.js").API) => (options: CreateReminderOptions, threadId: string, type?: ThreadType) => Promise<CreateReminderResponse>;

package/dist/apis/createReminder.js

@@ -0,0 +1,63 @@
+import { ZaloApiError } from "../Errors/ZaloApiError.js";
+import { ReminderRepeatMode, ThreadType } from "../models/index.js";
+import { apiFactory } from "../utils.js";
+export const createReminderFactory = apiFactory()((api, ctx, utils) => {
+    const serviceURL = {
+        [ThreadType.User]: utils.makeURL(`${api.zpwServiceMap.group_board[0]}/api/board/oneone/create`),
+        [ThreadType.Group]: utils.makeURL(`${api.zpwServiceMap.group_board[0]}/api/board/topic/createv2`),
+    };
+    /**
+     * Create a reminder in a group
+     *
+     * @param options reminder options
+     * @param threadId Group ID to create note from
+     * @param type Thread type (User or Group)
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function createReminder(options, threadId, type = ThreadType.User) {
+        var _a, _b, _c, _d, _e, _f;
+        const params = type === ThreadType.User
+            ? {
+                objectData: JSON.stringify({
+                    toUid: threadId,
+                    type: 0,
+                    color: -16245706,
+                    emoji: (_a = options.emoji) !== null && _a !== void 0 ? _a : "⏰",
+                    startTime: (_b = options.startTime) !== null && _b !== void 0 ? _b : Date.now(),
+                    duration: -1,
+                    params: { title: options.title },
+                    needPin: false,
+                    repeat: (_c = options.repeat) !== null && _c !== void 0 ? _c : ReminderRepeatMode.None,
+                    creatorUid: ctx.uid, // Note: for some reason, you can put any valid UID here instead of your own and it still works, atleast for mobile
+                    src: 1,
+                }),
+                imei: ctx.imei,
+            }
+            : {
+                grid: threadId,
+                type: 0,
+                color: -16245706,
+                emoji: (_d = options.emoji) !== null && _d !== void 0 ? _d : "⏰",
+                startTime: (_e = options.startTime) !== null && _e !== void 0 ? _e : Date.now(),
+                duration: -1,
+                params: JSON.stringify({
+                    title: options.title,
+                }),
+                repeat: (_f = options.repeat) !== null && _f !== void 0 ? _f : ReminderRepeatMode.None,
+                src: 1,
+                imei: ctx.imei,
+                pinAct: 0,
+            };
+        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/custom.d.ts

@@ -0,0 +1,9 @@
+import { type ContextSession } from "../context.js";
+import { type FactoryUtils } from "../utils.js";
+export type CustomAPIProps<T, K> = {
+    ctx: ContextSession;
+    utils: FactoryUtils<T>;
+    props: K;
+};
+export type CustomAPICallback<T, K> = (props: CustomAPIProps<T, K>) => T | Promise<T>;
+export declare const customFactory: (ctx: import("../context.js").ContextBase, api: import("../apis.js").API) => <T, K = any>(name: string, callback: CustomAPICallback<T, K>) => void;

package/dist/apis/custom.js

@@ -0,0 +1,15 @@
+import {} from "../context.js";
+import { apiFactory } from "../utils.js";
+/* eslint-disable */
+export const customFactory = apiFactory()((api, ctx, utils) => {
+    return function custom(name, callback) {
+        Object.defineProperty(api, name, {
+            value: function (props) {
+                return callback({ ctx, utils, props });
+            },
+            writable: false,
+            enumerable: false,
+            configurable: false,
+        });
+    };
+});

package/dist/apis/deleteAutoReply.d.ts

@@ -0,0 +1,5 @@
+export type DeleteAutoReplyResponse = {
+    item: number;
+    version: number;
+};
+export declare const deleteAutoReplyFactory: (ctx: import("../context.js").ContextBase, api: import("../apis.js").API) => (id: number) => Promise<DeleteAutoReplyResponse>;

package/dist/apis/deleteAutoReply.js

@@ -0,0 +1,29 @@
+import { ZaloApiError } from "../Errors/ZaloApiError.js";
+import { apiFactory } from "../utils.js";
+export const deleteAutoReplyFactory = apiFactory()((api, ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.auto_reply[0]}/api/autoreply/delete`);
+    /**
+     * Delete auto reply
+     *
+     * @param id id of auto reply
+     *
+     * @note this API used for zBusiness
+     * @throws {ZaloApiError}
+     */
+    return async function deleteAutoReply(id) {
+        const params = {
+            cliLang: ctx.language,
+            id: id,
+        };
+        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/deleteAvatar.d.ts

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

package/dist/apis/deleteAvatar.js

@@ -0,0 +1,27 @@
+import { ZaloApiError } from "../Errors/ZaloApiError.js";
+import { apiFactory } from "../utils.js";
+export const deleteAvatarFactory = apiFactory()((api, ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.profile[0]}/api/social/del-avatars`);
+    /**
+     * Delete avatar from avatar list
+     *
+     * @param photoId avatar photo ID(s) to delete - can be a single string or array of strings
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function deleteAvatar(photoId) {
+        const photoIds = Array.isArray(photoId) ? photoId : [photoId];
+        const delPhotos = photoIds.map((id) => ({ photoId: id }));
+        const params = {
+            delPhotos: JSON.stringify(delPhotos),
+            imei: ctx.imei,
+        };
+        const encryptedParams = utils.encodeAES(JSON.stringify(params));
+        if (!encryptedParams)
+            throw new ZaloApiError("Failed to encrypt params");
+        const response = await utils.request(utils.makeURL(serviceURL, { params: encryptedParams }), {
+            method: "GET",
+        });
+        return utils.resolve(response);
+    };
+});

package/dist/apis/deleteCatalog.d.ts

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

package/dist/apis/deleteCatalog.js

@@ -0,0 +1,28 @@
+import { ZaloApiError } from "../Errors/ZaloApiError.js";
+import { apiFactory } from "../utils.js";
+export const deleteCatalogFactory = apiFactory()((api, _, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.catalog[0]}/api/prodcatalog/catalog/delete`);
+    /**
+     * Delete catalog?
+     *
+     * @param catalogId catalog id
+     *
+     * @note this API is used for zBusiness
+     * @throws {ZaloApiError}
+     */
+    return async function deleteCatalog(catalogId) {
+        const params = {
+            catalog_id: catalogId,
+        };
+        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/deleteChat.d.ts

@@ -0,0 +1,19 @@
+import { ThreadType } from "../models/index.js";
+export type DeleteChatResponse = {
+    status: number;
+};
+export type DeleteChatLastMessage = {
+    /**
+     * Last message owner ID to delete backwards
+     */
+    ownerId: string;
+    /**
+     * Last message client ID to delete backwards
+     */
+    cliMsgId: string;
+    /**
+     * Last message global ID to delete backwards
+     */
+    globalMsgId: string;
+};
+export declare const deleteChatFactory: (ctx: import("../context.js").ContextBase, api: import("../apis.js").API) => (lastMessage: DeleteChatLastMessage, threadId: string, type?: ThreadType) => Promise<DeleteChatResponse>;

package/dist/apis/deleteChat.js

@@ -0,0 +1,50 @@
+import { ZaloApiError } from "../Errors/ZaloApiError.js";
+import { ThreadType } from "../models/index.js";
+import { apiFactory } from "../utils.js";
+export const deleteChatFactory = apiFactory()((api, ctx, utils) => {
+    const serviceURL = {
+        [ThreadType.User]: utils.makeURL(`${api.zpwServiceMap.chat[0]}/api/message/deleteconver`, {
+            nretry: 0,
+        }),
+        [ThreadType.Group]: utils.makeURL(`${api.zpwServiceMap.group[0]}/api/group/deleteconver`, {
+            nretry: 0,
+        }),
+    };
+    /**
+     * Delete chat
+     *
+     * @param lastMessage Last message info
+     * @param threadId Thread ID
+     * @param type Thread type
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function deleteChat(lastMessage, threadId, type = ThreadType.User) {
+        const timestampString = Date.now().toString();
+        const params = type === ThreadType.User
+            ? {
+                toid: threadId,
+                cliMsgId: timestampString,
+                conver: lastMessage,
+                onlyMe: 1,
+                imei: ctx.imei,
+            }
+            : {
+                grid: threadId,
+                cliMsgId: timestampString,
+                conver: lastMessage,
+                onlyMe: 1,
+                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[type], {
+            method: "POST",
+            body: new URLSearchParams({
+                params: encryptedParams,
+            }),
+        });
+        return utils.resolve(response);
+    };
+});