@d0v3riz/baileys 6.3.0 → 6.4.0

package/lib/Socket/messages-send.js

@@ -246,15 +246,17 @@ const makeMessagesSocket = (config) => {
         }));
         return { nodes, shouldIncludeDeviceIdentity };
     };
-    const relayMessage = async (jid, message, { messageId: msgId, participant, additionalAttributes, useUserDevicesCache, cachedGroupMetadata }) => {
+    const relayMessage = async (jid, message, { messageId: msgId, participant, additionalAttributes, useUserDevicesCache, cachedGroupMetadata, statusJidList }) => {
         const meId = authState.creds.me.id;
         let shouldIncludeDeviceIdentity = false;
         const { user, server } = (0, WABinary_1.jidDecode)(jid);
+        const statusJid = 'status@broadcast';
         const isGroup = server === 'g.us';
+        const isStatus = jid === statusJid;
         msgId = msgId || (0, Utils_1.generateMessageID)();
         useUserDevicesCache = useUserDevicesCache !== false;
         const participants = [];
-        const destinationJid = (0, WABinary_1.jidEncode)(user, isGroup ? 'g.us' : 's.whatsapp.net');
+        const destinationJid = (!isStatus) ? (0, WABinary_1.jidEncode)(user, isGroup ? 'g.us' : 's.whatsapp.net') : statusJid;
         const binaryNodeContent = [];
         const devices = [];
         const meMsg = {
@@ -267,7 +269,7 @@ const makeMessagesSocket = (config) => {
             // when the retry request is not for a group
             // only send to the specific device that asked for a retry
             // otherwise the message is sent out to every device that should be a recipient
-            if (!isGroup) {
+            if (!isGroup && !isStatus) {
                 additionalAttributes = { ...additionalAttributes, 'device_fanout': 'false' };
             }
             const { user, device } = (0, WABinary_1.jidDecode)(participant.jid);
@@ -275,20 +277,20 @@ const makeMessagesSocket = (config) => {
         }
         await authState.keys.transaction(async () => {
             const mediaType = getMediaType(message);
-            if (isGroup) {
+            if (isGroup || isStatus) {
                 const [groupData, senderKeyMap] = await Promise.all([
                     (async () => {
                         let groupData = cachedGroupMetadata ? await cachedGroupMetadata(jid) : undefined;
                         if (groupData) {
                             logger.trace({ jid, participants: groupData.participants.length }, 'using cached group metadata');
                         }
-                        if (!groupData) {
+                        if (!groupData && !isStatus) {
                             groupData = await groupMetadata(jid);
                         }
                         return groupData;
                     })(),
                     (async () => {
-                        if (!participant) {
+                        if (!participant && !isStatus) {
                             const result = await authState.keys.get('sender-key-memory', [jid]);
                             return result[jid] || {};
                         }
@@ -296,7 +298,10 @@ const makeMessagesSocket = (config) => {
                     })()
                 ]);
                 if (!participant) {
-                    const participantsList = groupData.participants.map(p => p.id);
+                    const participantsList = (groupData && !isStatus) ? groupData.participants.map(p => p.id) : [];
+                    if (isStatus && statusJidList) {
+                        participantsList.push(...statusJidList);
+                    }
                     const additionalDevices = await getUSyncDevices(participantsList, !!useUserDevicesCache, false);
                     devices.push(...additionalDevices);
                 }
@@ -623,6 +628,7 @@ const makeMessagesSocket = (config) => {
                     ...options,
                 });
                 const isDeleteMsg = 'delete' in content && !!content.delete;
+                const isEditMsg = 'edit' in content && !!content.edit;
                 const additionalAttributes = {};
                 // required for delete
                 if (isDeleteMsg) {
@@ -634,7 +640,10 @@ const makeMessagesSocket = (config) => {
                         additionalAttributes.edit = '7';
                     }
                 }
-                await relayMessage(jid, fullMsg.message, { messageId: fullMsg.key.id, cachedGroupMetadata: options.cachedGroupMetadata, additionalAttributes });
+                else if (isEditMsg) {
+                    additionalAttributes.edit = '1';
+                }
+                await relayMessage(jid, fullMsg.message, { messageId: fullMsg.key.id, cachedGroupMetadata: options.cachedGroupMetadata, additionalAttributes, statusJidList: options.statusJidList });
                 if (config.emitOwnEvents) {
                     process.nextTick(() => {
                         processingMutex.mutex(() => (upsertMessage(fullMsg, 'append')));

package/lib/Socket/registration.d.ts

@@ -3,7 +3,7 @@ import { AxiosRequestConfig } from 'axios';
 import { KeyPair, SignedKeyPair, SocketConfig } from '../Types';
 export declare const makeRegistrationSocket: (config: SocketConfig) => {
     register: (code: string) => Promise<ExistsResponse>;
-    requestRegistrationCode: (registrationOptions?: RegistrationOptions | undefined) => Promise<ExistsResponse>;
+    requestRegistrationCode: (registrationOptions?: RegistrationOptions) => Promise<ExistsResponse>;
     getOrderDetails: (orderId: string, tokenBase64: string) => Promise<import("../Types").OrderDetails>;
     getCatalog: ({ jid, limit, cursor }: import("../Types").GetCatalogOptions) => Promise<{
         products: import("../Types").Product[];
@@ -22,7 +22,7 @@ export declare const makeRegistrationSocket: (config: SocketConfig) => {
     rejectCall: (callId: string, callFrom: string) => Promise<void>;
     getPrivacyTokens: (jids: string[]) => Promise<import("../WABinary").BinaryNode>;
     assertSessions: (jids: string[], force: boolean) => Promise<boolean>;
-    relayMessage: (jid: string, message: import("../Types").WAProto.IMessage, { messageId: msgId, participant, additionalAttributes, useUserDevicesCache, cachedGroupMetadata }: import("../Types").MessageRelayOptions) => Promise<string>;
+    relayMessage: (jid: string, message: import("../Types").WAProto.IMessage, { messageId: msgId, participant, additionalAttributes, 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").WAProto.IMessageKey[], type: import("../Types").MessageReceiptType) => Promise<void>;
     readMessages: (keys: import("../Types").WAProto.IMessageKey[]) => Promise<void>;
@@ -47,6 +47,7 @@ export declare const makeRegistrationSocket: (config: SocketConfig) => {
     groupParticipantsUpdate: (jid: string, participants: string[], action: import("../Types").ParticipantAction) => Promise<{
         status: string;
         jid: string;
+        content: import("../WABinary").BinaryNode;
     }[]>;
     groupUpdateDescription: (jid: string, description?: string | undefined) => Promise<void>;
     groupInviteCode: (jid: string) => Promise<string | undefined>;
@@ -97,7 +98,7 @@ export declare const makeRegistrationSocket: (config: SocketConfig) => {
     addMessageLabel: (jid: string, messageId: string, labelId: string) => Promise<void>;
     removeMessageLabel: (jid: string, messageId: string, labelId: string) => Promise<void>;
     type: "md";
-    ws: import("./Client").MobileSocketClient | import("./Client").WebSocketClient;
+    ws: import("./Client/mobile-socket-client").MobileSocketClient | import("./Client/web-socket-client").WebSocketClient;
     ev: import("../Types").BaileysEventEmitter & {
         process(handler: (events: Partial<import("../Types").BaileysEventMap>) => void | Promise<void>): () => void;
         buffer(): void;
@@ -122,6 +123,7 @@ export declare const makeRegistrationSocket: (config: SocketConfig) => {
     onUnexpectedError: (err: Error | import("@hapi/boom").Boom<any>, msg: string) => void;
     uploadPreKeys: (count?: number) => Promise<void>;
     uploadPreKeysToServerIfRequired: () => Promise<void>;
+    requestPairingCode: (phoneNumber: string) => Promise<string>;
     waitForConnectionUpdate: (check: (u: Partial<import("../Types").ConnectionState>) => boolean | undefined, timeoutMs?: number | undefined) => Promise<void>;
 };
 export interface RegistrationData {
@@ -154,7 +156,7 @@ export interface RegistrationOptions {
      */
     method?: 'sms' | 'voice';
 }
-export declare type RegistrationParams = RegistrationData & RegistrationOptions;
+export type RegistrationParams = RegistrationData & RegistrationOptions;
 export declare function registrationParams(params: RegistrationParams): {
     cc: string;
     in: string;

package/lib/Socket/socket.d.ts

@@ -26,17 +26,18 @@ export declare const makeSocket: (config: SocketConfig) => {
     signalRepository: import("../Types").SignalRepository;
     readonly user: import("../Types").Contact | undefined;
     generateMessageTag: () => string;
-    query: (node: BinaryNode, timeoutMs?: number | undefined) => Promise<BinaryNode>;
+    query: (node: BinaryNode, timeoutMs?: number) => Promise<BinaryNode>;
     waitForMessage: <T_1>(msgId: string, timeoutMs?: number | undefined) => Promise<T_1>;
     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, msg: string) => void;
     uploadPreKeys: (count?: number) => Promise<void>;
     uploadPreKeysToServerIfRequired: () => Promise<void>;
+    requestPairingCode: (phoneNumber: string) => Promise<string>;
     /** Waits for the connection to WA to reach a state */
     waitForConnectionUpdate: (check: (u: Partial<import("../Types").ConnectionState>) => boolean | undefined, timeoutMs?: number | undefined) => Promise<void>;
 };
-export declare type Socket = ReturnType<typeof makeSocket>;
+export type Socket = ReturnType<typeof makeSocket>;

package/lib/Socket/socket.js

@@ -1,15 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.makeSocket = void 0;
-/* eslint-disable @typescript-eslint/no-explicit-any */
 const boom_1 = require("@hapi/boom");
+const crypto_1 = require("crypto");
 const url_1 = require("url");
 const util_1 = require("util");
 const WAProto_1 = require("../../WAProto");
 const Defaults_1 = require("../Defaults");
 const Types_1 = require("../Types");
 const Utils_1 = require("../Utils");
-const event_buffer_1 = require("../Utils/event-buffer");
 const WABinary_1 = require("../WABinary");
 const Client_1 = require("./Client");
 /**
@@ -19,16 +18,15 @@ const Client_1 = require("./Client");
  * - query phone connection
  */
 const makeSocket = (config) => {
-    var _a, _b;
     const { waWebSocketUrl, connectTimeoutMs, logger, keepAliveIntervalMs, browser, auth: authState, printQRInTerminal, defaultQueryTimeoutMs, transactionOpts, qrTimeout, makeSignalRepository, } = config;
     let url = typeof waWebSocketUrl === 'string' ? new url_1.URL(waWebSocketUrl) : waWebSocketUrl;
-    config.mobile = config.mobile || ((_b = (_a = config.auth) === null || _a === void 0 ? void 0 : _a.creds) === null || _b === void 0 ? void 0 : _b.registered) || url.protocol === 'tcp:';
+    config.mobile = config.mobile || url.protocol === 'tcp:';
     if (config.mobile && url.protocol !== 'tcp:') {
         url = new url_1.URL(`tcp://${Defaults_1.MOBILE_ENDPOINT}:${Defaults_1.MOBILE_PORT}`);
     }
     const ws = config.mobile ? new Client_1.MobileSocketClient(url, config) : new Client_1.WebSocketClient(url, config);
     ws.connect();
-    const ev = (0, event_buffer_1.makeEventBuffer)(logger);
+    const ev = (0, Utils_1.makeEventBuffer)(logger);
     /** ephemeral key pair used to encrypt/decrypt communication. Unique for each connection */
     const ephemeralKeyPair = Utils_1.Curve.generateKeyPair();
     /** WA noise protocol wrapper */
@@ -106,15 +104,14 @@ const makeSocket = (config) => {
     };
     /**
      * Wait for a message with a certain tag to be received
-     * @param tag the message tag to await
-     * @param json query that was sent
+     * @param msgId the message tag to await
      * @param timeoutMs timeout after which the promise will reject
      */
     const waitForMessage = async (msgId, timeoutMs = defaultQueryTimeoutMs) => {
         let onRecv;
         let onErr;
         try {
-            const result = await (0, Utils_1.promiseTimeout)(timeoutMs, (resolve, reject) => {
+            return await (0, Utils_1.promiseTimeout)(timeoutMs, (resolve, reject) => {
                 onRecv = resolve;
                 onErr = err => {
                     reject(err || new boom_1.Boom('Connection Closed', { statusCode: Types_1.DisconnectReason.connectionClosed }));
@@ -123,7 +120,6 @@ const makeSocket = (config) => {
                 ws.on('close', onErr); // if the socket closes, you'll never receive the message
                 ws.off('error', onErr);
             });
-            return result;
         }
         finally {
             ws.off(`TAG:${msgId}`, onRecv);
@@ -364,6 +360,69 @@ const makeSocket = (config) => {
         }
         end(new boom_1.Boom(msg || 'Intentional Logout', { statusCode: Types_1.DisconnectReason.loggedOut }));
     };
+    const requestPairingCode = async (phoneNumber) => {
+        authState.creds.pairingCode = (0, Utils_1.bytesToCrockford)((0, crypto_1.randomBytes)(5));
+        authState.creds.me = {
+            id: (0, WABinary_1.jidEncode)(phoneNumber, 's.whatsapp.net'),
+            name: '~'
+        };
+        ev.emit('creds.update', authState.creds);
+        await sendNode({
+            tag: 'iq',
+            attrs: {
+                to: WABinary_1.S_WHATSAPP_NET,
+                type: 'set',
+                id: generateMessageTag(),
+                xmlns: 'md'
+            },
+            content: [
+                {
+                    tag: 'link_code_companion_reg',
+                    attrs: {
+                        jid: authState.creds.me.id,
+                        stage: 'companion_hello',
+                        // eslint-disable-next-line camelcase
+                        should_show_push_notification: 'true'
+                    },
+                    content: [
+                        {
+                            tag: 'link_code_pairing_wrapped_companion_ephemeral_pub',
+                            attrs: {},
+                            content: await generatePairingKey()
+                        },
+                        {
+                            tag: 'companion_server_auth_key_pub',
+                            attrs: {},
+                            content: authState.creds.noiseKey.public
+                        },
+                        {
+                            tag: 'companion_platform_id',
+                            attrs: {},
+                            content: '49' // Chrome
+                        },
+                        {
+                            tag: 'companion_platform_display',
+                            attrs: {},
+                            content: config.browser[0]
+                        },
+                        {
+                            tag: 'link_code_pairing_nonce',
+                            attrs: {},
+                            content: '0'
+                        }
+                    ]
+                }
+            ]
+        });
+        return authState.creds.pairingCode;
+    };
+    async function generatePairingKey() {
+        const salt = (0, crypto_1.randomBytes)(32);
+        const randomIv = (0, crypto_1.randomBytes)(16);
+        const key = (0, Utils_1.derivePairingCodeKey)(authState.creds.pairingCode, salt);
+        const ciphered = (0, Utils_1.aesEncryptCTR)(authState.creds.pairingEphemeralKeyPair.public, key, randomIv);
+        return Buffer.concat([salt, randomIv, ciphered]);
+    }
     ws.on('message', onMessageRecieved);
     ws.on('open', async () => {
         try {
@@ -511,6 +570,7 @@ const makeSocket = (config) => {
         onUnexpectedError,
         uploadPreKeys,
         uploadPreKeysToServerIfRequired,
+        requestPairingCode,
         /** Waits for the connection to WA to reach a state */
         waitForConnectionUpdate: (0, Utils_1.bindWaitForConnectionUpdate)(ev),
     };

package/lib/Store/make-in-memory-store.d.ts

@@ -7,14 +7,14 @@ import type { BaileysEventEmitter, Chat, ConnectionState, Contact, GroupMetadata
 import { Label } from '../Types/Label';
 import { LabelAssociation } from '../Types/LabelAssociation';
 import { ObjectRepository } from './object-repository';
-declare type WASocket = ReturnType<typeof makeMDSocket>;
+type WASocket = ReturnType<typeof makeMDSocket>;
 export declare const waChatKey: (pin: boolean) => {
     key: (c: Chat) => string;
     compare: (k1: string, k2: string) => number;
 };
 export declare const waMessageID: (m: WAMessage) => string;
 export declare const waLabelAssociationKey: Comparable<LabelAssociation, string>;
-export declare type BaileysInMemoryStoreConfig = {
+export type BaileysInMemoryStoreConfig = {
     chatKey?: Comparable<Chat, string>;
     labelAssociationKey?: Comparable<LabelAssociation, string>;
     logger?: Logger;

package/lib/Types/Auth.d.ts

@@ -3,25 +3,25 @@ import type { proto } from '../../WAProto';
 import { RegistrationOptions } from '../Socket/registration';
 import type { Contact } from './Contact';
 import type { MinimalMessage } from './Message';
-export declare type KeyPair = {
+export type KeyPair = {
     public: Uint8Array;
     private: Uint8Array;
 };
-export declare type SignedKeyPair = {
+export type SignedKeyPair = {
     keyPair: KeyPair;
     signature: Uint8Array;
     keyId: number;
     timestampS?: number;
 };
-export declare type ProtocolAddress = {
+export type ProtocolAddress = {
     name: string;
     deviceId: number;
 };
-export declare type SignalIdentity = {
+export type SignalIdentity = {
     identifier: ProtocolAddress;
     identifierKey: Uint8Array;
 };
-export declare type LTHashState = {
+export type LTHashState = {
     version: number;
     hash: Buffer;
     indexValueMap: {
@@ -30,20 +30,21 @@ export declare type LTHashState = {
         };
     };
 };
-export declare type SignalCreds = {
+export type SignalCreds = {
     readonly signedIdentityKey: KeyPair;
     readonly signedPreKey: SignedKeyPair;
     readonly registrationId: number;
 };
-export declare type AccountSettings = {
+export type AccountSettings = {
     /** unarchive chats when a new message is received */
     unarchiveChats: boolean;
     /** the default mode to start new conversations with */
     defaultDisappearingMode?: Pick<proto.IConversation, 'ephemeralExpiration' | 'ephemeralSettingTimestamp'>;
 };
-export declare type AuthenticationCreds = SignalCreds & {
+export type AuthenticationCreds = SignalCreds & {
     readonly noiseKey: KeyPair;
-    readonly advSecretKey: string;
+    readonly pairingEphemeralKeyPair: KeyPair;
+    advSecretKey: string;
     me?: Contact;
     account?: proto.IADVSignedDeviceIdentity;
     signalIdentities?: SignalIdentity[];
@@ -62,8 +63,9 @@ export declare type AuthenticationCreds = SignalCreds & {
     registered: boolean;
     backupToken: Buffer;
     registration: RegistrationOptions;
+    pairingCode: string | undefined;
 };
-export declare type SignalDataTypeMap = {
+export type SignalDataTypeMap = {
     'pre-key': KeyPair;
     'session': Uint8Array;
     'sender-key': Uint8Array;
@@ -73,13 +75,13 @@ export declare type SignalDataTypeMap = {
     'app-state-sync-key': proto.Message.IAppStateSyncKeyData;
     'app-state-sync-version': LTHashState;
 };
-export declare type SignalDataSet = {
+export type SignalDataSet = {
     [T in keyof SignalDataTypeMap]?: {
         [id: string]: SignalDataTypeMap[T] | null;
     };
 };
-declare type Awaitable<T> = T | Promise<T>;
-export declare type SignalKeyStore = {
+type Awaitable<T> = T | Promise<T>;
+export type SignalKeyStore = {
     get<T extends keyof SignalDataTypeMap>(type: T, ids: string[]): Awaitable<{
         [id: string]: SignalDataTypeMap[T];
     }>;
@@ -87,19 +89,19 @@ export declare type SignalKeyStore = {
     /** clear all the data in the store */
     clear?(): Awaitable<void>;
 };
-export declare type SignalKeyStoreWithTransaction = SignalKeyStore & {
+export type SignalKeyStoreWithTransaction = SignalKeyStore & {
     isInTransaction: () => boolean;
     transaction<T>(exec: () => Promise<T>): Promise<T>;
 };
-export declare type TransactionCapabilityOptions = {
+export type TransactionCapabilityOptions = {
     maxCommitRetries: number;
     delayBetweenTriesMs: number;
 };
-export declare type SignalAuthState = {
+export type SignalAuthState = {
     creds: SignalCreds;
     keys: SignalKeyStore | SignalKeyStoreWithTransaction;
 };
-export declare type AuthenticationState = {
+export type AuthenticationState = {
     creds: AuthenticationCreds;
     keys: SignalKeyStore;
 };

package/lib/Types/Call.d.ts

@@ -1,5 +1,5 @@
-export declare type WACallUpdateType = 'offer' | 'ringing' | 'timeout' | 'reject' | 'accept';
-export declare type WACallEvent = {
+export type WACallUpdateType = 'offer' | 'ringing' | 'timeout' | 'reject' | 'accept';
+export type WACallEvent = {
     chatId: string;
     from: string;
     isGroup?: boolean;

package/lib/Types/Chat.d.ts

@@ -5,33 +5,33 @@ import type { ChatLabelAssociationActionBody } from './LabelAssociation';
 import type { MessageLabelAssociationActionBody } from './LabelAssociation';
 import type { MinimalMessage } from './Message';
 /** privacy settings in WhatsApp Web */
-export declare type WAPrivacyValue = 'all' | 'contacts' | 'contact_blacklist' | 'none';
-export declare type WAPrivacyOnlineValue = 'all' | 'match_last_seen';
-export declare type WAReadReceiptsValue = 'all' | 'none';
+export type WAPrivacyValue = 'all' | 'contacts' | 'contact_blacklist' | 'none';
+export type WAPrivacyOnlineValue = 'all' | 'match_last_seen';
+export type WAReadReceiptsValue = 'all' | 'none';
 /** set of statuses visible to other people; see updatePresence() in WhatsAppWeb.Send */
-export declare type WAPresence = 'unavailable' | 'available' | 'composing' | 'recording' | 'paused';
+export type WAPresence = 'unavailable' | 'available' | 'composing' | 'recording' | 'paused';
 export declare const ALL_WA_PATCH_NAMES: readonly ["critical_block", "critical_unblock_low", "regular_high", "regular_low", "regular"];
-export declare type WAPatchName = typeof ALL_WA_PATCH_NAMES[number];
+export type WAPatchName = typeof ALL_WA_PATCH_NAMES[number];
 export interface PresenceData {
     lastKnownPresence: WAPresence;
     lastSeen?: number;
 }
-export declare type ChatMutation = {
+export type ChatMutation = {
     syncAction: proto.ISyncActionData;
     index: string[];
 };
-export declare type WAPatchCreate = {
+export type WAPatchCreate = {
     syncAction: proto.ISyncActionValue;
     index: string[];
     type: WAPatchName;
     apiVersion: number;
     operation: proto.SyncdMutation.SyncdOperation;
 };
-export declare type Chat = proto.IConversation & {
+export type Chat = proto.IConversation & {
     /** unix timestamp of when the last message was received in the chat */
     lastMessageRecvTimestamp?: number;
 };
-export declare type ChatUpdate = Partial<Chat & {
+export type ChatUpdate = Partial<Chat & {
     /**
      * if specified in the update,
      * the EV buffer will check if the condition gets fulfilled before applying the update
@@ -47,8 +47,8 @@ export declare type ChatUpdate = Partial<Chat & {
  * the last messages in a chat, sorted reverse-chronologically. That is, the latest message should be first in the chat
  * for MD modifications, the last message in the array (i.e. the earlist message) must be the last message recv in the chat
  * */
-export declare type LastMessageList = MinimalMessage[] | proto.SyncActionValue.ISyncActionMessageRange;
-export declare type ChatModification = {
+export type LastMessageList = MinimalMessage[] | proto.SyncActionValue.ISyncActionMessageRange;
+export type ChatModification = {
     archive: boolean;
     lastMessages: LastMessageList;
 } | {
@@ -89,7 +89,7 @@ export declare type ChatModification = {
 } | {
     removeMessageLabel: MessageLabelAssociationActionBody;
 };
-export declare type InitialReceivedChatsState = {
+export type InitialReceivedChatsState = {
     [jid: string]: {
         /** the last message received from the other party */
         lastMsgRecvTimestamp?: number;
@@ -97,6 +97,6 @@ export declare type InitialReceivedChatsState = {
         lastMsgTimestamp: number;
     };
 };
-export declare type InitialAppStateSyncOptions = {
+export type InitialAppStateSyncOptions = {
     accountSettings: AccountSettings;
 };

package/lib/Types/Events.d.ts

@@ -9,7 +9,7 @@ import { Label } from './Label';
 import { LabelAssociation } from './LabelAssociation';
 import { MessageUpsertType, MessageUserReceiptUpdate, WAMessage, WAMessageKey, WAMessageUpdate } from './Message';
 import { ConnectionState } from './State';
-export declare type BaileysEventMap = {
+export type BaileysEventMap = {
     /** connection state has been updated -- WS closed, opened, connecting etc. */
     'connection.update': Partial<ConnectionState>;
     /** credentials updated -- some metadata, keys or something */
@@ -88,7 +88,7 @@ export declare type BaileysEventMap = {
         type: 'add' | 'remove';
     };
 };
-export declare type BufferedEventData = {
+export type BufferedEventData = {
     historySets: {
         chats: {
             [jid: string]: Chat;
@@ -143,7 +143,7 @@ export declare type BufferedEventData = {
         [jid: string]: Partial<GroupMetadata>;
     };
 };
-export declare type BaileysEvent = keyof BaileysEventMap;
+export type BaileysEvent = keyof BaileysEventMap;
 export interface BaileysEventEmitter {
     on<T extends keyof BaileysEventMap>(event: T, listener: (arg: BaileysEventMap[T]) => void): void;
     off<T extends keyof BaileysEventMap>(event: T, listener: (arg: BaileysEventMap[T]) => void): void;

package/lib/Types/GroupMetadata.d.ts

@@ -1,10 +1,10 @@
 import { Contact } from './Contact';
-export declare type GroupParticipant = (Contact & {
+export type GroupParticipant = (Contact & {
     isAdmin?: boolean;
     isSuperAdmin?: boolean;
     admin?: 'admin' | 'superadmin' | null;
 });
-export declare type ParticipantAction = 'add' | 'remove' | 'promote' | 'demote';
+export type ParticipantAction = 'add' | 'remove' | 'promote' | 'demote';
 export interface GroupMetadata {
     id: string;
     owner: string | undefined;
@@ -26,6 +26,8 @@ export interface GroupMetadata {
     participants: GroupParticipant[];
     ephemeralDuration?: number;
     inviteCode?: string;
+    /** the person who added you */
+    author?: string;
 }
 export interface WAGroupCreateResponse {
     status: number;

package/lib/Types/LabelAssociation.d.ts

@@ -3,7 +3,7 @@ export declare enum LabelAssociationType {
     Chat = "label_jid",
     Message = "label_message"
 }
-export declare type LabelAssociationTypes = `${LabelAssociationType}`;
+export type LabelAssociationTypes = `${LabelAssociationType}`;
 /** Association for chat */
 export interface ChatLabelAssociation {
     type: LabelAssociationType.Chat;
@@ -17,7 +17,7 @@ export interface MessageLabelAssociation {
     messageId: string;
     labelId: string;
 }
-export declare type LabelAssociation = ChatLabelAssociation | MessageLabelAssociation;
+export type LabelAssociation = ChatLabelAssociation | MessageLabelAssociation;
 /** Body for add/remove chat label association action */
 export interface ChatLabelAssociationActionBody {
     labelId: string;