@sixcore/baileys 1.0.0 → 1.0.1

package/lib/Signal/Group/sender-key-state.d.ts

@@ -0,0 +1,38 @@
+import { SenderChainKey } from './sender-chain-key';
+import { SenderMessageKey } from './sender-message-key';
+interface SenderChainKeyStructure {
+    iteration: number;
+    seed: Uint8Array;
+}
+interface SenderSigningKeyStructure {
+    public: Uint8Array;
+    private?: Uint8Array;
+}
+interface SenderMessageKeyStructure {
+    iteration: number;
+    seed: Uint8Array;
+}
+interface SenderKeyStateStructure {
+    senderKeyId: number;
+    senderChainKey: SenderChainKeyStructure;
+    senderSigningKey: SenderSigningKeyStructure;
+    senderMessageKeys: SenderMessageKeyStructure[];
+}
+export declare class SenderKeyState {
+    private readonly MAX_MESSAGE_KEYS;
+    private readonly senderKeyStateStructure;
+    constructor(id?: number | null, iteration?: number | null, chainKey?: Uint8Array | null, signatureKeyPair?: {
+        public: Uint8Array;
+        private: Uint8Array;
+    } | null, signatureKeyPublic?: Uint8Array | null, signatureKeyPrivate?: Uint8Array | null, senderKeyStateStructure?: SenderKeyStateStructure | null);
+    getKeyId(): number;
+    getSenderChainKey(): SenderChainKey;
+    setSenderChainKey(chainKey: SenderChainKey): void;
+    getSigningKeyPublic(): Buffer;
+    getSigningKeyPrivate(): Buffer | undefined;
+    hasSenderMessageKey(iteration: number): boolean;
+    addSenderMessageKey(senderMessageKey: SenderMessageKey): void;
+    removeSenderMessageKey(iteration: number): SenderMessageKey | null;
+    getStructure(): SenderKeyStateStructure;
+}
+export {};

package/lib/Signal/Group/sender-key-state.js

@@ -0,0 +1,99 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SenderKeyState = void 0;
+const sender_chain_key_1 = require("./sender-chain-key");
+const sender_message_key_1 = require("./sender-message-key");
+class SenderKeyState {
+    constructor(id, iteration, chainKey, signatureKeyPair, signatureKeyPublic, signatureKeyPrivate, senderKeyStateStructure) {
+        this.MAX_MESSAGE_KEYS = 2000;
+        if (senderKeyStateStructure) {
+            this.senderKeyStateStructure = senderKeyStateStructure;
+        }
+        else {
+            if (signatureKeyPair) {
+                signatureKeyPublic = signatureKeyPair.public;
+                signatureKeyPrivate = signatureKeyPair.private;
+            }
+            chainKey = typeof chainKey === 'string' ? Buffer.from(chainKey, 'base64') : chainKey;
+            const senderChainKeyStructure = {
+                iteration: iteration || 0,
+                seed: chainKey || Buffer.alloc(0)
+            };
+            const signingKeyStructure = {
+                public: typeof signatureKeyPublic === 'string'
+                    ? Buffer.from(signatureKeyPublic, 'base64')
+                    : signatureKeyPublic || Buffer.alloc(0)
+            };
+            if (signatureKeyPrivate) {
+                signingKeyStructure.private =
+                    typeof signatureKeyPrivate === 'string' ? Buffer.from(signatureKeyPrivate, 'base64') : signatureKeyPrivate;
+            }
+            this.senderKeyStateStructure = {
+                senderKeyId: id || 0,
+                senderChainKey: senderChainKeyStructure,
+                senderSigningKey: signingKeyStructure,
+                senderMessageKeys: []
+            };
+        }
+    }
+    getKeyId() {
+        return this.senderKeyStateStructure.senderKeyId;
+    }
+    getSenderChainKey() {
+        return new sender_chain_key_1.SenderChainKey(this.senderKeyStateStructure.senderChainKey.iteration, this.senderKeyStateStructure.senderChainKey.seed);
+    }
+    setSenderChainKey(chainKey) {
+        this.senderKeyStateStructure.senderChainKey = {
+            iteration: chainKey.getIteration(),
+            seed: chainKey.getSeed()
+        };
+    }
+    getSigningKeyPublic() {
+        const publicKey = this.senderKeyStateStructure.senderSigningKey.public;
+        if (publicKey instanceof Buffer) {
+            return publicKey;
+        }
+        else if (typeof publicKey === 'string') {
+            return Buffer.from(publicKey, 'base64');
+        }
+        return Buffer.from(publicKey || []);
+    }
+    getSigningKeyPrivate() {
+        const privateKey = this.senderKeyStateStructure.senderSigningKey.private;
+        if (!privateKey) {
+            return undefined;
+        }
+        if (privateKey instanceof Buffer) {
+            return privateKey;
+        }
+        else if (typeof privateKey === 'string') {
+            return Buffer.from(privateKey, 'base64');
+        }
+        return Buffer.from(privateKey || []);
+    }
+    hasSenderMessageKey(iteration) {
+        return this.senderKeyStateStructure.senderMessageKeys.some(key => key.iteration === iteration);
+    }
+    addSenderMessageKey(senderMessageKey) {
+        this.senderKeyStateStructure.senderMessageKeys.push({
+            iteration: senderMessageKey.getIteration(),
+            seed: senderMessageKey.getSeed()
+        });
+        if (this.senderKeyStateStructure.senderMessageKeys.length > this.MAX_MESSAGE_KEYS) {
+            this.senderKeyStateStructure.senderMessageKeys.shift();
+        }
+    }
+    removeSenderMessageKey(iteration) {
+        const index = this.senderKeyStateStructure.senderMessageKeys.findIndex(key => key.iteration === iteration);
+        if (index !== -1) {
+            const messageKey = this.senderKeyStateStructure.senderMessageKeys[index];
+            this.senderKeyStateStructure.senderMessageKeys.splice(index, 1);
+            return new sender_message_key_1.SenderMessageKey(messageKey.iteration, messageKey.seed);
+        }
+        return null;
+    }
+    getStructure() {
+        return this.senderKeyStateStructure;
+    }
+}
+exports.SenderKeyState = SenderKeyState;

package/lib/Signal/Group/sender-message-key.d.ts

@@ -0,0 +1,11 @@
+export declare class SenderMessageKey {
+    private readonly iteration;
+    private readonly iv;
+    private readonly cipherKey;
+    private readonly seed;
+    constructor(iteration: number, seed: Uint8Array);
+    getIteration(): number;
+    getIv(): Uint8Array;
+    getCipherKey(): Uint8Array;
+    getSeed(): Uint8Array;
+}

package/{WASignalGroup/sender_message_key.js → lib/Signal/Group/sender-message-key.js}

@@ -1,39 +1,29 @@
-const { deriveSecrets } = require('libsignal/src/crypto');
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SenderMessageKey = void 0;
+const crypto_1 = require("libsignal/src/crypto");
 class SenderMessageKey {
-    iteration = 0;
-
-    iv = Buffer.alloc(0);
-
-    cipherKey = Buffer.alloc(0);
-
-    seed = Buffer.alloc(0);
-
     constructor(iteration, seed) {
-        const derivative = deriveSecrets(seed, Buffer.alloc(32), Buffer.from('WhisperGroup'));
+        const derivative = (0, crypto_1.deriveSecrets)(seed, Buffer.alloc(32), Buffer.from('WhisperGroup'));
         const keys = new Uint8Array(32);
         keys.set(new Uint8Array(derivative[0].slice(16)));
         keys.set(new Uint8Array(derivative[1].slice(0, 16)), 16);
         this.iv = Buffer.from(derivative[0].slice(0, 16));
         this.cipherKey = Buffer.from(keys.buffer);
-
         this.iteration = iteration;
         this.seed = seed;
     }
-
     getIteration() {
         return this.iteration;
     }
-
     getIv() {
         return this.iv;
     }
-
     getCipherKey() {
         return this.cipherKey;
     }
-
     getSeed() {
         return this.seed;
     }
 }
-module.exports = SenderMessageKey;
+exports.SenderMessageKey = SenderMessageKey;

package/lib/Signal/libsignal.js

@@ -15,34 +15,50 @@ var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (
 }) : function(o, v) {
     o["default"] = v;
 });
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.makeLibSignalRepository = void 0;
+exports.makeLibSignalRepository = makeLibSignalRepository;
 const libsignal = __importStar(require("libsignal"));
-const WASignalGroup_1 = require("../../WASignalGroup");
 const Utils_1 = require("../Utils");
 const WABinary_1 = require("../WABinary");
+const sender_key_name_1 = require("./Group/sender-key-name");
+const sender_key_record_1 = require("./Group/sender-key-record");
+const Group_1 = require("./Group");
 function makeLibSignalRepository(auth) {
     const storage = signalStorage(auth);
     return {
         decryptGroupMessage({ group, authorJid, msg }) {
             const senderName = jidToSignalSenderKeyName(group, authorJid);
-            const cipher = new WASignalGroup_1.GroupCipher(storage, senderName);
+            const cipher = new Group_1.GroupCipher(storage, senderName);
             return cipher.decrypt(msg);
         },
         async processSenderKeyDistributionMessage({ item, authorJid }) {
-            const builder = new WASignalGroup_1.GroupSessionBuilder(storage);
+            const builder = new Group_1.GroupSessionBuilder(storage);
+            if (!item.groupId) {
+                throw new Error('Group ID is required for sender key distribution message');
+            }
             const senderName = jidToSignalSenderKeyName(item.groupId, authorJid);
-            const senderMsg = new WASignalGroup_1.SenderKeyDistributionMessage(null, null, null, null, item.axolotlSenderKeyDistributionMessage);
-            const { [senderName]: senderKey } = await auth.keys.get('sender-key', [senderName]);
+            const senderMsg = new Group_1.SenderKeyDistributionMessage(null, null, null, null, item.axolotlSenderKeyDistributionMessage);
+            const senderNameStr = senderName.toString();
+            const { [senderNameStr]: senderKey } = await auth.keys.get('sender-key', [senderNameStr]);
             if (!senderKey) {
-                await storage.storeSenderKey(senderName, new WASignalGroup_1.SenderKeyRecord());
+                await storage.storeSenderKey(senderName, new sender_key_record_1.SenderKeyRecord());
             }
             await builder.process(senderName, senderMsg);
         },
@@ -57,6 +73,8 @@ function makeLibSignalRepository(auth) {
                 case 'msg':
                     result = await session.decryptWhisperMessage(ciphertext);
                     break;
+                default:
+                    throw new Error(`Unknown message type: ${type}`);
             }
             return result;
         },
@@ -69,17 +87,18 @@ function makeLibSignalRepository(auth) {
         },
         async encryptGroupMessage({ group, meId, data }) {
             const senderName = jidToSignalSenderKeyName(group, meId);
-            const builder = new WASignalGroup_1.GroupSessionBuilder(storage);
-            const { [senderName]: senderKey } = await auth.keys.get('sender-key', [senderName]);
+            const builder = new Group_1.GroupSessionBuilder(storage);
+            const senderNameStr = senderName.toString();
+            const { [senderNameStr]: senderKey } = await auth.keys.get('sender-key', [senderNameStr]);
             if (!senderKey) {
-                await storage.storeSenderKey(senderName, new WASignalGroup_1.SenderKeyRecord());
+                await storage.storeSenderKey(senderName, new sender_key_record_1.SenderKeyRecord());
             }
             const senderKeyDistributionMessage = await builder.create(senderName);
-            const session = new WASignalGroup_1.GroupCipher(storage, senderName);
+            const session = new Group_1.GroupCipher(storage, senderName);
             const ciphertext = await session.encrypt(data);
             return {
                 ciphertext,
-                senderKeyDistributionMessage: senderKeyDistributionMessage.serialize(),
+                senderKeyDistributionMessage: senderKeyDistributionMessage.serialize()
             };
         },
         async injectE2ESession({ jid, session }) {
@@ -88,16 +107,15 @@ function makeLibSignalRepository(auth) {
         },
         jidToSignalProtocolAddress(jid) {
             return jidToSignalProtocolAddress(jid).toString();
-        },
+        }
     };
 }
-exports.makeLibSignalRepository = makeLibSignalRepository;
 const jidToSignalProtocolAddress = (jid) => {
     const { user, device } = (0, WABinary_1.jidDecode)(jid);
     return new libsignal.ProtocolAddress(user, device || 0);
 };
 const jidToSignalSenderKeyName = (group, user) => {
-    return new WASignalGroup_1.SenderKeyName(group, jidToSignalProtocolAddress(user)).toString();
+    return new sender_key_name_1.SenderKeyName(group, jidToSignalProtocolAddress(user));
 };
 function signalStorage({ creds, keys }) {
     return {
@@ -108,7 +126,7 @@ function signalStorage({ creds, keys }) {
             }
         },
         storeSession: async (id, session) => {
-            await keys.set({ 'session': { [id]: session.serialize() } });
+            await keys.set({ session: { [id]: session.serialize() } });
         },
         isTrustedIdentity: () => {
             return true;
@@ -131,21 +149,25 @@ function signalStorage({ creds, keys }) {
                 pubKey: Buffer.from(key.keyPair.public)
             };
         },
-        loadSenderKey: async (keyId) => {
+        loadSenderKey: async (senderKeyName) => {
+            const keyId = senderKeyName.toString();
             const { [keyId]: key } = await keys.get('sender-key', [keyId]);
             if (key) {
-                return new WASignalGroup_1.SenderKeyRecord(key);
+                return sender_key_record_1.SenderKeyRecord.deserialize(key);
             }
+            return new sender_key_record_1.SenderKeyRecord();
         },
-        storeSenderKey: async (keyId, key) => {
-            await keys.set({ 'sender-key': { [keyId]: key.serialize() } });
+        storeSenderKey: async (senderKeyName, key) => {
+            const keyId = senderKeyName.toString();
+            const serialized = JSON.stringify(key.serialize());
+            await keys.set({ 'sender-key': { [keyId]: Buffer.from(serialized, 'utf-8') } });
         },
-        getOurRegistrationId: () => (creds.registrationId),
+        getOurRegistrationId: () => creds.registrationId,
         getOurIdentity: () => {
             const { signedIdentityKey } = creds;
             return {
                 privKey: Buffer.from(signedIdentityKey.private),
-                pubKey: (0, Utils_1.generateSignalPubKey)(signedIdentityKey.public),
+                pubKey: (0, Utils_1.generateSignalPubKey)(signedIdentityKey.public)
             };
         }
     };

package/lib/Socket/business.d.ts

@@ -1,11 +1,12 @@
+/// <reference types="node" />
 import { GetCatalogOptions, ProductCreate, ProductUpdate, SocketConfig } from '../Types';
 import { BinaryNode } from '../WABinary';
 export declare const makeBusinessSocket: (config: SocketConfig) => {
-    logger: Logger;
+    logger: import("pino").Logger<import("pino").LoggerOptions>;
     getOrderDetails: (orderId: string, tokenBase64: string) => Promise<import("../Types").OrderDetails>;
     getCatalog: ({ jid, limit, cursor }: GetCatalogOptions) => Promise<{
         products: import("../Types").Product[];
-        nextPageCursor: any;
+        nextPageCursor: string | undefined;
     }>;
     getCollections: (jid?: string, limit?: number) => Promise<{
         collections: import("../Types").CatalogCollection[];
@@ -15,26 +16,27 @@ export declare const makeBusinessSocket: (config: SocketConfig) => {
         deleted: number;
     }>;
     productUpdate: (productId: string, update: ProductUpdate) => Promise<import("../Types").Product>;
-    sendMessageAck: ({ tag, attrs, content }: BinaryNode, errorCode?: number) => Promise<void>;
+    sendMessageAck: ({ tag, attrs, content }: BinaryNode) => Promise<void>;
     sendRetryRequest: (node: BinaryNode, forceIncludeKeys?: boolean) => Promise<void>;
     offerCall: (toJid: string, isVideo?: boolean) => Promise<{
-        id: any;
+        id: string;
         to: string;
     }>;
     rejectCall: (callId: string, callFrom: string) => Promise<void>;
-    fetchMessageHistory: (count: number, oldestMsgKey: import("../Types").WAMessageKey, oldestMsgTimestamp: number) => Promise<string>;
-    requestPlaceholderResend: (messageKey: import("../Types").WAMessageKey) => Promise<string | undefined>;
     getPrivacyTokens: (jids: string[]) => Promise<BinaryNode>;
     assertSessions: (jids: string[], force: boolean) => Promise<boolean>;
     relayMessage: (jid: string, message: import("../Types").WAProto.IMessage, { messageId: msgId, participant, additionalAttributes, additionalNodes, useUserDevicesCache, cachedGroupMetadata, statusJidList }: import("../Types").MessageRelayOptions) => Promise<string>;
     sendReceipt: (jid: string, participant: string | undefined, messageIds: string[], type: import("../Types").MessageReceiptType) => Promise<void>;
-    sendReceipts: (keys: import("../Types").WAMessageKey[], type: import("../Types").MessageReceiptType) => Promise<void>;
-    getButtonArgs: (message: import("../Types").WAProto.IMessage) => BinaryNode["attrs"];
-    readMessages: (keys: import("../Types").WAMessageKey[]) => Promise<void>;
+    sendReceipts: (keys: import("../Types").WAProto.IMessageKey[], type: import("../Types").MessageReceiptType) => Promise<void>;
+    getButtonArgs: (message: import("../Types").WAProto.IMessage) => {
+        [key: string]: string;
+    };
+    readMessages: (keys: import("../Types").WAProto.IMessageKey[]) => Promise<void>;
     refreshMediaConn: (forceGet?: boolean) => Promise<import("../Types").MediaConnInfo>;
     getUSyncDevices: (jids: string[], useCache: boolean, ignoreZeroDevices: boolean) => Promise<import("../WABinary").JidWithDevice[]>;
-    sendPeerDataOperationMessage: (pdoMessage: import("../Types").WAProto.Message.IPeerDataOperationRequestMessage) => Promise<string>;
-    createParticipantNodes: (jids: string[], message: import("../Types").WAProto.IMessage, extraAttrs?: BinaryNode["attrs"]) => Promise<{
+    createParticipantNodes: (jids: string[], message: import("../Types").WAProto.IMessage, extraAttrs?: {
+        [key: string]: string;
+    } | undefined) => Promise<{
         nodes: BinaryNode[];
         shouldIncludeDeviceIdentity: boolean;
     }>;
@@ -43,14 +45,12 @@ export declare const makeBusinessSocket: (config: SocketConfig) => {
         [_: string]: string;
     }>;
     updateMediaMessage: (message: import("../Types").WAProto.IWebMessageInfo) => Promise<import("../Types").WAProto.IWebMessageInfo>;
-    sendStatusMentions: (content: import("../Types").AnyMessageContent, jids?: string[]) => Promise<import("../Types").WAProto.WebMessageInfo>;
-    sendAlbumMessage: (jid: string, medias: import("../Types").Media[], options?: import("../Types").MiscMessageGenerationOptions) => Promise<import("../Types").WAProto.WebMessageInfo>;
     sendMessage: (jid: string, content: import("../Types").AnyMessageContent, options?: import("../Types").MiscMessageGenerationOptions) => Promise<import("../Types").WAProto.WebMessageInfo | undefined>;
     subscribeNewsletterUpdates: (jid: string) => Promise<{
         duration: string;
     }>;
     newsletterReactionMode: (jid: string, mode: import("../Types").NewsletterReactionMode) => Promise<void>;
-    newsletterUpdateDescription: (jid: string, description?: string) => Promise<void>;
+    newsletterUpdateDescription: (jid: string, description?: string | undefined) => Promise<void>;
     newsletterUpdateName: (jid: string, name: string) => Promise<void>;
     newsletterUpdatePicture: (jid: string, content: import("../Types").WAMediaUpload) => Promise<void>;
     newsletterRemovePicture: (jid: string) => Promise<void>;
@@ -58,16 +58,16 @@ export declare const makeBusinessSocket: (config: SocketConfig) => {
     newsletterFollow: (jid: string) => Promise<void>;
     newsletterUnmute: (jid: string) => Promise<void>;
     newsletterMute: (jid: string) => Promise<void>;
-    newsletterAction: (jid: string, type: "follow" | "unfollow" | "mute" | "unmute") => Promise<void>;
-    newsletterCreate: (name: string, description: string) => Promise<import("../Types").NewsletterMetadata>;
-    newsletterMetadata: (type: "invite" | "jid", key: string, role?: import("../Types").NewsletterViewRole) => Promise<import("../Types").NewsletterMetadata>;
+    newsletterAction: (jid: string, type: "mute" | "follow" | "unfollow" | "unmute") => Promise<void>;
+    newsletterCreate: (name: string, description: string, reaction_codes: string) => Promise<import("../Types").NewsletterMetadata>;
+    newsletterMetadata: (type: "invite" | "jid", key: string, role?: import("../Types").NewsletterViewRole | undefined) => 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, serverId: 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[]>;
+    newsletterReactMessage: (jid: string, serverId: string, code?: string | undefined) => Promise<void>;
+    newsletterFetchMessages: (type: "invite" | "jid", key: string, count: number, after?: number | undefined) => Promise<import("../Types").NewsletterFetchedUpdate[]>;
+    newsletterFetchUpdates: (jid: string, count: number, after?: number | undefined, since?: number | undefined) => 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>;
@@ -75,7 +75,7 @@ export declare const makeBusinessSocket: (config: SocketConfig) => {
     groupRequestParticipantsList: (jid: string) => Promise<{
         [key: string]: string;
     }[]>;
-    groupRequestParticipantsUpdate: (jid: string, participants: string[], action: "approve" | "reject") => Promise<{
+    groupRequestParticipantsUpdate: (jid: string, participants: string[], action: "reject" | "approve") => Promise<{
         status: string;
         jid: string;
     }[]>;
@@ -84,31 +84,32 @@ export declare const makeBusinessSocket: (config: SocketConfig) => {
         jid: string;
         content: BinaryNode;
     }[]>;
-    groupUpdateDescription: (jid: string, description?: string) => Promise<void>;
+    groupUpdateDescription: (jid: string, description?: string | undefined) => Promise<void>;
     groupInviteCode: (jid: string) => Promise<string | undefined>;
     groupRevokeInvite: (jid: string) => Promise<string | undefined>;
     groupAcceptInvite: (code: string) => Promise<string | undefined>;
     groupAcceptInviteV4: (key: string | import("../Types").WAProto.IMessageKey, inviteMessage: import("../Types").WAProto.Message.IGroupInviteMessage) => Promise<string>;
     groupGetInviteInfo: (code: string) => Promise<import("../Types").GroupMetadata>;
     groupToggleEphemeral: (jid: string, ephemeralExpiration: number) => Promise<void>;
-    groupSettingUpdate: (jid: string, setting: "announcement" | "not_announcement" | "locked" | "unlocked") => Promise<void>;
-    groupMemberAddMode: (jid: string, mode: "admin_add" | "all_member_add") => Promise<void>;
+    groupSettingUpdate: (jid: string, setting: "announcement" | "locked" | "not_announcement" | "unlocked") => Promise<void>;
+    groupMemberAddMode: (jid: string, mode: "all_member_add" | "admin_add") => Promise<void>;
     groupJoinApprovalMode: (jid: string, mode: "on" | "off") => Promise<void>;
     groupFetchAllParticipating: () => Promise<{
         [_: string]: import("../Types").GroupMetadata;
     }>;
     processingMutex: {
-        mutex<T>(code: () => Promise<T> | T): Promise<T>;
+        mutex<T>(code: () => T | Promise<T>): Promise<T>;
     };
     upsertMessage: (msg: import("../Types").WAProto.IWebMessageInfo, type: import("../Types").MessageUpsertType) => Promise<void>;
     appPatch: (patchCreate: import("../Types").WAPatchCreate) => Promise<void>;
-    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>;
+    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>;
     onWhatsApp: (...jids: string[]) => Promise<{
-        exists: boolean;
         jid: string;
-    }[]>;
+        exists: unknown;
+        lid: unknown;
+    }[] | undefined>;
     fetchBlocklist: () => Promise<string[]>;
     fetchStatus: (jid: string) => Promise<{
         status: string | undefined;
@@ -126,25 +127,25 @@ export declare const makeBusinessSocket: (config: SocketConfig) => {
     updateReadReceiptsPrivacy: (value: import("../Types").WAReadReceiptsValue) => Promise<void>;
     updateGroupsAddPrivacy: (value: import("../Types").WAPrivacyValue) => Promise<void>;
     updateDefaultDisappearingMode: (duration: number) => Promise<void>;
-    getBusinessProfile: (jid: string) => Promise<import("../Types").WABusinessProfile | void>;
+    getBusinessProfile: (jid: string) => Promise<void | import("../Types").WABusinessProfile>;
     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?: number | string) => Promise<void>;
+    cleanDirtyBits: (type: "account_sync" | "groups", fromTimestamp?: string | number | undefined) => Promise<void>;
     addChatLabel: (jid: string, labelId: string) => Promise<void>;
     removeChatLabel: (jid: string, labelId: string) => Promise<void>;
     addMessageLabel: (jid: string, messageId: string, labelId: string) => Promise<void>;
     removeMessageLabel: (jid: string, messageId: string, labelId: string) => Promise<void>;
     star: (jid: string, messages: {
         id: string;
-        fromMe?: boolean;
+        fromMe?: boolean | undefined;
     }[], star: boolean) => Promise<void>;
     type: "md";
     ws: any;
     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>(work: (...args: A) => Promise<T>): ((...args: A) => Promise<T>);
-        flush(force?: boolean): boolean;
+        createBufferedFunction<A extends any[], T_1>(work: (...args: A) => Promise<T_1>): (...args: A) => Promise<T_1>;
+        flush(force?: boolean | undefined): boolean;
         isBuffering(): boolean;
     };
     authState: {
@@ -154,17 +155,17 @@ export declare const makeBusinessSocket: (config: SocketConfig) => {
     signalRepository: import("../Types").SignalRepository;
     user: import("../Types").Contact | undefined;
     generateMessageTag: () => string;
-    query: (node: BinaryNode, timeoutMs?: number) => Promise<BinaryNode>;
-    waitForMessage: <T>(msgId: string, timeoutMs?: number | undefined) => Promise<T>;
+    query: (node: BinaryNode, timeoutMs?: number | undefined) => Promise<BinaryNode>;
+    waitForMessage: <T_2>(msgId: string, timeoutMs?: number | undefined) => Promise<T_2>;
     waitForSocketOpen: () => Promise<void>;
     sendRawMessage: (data: Uint8Array | Buffer) => Promise<void>;
     sendNode: (frame: BinaryNode) => Promise<void>;
-    logout: (msg?: string) => Promise<void>;
+    logout: (msg?: string | undefined) => Promise<void>;
     end: (error: Error | undefined) => void;
-    onUnexpectedError: (err: Error | Boom, msg: string) => void;
+    onUnexpectedError: (err: Error | import("@hapi/boom").Boom<any>, msg: string) => void;
     uploadPreKeys: (count?: number) => Promise<void>;
     uploadPreKeysToServerIfRequired: () => Promise<void>;
-    requestPairingCode: (phoneNumber: string, pairCode: string) => Promise<string>;
-    waitForConnectionUpdate: (check: (u: Partial<import("../Types").ConnectionState>) => boolean | undefined, timeoutMs?: number) => Promise<void>;
+    requestPairingCode: (phoneNumber: string) => Promise<string>;
+    waitForConnectionUpdate: (check: (u: Partial<import("../Types").ConnectionState>) => boolean | undefined, timeoutMs?: number | undefined) => Promise<void>;
     sendWAMBuffer: (wamBuffer: Buffer) => Promise<BinaryNode>;
 };