@softtynet/zca-js 2.2.8 → 2.2.9

package/dist/apis/getStickerSuggestion.d.ts

@@ -0,0 +1,12 @@
+export type GetStickerSuggestionOptions = {
+    keyword: string;
+    gif?: 0 | 1;
+    guggy?: 0 | 1;
+};
+export type GetStickerSuggestionResponse = {
+    sdata: unknown;
+    gif?: unknown;
+    guggy?: unknown;
+    [key: string]: unknown;
+};
+export declare const getStickerSuggestionFactory: (ctx: import("../context.js").ContextBase, api: import("../apis.js").API) => (options: GetStickerSuggestionOptions | string) => Promise<GetStickerSuggestionResponse>;

package/dist/apis/getStickerSuggestion.js

@@ -0,0 +1,30 @@
+import { ZaloApiError } from "../Errors/ZaloApiError.js";
+import { apiFactory } from "../utils.js";
+export const getStickerSuggestionFactory = apiFactory()((api, ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.sticker[0]}/api/message/sticker/suggest/stickers`);
+    /**
+     * Gợi ý Sticker/GIF theo từ khóa đang nhập (command 11741)
+     *
+     * @param options Từ khóa và tùy chọn kèm theo (`gif`, `guggy`)
+     * @throws {ZaloApiError}
+     */
+    return async function getStickerSuggestion(options) {
+        var _a, _b;
+        const normalized = typeof options === "string" ? { keyword: options } : options;
+        const params = {
+            keyword: normalized.keyword,
+            gif: (_a = normalized.gif) !== null && _a !== void 0 ? _a : 1,
+            guggy: (_b = normalized.guggy) !== null && _b !== void 0 ? _b : 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/getUsageMyCloud.d.ts

@@ -0,0 +1,7 @@
+import type { GetCloudViewerKeyResponse } from "./getCloudViewerKey.js";
+export type GetUsageMyCloudResponse = {
+    usage: number;
+    quota: number;
+    plan: number;
+};
+export declare const getUsageMyCloudFactory: (ctx: import("../context.js").ContextBase, api: import("../apis.js").API) => (viewerKeyInfo?: GetCloudViewerKeyResponse) => Promise<GetUsageMyCloudResponse>;

package/dist/apis/getUsageMyCloud.js

@@ -0,0 +1,34 @@
+import { ZaloApiError } from "../Errors/ZaloApiError.js";
+import { apiFactory, decryptZCloudAES } from "../utils.js";
+export const getUsageMyCloudFactory = apiFactory()((api, _ctx, utils) => {
+    var _a;
+    const baseDomain = ((_a = api.zpwServiceMap.zcloud) === null || _a === void 0 ? void 0 : _a[0]) || "https://zcld.chat.zalo.me";
+    const serviceURL = utils.makeURL(`${baseDomain}/cloudmedia/info/pc/v1/usage-mycloud`);
+    /**
+     * Kiểm tra hạn mức và dung lượng sử dụng Cloud của tôi (MyCloud - command 12748)
+     *
+     * @param viewerKeyInfo (Tùy chọn) Cặp `{ viewer_key, enk }` từ `api.getCloudViewerKey()`. Nếu không truyền sẽ tự động lấy mới.
+     * @throws {ZaloApiError}
+     */
+    return async function getUsageMyCloud(viewerKeyInfo) {
+        const keyInfo = viewerKeyInfo !== null && viewerKeyInfo !== void 0 ? viewerKeyInfo : (await api.getCloudViewerKey());
+        if (!(keyInfo === null || keyInfo === void 0 ? void 0 : keyInfo.viewer_key) || !(keyInfo === null || keyInfo === void 0 ? void 0 : keyInfo.enk)) {
+            throw new ZaloApiError("Invalid CloudViewerKey");
+        }
+        const response = await utils.request(serviceURL, {
+            method: "GET",
+            headers: {
+                "cloud-viewer-key": keyInfo.viewer_key,
+            },
+        });
+        const json = (await response.json());
+        if (json.error_code !== 0 && json.error_code !== -904) {
+            throw new ZaloApiError(json.error_message || "getUsageMyCloud failed", json.error_code);
+        }
+        if (!json.data) {
+            throw new ZaloApiError("Empty MyCloud usage data", json.error_code);
+        }
+        const decrypted = decryptZCloudAES(json.data, keyInfo.enk);
+        return JSON.parse(decrypted);
+    };
+});

package/dist/apis/getUsageZCloud.d.ts

@@ -0,0 +1,11 @@
+import type { GetCloudViewerKeyResponse } from "./getCloudViewerKey.js";
+export type GetUsageZCloudResponse = {
+    service_usage: {
+        my_cloud: number;
+        message_backup: number;
+    };
+    usage: number;
+    quota: number;
+    plan: number;
+};
+export declare const getUsageZCloudFactory: (ctx: import("../context.js").ContextBase, api: import("../apis.js").API) => (viewerKeyInfo?: GetCloudViewerKeyResponse) => Promise<GetUsageZCloudResponse>;

package/dist/apis/getUsageZCloud.js

@@ -0,0 +1,34 @@
+import { ZaloApiError } from "../Errors/ZaloApiError.js";
+import { apiFactory, decryptZCloudAES } from "../utils.js";
+export const getUsageZCloudFactory = apiFactory()((api, _ctx, utils) => {
+    var _a;
+    const baseDomain = ((_a = api.zpwServiceMap.zcloud) === null || _a === void 0 ? void 0 : _a[0]) || "https://zcld.chat.zalo.me";
+    const serviceURL = utils.makeURL(`${baseDomain}/cloudmedia/info/pc/v2/usage`);
+    /**
+     * Kiểm tra dung lượng sử dụng ZCloud V2 (bao gồm MyCloud và Sao lưu tin nhắn - command 12749)
+     *
+     * @param viewerKeyInfo (Tùy chọn) Cặp `{ viewer_key, enk }` từ `api.getCloudViewerKey()`. Nếu không truyền sẽ tự động lấy mới.
+     * @throws {ZaloApiError}
+     */
+    return async function getUsageZCloud(viewerKeyInfo) {
+        const keyInfo = viewerKeyInfo !== null && viewerKeyInfo !== void 0 ? viewerKeyInfo : (await api.getCloudViewerKey());
+        if (!(keyInfo === null || keyInfo === void 0 ? void 0 : keyInfo.viewer_key) || !(keyInfo === null || keyInfo === void 0 ? void 0 : keyInfo.enk)) {
+            throw new ZaloApiError("Invalid CloudViewerKey");
+        }
+        const response = await utils.request(serviceURL, {
+            method: "GET",
+            headers: {
+                "cloud-viewer-key": keyInfo.viewer_key,
+            },
+        });
+        const json = (await response.json());
+        if (json.error_code !== 0 && json.error_code !== -904) {
+            throw new ZaloApiError(json.error_message || "getUsageZCloud failed", json.error_code);
+        }
+        if (!json.data) {
+            throw new ZaloApiError("Empty ZCloud usage data", json.error_code);
+        }
+        const decrypted = decryptZCloudAES(json.data, keyInfo.enk);
+        return JSON.parse(decrypted);
+    };
+});

package/dist/apis/keepAlive.d.ts

@@ -1,4 +1,5 @@
 export type KeepAliveResponse = {
-    config_vesion: number;
+    config_vesion?: number;
+    [key: string]: unknown;
 };
 export declare const keepAliveFactory: (ctx: import("../context.js").ContextBase, api: import("../apis.js").API) => () => Promise<KeepAliveResponse>;

package/dist/apis/keepAlive.js

@@ -3,7 +3,7 @@ import { apiFactory } from "../utils.js";
 export const keepAliveFactory = apiFactory()((api, ctx, utils) => {
     const serviceURL = utils.makeURL(`${api.zpwServiceMap.chat[0]}/keepalive`);
     /**
-     * Keep Alive?
+     * Gửi tín hiệu duy trì phiên kết nối HTTP tới máy chủ Chat (KeepAlive - command 11770)
      *
      * @throws {ZaloApiError}
      */
@@ -14,9 +14,11 @@ export const keepAliveFactory = apiFactory()((api, ctx, utils) => {
         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 }), {
+        const response = await utils.request(utils.makeURL(serviceURL, {
+            params: encryptedParams,
+        }), {
             method: "GET",
         });
-        return utils.resolve(response, undefined, false);
+        return utils.resolve(response);
     };
 });

package/dist/apis/listen.d.ts

@@ -13,6 +13,18 @@ type UploadEventData = {
     fileUrl: string;
     fileId: string;
 };
+export type Voice2TextEventData = {
+    req_id: string;
+    err?: number;
+    text?: string;
+    content?: string;
+    [key: string]: unknown;
+};
+export type Voice2TextEvent = {
+    act: string;
+    act_type: "voice2text";
+    data: Voice2TextEventData;
+};
 export type WsPayload<T = Record<string, unknown>> = {
     version: number;
     cmd: number;
@@ -48,6 +60,7 @@ interface ListenerEvents {
     group_event: [data: GroupEvent];
     sync_event: [data: SyncEvent];
     call_event: [data: CallEvent];
+    voice2text_event: [data: Voice2TextEvent];
     cipher_key: [key: string];
     ping: [];
     pong: [];

package/dist/apis/listen.js

@@ -360,6 +360,16 @@ export class Listener extends EventEmitter {
                             const callEvent = initializeCallEvent(callEventData, control.content.act, control.content.act_type);
                             this.emit("call_event", callEvent);
                         }
+                        else if (control.content.act_type == "voice2text") {
+                            const v2tData = typeof control.content.data == "string"
+                                ? JSON.parse(control.content.data)
+                                : control.content.data;
+                            this.emit("voice2text_event", {
+                                act: control.content.act,
+                                act_type: "voice2text",
+                                data: v2tData,
+                            });
+                        }
                     }
                 }
                 if (cmd == 612) {

package/dist/apis/readContactTab.d.ts

@@ -0,0 +1,2 @@
+export type ReadContactTabResponse = Record<string, unknown> | string;
+export declare const readContactTabFactory: (ctx: import("../context.js").ContextBase, api: import("../apis.js").API) => (ts?: number) => Promise<ReadContactTabResponse>;

package/dist/apis/readContactTab.js

@@ -0,0 +1,26 @@
+import { ZaloApiError } from "../Errors/ZaloApiError.js";
+import { apiFactory } from "../utils.js";
+export const readContactTabFactory = apiFactory()((api, _ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.friend[0]}/api/friend/read-contact-tab`);
+    /**
+     * Đánh dấu đã đọc tab Danh bạ (command 12231)
+     *
+     * @param ts Dấu thời gian (mặc định: `Date.now()`)
+     * @throws {ZaloApiError}
+     */
+    return async function readContactTab(ts = Date.now()) {
+        const params = {
+            ts,
+        };
+        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/removeConversationMedia.d.ts

@@ -0,0 +1,8 @@
+import type { MediaStoreType } from "./getConversationMedia.js";
+export type RemoveConversationMediaOptions = {
+    groupId: string;
+    mediaType: MediaStoreType;
+    mediaId: string | number | (string | number)[];
+};
+export type RemoveConversationMediaResponse = unknown;
+export declare const removeConversationMediaFactory: (ctx: import("../context.js").ContextBase, api: import("../apis.js").API) => (options: RemoveConversationMediaOptions) => Promise<unknown>;

package/dist/apis/removeConversationMedia.js

@@ -0,0 +1,30 @@
+import { ZaloApiError } from "../Errors/ZaloApiError.js";
+import { apiFactory } from "../utils.js";
+export const removeConversationMediaFactory = apiFactory()((api, _ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.media_store[0]}/api/mediastore/remove`);
+    /**
+     * Xóa mục Ảnh/Video, File hoặc Link khỏi Kho Lưu Trữ của nhóm (command 11842)
+     *
+     * @param options Thông tin mục cần xóa (`groupId`, `mediaType`, `mediaId`)
+     * @throws {ZaloApiError}
+     */
+    return async function removeConversationMedia(options) {
+        if (!options.groupId) {
+            throw new ZaloApiError("Missing groupId");
+        }
+        const cleanGroupId = options.groupId.startsWith("g") ? options.groupId.slice(1) : options.groupId;
+        const params = {
+            media_type: options.mediaType,
+            media_id: options.mediaId,
+            group_id: cleanGroupId,
+        };
+        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: "POST",
+        });
+        return utils.resolve(response);
+    };
+});

package/dist/apis/undoMultiMessage.d.ts

@@ -0,0 +1,9 @@
+import { ThreadType } from "../models/index.js";
+export type UndoMultiMessageItem = {
+    globalMsgId: string | number;
+    cliMsgId: string | number;
+    cliMsgIdUndo?: string | number;
+    destId?: string;
+};
+export type UndoMultiMessageResponse = Record<string, unknown>;
+export declare const undoMultiMessageFactory: (ctx: import("../context.js").ContextBase, api: import("../apis.js").API) => (msgs: UndoMultiMessageItem[], threadId: string, type?: ThreadType) => Promise<UndoMultiMessageResponse>;

package/dist/apis/undoMultiMessage.js

@@ -0,0 +1,46 @@
+import { ZaloApiError } from "../Errors/ZaloApiError.js";
+import { ThreadType } from "../models/index.js";
+import { apiFactory } from "../utils.js";
+export const undoMultiMessageFactory = apiFactory()((api, _ctx, utils) => {
+    /**
+     * Thu hồi hàng loạt nhiều tin nhắn cùng lúc trong hội thoại cá nhân hoặc nhóm (command 12115 / 12116)
+     *
+     * @param msgs Danh sách tin nhắn cần thu hồi (`globalMsgId`, `cliMsgId` của tin nhắn gốc)
+     * @param threadId ID người nhận hoặc ID nhóm
+     * @param type Loại hội thoại (`ThreadType.User` hoặc `ThreadType.Group`)
+     * @throws {ZaloApiError}
+     */
+    return async function undoMultiMessage(msgs, threadId, type = ThreadType.User) {
+        if (!Array.isArray(msgs) || msgs.length === 0) {
+            throw new ZaloApiError("Missing messages to undo");
+        }
+        if (!threadId) {
+            throw new ZaloApiError("Missing threadId");
+        }
+        const isGroup = type === ThreadType.Group || threadId.startsWith("g");
+        const cleanThreadId = threadId.startsWith("g") ? threadId.slice(1) : threadId;
+        const serviceURL = isGroup
+            ? utils.makeURL(`${api.zpwServiceMap.group[0]}/api/group/multi_undomsg`)
+            : utils.makeURL(`${api.zpwServiceMap.chat[0]}/api/message/multi_undo`);
+        const now = Date.now();
+        const normalizedMsgs = msgs.map((m, idx) => ({
+            cliMsgId: m.cliMsgIdUndo !== undefined ? m.cliMsgId : now + idx,
+            cliMsgIdUndo: m.cliMsgIdUndo !== undefined ? m.cliMsgIdUndo : m.cliMsgId,
+            globalMsgId: String(m.globalMsgId),
+        }));
+        const payload = isGroup
+            ? { grid: cleanThreadId, msgs: normalizedMsgs }
+            : { toid: cleanThreadId, msgs: normalizedMsgs };
+        const encryptedParams = utils.encodeAES(JSON.stringify(payload));
+        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/updateRecentSearch.d.ts

@@ -0,0 +1,11 @@
+export type UpdateRecentSearchOptions = {
+    listRecent?: Record<string, unknown>[];
+    listKeyword?: string[];
+    version?: number;
+};
+export type UpdateRecentSearchResponse = {
+    version: number;
+    list_recent: Record<string, unknown>[];
+    list_keyword: string[];
+};
+export declare const updateRecentSearchFactory: (ctx: import("../context.js").ContextBase, api: import("../apis.js").API) => (options?: UpdateRecentSearchOptions) => Promise<UpdateRecentSearchResponse>;

package/dist/apis/updateRecentSearch.js

@@ -0,0 +1,41 @@
+import { ZaloApiError } from "../Errors/ZaloApiError.js";
+import { apiFactory } from "../utils.js";
+export const updateRecentSearchFactory = apiFactory()((api, ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.recent_search[0]}/api/recentsearch/update`);
+    /**
+     * Cập nhật danh sách lịch sử tìm kiếm gần đây trên Zalo (command 12126)
+     *
+     * @param options Danh sách tìm kiếm gần đây và từ khóa (`listRecent`, `listKeyword`, `version`)
+     * @throws {ZaloApiError}
+     */
+    return async function updateRecentSearch(options = {}) {
+        var _a, _b, _c;
+        let currentVersion = options.version;
+        if (currentVersion === undefined) {
+            try {
+                const current = await api.getRecentSearchList(0);
+                currentVersion = (_a = current === null || current === void 0 ? void 0 : current.version) !== null && _a !== void 0 ? _a : 0;
+            }
+            catch (_d) {
+                currentVersion = 0;
+            }
+        }
+        const params = {
+            list_recent: (_b = options.listRecent) !== null && _b !== void 0 ? _b : [],
+            version: currentVersion,
+            list_keyword: (_c = options.listKeyword) !== null && _c !== void 0 ? _c : [],
+            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/verifyCloudMedia.d.ts

@@ -0,0 +1,14 @@
+import type { GetCloudViewerKeyResponse } from "./getCloudViewerKey.js";
+export type VerifyCloudMediaOptions = {
+    lastNoiseId?: string;
+    loadType?: number;
+    listNoiseIds?: string[];
+    trackingSource?: number;
+};
+export type VerifyCloudMediaResponse = {
+    lastNoiseId: string;
+    hasMore: number;
+    mediaItems: Record<string, unknown>[];
+    listVerifyNoiseIds: string[];
+};
+export declare const verifyCloudMediaFactory: (ctx: import("../context.js").ContextBase, api: import("../apis.js").API) => (options?: VerifyCloudMediaOptions, viewerKeyInfo?: GetCloudViewerKeyResponse) => Promise<VerifyCloudMediaResponse>;

package/dist/apis/verifyCloudMedia.js

@@ -0,0 +1,43 @@
+import { ZaloApiError } from "../Errors/ZaloApiError.js";
+import { apiFactory, decryptZCloudAES, encryptZCloudAES } from "../utils.js";
+export const verifyCloudMediaFactory = apiFactory()((api, _ctx, utils) => {
+    var _a;
+    const baseDomain = ((_a = api.zpwServiceMap.zcloud) === null || _a === void 0 ? void 0 : _a[0]) || "https://zcld.chat.zalo.me";
+    const serviceURL = utils.makeURL(`${baseDomain}/cloudmedia/queue/pc/verify`);
+    /**
+     * Kiểm tra và lấy danh sách mục Media lưu trữ trên ZCloud (command 12740 / 12761)
+     *
+     * @param options Tùy chọn truy vấn (`lastNoiseId`, `loadType`, `listNoiseIds`, `trackingSource`)
+     * @param viewerKeyInfo (Tùy chọn) Cặp `{ viewer_key, enk }` từ `api.getCloudViewerKey()`.
+     * @throws {ZaloApiError}
+     */
+    return async function verifyCloudMedia(options = {}, viewerKeyInfo) {
+        var _a, _b, _c, _d;
+        const keyInfo = viewerKeyInfo !== null && viewerKeyInfo !== void 0 ? viewerKeyInfo : (await api.getCloudViewerKey());
+        if (!(keyInfo === null || keyInfo === void 0 ? void 0 : keyInfo.viewer_key) || !(keyInfo === null || keyInfo === void 0 ? void 0 : keyInfo.enk)) {
+            throw new ZaloApiError("Invalid CloudViewerKey");
+        }
+        const payload = {
+            lastNoiseId: (_a = options.lastNoiseId) !== null && _a !== void 0 ? _a : "",
+            loadType: (_b = options.loadType) !== null && _b !== void 0 ? _b : 0,
+            listNoiseIds: (_c = options.listNoiseIds) !== null && _c !== void 0 ? _c : [],
+            tracking_source: (_d = options.trackingSource) !== null && _d !== void 0 ? _d : 0,
+        };
+        const encryptedParams = encryptZCloudAES(JSON.stringify(payload), keyInfo.enk);
+        const response = await utils.request(utils.makeURL(serviceURL, { params: encryptedParams }), {
+            method: "GET",
+            headers: {
+                "cloud-viewer-key": keyInfo.viewer_key,
+            },
+        });
+        const json = (await response.json());
+        if (json.error_code !== 0 && json.error_code !== -904) {
+            throw new ZaloApiError(json.error_message || "verifyCloudMedia failed", json.error_code);
+        }
+        if (!json.data) {
+            throw new ZaloApiError("Empty verifyCloudMedia response", json.error_code);
+        }
+        const decrypted = decryptZCloudAES(json.data, keyInfo.enk);
+        return JSON.parse(decrypted);
+    };
+});

package/dist/apis/voiceToText.d.ts

@@ -0,0 +1,4 @@
+export type VoiceToTextResponse = {
+    req_id: string;
+};
+export declare const voiceToTextFactory: (ctx: import("../context.js").ContextBase, api: import("../apis.js").API) => (voiceUrl: string) => Promise<VoiceToTextResponse>;

package/dist/apis/voiceToText.js

@@ -0,0 +1,30 @@
+import { ZaloApiError } from "../Errors/ZaloApiError.js";
+import { apiFactory } from "../utils.js";
+export const voiceToTextFactory = apiFactory()((api, _ctx, utils) => {
+    var _a;
+    const baseDomain = ((_a = api.zpwServiceMap.ai_features) === null || _a === void 0 ? void 0 : _a[0]) || "https://tt-ai-features-wpa.chat.zalo.me";
+    const serviceURL = utils.makeURL(`${baseDomain}/api/aifeatures/voice2text`);
+    /**
+     * Gửi yêu cầu chuyển đổi tin nhắn thoại sang văn bản bằng Zalo AI (command 13394).
+     * Kết quả văn bản sau khi xử lý xong sẽ được đẩy về qua sự kiện `api.listener.on("voice2text_event", ...)` khớp với `req_id`.
+     *
+     * @param voiceUrl Đường dẫn URL của tệp ghi âm tin nhắn thoại (`.aac` / `.mp3` / `.m4a`)
+     * @throws {ZaloApiError}
+     */
+    return async function voiceToText(voiceUrl) {
+        if (!voiceUrl) {
+            throw new ZaloApiError("Missing voiceUrl");
+        }
+        const encryptedParams = utils.encodeAES(JSON.stringify({ url: voiceUrl }));
+        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);
+    };
+});