zapo-js 0.1.0

package/dist/client/WaClientFactory.js

@@ -0,0 +1,381 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveWaClientBase = resolveWaClientBase;
+exports.buildWaClientDependencies = buildWaClientDependencies;
+const WaAppStateSyncClient_1 = require("../appstate/WaAppStateSyncClient");
+const WaAuthClient_1 = require("../auth/WaAuthClient");
+const WaGroupCoordinator_1 = require("./coordinators/WaGroupCoordinator");
+const WaIncomingNodeCoordinator_1 = require("./coordinators/WaIncomingNodeCoordinator");
+const WaMessageDispatchCoordinator_1 = require("./coordinators/WaMessageDispatchCoordinator");
+const WaPassiveTasksCoordinator_1 = require("./coordinators/WaPassiveTasksCoordinator");
+const WaRetryCoordinator_1 = require("./coordinators/WaRetryCoordinator");
+const WaStreamControlCoordinator_1 = require("./coordinators/WaStreamControlCoordinator");
+const dirty_1 = require("./dirty");
+const messages_1 = require("./messages");
+const WaMediaTransferClient_1 = require("../media/WaMediaTransferClient");
+const incoming_1 = require("../message/incoming");
+const WaMessageClient_1 = require("../message/WaMessageClient");
+const constants_1 = require("../protocol/constants");
+const SignalDeviceSyncApi_1 = require("../signal/api/SignalDeviceSyncApi");
+const SignalDigestSyncApi_1 = require("../signal/api/SignalDigestSyncApi");
+const SignalIdentitySyncApi_1 = require("../signal/api/SignalIdentitySyncApi");
+const SignalMissingPreKeysSyncApi_1 = require("../signal/api/SignalMissingPreKeysSyncApi");
+const SignalRotateKeyApi_1 = require("../signal/api/SignalRotateKeyApi");
+const SignalSessionSyncApi_1 = require("../signal/api/SignalSessionSyncApi");
+const SenderKeyManager_1 = require("../signal/group/SenderKeyManager");
+const SignalProtocol_1 = require("../signal/session/SignalProtocol");
+const WaKeepAlive_1 = require("../transport/keepalive/WaKeepAlive");
+const WaNodeOrchestrator_1 = require("../transport/node/WaNodeOrchestrator");
+const WaNodeTransport_1 = require("../transport/node/WaNodeTransport");
+const primitives_1 = require("../util/primitives");
+const runtime_1 = require("../util/runtime");
+function resolveWaClientBase(options, logger) {
+    const deviceBrowser = options.deviceBrowser ?? constants_1.WA_DEFAULTS.DEVICE_BROWSER;
+    const sessionId = options.sessionId.trim();
+    if (sessionId.length === 0) {
+        throw new Error('sessionId must be a non-empty string');
+    }
+    const sessionStore = options.store.session(sessionId);
+    const normalizedOptions = Object.freeze({
+        ...options,
+        sessionId,
+        deviceBrowser,
+        deviceOsDisplayName: options.deviceOsDisplayName ?? (0, runtime_1.getRuntimeOsDisplayName)(),
+        devicePlatform: options.devicePlatform ?? (0, constants_1.getWaCompanionPlatformId)(deviceBrowser),
+        urls: options.urls ?? options.chatSocketUrls ?? constants_1.WA_DEFAULTS.CHAT_SOCKET_URLS,
+        iqTimeoutMs: options.iqTimeoutMs ?? constants_1.WA_DEFAULTS.IQ_TIMEOUT_MS,
+        nodeQueryTimeoutMs: options.nodeQueryTimeoutMs ?? constants_1.WA_DEFAULTS.NODE_QUERY_TIMEOUT_MS,
+        keepAliveIntervalMs: options.keepAliveIntervalMs ?? constants_1.WA_DEFAULTS.HEALTH_CHECK_INTERVAL_MS,
+        deadSocketTimeoutMs: options.deadSocketTimeoutMs ?? constants_1.WA_DEFAULTS.DEAD_SOCKET_TIMEOUT_MS,
+        mediaTimeoutMs: options.mediaTimeoutMs ?? constants_1.WA_DEFAULTS.MEDIA_TIMEOUT_MS,
+        appStateSyncTimeoutMs: options.appStateSyncTimeoutMs ?? constants_1.WA_DEFAULTS.APP_STATE_SYNC_TIMEOUT_MS,
+        signalFetchKeyBundlesTimeoutMs: options.signalFetchKeyBundlesTimeoutMs ??
+            constants_1.WA_DEFAULTS.SIGNAL_FETCH_KEY_BUNDLES_TIMEOUT_MS,
+        messageAckTimeoutMs: options.messageAckTimeoutMs ?? constants_1.WA_DEFAULTS.MESSAGE_ACK_TIMEOUT_MS,
+        messageMaxAttempts: options.messageMaxAttempts ?? constants_1.WA_DEFAULTS.MESSAGE_MAX_ATTEMPTS,
+        messageRetryDelayMs: options.messageRetryDelayMs ?? constants_1.WA_DEFAULTS.MESSAGE_RETRY_DELAY_MS
+    });
+    return {
+        options: normalizedOptions,
+        logger,
+        sessionStore
+    };
+}
+function createAuthClient(input) {
+    const { options, logger, sessionStore, host } = input;
+    return new WaAuthClient_1.WaAuthClient({
+        deviceBrowser: options.deviceBrowser,
+        deviceOsDisplayName: options.deviceOsDisplayName,
+        devicePlatform: options.devicePlatform,
+        requireFullSync: options.requireFullSync
+    }, {
+        logger,
+        authStore: sessionStore.auth,
+        signalStore: sessionStore.signal,
+        socket: {
+            sendNode: host.sendNode,
+            query: host.query
+        },
+        callbacks: {
+            onQr: (qr, ttlMs) => host.emitEvent('auth_qr', { qr, ttlMs }),
+            onPairingCode: (code) => host.emitEvent('auth_pairing_code', { code }),
+            onPairingRefresh: (forceManual) => host.emitEvent('auth_pairing_refresh', { forceManual }),
+            onPaired: (credentials) => {
+                host.emitEvent('auth_paired', { credentials });
+                host.scheduleReconnectAfterPairing();
+            },
+            onError: (error) => host.handleError(error)
+        }
+    });
+}
+function createCurrentAuthGetters(authClient) {
+    const getCurrentCredentials = () => authClient.getCurrentCredentials();
+    return {
+        getCurrentCredentials,
+        getCurrentMeJid: () => getCurrentCredentials()?.meJid,
+        getCurrentMeLid: () => getCurrentCredentials()?.meLid,
+        getCurrentSignedIdentity: () => getCurrentCredentials()?.signedIdentity
+    };
+}
+function createIncomingMessageAckOptions(input) {
+    const { logger, host, getCurrentMeJid, signalProtocol, senderKeyManager, retryCoordinator } = input;
+    return {
+        logger,
+        sendNode: host.sendNode,
+        getMeJid: getCurrentMeJid,
+        signalProtocol,
+        senderKeyManager,
+        onDecryptFailure: (context, error) => retryCoordinator.onDecryptFailure(context, error),
+        emitIncomingMessage: (event) => {
+            void host
+                .handleIncomingMessageEvent(event)
+                .catch((err) => host.handleError((0, primitives_1.toError)(err)));
+        },
+        emitUnhandledStanza: (event) => host.emitEvent('stanza_unhandled', event)
+    };
+}
+function createHandleClientDirtyBits(input) {
+    const { logger, host, getCurrentCredentials } = input;
+    return (dirtyBits) => (0, dirty_1.handleDirtyBits)({
+        logger,
+        queryWithContext: host.queryWithContext,
+        getCurrentCredentials,
+        syncAppState: host.syncAppState
+    }, dirtyBits);
+}
+function createIncomingNodeRuntime(input) {
+    const { logger, host, authClient, nodeOrchestrator, streamControl, mediaMessageBuildOptions, retryCoordinator, messageDispatch, getCurrentMeJid, handleClientDirtyBits, incomingMessageAckOptions } = input;
+    return {
+        handleStreamControlResult: streamControl.handleStreamControlResult,
+        persistSuccessAttributes: (attributes) => authClient.persistSuccessAttributes(attributes),
+        emitSuccessNode: (node) => host.emitEvent('connection_success', { node }),
+        updateClockSkewFromSuccess: host.updateClockSkewFromSuccess,
+        shouldWarmupMediaConn: () => {
+            const comms = host.getComms();
+            return !!(getCurrentMeJid() && comms && comms.getCommsState().connected);
+        },
+        warmupMediaConn: async () => {
+            await (0, messages_1.getMediaConn)(mediaMessageBuildOptions, true);
+        },
+        persistRoutingInfo: (routingInfo) => authClient.persistRoutingInfo(routingInfo),
+        tryResolvePendingNode: (node) => nodeOrchestrator.tryResolvePending(node),
+        handleGenericIncomingNode: (node) => nodeOrchestrator.handleIncomingNode(node),
+        handleIncomingIqSetNode: (node) => authClient.handleIncomingIqSet(node),
+        handleLinkCodeNotificationNode: (node) => authClient.handleLinkCodeNotification(node),
+        handleCompanionRegRefreshNotificationNode: (node) => authClient.handleCompanionRegRefreshNotification(node),
+        handleIncomingMessageNode: (node) => (0, incoming_1.handleIncomingMessageAck)(node, incomingMessageAckOptions),
+        sendNode: host.sendNode,
+        handleIncomingRetryReceipt: (node) => retryCoordinator.handleIncomingRetryReceipt(node),
+        trackOutboundReceipt: (node) => retryCoordinator.trackOutboundReceipt(node),
+        emitIncomingReceipt: (event) => host.emitEvent('message_receipt', event),
+        emitIncomingPresence: (event) => host.emitEvent('presence', event),
+        emitIncomingChatstate: (event) => host.emitEvent('chatstate', event),
+        emitIncomingCall: (event) => host.emitEvent('call', event),
+        emitIncomingFailure: (event) => host.emitEvent('failure', event),
+        emitIncomingErrorStanza: (event) => host.emitEvent('stanza_error', event),
+        emitIncomingNotification: (event) => host.emitEvent('notification', event),
+        emitGroupEvent: (event) => {
+            host.emitEvent('group_event', event);
+            void messageDispatch.mutateParticipantsCacheFromGroupEvent(event).catch((error) => {
+                logger.warn('failed to mutate participants cache from group event', {
+                    action: event.action,
+                    groupJid: event.groupJid,
+                    contextGroupJid: event.contextGroupJid,
+                    message: (0, primitives_1.toError)(error).message
+                });
+            });
+        },
+        emitUnhandledIncomingNode: (event) => host.emitEvent('stanza_unhandled', event),
+        syncAppState: host.syncAppState,
+        disconnect: host.disconnect,
+        clearStoredCredentials: host.clearStoredState,
+        parseDirtyBits: (nodes) => (0, dirty_1.parseDirtyBits)(nodes, logger),
+        handleDirtyBits: (dirtyBits) => handleClientDirtyBits(dirtyBits)
+    };
+}
+function createPassiveTasksRuntime(input) {
+    const { host, authClient, nodeOrchestrator, getCurrentCredentials } = input;
+    return {
+        queryWithContext: host.queryWithContext,
+        getCurrentCredentials,
+        persistServerHasPreKeys: (serverHasPreKeys) => authClient.persistServerHasPreKeys(serverHasPreKeys),
+        sendNodeDirect: (node) => nodeOrchestrator.sendNode(node),
+        takeDanglingReceipts: host.takeDanglingReceipts,
+        requeueDanglingReceipt: host.enqueueDanglingReceipt,
+        shouldQueueDanglingReceipt: host.shouldQueueDanglingReceipt
+    };
+}
+function buildWaClientDependencies(input) {
+    const { base, host } = input;
+    const { options, logger, sessionStore } = base;
+    const nodeTransport = new WaNodeTransport_1.WaNodeTransport(logger);
+    const nodeOrchestrator = new WaNodeOrchestrator_1.WaNodeOrchestrator({
+        sendNode: async (node) => nodeTransport.sendNode(node),
+        logger,
+        defaultTimeoutMs: options.nodeQueryTimeoutMs,
+        hostDomain: constants_1.WA_DEFAULTS.HOST_DOMAIN
+    });
+    const keepAlive = new WaKeepAlive_1.WaKeepAlive({
+        logger,
+        nodeOrchestrator,
+        getComms: host.getComms,
+        intervalMs: options.keepAliveIntervalMs,
+        timeoutMs: options.deadSocketTimeoutMs,
+        hostDomain: constants_1.WA_DEFAULTS.HOST_DOMAIN
+    });
+    const mediaTransfer = new WaMediaTransferClient_1.WaMediaTransferClient({
+        logger,
+        defaultTimeoutMs: options.mediaTimeoutMs
+    });
+    const mediaMessageBuildOptions = {
+        logger,
+        mediaTransfer,
+        iqTimeoutMs: options.iqTimeoutMs,
+        queryWithContext: host.queryWithContext,
+        getMediaConnCache: host.getMediaConnCache,
+        setMediaConnCache: host.setMediaConnCache
+    };
+    const messageClient = new WaMessageClient_1.WaMessageClient({
+        logger,
+        sendNode: host.sendNode,
+        query: host.query,
+        defaultAckTimeoutMs: options.messageAckTimeoutMs,
+        defaultMaxAttempts: options.messageMaxAttempts,
+        defaultRetryDelayMs: options.messageRetryDelayMs
+    });
+    const senderKeyManager = new SenderKeyManager_1.SenderKeyManager(sessionStore.senderKey);
+    const signalProtocol = new SignalProtocol_1.SignalProtocol(sessionStore.signal, logger);
+    const signalDigestSync = new SignalDigestSyncApi_1.SignalDigestSyncApi({
+        logger,
+        query: host.query,
+        signalStore: sessionStore.signal,
+        defaultTimeoutMs: options.signalFetchKeyBundlesTimeoutMs
+    });
+    const signalDeviceSync = new SignalDeviceSyncApi_1.SignalDeviceSyncApi({
+        logger,
+        query: host.query,
+        deviceListStore: sessionStore.deviceList,
+        defaultTimeoutMs: options.signalFetchKeyBundlesTimeoutMs
+    });
+    const signalIdentitySync = new SignalIdentitySyncApi_1.SignalIdentitySyncApi({
+        logger,
+        query: host.query,
+        signalStore: sessionStore.signal,
+        defaultTimeoutMs: options.signalFetchKeyBundlesTimeoutMs
+    });
+    const signalMissingPreKeysSync = new SignalMissingPreKeysSyncApi_1.SignalMissingPreKeysSyncApi({
+        logger,
+        query: host.query,
+        defaultTimeoutMs: options.signalFetchKeyBundlesTimeoutMs
+    });
+    const signalRotateKey = new SignalRotateKeyApi_1.SignalRotateKeyApi({
+        logger,
+        query: host.query,
+        signalStore: sessionStore.signal,
+        defaultTimeoutMs: options.signalFetchKeyBundlesTimeoutMs
+    });
+    const signalSessionSync = new SignalSessionSyncApi_1.SignalSessionSyncApi({
+        logger,
+        query: host.query,
+        defaultTimeoutMs: options.signalFetchKeyBundlesTimeoutMs
+    });
+    const authClient = createAuthClient({ options, logger, sessionStore, host });
+    const { getCurrentCredentials, getCurrentMeJid, getCurrentMeLid, getCurrentSignedIdentity } = createCurrentAuthGetters(authClient);
+    const groupCoordinator = (0, WaGroupCoordinator_1.createGroupCoordinator)({
+        queryWithContext: host.queryWithContext
+    });
+    const messageDispatch = new WaMessageDispatchCoordinator_1.WaMessageDispatchCoordinator({
+        logger,
+        messageClient,
+        retryStore: sessionStore.retry,
+        participantsStore: sessionStore.participants,
+        buildMessageContent: async (content) => (0, messages_1.buildMediaMessageContent)(mediaMessageBuildOptions, content),
+        queryGroupParticipantJids: async (groupJid) => (await groupCoordinator.queryGroupMetadata(groupJid)).participants.map((participant) => participant.jid),
+        senderKeyManager,
+        signalProtocol,
+        signalStore: sessionStore.signal,
+        signalDeviceSync,
+        signalIdentitySync,
+        signalSessionSync,
+        getCurrentMeJid,
+        getCurrentMeLid,
+        getCurrentSignedIdentity
+    });
+    const retryCoordinator = new WaRetryCoordinator_1.WaRetryCoordinator({
+        logger,
+        retryStore: sessionStore.retry,
+        signalStore: sessionStore.signal,
+        senderKeyStore: sessionStore.senderKey,
+        signalProtocol,
+        signalDeviceSync,
+        signalMissingPreKeysSync,
+        messageClient,
+        sendNode: host.sendNode,
+        getCurrentMeJid,
+        getCurrentMeLid,
+        getCurrentSignedIdentity
+    });
+    const appStateSync = new WaAppStateSyncClient_1.WaAppStateSyncClient({
+        logger,
+        query: host.query,
+        defaultTimeoutMs: options.appStateSyncTimeoutMs,
+        store: sessionStore.appState,
+        onMissingKeys: async ({ keyIds }) => {
+            await messageDispatch.requestAppStateSyncKeys(keyIds);
+        }
+    });
+    const streamControl = (0, WaStreamControlCoordinator_1.createStreamControlHandler)({
+        logger,
+        getComms: host.getComms,
+        clearPendingQueries: (error) => nodeOrchestrator.clearPending(error),
+        clearMediaConnCache: () => host.setMediaConnCache(null),
+        disconnect: host.disconnect,
+        clearStoredCredentials: host.clearStoredState,
+        connect: host.connect
+    });
+    const incomingMessageAckOptions = createIncomingMessageAckOptions({
+        logger,
+        host,
+        getCurrentMeJid,
+        signalProtocol,
+        senderKeyManager,
+        retryCoordinator
+    });
+    const handleClientDirtyBits = createHandleClientDirtyBits({
+        logger,
+        host,
+        getCurrentCredentials
+    });
+    const incomingNode = new WaIncomingNodeCoordinator_1.WaIncomingNodeCoordinator({
+        logger,
+        runtime: createIncomingNodeRuntime({
+            logger,
+            host,
+            authClient,
+            nodeOrchestrator,
+            streamControl,
+            mediaMessageBuildOptions,
+            retryCoordinator,
+            messageDispatch,
+            getCurrentMeJid,
+            handleClientDirtyBits,
+            incomingMessageAckOptions
+        })
+    });
+    const passiveTasks = new WaPassiveTasksCoordinator_1.WaPassiveTasksCoordinator({
+        logger,
+        signalStore: sessionStore.signal,
+        signalDigestSync,
+        signalRotateKey,
+        runtime: createPassiveTasksRuntime({
+            host,
+            authClient,
+            nodeOrchestrator,
+            getCurrentCredentials
+        })
+    });
+    return {
+        nodeTransport,
+        nodeOrchestrator,
+        keepAlive,
+        mediaTransfer,
+        mediaMessageBuildOptions,
+        messageClient,
+        senderKeyManager,
+        signalProtocol,
+        signalDigestSync,
+        signalDeviceSync,
+        signalIdentitySync,
+        signalMissingPreKeysSync,
+        signalRotateKey,
+        signalSessionSync,
+        authClient,
+        messageDispatch,
+        retryCoordinator,
+        appStateSync,
+        streamControl,
+        incomingNode,
+        passiveTasks,
+        groupCoordinator
+    };
+}

package/dist/client/coordinators/WaGroupCoordinator.js

@@ -0,0 +1,191 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createGroupCoordinator = createGroupCoordinator;
+const defaults_1 = require("../../protocol/defaults");
+const group_1 = require("../../protocol/group");
+const nodes_1 = require("../../protocol/nodes");
+const group_2 = require("../../transport/node/builders/group");
+const helpers_1 = require("../../transport/node/helpers");
+const query_1 = require("../../transport/node/query");
+function parseGroupParticipants(node) {
+    const participantNodes = (0, helpers_1.getNodeChildrenByTag)(node, nodes_1.WA_NODE_TAGS.PARTICIPANT);
+    return participantNodes.map((p) => {
+        const type = p.attrs.type ?? group_1.WA_GROUP_PARTICIPANT_TYPES.REGULAR;
+        return {
+            jid: p.attrs.jid,
+            type,
+            isAdmin: type === group_1.WA_GROUP_PARTICIPANT_TYPES.ADMIN ||
+                type === group_1.WA_GROUP_PARTICIPANT_TYPES.SUPERADMIN,
+            isSuperAdmin: type === group_1.WA_GROUP_PARTICIPANT_TYPES.SUPERADMIN
+        };
+    });
+}
+function parseGroupMetadata(node) {
+    const groupNode = node.tag === nodes_1.WA_NODE_TAGS.GROUP ? node : (0, helpers_1.findNodeChild)(node, nodes_1.WA_NODE_TAGS.GROUP);
+    const target = groupNode ?? node;
+    const attrs = target.attrs;
+    const descNode = (0, helpers_1.findNodeChild)(target, nodes_1.WA_NODE_TAGS.DESCRIPTION);
+    let desc;
+    if (descNode) {
+        const bodyNode = (0, helpers_1.findNodeChild)(descNode, nodes_1.WA_NODE_TAGS.BODY);
+        if (bodyNode && typeof bodyNode.content === 'string') {
+            desc = bodyNode.content;
+        }
+    }
+    const ephemeralNode = (0, helpers_1.findNodeChild)(target, nodes_1.WA_NODE_TAGS.EPHEMERAL);
+    const ephemeral = ephemeralNode?.attrs.expiration
+        ? Number(ephemeralNode.attrs.expiration)
+        : undefined;
+    return {
+        jid: attrs.id ?? attrs.jid ?? '',
+        subject: attrs.subject ?? '',
+        subjectOwner: attrs.s_o ?? attrs.subject_owner,
+        subjectTime: attrs.s_t ? Number(attrs.s_t) : undefined,
+        owner: attrs.creator ?? attrs.owner,
+        creation: attrs.creation ? Number(attrs.creation) : undefined,
+        desc,
+        descId: descNode?.attrs.id,
+        descOwner: descNode?.attrs.participant,
+        restrict: (0, helpers_1.hasNodeChild)(target, nodes_1.WA_NODE_TAGS.LOCKED),
+        announce: (0, helpers_1.hasNodeChild)(target, nodes_1.WA_NODE_TAGS.ANNOUNCEMENT),
+        ephemeral,
+        size: attrs.size ? Number(attrs.size) : undefined,
+        participants: parseGroupParticipants(target)
+    };
+}
+const SETTING_TAGS = {
+    announcement: { on: 'announcement', off: 'not_announcement' },
+    restrict: { on: 'locked', off: 'unlocked' },
+    ephemeral: { on: 'ephemeral', off: 'not_ephemeral' },
+    membership_approval_mode: { on: 'membership_approval_mode', off: 'membership_approval_mode' }
+};
+function createGroupCoordinator(options) {
+    const { queryWithContext } = options;
+    const changeParticipants = async (action, groupJid, participants) => {
+        const context = `group.${action}Participants`;
+        const node = (0, group_2.buildGroupParticipantChangeIq)({
+            groupJid,
+            action,
+            participants
+        });
+        const result = await queryWithContext(context, node);
+        (0, query_1.assertIqResult)(result, context);
+        return result;
+    };
+    return {
+        queryGroupMetadata: async (groupJid) => {
+            const node = (0, query_1.buildIqNode)('get', groupJid, nodes_1.WA_XMLNS.GROUPS, [
+                {
+                    tag: nodes_1.WA_NODE_TAGS.QUERY,
+                    attrs: {}
+                }
+            ]);
+            const result = await queryWithContext('group.metadata', node);
+            (0, query_1.assertIqResult)(result, 'group.metadata');
+            return parseGroupMetadata(result);
+        },
+        queryAllGroups: async () => {
+            const node = (0, query_1.buildIqNode)('get', defaults_1.WA_DEFAULTS.GROUP_SERVER, nodes_1.WA_XMLNS.GROUPS, [
+                {
+                    tag: nodes_1.WA_NODE_TAGS.PARTICIPATING,
+                    attrs: {},
+                    content: [
+                        { tag: nodes_1.WA_NODE_TAGS.PARTICIPANTS, attrs: {} },
+                        { tag: nodes_1.WA_NODE_TAGS.DESCRIPTION, attrs: {} }
+                    ]
+                }
+            ]);
+            const result = await queryWithContext('group.list', node);
+            (0, query_1.assertIqResult)(result, 'group.list');
+            const groupNodes = (0, helpers_1.getNodeChildren)(result).flatMap((child) => (0, helpers_1.getNodeChildrenByTag)(child, nodes_1.WA_NODE_TAGS.GROUP));
+            return groupNodes.map(parseGroupMetadata);
+        },
+        queryGroupInviteInfo: async (code) => {
+            const node = (0, query_1.buildIqNode)('get', defaults_1.WA_DEFAULTS.GROUP_SERVER, nodes_1.WA_XMLNS.GROUPS, [
+                { tag: nodes_1.WA_NODE_TAGS.INVITE, attrs: { code } }
+            ]);
+            const result = await queryWithContext('group.invite.info', node);
+            (0, query_1.assertIqResult)(result, 'group.invite.info');
+            return result;
+        },
+        createGroup: async (subject, participants, opts) => {
+            const node = (0, group_2.buildCreateGroupIq)({
+                subject,
+                participants,
+                description: opts?.description
+            });
+            const result = await queryWithContext('group.create', node);
+            (0, query_1.assertIqResult)(result, 'group.create');
+            return result;
+        },
+        setSubject: async (groupJid, subject) => {
+            const node = (0, query_1.buildIqNode)('set', groupJid, nodes_1.WA_XMLNS.GROUPS, [
+                { tag: nodes_1.WA_NODE_TAGS.SUBJECT, attrs: {}, content: subject }
+            ]);
+            const result = await queryWithContext('group.setSubject', node);
+            (0, query_1.assertIqResult)(result, 'group.setSubject');
+        },
+        setDescription: async (groupJid, description, prevDescId) => {
+            const descId = `${Date.now()}`;
+            const attrs = { id: descId };
+            if (prevDescId)
+                attrs.prev = prevDescId;
+            let content;
+            if (description === null) {
+                attrs.delete = 'true';
+            }
+            else {
+                content = [{ tag: nodes_1.WA_NODE_TAGS.BODY, attrs: {}, content: description }];
+            }
+            const node = (0, query_1.buildIqNode)('set', groupJid, nodes_1.WA_XMLNS.GROUPS, [
+                { tag: nodes_1.WA_NODE_TAGS.DESCRIPTION, attrs, content }
+            ]);
+            const result = await queryWithContext('group.setDescription', node);
+            (0, query_1.assertIqResult)(result, 'group.setDescription');
+        },
+        setSetting: async (groupJid, setting, enabled) => {
+            const tags = SETTING_TAGS[setting];
+            const tag = enabled ? tags.on : tags.off;
+            let content;
+            if (setting === 'membership_approval_mode') {
+                content = [
+                    {
+                        tag: nodes_1.WA_NODE_TAGS.GROUP_JOIN,
+                        attrs: { state: enabled ? 'on' : 'off' }
+                    }
+                ];
+            }
+            const node = (0, query_1.buildIqNode)('set', groupJid, nodes_1.WA_XMLNS.GROUPS, [
+                { tag, attrs: {}, ...(content ? { content } : {}) }
+            ]);
+            const result = await queryWithContext('group.setSetting', node);
+            (0, query_1.assertIqResult)(result, 'group.setSetting');
+        },
+        addParticipants: async (groupJid, participants) => changeParticipants('add', groupJid, participants),
+        removeParticipants: async (groupJid, participants) => changeParticipants('remove', groupJid, participants),
+        promoteParticipants: async (groupJid, participants) => changeParticipants('promote', groupJid, participants),
+        demoteParticipants: async (groupJid, participants) => changeParticipants('demote', groupJid, participants),
+        leaveGroup: async (groupJids) => {
+            const node = (0, group_2.buildLeaveGroupIq)(groupJids);
+            const result = await queryWithContext('group.leave', node);
+            (0, query_1.assertIqResult)(result, 'group.leave');
+            return result;
+        },
+        revokeInvite: async (groupJid) => {
+            const node = (0, query_1.buildIqNode)('set', groupJid, nodes_1.WA_XMLNS.GROUPS, [
+                { tag: nodes_1.WA_NODE_TAGS.INVITE, attrs: {} }
+            ]);
+            const result = await queryWithContext('group.revokeInvite', node);
+            (0, query_1.assertIqResult)(result, 'group.revokeInvite');
+            return result;
+        },
+        joinGroupViaInvite: async (code) => {
+            const node = (0, query_1.buildIqNode)('set', defaults_1.WA_DEFAULTS.GROUP_SERVER, nodes_1.WA_XMLNS.GROUPS, [
+                { tag: nodes_1.WA_NODE_TAGS.INVITE, attrs: { code } }
+            ]);
+            const result = await queryWithContext('group.joinViaInvite', node);
+            (0, query_1.assertIqResult)(result, 'group.joinViaInvite');
+            return result;
+        }
+    };
+}