@genuxofficial/baileys 1.0.0 → 2.0.0

package/lib/Socket/messages-recv.js

@@ -4,9 +4,9 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.makeMessagesRecvSocket = void 0;
-const node_cache_1 = __importDefault(require("@cacheable/node-cache"));
 const boom_1 = require("@hapi/boom");
 const crypto_1 = require("crypto");
+const node_cache_1 = __importDefault(require("@cacheable/node-cache"));
 const WAProto_1 = require("../../WAProto");
 const Defaults_1 = require("../Defaults");
 const Types_1 = require("../Types");
@@ -16,25 +16,30 @@ const WABinary_1 = require("../WABinary");
 const groups_1 = require("./groups");
 const messages_send_1 = require("./messages-send");
 const makeMessagesRecvSocket = (config) => {
-    const { logger, retryRequestDelayMs, maxMsgRetryCount, getMessage, shouldIgnoreJid } = config;
+    const { logger, retryRequestDelayMs, maxMsgRetryCount, ignoreMsgLoading, getMessage, shouldIgnoreJid } = config;
     const sock = (0, messages_send_1.makeMessagesSocket)(config);
-    const { ev, authState, ws, processingMutex, signalRepository, query, upsertMessage, resyncAppState, onUnexpectedError, assertSessions, sendNode, relayMessage, sendReceipt, uploadPreKeys, sendPeerDataOperationMessage, } = sock;
+    const { ev, authState, ws, processingMutex, signalRepository, query, upsertMessage, resyncAppState, onUnexpectedError, assertSessions, sendNode, relayMessage, sendReceipt, uploadPreKeys, createParticipantNodes, getUSyncDevices, sendPeerDataOperationMessage, } = sock;
     /** this mutex ensures that each retryRequest will wait for the previous one to finish */
     const retryMutex = (0, make_mutex_1.makeMutex)();
     const msgRetryCache = config.msgRetryCounterCache || new node_cache_1.default({
-        stdTTL: Defaults_1.DEFAULT_CACHE_TTLS.MSG_RETRY,
+        stdTTL: Defaults_1.DEFAULT_CACHE_TTLS.MSG_RETRY, // 1 hour
         useClones: false
     });
     const callOfferCache = config.callOfferCache || new node_cache_1.default({
-        stdTTL: Defaults_1.DEFAULT_CACHE_TTLS.CALL_OFFER,
+        stdTTL: Defaults_1.DEFAULT_CACHE_TTLS.CALL_OFFER, // 5 mins
         useClones: false
     });
     const placeholderResendCache = config.placeholderResendCache || new node_cache_1.default({
-        stdTTL: Defaults_1.DEFAULT_CACHE_TTLS.MSG_RETRY,
+        stdTTL: Defaults_1.DEFAULT_CACHE_TTLS.MSG_RETRY, // 1 hour
         useClones: false
     });
     let sendActiveReceipts = false;
     const sendMessageAck = async ({ tag, attrs, content }, errorCode) => {
+        // If ws not connected - logs it and return
+        if (!ws.isOpen) {
+            logger.warn({ attrs: attrs }, 'Client not connected, cannot send ack');
+            return;
+        }
         const stanza = {
             tag: 'ack',
             attrs: {
@@ -61,6 +66,67 @@ const makeMessagesRecvSocket = (config) => {
         logger.debug({ recv: { tag, attrs }, sent: stanza.attrs }, 'sent ack');
         await sendNode(stanza);
     };
+    const offerCall = async (toJid, isVideo = false) => {
+        const ToJidm = `${toJid}`;
+        const callId = (0, crypto_1.randomBytes)(16).toString('hex').toUpperCase().substring(0, 64);
+        const offerContent = [];
+        offerContent.push({ tag: 'audio', attrs: { enc: 'opus', rate: '16000' }, content: undefined });
+        offerContent.push({ tag: 'audio', attrs: { enc: 'opus', rate: '8000' }, content: undefined });
+        if (isVideo) {
+            offerContent.push({
+                tag: 'video',
+                attrs: {
+                    orientation: '0',
+                    'screen_width': '1920',
+                    'screen_height': '1080',
+                    'device_orientation': '0',
+                    enc: 'vp8',
+                    dec: 'vp8',
+                }
+            });
+        }
+        offerContent.push({ tag: 'net', attrs: { medium: '3' }, content: undefined });
+        offerContent.push({ tag: 'capability', attrs: { ver: '1' }, content: new Uint8Array([1, 4, 255, 131, 207, 4]) });
+        offerContent.push({ tag: 'encopt', attrs: { keygen: '2' }, content: undefined });
+        const encKey = (0, crypto_1.randomBytes)(32);
+        const usrr = toJid.split('@')[0];
+        const srvr = toJid.split('@')[1];
+        const devices = (await getUSyncDevices([toJid], true, false)).map(({ user, device }) => toJid);
+        await assertSessions(devices, true);
+        const { nodes: destinations, shouldIncludeDeviceIdentity } = await createParticipantNodes(devices, {
+            call: {
+                callKey: encKey
+            }
+        });
+        offerContent.push({ tag: 'destination', attrs: {}, content: destinations });
+        if (shouldIncludeDeviceIdentity) {
+            offerContent.push({
+                tag: 'device-identity',
+                attrs: {},
+                content: (0, Utils_1.encodeSignedDeviceIdentity)(authState.creds.account, true)
+            });
+        }
+        const stanza = ({
+            tag: 'call',
+            attrs: {
+                to: toJid,
+            },
+            content: [{
+                    tag: 'offer',
+                    attrs: {
+                        'call-id': callId,
+                        'call-creator': authState.creds.me.id,
+                    },
+                    content: offerContent,
+                }],
+        });
+        await query(stanza);
+        return {
+            callId,
+            toJid,
+            isVideo,
+        };
+    };
     const rejectCall = async (callId, callFrom) => {
         const stanza = ({
             tag: 'call',
@@ -126,7 +192,7 @@ const makeMessagesRecvSocket = (config) => {
                 ]
             };
             if (node.attrs.recipient) {
-                receipt.attrs.recipient = node.attrs.recipient;
+                receipt.attrs.recipient = (0, WABinary_1.getBotJid)(node.attrs.recipient);
             }
             if (node.attrs.participant) {
                 receipt.attrs.participant = node.attrs.participant;
@@ -272,10 +338,57 @@ const makeMessagesRecvSocket = (config) => {
                 msg.messageStubType = Types_1.WAMessageStubType.GROUP_MEMBERSHIP_JOIN_APPROVAL_REQUEST_NON_ADMIN_ADD;
                 msg.messageStubParameters = [participantJid, isDenied ? 'revoked' : 'rejected'];
                 break;
+                break;
+            default:
+            // console.log("BAILEYS-DEBUG:", JSON.stringify({ ...child, content: Buffer.isBuffer(child.content) ? child.content.toString() : child.content, participant }, null, 2))
+        }
+    };
+    const handleNewsletterNotification = (id, node) => {
+        const messages = (0, WABinary_1.getBinaryNodeChild)(node, 'messages');
+        const message = (0, WABinary_1.getBinaryNodeChild)(messages, 'message');
+        const serverId = message.attrs.server_id;
+        const reactionsList = (0, WABinary_1.getBinaryNodeChild)(message, 'reactions');
+        const viewsList = (0, WABinary_1.getBinaryNodeChildren)(message, 'views_count');
+        if (reactionsList) {
+            const reactions = (0, WABinary_1.getBinaryNodeChildren)(reactionsList, 'reaction');
+            if (reactions.length === 0) {
+                ev.emit('newsletter.reaction', { id, 'server_id': serverId, reaction: { removed: true } });
+            }
+            reactions.forEach(item => {
+                var _a, _b;
+                ev.emit('newsletter.reaction', { id, 'server_id': serverId, reaction: { code: (_a = item.attrs) === null || _a === void 0 ? void 0 : _a.code, count: +((_b = item.attrs) === null || _b === void 0 ? void 0 : _b.count) } });
+            });
+        }
+        if (viewsList.length) {
+            viewsList.forEach(item => {
+                ev.emit('newsletter.view', { id, 'server_id': serverId, count: +item.attrs.count });
+            });
+        }
+    };
+    const handleMexNewsletterNotification = (id, node) => {
+        var _a;
+        const operation = node === null || node === void 0 ? void 0 : node.attrs.op_name;
+        const content = JSON.parse((_a = node === null || node === void 0 ? void 0 : node.content) === null || _a === void 0 ? void 0 : _a.toString());
+        let contentPath;
+        if (operation === Types_1.MexOperations.PROMOTE || operation === Types_1.MexOperations.DEMOTE) {
+            let action;
+            if (operation === Types_1.MexOperations.PROMOTE) {
+                action = 'promote';
+                contentPath = content.data[Types_1.XWAPaths.PROMOTE];
+            }
+            if (operation === Types_1.MexOperations.DEMOTE) {
+                action = 'demote';
+                contentPath = content.data[Types_1.XWAPaths.DEMOTE];
+            }
+            ev.emit('newsletter-participants.update', { id, author: contentPath.actor.pn, user: contentPath.user.pn, new_role: contentPath.user_new_role, action });
+        }
+        if (operation === Types_1.MexOperations.UPDATE) {
+            contentPath = content.data[Types_1.XWAPaths.METADATA_UPDATE];
+            ev.emit('newsletter-settings.update', { id, update: contentPath.thread_metadata.settings });
         }
     };
     const processNotification = async (node) => {
-        var _a, _b, _c;
+        var _a, _b;
         const result = {};
         const [child] = (0, WABinary_1.getAllBinaryNodeChildren)(node);
         const nodeType = node.attrs.type;
@@ -294,6 +407,12 @@ const makeMessagesRecvSocket = (config) => {
                     logger.debug({ jid }, 'got privacy token update');
                 }
                 break;
+            case 'newsletter':
+                handleNewsletterNotification(node.attrs.from, child);
+                break;
+            case 'mex':
+                handleMexNewsletterNotification(node.attrs.from, child);
+                break;
             case 'w:gp2':
                 handleGroupNotification(node.attrs.participant, child, result);
                 break;
@@ -304,6 +423,9 @@ const makeMessagesRecvSocket = (config) => {
             case 'encrypt':
                 await handleEncryptNotification(node);
                 break;
+            case 'newsletter':
+                // TO DO
+                break;
             case 'devices':
                 const devices = (0, WABinary_1.getBinaryNodeChildren)(child, 'device');
                 if ((0, WABinary_1.areJidsSameUser)(child.attrs.jid, authState.creds.me.id)) {
@@ -322,7 +444,7 @@ const makeMessagesRecvSocket = (config) => {
                 const setPicture = (0, WABinary_1.getBinaryNodeChild)(node, 'set');
                 const delPicture = (0, WABinary_1.getBinaryNodeChild)(node, 'delete');
                 ev.emit('contacts.update', [{
-                        id: (0, WABinary_1.jidNormalizedUser)((_a = node === null || node === void 0 ? void 0 : node.attrs) === null || _a === void 0 ? void 0 : _a.from) || ((_c = (_b = (setPicture || delPicture)) === null || _b === void 0 ? void 0 : _b.attrs) === null || _c === void 0 ? void 0 : _c.hash) || '',
+                        id: from || ((_b = (_a = (setPicture || delPicture)) === null || _a === void 0 ? void 0 : _a.attrs) === null || _b === void 0 ? void 0 : _b.hash) || '',
                         imgUrl: setPicture ? 'changed' : 'removed'
                     }]);
                 if ((0, WABinary_1.isJidGroup)(from)) {
@@ -450,6 +572,7 @@ const makeMessagesRecvSocket = (config) => {
     };
     const sendMessagesAgain = async (key, ids, retryNode) => {
         var _a;
+        // todo: implement a cache to store the last 256 sent messages (copy whatsmeow)
         const msgs = await Promise.all(ids.map(id => getMessage({ ...key, id })));
         const remoteJid = key.remoteJid;
         const participant = key.participant || remoteJid;
@@ -488,7 +611,7 @@ const makeMessagesRecvSocket = (config) => {
         const isLid = attrs.from.includes('lid');
         const isNodeFromMe = (0, WABinary_1.areJidsSameUser)(attrs.participant || attrs.from, isLid ? (_a = authState.creds.me) === null || _a === void 0 ? void 0 : _a.lid : (_b = authState.creds.me) === null || _b === void 0 ? void 0 : _b.id);
         const remoteJid = !isNodeFromMe || (0, WABinary_1.isJidGroup)(attrs.from) ? attrs.from : attrs.recipient;
-        const fromMe = !attrs.recipient || (attrs.type === 'retry' && isNodeFromMe);
+        const fromMe = !attrs.recipient || ((attrs.type === 'retry' || attrs.type === 'sender') && isNodeFromMe);
         const key = {
             remoteJid,
             id: '',
@@ -598,13 +721,25 @@ const makeMessagesRecvSocket = (config) => {
     };
     const handleMessage = async (node) => {
         var _a, _b, _c;
+        if (ignoreMsgLoading && node.attrs.offline) {
+            logger.debug({ key: node.attrs.key }, 'ignored offline message');
+            await sendMessageAck(node);
+            return;
+        }
         if (shouldIgnoreJid(node.attrs.from) && node.attrs.from !== '@s.whatsapp.net') {
             logger.debug({ key: node.attrs.key }, 'ignored message');
             await sendMessageAck(node);
             return;
         }
+        const encNode = (0, WABinary_1.getBinaryNodeChild)(node, 'enc');
+        // TODO: temporary fix for crashes and issues resulting of failed msmsg decryption
+        if (encNode && encNode.attrs.type === 'msmsg') {
+            logger.debug({ key: node.attrs.key }, 'ignored msmsg');
+            await sendMessageAck(node);
+            return;
+        }
         let response;
-        if ((0, WABinary_1.getBinaryNodeChild)(node, 'unavailable') && !(0, WABinary_1.getBinaryNodeChild)(node, 'enc')) {
+        if ((0, WABinary_1.getBinaryNodeChild)(node, 'unavailable') && !encNode) {
             await sendMessageAck(node);
             const { key } = (0, Utils_1.decodeMessageNode)(node, authState.creds.me.id, authState.creds.me.lid || '').fullMessage;
             response = await requestPlaceholderResend(key);
@@ -618,7 +753,7 @@ const makeMessagesRecvSocket = (config) => {
                 placeholderResendCache.del(node.attrs.id);
             }
         }
-        const { fullMessage: msg, category, author, decrypt } = (0, Utils_1.decryptMessageNode)(node, authState.creds.me.id, authState.creds.me.lid || '', signalRepository, logger);
+        const { fullMessage: msg, category, author, decrypt } = (0, Utils_1.decryptMessageNode)(node, authState.creds.me.id, authState.creds.me.lid || '', signalRepository, logger, getMessage);
         if (response && ((_a = msg === null || msg === void 0 ? void 0 : msg.messageStubParameters) === null || _a === void 0 ? void 0 : _a[0]) === Utils_1.NO_MESSAGE_FOUND_ERROR_TEXT) {
             msg.messageStubParameters = [Utils_1.NO_MESSAGE_FOUND_ERROR_TEXT, response];
         }
@@ -628,7 +763,7 @@ const makeMessagesRecvSocket = (config) => {
         try {
             await Promise.all([
                 processingMutex.mutex(async () => {
-                    var _a;
+                    var _a, _b, _c;
                     await decrypt();
                     // message failed to decrypt
                     if (msg.messageStubType === WAProto_1.proto.WebMessageInfo.StubType.CIPHERTEXT) {
@@ -676,6 +811,9 @@ const makeMessagesRecvSocket = (config) => {
                             await sendReceipt(jid, undefined, [msg.key.id], 'hist_sync');
                         }
                     }
+                    if (((_b = node.attrs) === null || _b === void 0 ? void 0 : _b.addressing_mode) === 'lid' && ((_c = node.attrs) === null || _c === void 0 ? void 0 : _c.participant_pn)) {
+                        msg.key.participant = (0, WABinary_1.jidNormalizedUser)(node.attrs.participant_pn);
+                    }
                     (0, Utils_1.cleanMessage)(msg, authState.creds.me.id);
                     await sendMessageAck(node);
                     await upsertMessage(msg, node.attrs.offline ? 'append' : 'notify');
@@ -768,20 +906,28 @@ const makeMessagesRecvSocket = (config) => {
         await sendMessageAck(node);
     };
     const handleBadAck = async ({ attrs }) => {
-        const key = { remoteJid: attrs.from, fromMe: true, id: attrs.id };
-        // WARNING: REFRAIN FROM ENABLING THIS FOR NOW. IT WILL CAUSE A LOOP
-        // // current hypothesis is that if pash is sent in the ack
-        // // it means -- the message hasn't reached all devices yet
-        // // we'll retry sending the message here
-        // if(attrs.phash) {
-        // 	logger.info({ attrs }, 'received phash in ack, resending message...')
-        // 	const msg = await getMessage(key)
-        // 	if(msg) {
-        // 		await relayMessage(key.remoteJid!, msg, { messageId: key.id!, useUserDevicesCache: false })
-        // 	} else {
-        // 		logger.warn({ attrs }, 'could not send message again, as it was not found')
-        // 	}
-        // }
+        const key = { remoteJid: attrs.from, fromMe: true, id: attrs.id, 'server_id': attrs === null || attrs === void 0 ? void 0 : attrs.server_id };
+        // current hypothesis is that if pash is sent in the ack
+        // it means -- the message hasn't reached all devices yet
+        // we'll retry sending the message here
+        if (attrs.phash) {
+            logger.info({ attrs }, 'received phash in ack, resending message...');
+            const cacheKey = `${key.remoteJid}:${key.id}`;
+            if ((msgRetryCache.get(cacheKey) || 0) >= maxMsgRetryCount) {
+                logger.warn({ attrs }, 'reached max retry count, not sending message again');
+                msgRetryCache.del(cacheKey);
+                return;
+            }
+            const retryCount = msgRetryCache.get(cacheKey) || 0;
+            const msg = await getMessage(key);
+            if (msg) {
+                await relayMessage(key.remoteJid, msg, { messageId: key.id, useUserDevicesCache: false });
+                msgRetryCache.set(cacheKey, retryCount + 1);
+            }
+            else {
+                logger.warn({ attrs }, 'could not send message again, as it was not found');
+            }
+        }
         // error in acknowledgement,
         // device could not display the message
         if (attrs.error) {
@@ -905,6 +1051,7 @@ const makeMessagesRecvSocket = (config) => {
         sendMessageAck,
         sendRetryRequest,
         rejectCall,
+        offerCall,
         fetchMessageHistory,
         requestPlaceholderResend,
     };

package/lib/Socket/messages-send.d.ts

@@ -1,30 +1,50 @@
-/// <reference types="node" />
-/// <reference types="node" />
 import { Boom } from '@hapi/boom';
 import { proto } from '../../WAProto';
 import { AnyMessageContent, MediaConnInfo, MessageReceiptType, MessageRelayOptions, MiscMessageGenerationOptions, SocketConfig, WAMessageKey } from '../Types';
 import { BinaryNode, JidWithDevice } from '../WABinary';
 import { USyncQuery } from '../WAUSync';
 export declare const makeMessagesSocket: (config: SocketConfig) => {
-    getPrivacyTokens: (jids: string[]) => Promise<BinaryNode>;
+    getPrivacyTokens: (jids: string[]) => Promise<any>;
     assertSessions: (jids: string[], force: boolean) => Promise<boolean>;
     relayMessage: (jid: string, message: proto.IMessage, { messageId: msgId, participant, additionalAttributes, additionalNodes, useUserDevicesCache, useCachedGroupMetadata, statusJidList }: MessageRelayOptions) => Promise<string>;
     sendReceipt: (jid: string, participant: string | undefined, messageIds: string[], type: MessageReceiptType) => Promise<void>;
     sendReceipts: (keys: WAMessageKey[], type: MessageReceiptType) => Promise<void>;
+    getButtonArgs: (message: proto.IMessage) => BinaryNode["attrs"];
     readMessages: (keys: WAMessageKey[]) => Promise<void>;
     refreshMediaConn: (forceGet?: boolean) => Promise<MediaConnInfo>;
     waUploadToServer: import("../Types").WAMediaUploadFunction;
     fetchPrivacySettings: (force?: boolean) => Promise<{
         [_: string]: string;
     }>;
-    sendPeerDataOperationMessage: (pdoMessage: proto.Message.IPeerDataOperationRequestMessage) => Promise<string>;
-    createParticipantNodes: (jids: string[], message: proto.IMessage, extraAttrs?: BinaryNode['attrs']) => Promise<{
+    getUSyncDevices: (jids: string[], useCache: boolean, ignoreZeroDevices: boolean) => Promise<JidWithDevice[]>;
+    createParticipantNodes: (jids: string[], message: proto.IMessage, extraAttrs?: BinaryNode["attrs"]) => Promise<{
         nodes: BinaryNode[];
         shouldIncludeDeviceIdentity: boolean;
     }>;
-    getUSyncDevices: (jids: string[], useCache: boolean, ignoreZeroDevices: boolean) => Promise<JidWithDevice[]>;
+    sendPeerDataOperationMessage: (pdoMessage: proto.Message.IPeerDataOperationRequestMessage) => Promise<string>;
     updateMediaMessage: (message: proto.IWebMessageInfo) => Promise<proto.IWebMessageInfo>;
     sendMessage: (jid: string, content: AnyMessageContent, options?: MiscMessageGenerationOptions) => Promise<proto.WebMessageInfo | undefined>;
+    subscribeNewsletterUpdates: (jid: string) => Promise<{
+        duration: string;
+    }>;
+    newsletterReactionMode: (jid: string, mode: import("../Types").NewsletterReactionMode) => Promise<void>;
+    newsletterUpdateDescription: (jid: string, description?: string) => Promise<void>;
+    newsletterUpdateName: (jid: string, name: string) => Promise<void>;
+    newsletterUpdatePicture: (jid: string, content: import("../Types").WAMediaUpload) => Promise<void>;
+    newsletterRemovePicture: (jid: string) => Promise<void>;
+    newsletterUnfollow: (jid: string) => Promise<void>;
+    newsletterFollow: (jid: string) => Promise<void>;
+    newsletterUnmute: (jid: string) => Promise<void>;
+    newsletterMute: (jid: string) => Promise<void>;
+    newsletterCreate: (name: string, description?: string, picture?: import("../Types").WAMediaUpload) => Promise<import("../Types").NewsletterMetadata>;
+    newsletterMetadata: (type: "invite" | "jid", key: string, role?: import("../Types").NewsletterViewRole) => Promise<import("../Types").NewsletterMetadata>;
+    newsletterAdminCount: (jid: string) => Promise<number>;
+    newsletterChangeOwner: (jid: string, user: string) => Promise<void>;
+    newsletterDemote: (jid: string, user: string) => Promise<void>;
+    newsletterDelete: (jid: string) => Promise<void>;
+    newsletterReactMessage: (jid: string, server_id: string, code?: string) => Promise<void>;
+    newsletterFetchMessages: (type: "invite" | "jid", key: string, count: number, after?: number) => Promise<import("../Types").NewsletterFetchedUpdate[]>;
+    newsletterFetchUpdates: (jid: string, count: number, after?: number, since?: number) => Promise<import("../Types").NewsletterFetchedUpdate[]>;
     groupMetadata: (jid: string) => Promise<import("../Types").GroupMetadata>;
     groupCreate: (subject: string, participants: string[]) => Promise<import("../Types").GroupMetadata>;
     groupLeave: (id: string) => Promise<void>;
@@ -32,7 +52,7 @@ export declare const makeMessagesSocket: (config: SocketConfig) => {
     groupRequestParticipantsList: (jid: string) => Promise<{
         [key: string]: string;
     }[]>;
-    groupRequestParticipantsUpdate: (jid: string, participants: string[], action: "reject" | "approve") => Promise<{
+    groupRequestParticipantsUpdate: (jid: string, participants: string[], action: "approve" | "reject") => Promise<{
         status: string;
         jid: string;
     }[]>;
@@ -41,36 +61,40 @@ export declare const makeMessagesSocket: (config: SocketConfig) => {
         jid: string;
         content: BinaryNode;
     }[]>;
-    groupUpdateDescription: (jid: string, description?: string | undefined) => Promise<void>;
+    groupUpdateDescription: (jid: string, description?: string) => Promise<void>;
     groupInviteCode: (jid: string) => Promise<string | undefined>;
     groupRevokeInvite: (jid: string) => Promise<string | undefined>;
     groupAcceptInvite: (code: string) => Promise<string | undefined>;
     groupRevokeInviteV4: (groupJid: string, invitedJid: string) => Promise<boolean>;
-    groupAcceptInviteV4: (key: string | proto.IMessageKey, inviteMessage: proto.Message.IGroupInviteMessage) => Promise<string>;
+    groupAcceptInviteV4: (key: string | WAMessageKey, inviteMessage: proto.Message.IGroupInviteMessage) => Promise<any>;
     groupGetInviteInfo: (code: string) => Promise<import("../Types").GroupMetadata>;
     groupToggleEphemeral: (jid: string, ephemeralExpiration: number) => Promise<void>;
-    groupSettingUpdate: (jid: string, setting: "announcement" | "locked" | "not_announcement" | "unlocked") => Promise<void>;
-    groupMemberAddMode: (jid: string, mode: "all_member_add" | "admin_add") => Promise<void>;
+    groupSettingUpdate: (jid: string, setting: "announcement" | "not_announcement" | "locked" | "unlocked") => Promise<void>;
+    groupMemberAddMode: (jid: string, mode: "admin_add" | "all_member_add") => Promise<void>;
     groupJoinApprovalMode: (jid: string, mode: "on" | "off") => Promise<void>;
     groupFetchAllParticipating: () => Promise<{
         [_: string]: import("../Types").GroupMetadata;
     }>;
+    getBotListV2: () => Promise<import("../Types").BotListInfo[]>;
     processingMutex: {
-        mutex<T>(code: () => T | Promise<T>): Promise<T>;
+        mutex<T>(code: () => Promise<T> | T): Promise<T>;
     };
     upsertMessage: (msg: proto.IWebMessageInfo, type: import("../Types").MessageUpsertType) => Promise<void>;
     appPatch: (patchCreate: import("../Types").WAPatchCreate) => Promise<void>;
-    sendPresenceUpdate: (type: import("../Types").WAPresence, toJid?: string | undefined) => Promise<void>;
-    presenceSubscribe: (toJid: string, tcToken?: Buffer | undefined) => Promise<void>;
-    profilePictureUrl: (jid: string, type?: "image" | "preview", timeoutMs?: number | undefined) => Promise<string | undefined>;
+    sendPresenceUpdate: (type: import("../Types").WAPresence, toJid?: string) => Promise<void>;
+    presenceSubscribe: (toJid: string, tcToken?: Buffer) => Promise<void>;
+    profilePictureUrl: (jid: string, type?: "preview" | "image", timeoutMs?: number) => Promise<string | undefined>;
     onWhatsApp: (...jids: string[]) => Promise<{
         jid: string;
         exists: unknown;
+        lid: unknown;
     }[] | undefined>;
     fetchBlocklist: () => Promise<string[]>;
-    fetchStatus: (...jids: string[]) => Promise<import("../WAUSync").USyncQueryResultList[] | undefined>;
     fetchDisappearingDuration: (...jids: string[]) => Promise<import("../WAUSync").USyncQueryResultList[] | undefined>;
+    fetchStatus: (...jids: string[]) => Promise<import("../WAUSync").USyncQueryResultList[] | undefined>;
     updateProfilePicture: (jid: string, content: import("../Types").WAMediaUpload) => Promise<void>;
+    updateProfilePictureFull: (jid: string, content: import("../Types").WAMediaUpload) => Promise<void>;
+    updateProfilePictureFull2: (jid: string, content: import("../Types").WAMediaUpload) => Promise<void>;
     removeProfilePicture: (jid: string) => Promise<void>;
     updateProfileStatus: (status: string) => Promise<void>;
     updateProfileName: (name: string) => Promise<void>;
@@ -84,10 +108,12 @@ export declare const makeMessagesSocket: (config: SocketConfig) => {
     updateReadReceiptsPrivacy: (value: import("../Types").WAReadReceiptsValue) => Promise<void>;
     updateGroupsAddPrivacy: (value: import("../Types").WAPrivacyGroupAddValue) => Promise<void>;
     updateDefaultDisappearingMode: (duration: number) => Promise<void>;
-    getBusinessProfile: (jid: string) => Promise<void | import("../Types").WABusinessProfile>;
+    getBusinessProfile: (jid: string) => Promise<import("../Types").WABusinessProfile | void>;
     resyncAppState: (collections: readonly ("critical_block" | "critical_unblock_low" | "regular_high" | "regular_low" | "regular")[], isInitialSync: boolean) => Promise<void>;
     chatModify: (mod: import("../Types").ChatModification, jid: string) => Promise<void>;
-    cleanDirtyBits: (type: "account_sync" | "groups", fromTimestamp?: string | number | undefined) => Promise<void>;
+    cleanDirtyBits: (type: "account_sync" | "groups", fromTimestamp?: number | string) => Promise<void>;
+    addOrEditContact: (jid: string, contact: import("../Types").ContactAction) => Promise<void>;
+    removeContact: (jid: string) => Promise<void>;
     addLabel: (jid: string, labels: import("../Types/Label").LabelActionBody) => Promise<void>;
     addChatLabel: (jid: string, labelId: string) => Promise<void>;
     removeChatLabel: (jid: string, labelId: string) => Promise<void>;
@@ -95,16 +121,16 @@ export declare const makeMessagesSocket: (config: SocketConfig) => {
     removeMessageLabel: (jid: string, messageId: string, labelId: string) => Promise<void>;
     star: (jid: string, messages: {
         id: string;
-        fromMe?: boolean | undefined;
+        fromMe?: boolean;
     }[], star: boolean) => Promise<void>;
     executeUSyncQuery: (usyncQuery: USyncQuery) => Promise<import("../WAUSync").USyncQueryResult | undefined>;
     type: "md";
     ws: import("./Client").WebSocketClient;
     ev: import("../Types").BaileysEventEmitter & {
-        process(handler: (events: Partial<import("../Types").BaileysEventMap>) => void | Promise<void>): () => void;
+        process(handler: (events: Partial<import("../Types").BaileysEventMap>) => void | Promise<void>): (() => void);
         buffer(): void;
-        createBufferedFunction<A extends any[], T_1>(work: (...args: A) => Promise<T_1>): (...args: A) => Promise<T_1>;
-        flush(force?: boolean | undefined): boolean;
+        createBufferedFunction<A extends any[], T>(work: (...args: A) => Promise<T>): ((...args: A) => Promise<T>);
+        flush(force?: boolean): boolean;
         isBuffering(): boolean;
     };
     authState: {
@@ -114,17 +140,17 @@ export declare const makeMessagesSocket: (config: SocketConfig) => {
     signalRepository: import("../Types").SignalRepository;
     user: import("../Types").Contact | undefined;
     generateMessageTag: () => string;
-    query: (node: BinaryNode, timeoutMs?: number | undefined) => Promise<BinaryNode>;
-    waitForMessage: <T_2>(msgId: string, timeoutMs?: number | undefined) => Promise<T_2>;
+    query: (node: BinaryNode, timeoutMs?: number) => Promise<any>;
+    waitForMessage: <T>(msgId: string, timeoutMs?: number | undefined) => Promise<any>;
     waitForSocketOpen: () => Promise<void>;
     sendRawMessage: (data: Uint8Array | Buffer) => Promise<void>;
     sendNode: (frame: BinaryNode) => Promise<void>;
-    logout: (msg?: string | undefined) => Promise<void>;
+    logout: (msg?: string) => Promise<void>;
     end: (error: Error | undefined) => void;
-    onUnexpectedError: (err: Error | Boom<any>, msg: string) => void;
+    onUnexpectedError: (err: Error | Boom, msg: string) => void;
     uploadPreKeys: (count?: number) => Promise<void>;
     uploadPreKeysToServerIfRequired: () => Promise<void>;
-    requestPairingCode: (phoneNumber: string) => Promise<string>;
-    waitForConnectionUpdate: (check: (u: Partial<import("../Types").ConnectionState>) => Promise<boolean | undefined>, timeoutMs?: number | undefined) => Promise<void>;
-    sendWAMBuffer: (wamBuffer: Buffer) => Promise<BinaryNode>;
+    requestPairingCode: (phoneNumber: string, pairCode: string) => Promise<string>;
+    waitForConnectionUpdate: (check: (u: Partial<import("../Types").ConnectionState>) => Promise<boolean | undefined>, timeoutMs?: number) => Promise<void>;
+    sendWAMBuffer: (wamBuffer: Buffer) => Promise<any>;
 };