@softtynet/zca-js 2.3.4 → 2.3.5

package/dist/cjs/apis/call/cancelGroupCall.cjs

@@ -0,0 +1,50 @@
+'use strict';
+
+var ZaloApiError = require('../../Errors/ZaloApiError.cjs');
+var utils = require('../../utils.cjs');
+var sendVoiceCall = require('./sendVoiceCall.cjs');
+
+const cancelGroupCallFactory = utils.apiFactory()((api, ctx, utils) => {
+    const voiceCallService = api.zpwServiceMap.voice_call?.[0];
+    /**
+     * Từ chối / Huỷ lời mời tham gia cuộc gọi nhóm (`/api/voicecall/group/cancel`, command `12437`).
+     *
+     * @param callId ID của cuộc gọi nhóm
+     * @param options Thông tin `hostCall`, `calleeId`, `callType`, `partners` và `data`
+     * @throws {ZaloApiError}
+     */
+    return async function cancelGroupCall(callId, options) {
+        if (!callId)
+            throw new ZaloApiError.ZaloApiError("Missing callId");
+        if (!options?.hostCall)
+            throw new ZaloApiError.ZaloApiError("Missing hostCall");
+        if (!voiceCallService)
+            throw new ZaloApiError.ZaloApiError("Missing voice_call service URL in zpwServiceMap");
+        const dataStr = options.data === undefined
+            ? "{}"
+            : typeof options.data === "string"
+                ? options.data
+                : JSON.stringify(options.data);
+        const params = {
+            calleeId: String(options.calleeId ?? ctx.uid),
+            callId,
+            callType: options.callType ?? sendVoiceCall.CallType.GroupAudio,
+            hostCall: String(options.hostCall),
+            data: dataStr,
+            partners: (options.partners ?? []).map(String),
+        };
+        const encryptedParams = utils.encodeAES(JSON.stringify(params));
+        if (!encryptedParams)
+            throw new ZaloApiError.ZaloApiError("Failed to encrypt cancelGroupCall params");
+        const url = utils.makeURL(`${voiceCallService}/api/voicecall/group/cancel`, {
+            zpw_type: 24,
+            params: encryptedParams,
+        });
+        const response = await utils.request(url, {
+            method: "GET",
+        });
+        return utils.resolve(response);
+    };
+});
+
+exports.cancelGroupCallFactory = cancelGroupCallFactory;

package/dist/cjs/apis/call/cancelVoiceCall.cjs

@@ -21,10 +21,14 @@ const cancelVoiceCallFactory = utils.apiFactory()((api, ctx, utils) => {
             throw new ZaloApiError.ZaloApiError("Missing callId");
         if (!voiceCallService)
             throw new ZaloApiError.ZaloApiError("Missing voice_call service URL in zpwServiceMap");
+        const rawCallType = options.callType ?? sendVoiceCall.CallType.Audio;
+        // Khớp với ZMessageSerializer::sendCancelCall (0x100026acc): callType = (callType != 1 ? 1 : 0)
+        // Cho phép truyền trực tiếp 0 (Audio) hoặc 1 (Video), hoặc CallType.Audio (1) -> 0, CallType.Video (3) -> 1
+        const normalizedCallType = rawCallType === 0 || rawCallType === sendVoiceCall.CallType.Audio ? 0 : 1;
         const params = {
             callerId: String(calleeId),
             callId,
-            callType: options.callType ?? sendVoiceCall.CallType.Audio,
+            callType: normalizedCallType,
             status: options.status ?? 0,
             imei: ctx.imei,
         };

package/dist/cjs/apis/call/createController.cjs

@@ -0,0 +1,14 @@
+'use strict';
+
+var ZaloCallController = require('../../call-engine/ZaloCallController.cjs');
+
+/**
+ * Khởi tạo bộ điều phối cuộc gọi thuần TypeScript `ZaloCallController` (tích hợp `ZaloRtcSession` và kênh IPC `ZaloCallTransport`).
+ */
+function createControllerFactory(_ctx, api) {
+    return function createController(options = {}) {
+        return new ZaloCallController.ZaloCallController(api, options);
+    };
+}
+
+exports.createControllerFactory = createControllerFactory;

package/dist/cjs/apis/call/createRtcSession.cjs

@@ -0,0 +1,15 @@
+'use strict';
+
+var ZaloRtcSession = require('../../call-engine/ZaloRtcSession.cjs');
+
+/**
+ * Khởi tạo phiên gọi Thoại & Video thuần TypeScript / Node.js (`ZaloRtcSession` — UDP `ZRTPPacket` + `SRTP`)
+ * hoạt động độc lập 100% trên Worker / Server / Desktop / Mobile Bridge mà không cần cài đặt Zalo PC.
+ */
+function createRtcSessionFactory(_ctx, api) {
+    return function createRtcSession(options = {}) {
+        return new ZaloRtcSession.ZaloRtcSession(api, options);
+    };
+}
+
+exports.createRtcSessionFactory = createRtcSessionFactory;

package/dist/cjs/apis/call/endGroupCall.cjs

@@ -0,0 +1,50 @@
+'use strict';
+
+var ZaloApiError = require('../../Errors/ZaloApiError.cjs');
+var utils = require('../../utils.cjs');
+var sendVoiceCall = require('./sendVoiceCall.cjs');
+
+const endGroupCallFactory = utils.apiFactory()((api, ctx, utils) => {
+    const voiceCallService = api.zpwServiceMap.voice_call?.[0];
+    /**
+     * Rời khỏi hoặc kết thúc cuộc gọi nhóm (`/api/voicecall/group/endcall`, command `12438`).
+     *
+     * @param callId ID của cuộc gọi nhóm
+     * @param options Thông tin `hostCall`, `calleeId`, `callType`, `partners` và `data`
+     * @throws {ZaloApiError}
+     */
+    return async function endGroupCall(callId, options) {
+        if (!callId)
+            throw new ZaloApiError.ZaloApiError("Missing callId");
+        if (!options?.hostCall)
+            throw new ZaloApiError.ZaloApiError("Missing hostCall");
+        if (!voiceCallService)
+            throw new ZaloApiError.ZaloApiError("Missing voice_call service URL in zpwServiceMap");
+        const dataStr = options.data === undefined
+            ? "{}"
+            : typeof options.data === "string"
+                ? options.data
+                : JSON.stringify(options.data);
+        const params = {
+            calleeId: String(options.calleeId ?? ctx.uid),
+            callId,
+            callType: options.callType ?? sendVoiceCall.CallType.GroupAudio,
+            hostCall: String(options.hostCall),
+            data: dataStr,
+            partners: (options.partners ?? []).map(String),
+        };
+        const encryptedParams = utils.encodeAES(JSON.stringify(params));
+        if (!encryptedParams)
+            throw new ZaloApiError.ZaloApiError("Failed to encrypt endGroupCall params");
+        const url = utils.makeURL(`${voiceCallService}/api/voicecall/group/endcall`, {
+            zpw_type: 24,
+            params: encryptedParams,
+        });
+        const response = await utils.request(url, {
+            method: "GET",
+        });
+        return utils.resolve(response);
+    };
+});
+
+exports.endGroupCallFactory = endGroupCallFactory;

package/dist/cjs/apis/call/finishGroupCall.cjs

@@ -0,0 +1,52 @@
+'use strict';
+
+var ZaloApiError = require('../../Errors/ZaloApiError.cjs');
+var utils = require('../../utils.cjs');
+var sendVoiceCall = require('./sendVoiceCall.cjs');
+
+const finishGroupCallFactory = utils.apiFactory()((api, _ctx, utils) => {
+    const voiceCallService = api.zpwServiceMap.voice_call?.[0];
+    /**
+     * Gửi báo cáo hoàn tất / kết thúc phiên gọi nhóm (`/api/voicecall/group/finish`, command `12446`).
+     *
+     * @param callId ID của cuộc gọi nhóm
+     * @param options Thông tin `hostCall`, `duration`, `joinTime`, `status`, `partners` và `data`
+     * @throws {ZaloApiError}
+     */
+    return async function finishGroupCall(callId, options) {
+        if (!callId)
+            throw new ZaloApiError.ZaloApiError("Missing callId");
+        if (!options?.hostCall)
+            throw new ZaloApiError.ZaloApiError("Missing hostCall");
+        if (!voiceCallService)
+            throw new ZaloApiError.ZaloApiError("Missing voice_call service URL in zpwServiceMap");
+        const dataStr = options.data === undefined
+            ? "{}"
+            : typeof options.data === "string"
+                ? options.data
+                : JSON.stringify(options.data);
+        const params = {
+            callId,
+            callType: options.callType ?? sendVoiceCall.CallType.GroupAudio,
+            data: dataStr,
+            duration: options.duration ?? 0,
+            hostCall: String(options.hostCall),
+            partners: (options.partners ?? []).map(String),
+            status: options.status ?? 0,
+            joinTime: options.joinTime ?? 0,
+        };
+        const encryptedParams = utils.encodeAES(JSON.stringify(params));
+        if (!encryptedParams)
+            throw new ZaloApiError.ZaloApiError("Failed to encrypt finishGroupCall params");
+        const url = utils.makeURL(`${voiceCallService}/api/voicecall/group/finish`, {
+            zpw_type: 24,
+            params: encryptedParams,
+        });
+        const response = await utils.request(url, {
+            method: "GET",
+        });
+        return utils.resolve(response);
+    };
+});
+
+exports.finishGroupCallFactory = finishGroupCallFactory;

package/dist/cjs/apis/call/getGroupCallState.cjs

@@ -0,0 +1,43 @@
+'use strict';
+
+var ZaloApiError = require('../../Errors/ZaloApiError.cjs');
+var utils = require('../../utils.cjs');
+var sendVoiceCall = require('./sendVoiceCall.cjs');
+
+const getGroupCallStateFactory = utils.apiFactory()((api, _ctx, utils) => {
+    const voiceCallService = api.zpwServiceMap.voice_call?.[0];
+    /**
+     * Lấy trạng thái hiện tại của cuộc gọi nhóm (`/api/voicecall/group/state`, command `12445`).
+     *
+     * @param callId ID của cuộc gọi nhóm
+     * @param hostCall User ID hoặc Group ID chủ trì cuộc gọi (`hostCall`)
+     * @param callType Loại cuộc gọi nhóm (`CallType.GroupAudio = 5` hoặc `CallType.GroupVideo = 6`)
+     * @throws {ZaloApiError}
+     */
+    return async function getGroupCallState(callId, hostCall, callType = sendVoiceCall.CallType.GroupAudio) {
+        if (!callId)
+            throw new ZaloApiError.ZaloApiError("Missing callId");
+        if (!hostCall)
+            throw new ZaloApiError.ZaloApiError("Missing hostCall");
+        if (!voiceCallService)
+            throw new ZaloApiError.ZaloApiError("Missing voice_call service URL in zpwServiceMap");
+        const params = {
+            callId,
+            hostCall: String(hostCall),
+            callType,
+        };
+        const encryptedParams = utils.encodeAES(JSON.stringify(params));
+        if (!encryptedParams)
+            throw new ZaloApiError.ZaloApiError("Failed to encrypt getGroupCallState params");
+        const url = utils.makeURL(`${voiceCallService}/api/voicecall/group/state`, {
+            zpw_type: 24,
+            params: encryptedParams,
+        });
+        const response = await utils.request(url, {
+            method: "GET",
+        });
+        return utils.resolve(response);
+    };
+});
+
+exports.getGroupCallStateFactory = getGroupCallStateFactory;

package/dist/cjs/apis/call/holdVoiceCall.cjs

@@ -0,0 +1,39 @@
+'use strict';
+
+var ZaloApiError = require('../../Errors/ZaloApiError.cjs');
+var utils = require('../../utils.cjs');
+
+const holdVoiceCallFactory = utils.apiFactory()((api, _ctx, utils) => {
+    const voiceCallService = api.zpwServiceMap.voice_call?.[0];
+    /**
+     * Gửi yêu cầu tạm giữ cuộc gọi (`/api/voicecall/holdreq`, command `11307`, signal `411`)
+     * hoặc phản hồi tạm giữ cuộc gọi (`/api/voicecall/holdresp`, command `11308`, signal `412`).
+     *
+     * @param toId User ID của đối phương trong cuộc gọi
+     * @param options Đặt `isResponse = true` nếu là gói phản hồi (`holdresp`)
+     * @throws {ZaloApiError}
+     */
+    return async function holdVoiceCall(toId, options = {}) {
+        if (!toId)
+            throw new ZaloApiError.ZaloApiError("Missing toId");
+        if (!voiceCallService)
+            throw new ZaloApiError.ZaloApiError("Missing voice_call service URL in zpwServiceMap");
+        const params = {
+            toId: String(toId),
+        };
+        const encryptedParams = utils.encodeAES(JSON.stringify(params));
+        if (!encryptedParams)
+            throw new ZaloApiError.ZaloApiError("Failed to encrypt holdVoiceCall params");
+        const endpoint = options.isResponse ? "holdresp" : "holdreq";
+        const url = utils.makeURL(`${voiceCallService}/api/voicecall/${endpoint}`, {
+            zpw_type: 24,
+            params: encryptedParams,
+        });
+        const response = await utils.request(url, {
+            method: "GET",
+        });
+        return utils.resolve(response);
+    };
+});
+
+exports.holdVoiceCallFactory = holdVoiceCallFactory;

package/dist/cjs/apis/call/joinGroupCall.cjs

@@ -0,0 +1,51 @@
+'use strict';
+
+var ZaloApiError = require('../../Errors/ZaloApiError.cjs');
+var utils = require('../../utils.cjs');
+
+const joinGroupCallFactory = utils.apiFactory()((api, ctx, utils) => {
+    const voiceCallService = api.zpwServiceMap.voice_call?.[0];
+    /**
+     * Tham gia vào một cuộc gọi nhóm đang diễn ra (`/api/voicecall/group/join`, command `12043`).
+     *
+     * @param callId ID của cuộc gọi nhóm
+     * @param options Thông tin `hostCall`, `userId`, `status`, `srcJoinCall`, `audioState`, `videoState` và `data`
+     * @throws {ZaloApiError}
+     */
+    return async function joinGroupCall(callId, options) {
+        if (!callId)
+            throw new ZaloApiError.ZaloApiError("Missing callId");
+        if (!options?.hostCall)
+            throw new ZaloApiError.ZaloApiError("Missing hostCall");
+        if (!voiceCallService)
+            throw new ZaloApiError.ZaloApiError("Missing voice_call service URL in zpwServiceMap");
+        const dataStr = options.data === undefined
+            ? "{}"
+            : typeof options.data === "string"
+                ? options.data
+                : JSON.stringify(options.data);
+        const params = {
+            userId: String(options.userId ?? ctx.uid),
+            callId,
+            hostCall: String(options.hostCall),
+            status: options.status ?? 0,
+            srcJoinCall: options.srcJoinCall ?? 0,
+            audiostate: options.audioState ?? 1,
+            videostate: options.videoState ?? 0,
+            data: dataStr,
+        };
+        const encryptedParams = utils.encodeAES(JSON.stringify(params));
+        if (!encryptedParams)
+            throw new ZaloApiError.ZaloApiError("Failed to encrypt joinGroupCall params");
+        const url = utils.makeURL(`${voiceCallService}/api/voicecall/group/join`, {
+            zpw_type: 24,
+            params: encryptedParams,
+        });
+        const response = await utils.request(url, {
+            method: "GET",
+        });
+        return utils.resolve(response);
+    };
+});
+
+exports.joinGroupCallFactory = joinGroupCallFactory;

package/dist/cjs/apis/call/logEndVoiceCall.cjs

@@ -0,0 +1,51 @@
+'use strict';
+
+var ZaloApiError = require('../../Errors/ZaloApiError.cjs');
+var utils = require('../../utils.cjs');
+
+const logEndVoiceCallFactory = utils.apiFactory()((api, ctx, utils) => {
+    const voiceCallService = api.zpwServiceMap.voice_call?.[0];
+    /**
+     * Gửi báo cáo thống kê chất lượng / kết thúc cuộc gọi (`/api/voicecall/logendcall`, command `11311`, signal `406`).
+     *
+     * @param partnerId User ID của đối phương
+     * @param callId ID của cuộc gọi
+     * @param options Thông tin `status`, `duration`, `role` và `logData`
+     * @throws {ZaloApiError}
+     */
+    return async function logEndVoiceCall(partnerId, callId, options = {}) {
+        if (!partnerId)
+            throw new ZaloApiError.ZaloApiError("Missing partnerId");
+        if (!callId)
+            throw new ZaloApiError.ZaloApiError("Missing callId");
+        if (!voiceCallService)
+            throw new ZaloApiError.ZaloApiError("Missing voice_call service URL in zpwServiceMap");
+        const logdata = options.logData === undefined
+            ? "{}"
+            : typeof options.logData === "string"
+                ? options.logData
+                : JSON.stringify(options.logData);
+        const params = {
+            call_id: callId,
+            partner_id: String(partnerId),
+            status: options.status ?? 0,
+            logdata,
+            duration: options.duration ?? 0,
+            role: options.role ?? true,
+            imei: ctx.imei,
+        };
+        const encryptedParams = utils.encodeAES(JSON.stringify(params));
+        if (!encryptedParams)
+            throw new ZaloApiError.ZaloApiError("Failed to encrypt logEndVoiceCall params");
+        const url = utils.makeURL(`${voiceCallService}/api/voicecall/logendcall`, {
+            zpw_type: 24,
+            params: encryptedParams,
+        });
+        const response = await utils.request(url, {
+            method: "GET",
+        });
+        return utils.resolve(response);
+    };
+});
+
+exports.logEndVoiceCallFactory = logEndVoiceCallFactory;

package/dist/cjs/apis/call/notifyGroupCall.cjs

@@ -0,0 +1,49 @@
+'use strict';
+
+var ZaloApiError = require('../../Errors/ZaloApiError.cjs');
+var utils = require('../../utils.cjs');
+var sendVoiceCall = require('./sendVoiceCall.cjs');
+
+const notifyGroupCallFactory = utils.apiFactory()((api, _ctx, utils) => {
+    const voiceCallService = api.zpwServiceMap.voice_call?.[0];
+    /**
+     * Gửi thông báo sự kiện trong cuộc gọi nhóm (`/api/voicecall/group/notify`, command `12447`).
+     *
+     * @param callId ID của cuộc gọi nhóm
+     * @param options Thông tin `hostCall`, `callType`, `status` và `data`
+     * @throws {ZaloApiError}
+     */
+    return async function notifyGroupCall(callId, options) {
+        if (!callId)
+            throw new ZaloApiError.ZaloApiError("Missing callId");
+        if (!options?.hostCall)
+            throw new ZaloApiError.ZaloApiError("Missing hostCall");
+        if (!voiceCallService)
+            throw new ZaloApiError.ZaloApiError("Missing voice_call service URL in zpwServiceMap");
+        const dataStr = options.data === undefined
+            ? "{}"
+            : typeof options.data === "string"
+                ? options.data
+                : JSON.stringify(options.data);
+        const params = {
+            callId,
+            hostCall: String(options.hostCall),
+            callType: options.callType ?? sendVoiceCall.CallType.GroupAudio,
+            status: options.status ?? 0,
+            data: dataStr,
+        };
+        const encryptedParams = utils.encodeAES(JSON.stringify(params));
+        if (!encryptedParams)
+            throw new ZaloApiError.ZaloApiError("Failed to encrypt notifyGroupCall params");
+        const url = utils.makeURL(`${voiceCallService}/api/voicecall/group/notify`, {
+            zpw_type: 24,
+            params: encryptedParams,
+        });
+        const response = await utils.request(url, {
+            method: "GET",
+        });
+        return utils.resolve(response);
+    };
+});
+
+exports.notifyGroupCallFactory = notifyGroupCallFactory;

package/dist/cjs/apis/call/pingGroupCall.cjs

@@ -0,0 +1,50 @@
+'use strict';
+
+var ZaloApiError = require('../../Errors/ZaloApiError.cjs');
+var utils = require('../../utils.cjs');
+
+const pingGroupCallFactory = utils.apiFactory()((api, ctx, utils) => {
+    const voiceCallService = api.zpwServiceMap.voice_call?.[0];
+    /**
+     * Gửi gói tin heartbeat (ping) duy trì kết nối cuộc gọi nhóm (`/api/voicecall/group/ping`, command `12097`).
+     *
+     * @param callId ID của cuộc gọi nhóm
+     * @param options Thông tin `hostCall`, `userId`, `callState`, `audioState`, `videoState` và `params`
+     * @throws {ZaloApiError}
+     */
+    return async function pingGroupCall(callId, options) {
+        if (!callId)
+            throw new ZaloApiError.ZaloApiError("Missing callId");
+        if (!options?.hostCall)
+            throw new ZaloApiError.ZaloApiError("Missing hostCall");
+        if (!voiceCallService)
+            throw new ZaloApiError.ZaloApiError("Missing voice_call service URL in zpwServiceMap");
+        const paramsStr = options.params === undefined
+            ? "{}"
+            : typeof options.params === "string"
+                ? options.params
+                : JSON.stringify(options.params);
+        const payload = {
+            callId,
+            hostCall: String(options.hostCall),
+            userId: String(options.userId ?? ctx.uid),
+            callstate: options.callState ?? 1,
+            audiostate: options.audioState ?? 1,
+            videostate: options.videoState ?? 0,
+            params: paramsStr,
+        };
+        const encryptedParams = utils.encodeAES(JSON.stringify(payload));
+        if (!encryptedParams)
+            throw new ZaloApiError.ZaloApiError("Failed to encrypt pingGroupCall params");
+        const url = utils.makeURL(`${voiceCallService}/api/voicecall/group/ping`, {
+            zpw_type: 24,
+            params: encryptedParams,
+        });
+        const response = await utils.request(url, {
+            method: "GET",
+        });
+        return utils.resolve(response);
+    };
+});
+
+exports.pingGroupCallFactory = pingGroupCallFactory;

package/dist/cjs/apis/call/requestAudioToVideoCall.cjs

@@ -0,0 +1,42 @@
+'use strict';
+
+var ZaloApiError = require('../../Errors/ZaloApiError.cjs');
+var utils = require('../../utils.cjs');
+
+const requestAudioToVideoCallFactory = utils.apiFactory()((api, _ctx, utils) => {
+    const voiceCallService = api.zpwServiceMap.voice_call?.[0];
+    /**
+     * Gửi yêu cầu chuyển đổi cuộc gọi thoại đang diễn ra sang cuộc gọi video (`/api/voicecall/requestaudio2video`, command `12056`).
+     *
+     * @param uidTo User ID của đối phương
+     * @param callId ID của cuộc gọi
+     * @param options Trạng thái yêu cầu (`status`, mặc định `1`)
+     * @throws {ZaloApiError}
+     */
+    return async function requestAudioToVideoCall(uidTo, callId, options = {}) {
+        if (!uidTo)
+            throw new ZaloApiError.ZaloApiError("Missing uidTo");
+        if (!callId)
+            throw new ZaloApiError.ZaloApiError("Missing callId");
+        if (!voiceCallService)
+            throw new ZaloApiError.ZaloApiError("Missing voice_call service URL in zpwServiceMap");
+        const params = {
+            uidTo: String(uidTo),
+            callId,
+            status: options.status ?? 1,
+        };
+        const encryptedParams = utils.encodeAES(JSON.stringify(params));
+        if (!encryptedParams)
+            throw new ZaloApiError.ZaloApiError("Failed to encrypt requestAudioToVideoCall params");
+        const url = utils.makeURL(`${voiceCallService}/api/voicecall/requestaudio2video`, {
+            zpw_type: 24,
+            params: encryptedParams,
+        });
+        const response = await utils.request(url, {
+            method: "GET",
+        });
+        return utils.resolve(response);
+    };
+});
+
+exports.requestAudioToVideoCallFactory = requestAudioToVideoCallFactory;

package/dist/cjs/apis/call/requestGroupCall.cjs

@@ -0,0 +1,51 @@
+'use strict';
+
+var ZaloApiError = require('../../Errors/ZaloApiError.cjs');
+var utils = require('../../utils.cjs');
+var sendVoiceCall = require('./sendVoiceCall.cjs');
+
+const requestGroupCallFactory = utils.apiFactory()((api, _ctx, utils) => {
+    const voiceCallService = api.zpwServiceMap.voice_call?.[0];
+    /**
+     * Xin cấp phát phiên gọi nhóm (Group Call) và máy chủ relay (`/api/voicecall/group/requestcall`, command `12433`).
+     *
+     * @param groupId ID của nhóm
+     * @param options Danh sách `partners`, `callId`, `typeRequest` (`CallType.GroupAudio = 5` hoặc `CallType.GroupVideo = 6`) và `data`
+     * @throws {ZaloApiError}
+     */
+    return async function requestGroupCall(groupId, options) {
+        if (!groupId)
+            throw new ZaloApiError.ZaloApiError("Missing groupId");
+        if (!options?.partners || !Array.isArray(options.partners)) {
+            throw new ZaloApiError.ZaloApiError("Missing partners array");
+        }
+        if (!voiceCallService)
+            throw new ZaloApiError.ZaloApiError("Missing voice_call service URL in zpwServiceMap");
+        const callId = options.callId ?? Math.floor(Math.random() * 2_000_000_000);
+        const dataStr = options.data === undefined
+            ? "{}"
+            : typeof options.data === "string"
+                ? options.data
+                : JSON.stringify(options.data);
+        const params = {
+            groupId: String(groupId),
+            callId,
+            typeRequest: options.typeRequest ?? sendVoiceCall.CallType.GroupAudio,
+            data: dataStr,
+            partners: options.partners.map(String),
+        };
+        const encryptedParams = utils.encodeAES(JSON.stringify(params));
+        if (!encryptedParams)
+            throw new ZaloApiError.ZaloApiError("Failed to encrypt requestGroupCall params");
+        const url = utils.makeURL(`${voiceCallService}/api/voicecall/group/requestcall`, {
+            zpw_type: 24,
+            params: encryptedParams,
+        });
+        const response = await utils.request(url, {
+            method: "GET",
+        });
+        return utils.resolve(response);
+    };
+});
+
+exports.requestGroupCallFactory = requestGroupCallFactory;

package/dist/cjs/apis/call/requestShareScreenCall.cjs

@@ -0,0 +1,42 @@
+'use strict';
+
+var ZaloApiError = require('../../Errors/ZaloApiError.cjs');
+var utils = require('../../utils.cjs');
+
+const requestShareScreenCallFactory = utils.apiFactory()((api, _ctx, utils) => {
+    const voiceCallService = api.zpwServiceMap.voice_call?.[0];
+    /**
+     * Gửi tín hiệu bật/tắt chia sẻ màn hình trong cuộc gọi 1-1 (`/api/voicecall/requestsharescreen`, command `12064`).
+     *
+     * @param uidTo User ID của đối phương
+     * @param callId ID của cuộc gọi
+     * @param options Trạng thái chia sẻ màn hình (`status`: `1` bật, `0` tắt)
+     * @throws {ZaloApiError}
+     */
+    return async function requestShareScreenCall(uidTo, callId, options = {}) {
+        if (!uidTo)
+            throw new ZaloApiError.ZaloApiError("Missing uidTo");
+        if (!callId)
+            throw new ZaloApiError.ZaloApiError("Missing callId");
+        if (!voiceCallService)
+            throw new ZaloApiError.ZaloApiError("Missing voice_call service URL in zpwServiceMap");
+        const params = {
+            uidTo: String(uidTo),
+            callId,
+            status: options.status ?? 1,
+        };
+        const encryptedParams = utils.encodeAES(JSON.stringify(params));
+        if (!encryptedParams)
+            throw new ZaloApiError.ZaloApiError("Failed to encrypt requestShareScreenCall params");
+        const url = utils.makeURL(`${voiceCallService}/api/voicecall/requestsharescreen`, {
+            zpw_type: 24,
+            params: encryptedParams,
+        });
+        const response = await utils.request(url, {
+            method: "GET",
+        });
+        return utils.resolve(response);
+    };
+});
+
+exports.requestShareScreenCallFactory = requestShareScreenCallFactory;