@softtynet/zca-js 2.3.4 → 2.3.6

package/dist/apis/call/getGroupCallState.js

@@ -0,0 +1,38 @@
+import { ZaloApiError } from "../../Errors/ZaloApiError.js";
+import { apiFactory } from "../../utils.js";
+import { CallType } from "./sendVoiceCall.js";
+export const getGroupCallStateFactory = 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 = CallType.GroupAudio) {
+        if (!callId)
+            throw new ZaloApiError("Missing callId");
+        if (!hostCall)
+            throw new ZaloApiError("Missing hostCall");
+        if (!voiceCallService)
+            throw new 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("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);
+    };
+});

package/dist/apis/call/holdVoiceCall.d.ts

@@ -0,0 +1,5 @@
+export type HoldVoiceCallOptions = {
+    isResponse?: boolean;
+};
+export type HoldVoiceCallResponse = Record<string, unknown>;
+export declare const holdVoiceCallFactory: (ctx: import("../../context.js").ContextBase, api: import("../../apis.js").API) => (toId: string, options?: HoldVoiceCallOptions) => Promise<HoldVoiceCallResponse>;

package/dist/apis/call/holdVoiceCall.js

@@ -0,0 +1,34 @@
+import { ZaloApiError } from "../../Errors/ZaloApiError.js";
+import { apiFactory } from "../../utils.js";
+export const holdVoiceCallFactory = 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("Missing toId");
+        if (!voiceCallService)
+            throw new 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("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);
+    };
+});

package/dist/apis/call/joinGroupCall.d.ts

@@ -0,0 +1,11 @@
+export type JoinGroupCallOptions = {
+    userId?: string;
+    hostCall: string;
+    status?: number;
+    srcJoinCall?: number;
+    audioState?: number;
+    videoState?: number;
+    data?: string | Record<string, unknown>;
+};
+export type JoinGroupCallResponse = Record<string, unknown>;
+export declare const joinGroupCallFactory: (ctx: import("../../context.js").ContextBase, api: import("../../apis.js").API) => (callId: number, options: JoinGroupCallOptions) => Promise<JoinGroupCallResponse>;

package/dist/apis/call/joinGroupCall.js

@@ -0,0 +1,46 @@
+import { ZaloApiError } from "../../Errors/ZaloApiError.js";
+import { apiFactory } from "../../utils.js";
+export const joinGroupCallFactory = 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("Missing callId");
+        if (!options?.hostCall)
+            throw new ZaloApiError("Missing hostCall");
+        if (!voiceCallService)
+            throw new 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("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);
+    };
+});

package/dist/apis/call/logEndVoiceCall.d.ts

@@ -0,0 +1,8 @@
+export type LogEndVoiceCallOptions = {
+    status?: number;
+    logData?: string | Record<string, unknown>;
+    duration?: number;
+    role?: boolean | number;
+};
+export type LogEndVoiceCallResponse = Record<string, unknown>;
+export declare const logEndVoiceCallFactory: (ctx: import("../../context.js").ContextBase, api: import("../../apis.js").API) => (partnerId: string, callId: number, options?: LogEndVoiceCallOptions) => Promise<LogEndVoiceCallResponse>;

package/dist/apis/call/logEndVoiceCall.js

@@ -0,0 +1,46 @@
+import { ZaloApiError } from "../../Errors/ZaloApiError.js";
+import { apiFactory } from "../../utils.js";
+export const logEndVoiceCallFactory = 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("Missing partnerId");
+        if (!callId)
+            throw new ZaloApiError("Missing callId");
+        if (!voiceCallService)
+            throw new 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("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);
+    };
+});

package/dist/apis/call/notifyGroupCall.d.ts

@@ -0,0 +1,9 @@
+import { CallType } from "./sendVoiceCall.js";
+export type NotifyGroupCallOptions = {
+    hostCall: string;
+    callType?: CallType | number;
+    status?: number;
+    data?: string | Record<string, unknown>;
+};
+export type NotifyGroupCallResponse = Record<string, unknown>;
+export declare const notifyGroupCallFactory: (ctx: import("../../context.js").ContextBase, api: import("../../apis.js").API) => (callId: number, options: NotifyGroupCallOptions) => Promise<NotifyGroupCallResponse>;

package/dist/apis/call/notifyGroupCall.js

@@ -0,0 +1,44 @@
+import { ZaloApiError } from "../../Errors/ZaloApiError.js";
+import { apiFactory } from "../../utils.js";
+import { CallType } from "./sendVoiceCall.js";
+export const notifyGroupCallFactory = 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("Missing callId");
+        if (!options?.hostCall)
+            throw new ZaloApiError("Missing hostCall");
+        if (!voiceCallService)
+            throw new 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 ?? CallType.GroupAudio,
+            status: options.status ?? 0,
+            data: dataStr,
+        };
+        const encryptedParams = utils.encodeAES(JSON.stringify(params));
+        if (!encryptedParams)
+            throw new 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);
+    };
+});

package/dist/apis/call/pingGroupCall.d.ts

@@ -0,0 +1,10 @@
+export type PingGroupCallOptions = {
+    hostCall: string;
+    userId?: string;
+    callState?: number;
+    audioState?: number;
+    videoState?: number;
+    params?: string | Record<string, unknown>;
+};
+export type PingGroupCallResponse = Record<string, unknown>;
+export declare const pingGroupCallFactory: (ctx: import("../../context.js").ContextBase, api: import("../../apis.js").API) => (callId: number, options: PingGroupCallOptions) => Promise<PingGroupCallResponse>;

package/dist/apis/call/pingGroupCall.js

@@ -0,0 +1,45 @@
+import { ZaloApiError } from "../../Errors/ZaloApiError.js";
+import { apiFactory } from "../../utils.js";
+export const pingGroupCallFactory = 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("Missing callId");
+        if (!options?.hostCall)
+            throw new ZaloApiError("Missing hostCall");
+        if (!voiceCallService)
+            throw new 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("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);
+    };
+});

package/dist/apis/call/requestAudioToVideoCall.d.ts

@@ -0,0 +1,5 @@
+export type RequestAudioToVideoCallOptions = {
+    status?: number;
+};
+export type RequestAudioToVideoCallResponse = Record<string, unknown>;
+export declare const requestAudioToVideoCallFactory: (ctx: import("../../context.js").ContextBase, api: import("../../apis.js").API) => (uidTo: string, callId: number, options?: RequestAudioToVideoCallOptions) => Promise<RequestAudioToVideoCallResponse>;

package/dist/apis/call/requestAudioToVideoCall.js

@@ -0,0 +1,37 @@
+import { ZaloApiError } from "../../Errors/ZaloApiError.js";
+import { apiFactory } from "../../utils.js";
+export const requestAudioToVideoCallFactory = 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("Missing uidTo");
+        if (!callId)
+            throw new ZaloApiError("Missing callId");
+        if (!voiceCallService)
+            throw new 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("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);
+    };
+});

package/dist/apis/call/requestGroupCall.d.ts

@@ -0,0 +1,9 @@
+import { CallType } from "./sendVoiceCall.js";
+export type RequestGroupCallOptions = {
+    callId?: number;
+    typeRequest?: CallType | number;
+    data?: string | Record<string, unknown>;
+    partners: string[];
+};
+export type RequestGroupCallResponse = Record<string, unknown>;
+export declare const requestGroupCallFactory: (ctx: import("../../context.js").ContextBase, api: import("../../apis.js").API) => (groupId: string, options: RequestGroupCallOptions) => Promise<RequestGroupCallResponse>;

package/dist/apis/call/requestGroupCall.js

@@ -0,0 +1,46 @@
+import { ZaloApiError } from "../../Errors/ZaloApiError.js";
+import { apiFactory } from "../../utils.js";
+import { CallType } from "./sendVoiceCall.js";
+export const requestGroupCallFactory = 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("Missing groupId");
+        if (!options?.partners || !Array.isArray(options.partners)) {
+            throw new ZaloApiError("Missing partners array");
+        }
+        if (!voiceCallService)
+            throw new 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 ?? CallType.GroupAudio,
+            data: dataStr,
+            partners: options.partners.map(String),
+        };
+        const encryptedParams = utils.encodeAES(JSON.stringify(params));
+        if (!encryptedParams)
+            throw new 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);
+    };
+});

package/dist/apis/call/requestShareScreenCall.d.ts

@@ -0,0 +1,5 @@
+export type RequestShareScreenCallOptions = {
+    status?: number;
+};
+export type RequestShareScreenCallResponse = Record<string, unknown>;
+export declare const requestShareScreenCallFactory: (ctx: import("../../context.js").ContextBase, api: import("../../apis.js").API) => (uidTo: string, callId: number, options?: RequestShareScreenCallOptions) => Promise<RequestShareScreenCallResponse>;

package/dist/apis/call/requestShareScreenCall.js

@@ -0,0 +1,37 @@
+import { ZaloApiError } from "../../Errors/ZaloApiError.js";
+import { apiFactory } from "../../utils.js";
+export const requestShareScreenCallFactory = 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("Missing uidTo");
+        if (!callId)
+            throw new ZaloApiError("Missing callId");
+        if (!voiceCallService)
+            throw new 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("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);
+    };
+});

package/dist/apis/call/requestVoiceCall.d.ts

@@ -0,0 +1,10 @@
+import { CallType, type RequestCallServerInfo } from "./sendVoiceCall.js";
+export type RequestVoiceCallOptions = {
+    callType?: CallType;
+    callId?: number;
+    codec?: string;
+};
+export type RequestVoiceCallResponse = RequestCallServerInfo & {
+    callId: number;
+};
+export declare const requestVoiceCallFactory: (ctx: import("../../context.js").ContextBase, api: import("../../apis.js").API) => (calleeId: string, options?: RequestVoiceCallOptions) => Promise<RequestVoiceCallResponse>;

package/dist/apis/call/requestVoiceCall.js

@@ -0,0 +1,47 @@
+import { ZaloApiError } from "../../Errors/ZaloApiError.js";
+import { apiFactory, resolveResponse } from "../../utils.js";
+import { CallType } from "./sendVoiceCall.js";
+export const requestVoiceCallFactory = apiFactory()((api, ctx, utils) => {
+    const voiceCallService = api.zpwServiceMap.voice_call?.[0];
+    /**
+     * Xin cấp phát phiên gọi thoại / video và máy chủ relay RTP/RTCP (`/api/voicecall/requestcall`, command `11300`, signal `401`).
+     *
+     * @param calleeId User ID của người nhận cuộc gọi
+     * @param options Tuỳ chọn loại cuộc gọi (`callType`), `callId` và `codec`
+     * @throws {ZaloApiError}
+     */
+    return async function requestVoiceCall(calleeId, options = {}) {
+        if (!calleeId)
+            throw new ZaloApiError("Missing calleeId");
+        if (!voiceCallService)
+            throw new ZaloApiError("Missing voice_call service URL in zpwServiceMap");
+        const callType = options.callType ?? CallType.Audio;
+        const callId = options.callId ?? Math.floor(Math.random() * 2_000_000_000);
+        const codec = options.codec ?? "[]";
+        const params = {
+            calleeId: String(calleeId),
+            callId,
+            codec,
+            typeRequest: callType,
+            imei: ctx.imei,
+        };
+        const encryptedParams = utils.encodeAES(JSON.stringify(params));
+        if (!encryptedParams)
+            throw new ZaloApiError("Failed to encrypt requestVoiceCall params");
+        const url = utils.makeURL(`${voiceCallService}/api/voicecall/requestcall`, {
+            zpw_type: 24,
+            params: encryptedParams,
+        });
+        const response = await utils.request(url, {
+            method: "GET",
+        });
+        const serverInfo = await resolveResponse(ctx, response, (result) => {
+            const raw = result.data;
+            return typeof raw === "string" ? JSON.parse(raw) : raw;
+        });
+        return {
+            ...serverInfo,
+            callId,
+        };
+    };
+});

package/dist/apis/call/ringRingGroupCall.d.ts

@@ -0,0 +1,10 @@
+import { CallType } from "./sendVoiceCall.js";
+export type RingRingGroupCallOptions = {
+    calleeId?: string;
+    callType?: CallType | number;
+    hostCall: string;
+    data?: string | Record<string, unknown>;
+    partners?: string[];
+};
+export type RingRingGroupCallResponse = Record<string, unknown>;
+export declare const ringRingGroupCallFactory: (ctx: import("../../context.js").ContextBase, api: import("../../apis.js").API) => (callId: number, options: RingRingGroupCallOptions) => Promise<RingRingGroupCallResponse>;

package/dist/apis/call/ringRingGroupCall.js

@@ -0,0 +1,45 @@
+import { ZaloApiError } from "../../Errors/ZaloApiError.js";
+import { apiFactory } from "../../utils.js";
+import { CallType } from "./sendVoiceCall.js";
+export const ringRingGroupCallFactory = apiFactory()((api, ctx, utils) => {
+    const voiceCallService = api.zpwServiceMap.voice_call?.[0];
+    /**
+     * Báo hiệu thiết bị đang đổ chuông cho cuộc gọi nhóm (`/api/voicecall/group/ringring`, command `12439`).
+     *
+     * @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 ringRingGroupCall(callId, options) {
+        if (!callId)
+            throw new ZaloApiError("Missing callId");
+        if (!options?.hostCall)
+            throw new ZaloApiError("Missing hostCall");
+        if (!voiceCallService)
+            throw new 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 ?? 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("Failed to encrypt ringRingGroupCall params");
+        const url = utils.makeURL(`${voiceCallService}/api/voicecall/group/ringring`, {
+            zpw_type: 24,
+            params: encryptedParams,
+        });
+        const response = await utils.request(url, {
+            method: "GET",
+        });
+        return utils.resolve(response);
+    };
+});

package/dist/apis/call/ringRingVoiceCall.d.ts

@@ -0,0 +1,5 @@
+export type RingRingVoiceCallOptions = {
+    status?: number;
+};
+export type RingRingVoiceCallResponse = Record<string, unknown>;
+export declare const ringRingVoiceCallFactory: (ctx: import("../../context.js").ContextBase, api: import("../../apis.js").API) => (callerId: string, callId: number, options?: RingRingVoiceCallOptions) => Promise<RingRingVoiceCallResponse>;

package/dist/apis/call/ringRingVoiceCall.js

@@ -0,0 +1,38 @@
+import { ZaloApiError } from "../../Errors/ZaloApiError.js";
+import { apiFactory } from "../../utils.js";
+export const ringRingVoiceCallFactory = apiFactory()((api, ctx, utils) => {
+    const voiceCallService = api.zpwServiceMap.voice_call?.[0];
+    /**
+     * Báo hiệu thiết bị của người nhận đang đổ chuông cho người gọi (`/api/voicecall/ringring`, command `11302`, signal `407`).
+     *
+     * @param callerId User ID của người gọi đến
+     * @param callId ID của cuộc gọi
+     * @param options Tuỳ chọn mã trạng thái (`status`, mặc định `0`)
+     * @throws {ZaloApiError}
+     */
+    return async function ringRingVoiceCall(callerId, callId, options = {}) {
+        if (!callerId)
+            throw new ZaloApiError("Missing callerId");
+        if (!callId)
+            throw new ZaloApiError("Missing callId");
+        if (!voiceCallService)
+            throw new ZaloApiError("Missing voice_call service URL in zpwServiceMap");
+        const params = {
+            callerId: String(callerId),
+            callId,
+            status: options.status ?? 0,
+            imei: ctx.imei,
+        };
+        const encryptedParams = utils.encodeAES(JSON.stringify(params));
+        if (!encryptedParams)
+            throw new ZaloApiError("Failed to encrypt ringRingVoiceCall params");
+        const url = utils.makeURL(`${voiceCallService}/api/voicecall/ringring`, {
+            zpw_type: 24,
+            params: encryptedParams,
+        });
+        const response = await utils.request(url, {
+            method: "GET",
+        });
+        return utils.resolve(response);
+    };
+});

package/dist/apis/call/sendRequestGroupCall.d.ts

@@ -0,0 +1,11 @@
+import { CallType } from "./sendVoiceCall.js";
+export type SendRequestGroupCallOptions = {
+    calleeId?: string;
+    callId: number;
+    callType?: CallType | number;
+    data?: string | Record<string, unknown>;
+    session: string;
+    partners: string[];
+};
+export type SendRequestGroupCallResponse = Record<string, unknown>;
+export declare const sendRequestGroupCallFactory: (ctx: import("../../context.js").ContextBase, api: import("../../apis.js").API) => (groupId: string, options: SendRequestGroupCallOptions) => Promise<SendRequestGroupCallResponse>;