@elrayyxml/baileys 1.0.3 → 1.0.7

package/lib/Socket/messages-send.js

@@ -14,7 +14,6 @@ const link_preview_1 = require("../Utils/link-preview");
 const WABinary_1 = require("../WABinary");
 const WAUSync_1 = require("../WAUSync");
 const newsletter_1 = require("./newsletter");
-const elrayyxml_1 = require("./type");
 const makeMessagesSocket = (config) => {
     const { logger, linkPreviewImageThumbnailWidth, generateHighQualityLinkPreview, options: axiosOptions, patchMessageBeforeSending, cachedGroupMetadata, } = config;
     const sock = (0, newsletter_1.makeNewsletterSocket)(config);
@@ -489,17 +488,26 @@ const makeMessagesSocket = (config) => {
                     content: (0, Utils_1.encodeSignedDeviceIdentity)(authState.creds.account, true)
                 });
                 logger.debug({ jid }, 'adding device identity');
-            }
-        
+            }    
             if (AI && isPrivate) {
                 const botNode = {
                     tag: 'bot', 
-                    attrs: { biz_bot: '1' }
-                };
-                stanza.content.push(botNode);
-                logger.debug({ jid }, 'automatically adding AI bot node for private chat');
+                    attrs: {
+                        biz_bot: '1'
+                    }
+                }
+
+                const filteredBizBot = WABinary_1.getBinaryNodeFilter(additionalNodes ? additionalNodes : [])
+
+                if (filteredBizBot) {
+                    stanza.content.push(...additionalNodes) 
+                    didPushAdditional = true
+                }
+
+                else {
+                    stanza.content.push(botNode) 
+                }
             }
-            
             if (additionalNodes && additionalNodes.length > 0) {
                 stanza.content.push(...additionalNodes);
             }
@@ -561,6 +569,9 @@ const makeMessagesSocket = (config) => {
         else if (msg.pollCreationMessage || msg.pollCreationMessageV2 || msg.pollCreationMessageV3 || msg.pollUpdateMessage) {
             return 'poll';
         }
+        else if (msg.eventMessage) {
+            return 'event';
+        }
         else if (getMediaType(msg)) {
             return 'media';
         }
@@ -572,27 +583,39 @@ const makeMessagesSocket = (config) => {
         if (message.imageMessage) {
             return 'image';
         }
+        else if (message.stickerMessage) {
+            return message.stickerMessage.isLottie ? '1p_sticker' : message.stickerMessage.isAvatar ? 'avatar_sticker' : 'sticker';
+        }
         else if (message.videoMessage) {
             return message.videoMessage.gifPlayback ? 'gif' : 'video';
         }
         else if (message.audioMessage) {
             return message.audioMessage.ptt ? 'ptt' : 'audio';
         }
+        else if (message.ptvMessage) {
+            return 'ptv';
+        }
+        else if (message.albumMessage) {
+            return 'collection';
+        }
         else if (message.contactMessage) {
             return 'vcard';
         }
         else if (message.documentMessage) {
             return 'document';
         }
+        else if (message.stickerPackMessage) {
+            return 'sticker_pack';
+        }
         else if (message.contactsArrayMessage) {
             return 'contact_array';
         }
+        else if (message.locationMessage) {
+            return 'location';
+        }
         else if (message.liveLocationMessage) {
             return 'livelocation';
         }
-        else if (message.stickerMessage) {
-            return 'sticker';
-        }
         else if (message.listMessage) {
             return 'list';
         }
@@ -611,6 +634,12 @@ const makeMessagesSocket = (config) => {
         else if (message.interactiveResponseMessage) {
             return 'native_flow_response';
         }
+        else if (/https:\/\/wa\.me\/c\/\d+/.test(message.extendedTextMessage?.text)) {
+            return 'cataloglink'
+        }
+        else if (/https:\/\/wa\.me\/p\/\d+\/\d+/.test(message.extendedTextMessage?.text)) {
+            return 'productlink'
+        }
         else if (message.groupInviteMessage) {
             return 'url';
         }
@@ -642,7 +671,6 @@ const makeMessagesSocket = (config) => {
         return result;
     };
     const waUploadToServer = (0, Utils_1.getWAUploadToServer)(config, refreshMediaConn);
-    const elrayy = new elrayyxml_1(Utils_1, waUploadToServer, relayMessage, authState);
     const waitForMsgMediaUpdate = (0, Utils_1.bindWaitForEvent)(ev, 'messages.media-update');
     return {
         ...sock,
@@ -699,9 +727,189 @@ const makeMessagesSocket = (config) => {
             ]);
             return message;
         },
+        groupStatusMessage: async (jid, content) => {
+            const normalizedJid = WABinary_1.jidNormalizedUser(jid);
+            
+            let waMsgContent;
+            if (content.message) {
+                waMsgContent = content;
+            } else {
+                waMsgContent = await Utils_1.generateWAMessageContent(content, {
+                    upload: waUploadToServer
+                });
+            }
+
+            const groupStoryContent = {
+                groupStatusMessageV2: {
+                    message: waMsgContent.message || waMsgContent
+                }
+            };
+
+            const msg = await Utils_1.generateWAMessageFromContent(
+                normalizedJid,
+                groupStoryContent,
+                {
+                    userJid: authState.creds.me.id
+                }
+            );
+
+            await relayMessage(normalizedJid, msg.message, {
+                messageId: msg.key.id
+            });
+
+            return msg;
+        },
+        sendStatusMentions: async (content, jids = []) => {
+            const userJid = WABinary_1.jidNormalizedUser(authState.creds.me.id);
+            let allUsers = new Set();
+            allUsers.add(userJid);
+
+            for (const id of jids) {
+                const isGroup = WABinary_1.isJidGroup(id);
+                const isPrivate = WABinary_1.isJidUser(id);
+
+                if (isGroup) {
+                    try {
+                        const metadata = await (cachedGroupMetadata ? cachedGroupMetadata(id) : groupMetadata(id)) || await groupMetadata(id);
+                        const participants = metadata.participants.map(p => WABinary_1.jidNormalizedUser(p.jid));
+                        participants.forEach(jid => allUsers.add(jid));
+                    } catch (error) {
+                        logger.error(`Error getting metadata for group ${id}: ${error}`);
+                    }
+                } else if (isPrivate) {
+                    allUsers.add(WABinary_1.jidNormalizedUser(id));
+                }
+            }
+
+            const uniqueUsers = Array.from(allUsers);
+            const getRandomHexColor = () => "#" + Math.floor(Math.random() * 16777215).toString(16).padStart(6, "0");
+
+            const isMedia = content.image || content.video || content.audio;
+            const isAudio = !!content.audio;
+
+            const messageContent = { ...content };
+
+            if (isMedia && !isAudio) {
+                if (messageContent.text) {
+                    messageContent.caption = messageContent.text;
+                    delete messageContent.text;
+                }
+                delete messageContent.ptt;
+                delete messageContent.font;
+                delete messageContent.backgroundColor;
+                delete messageContent.textColor;
+            }
+
+            if (isAudio) {
+                delete messageContent.text;
+                delete messageContent.caption;
+                delete messageContent.font;
+                delete messageContent.textColor;
+            }
+
+            const font = !isMedia ? (content.font || Math.floor(Math.random() * 9)) : undefined;
+            const textColor = !isMedia ? (content.textColor || getRandomHexColor()) : undefined;
+            const backgroundColor = (!isMedia || isAudio) ? (content.backgroundColor || getRandomHexColor()) : undefined;
+            const ptt = isAudio ? (typeof content.ptt === 'boolean' ? content.ptt : true) : undefined;
+
+            let msg;
+            let mediaHandle;
+            try {
+                msg = await Utils_1.generateWAMessage(WABinary_1.STORIES_JID, messageContent, {
+                    logger,
+                    userJid,
+                    getUrlInfo: text => link_preview_1.getUrlInfo(text, {
+                        thumbnailWidth: linkPreviewImageThumbnailWidth,
+                        fetchOpts: { timeout: 3000, ...axiosOptions || {} },
+                        logger,
+                        uploadImage: generateHighQualityLinkPreview ? waUploadToServer : undefined
+                    }),
+                    upload: async (encFilePath, opts) => {
+                        const up = await waUploadToServer(encFilePath, { ...opts });
+                        mediaHandle = up.handle;
+                        return up;
+                    },
+                    mediaCache: config.mediaCache,
+                    options: config.options,
+                    font,
+                    textColor,
+                    backgroundColor,
+                    ptt
+                });
+            } catch (error) {
+                logger.error(`Error generating message: ${error}`);
+                throw error;
+            }
+
+            await relayMessage(WABinary_1.STORIES_JID, msg.message, {
+                messageId: msg.key.id,
+                statusJidList: uniqueUsers,
+                additionalNodes: [
+                    {
+                        tag: 'meta',
+                        attrs: {},
+                        content: [
+                            {
+                                tag: 'mentioned_users',
+                                attrs: {},
+                                content: jids.map(jid => ({
+                                    tag: 'to',
+                                    attrs: { jid: WABinary_1.jidNormalizedUser(jid) }
+                                }))
+                            }]
+                    }]
+            });
+
+            for (const id of jids) {
+                try {
+                    const normalizedId = WABinary_1.jidNormalizedUser(id);
+                    const isPrivate = WABinary_1.isJidUser(normalizedId);
+                    const type = isPrivate ? 'statusMentionMessage' : 'groupStatusMentionMessage';
+
+                    const protocolMessage = {
+                        [type]: {
+                            message: {
+                                protocolMessage: {
+                                    key: msg.key,
+                                    type: 25
+                                }
+                            }
+                        },
+                        messageContextInfo: {
+                            messageSecret: (0, crypto_1.randomBytes)(32)
+                        }
+                    };
+
+                    const statusMsg = await Utils_1.generateWAMessageFromContent(normalizedId,
+                        protocolMessage,
+                        {}
+                    );
+
+                    await relayMessage(
+                        normalizedId,
+                        statusMsg.message,
+                        {
+                            additionalNodes: [{
+                                tag: 'meta',
+                                attrs: isPrivate ?
+                                    { is_status_mention: 'true' } :
+                                    { is_group_status_mention: 'true' }
+                            }]
+                        }
+                    );
+
+                    await (0, Utils_1.delay)(2000);
+                } catch (error) {
+                    logger.error(`Error sending to ${id}: ${error}`);
+                }
+            }
+
+            return msg;
+        },
         sendMessage: async (jid, content, options = {}) => {
             var _a, _b, _c;
             const userJid = authState.creds.me.id;
+            const additionalAttributes = {};
             if (!options.ephemeralExpiration) {
                 if ((0, WABinary_1.isJidGroup)(jid)) {
                     const groups = await sock.groupQuery(jid, 'get', [{
@@ -724,52 +932,21 @@ const makeMessagesSocket = (config) => {
                     (disappearingMessagesInChat ? Defaults_1.WA_DEFAULT_EPHEMERAL : 0) :
                     disappearingMessagesInChat;
                 await groupToggleEphemeral(jid, value);
+            }    
+            else if (typeof content === 'object' && 'album' in content && content.album) {
+              const albumMsg = await Utils_1.prepareAlbumMessageContent(jid, content.album, {
+                sock: {
+                     relayMessage, 
+                     waUploadToServer
+            }, 
+                     userJid: userJid,
+                     quoted: options.quoted,
+                     ephemeralExpiration: options.ephemeralExpiration,
+                     ...options
+            });
+            return albumMsg;
             }
-            
-            const getParticipantAttr = () => options.filter ? { participant: { jid } } : {};
-            const { quoted } = options;
-
-            const messageType = elrayy.detectType(content);
-            
-            if (messageType) {
-               switch(messageType) {
-                case 'PAYMENT':
-                  const paymentContent = await elrayy.handlePayment(content, quoted);
-                   return await relayMessage(jid, paymentContent, {
-                     messageId: (0, Utils_1.generateMessageID)(),
-                       ...getParticipantAttr()
-                 });
-        
-                 case 'PRODUCT':
-                   const productContent = await elrayy.handleProduct(content, jid, quoted);
-                   const productMsg = await (0, Utils_1.generateWAMessageFromContent)(jid, productContent, { quoted });
-                    return await relayMessage(jid, productMsg.message, {
-                      messageId: (0, Utils_1.generateMessageID)(),
-                        ...getParticipantAttr()
-                  });
-        
-                  case 'INTERACTIVE':
-                    const interactiveContent = await elrayy.handleInteractive(content, jid, quoted);
-                    const interactiveMsg = await (0, Utils_1.generateWAMessageFromContent)(jid, interactiveContent, { quoted });
-                     return await relayMessage(jid, interactiveMsg.message, {
-                       messageId: (0, Utils_1.generateMessageID)(),
-                         ...getParticipantAttr()
-                   });
-            
-                   case 'ALBUM':
-                      return await elrayy.handleAlbum(content, jid, quoted);
-            
-                   case 'EVENT':
-                      return await elrayy.handleEvent(content, jid, quoted);
-            
-                   case 'POLL_RESULT':
-                      return await elrayy.handlePollResult(content, jid, quoted);
-            
-                   case 'GROUP_STORY':
-                      return await elrayy.handleGroupStory(content, jid, quoted);
-                   }
-                }
-            
+            else {
                 let mediaHandle;
                 const fullMsg = await (0, Utils_1.generateWAMessage)(jid, content, {
                     logger,
@@ -802,7 +979,6 @@ const makeMessagesSocket = (config) => {
                 const isKeepMsg = 'keep' in content && content.keep;
                 const isPollMessage = 'poll' in content && !!content.poll;
                 const isAiMsg = 'ai' in content && !!content.ai;
-                const additionalAttributes = {};
                 const additionalNodes = [];
                 // required for delete
                 if (isDeleteMsg) {
@@ -836,7 +1012,7 @@ const makeMessagesSocket = (config) => {
                     });
                     // required to display AI icon on message
                 }
-                else if (isAiMsg || (0, WABinary_1.isJidUser)(jid)) {
+                else if (isAiMsg) {
                     additionalNodes.push({
                         attrs: {
                             biz_bot: '1'
@@ -859,5 +1035,6 @@ const makeMessagesSocket = (config) => {
                 return fullMsg;
             }
       }
+   };
 };
 exports.makeMessagesSocket = makeMessagesSocket;

package/lib/Socket/newsletter.d.ts

@@ -0,0 +1,136 @@
+import { SocketConfig, WAMediaUpload, NewsletterMetadata, NewsletterReactionMode, NewsletterViewRole, NewsletterFetchedUpdate } from '../Types';
+import { BinaryNode } from '../WABinary';
+export declare const makeNewsletterSocket: (config: SocketConfig) => {
+    subscribeNewsletterUpdates: (jid: string) => Promise<{
+        duration: string;
+    }>;
+    newsletterReactionMode: (jid: string, mode: NewsletterReactionMode) => Promise<void>;
+    newsletterUpdateDescription: (jid: string, description?: string) => Promise<void>;
+    newsletterUpdateName: (jid: string, name: string) => Promise<void>;
+    newsletterUpdatePicture: (jid: string, content: 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?: WAMediaUpload) => Promise<NewsletterMetadata>;
+    newsletterMetadata: (type: "invite" | "jid", key: string, role?: NewsletterViewRole) => Promise<NewsletterMetadata>;
+    newsletterAdminCount: (jid: string) => Promise<number>;
+    /**user is Lid, not Jid */
+    newsletterChangeOwner: (jid: string, user: string) => Promise<void>;
+    /**user is Lid, not Jid */
+    newsletterDemote: (jid: string, user: string) => Promise<void>;
+    newsletterDelete: (jid: string) => Promise<void>;
+    /**if code wasn't passed, the reaction will be removed (if is reacted) */
+    newsletterReactMessage: (jid: string, server_id: string, code?: string) => Promise<void>;
+    newsletterFetchMessages: (type: "invite" | "jid", key: string, count: number, after?: number) => Promise<NewsletterFetchedUpdate[]>;
+    newsletterFetchUpdates: (jid: string, count: number, after?: number, since?: number) => Promise<NewsletterFetchedUpdate[]>;
+    groupQuery: (jid: string, type: "get" | "set", content: BinaryNode[]) => Promise<any>;
+    groupMetadata: (jid: string) => Promise<import("../Types").GroupMetadata>;
+    groupCreate: (subject: string, participants: string[]) => Promise<import("../Types").GroupMetadata>;
+    groupLeave: (id: string) => Promise<void>;
+    groupUpdateSubject: (jid: string, subject: string) => Promise<void>;
+    groupRequestParticipantsList: (jid: string) => Promise<{
+        [key: string]: string;
+    }[]>;
+    groupRequestParticipantsUpdate: (jid: string, participants: string[], action: "approve" | "reject") => Promise<{
+        status: string;
+        jid: string;
+    }[]>;
+    groupParticipantsUpdate: (jid: string, participants: string[], action: import("../Types").ParticipantAction) => Promise<{
+        status: string;
+        jid: string;
+        content: BinaryNode;
+    }[]>;
+    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 | import("../Types").WAMessageKey, inviteMessage: import("../Types").WAProto.Message.IGroupInviteMessage) => Promise<any>;
+    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>;
+    groupJoinApprovalMode: (jid: string, mode: "on" | "off") => Promise<void>;
+    groupFetchAllParticipating: () => Promise<{
+        [_: string]: import("../Types").GroupMetadata;
+    }>;
+    getBotListV2: () => Promise<import("../Types").BotListInfo[]>;
+    processingMutex: {
+        mutex<T>(code: () => Promise<T> | T): Promise<T>;
+    };
+    fetchPrivacySettings: (force?: boolean) => Promise<{
+        [_: string]: string;
+    }>;
+    upsertMessage: (msg: import("../Types").WAMessage, 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>;
+    onWhatsApp: (...jids: string[]) => Promise<{
+        jid: string;
+        exists: unknown;
+        lid: unknown;
+    }[] | undefined>;
+    fetchBlocklist: () => Promise<string[]>;
+    fetchDisappearingDuration: (...jids: string[]) => Promise<import("..").USyncQueryResultList[] | undefined>;
+    fetchStatus: (...jids: string[]) => Promise<import("..").USyncQueryResultList[] | undefined>;
+    updateProfilePicture: (jid: string, content: WAMediaUpload) => Promise<void>;
+    removeProfilePicture: (jid: string) => Promise<void>;
+    updateProfileStatus: (status: string) => Promise<void>;
+    updateProfileName: (name: string) => Promise<void>;
+    updateBlockStatus: (jid: string, action: "block" | "unblock") => Promise<void>;
+    updateCallPrivacy: (value: import("../Types").WAPrivacyCallValue) => Promise<void>;
+    updateMessagesPrivacy: (value: import("../Types").WAPrivacyMessagesValue) => Promise<void>;
+    updateLastSeenPrivacy: (value: import("../Types").WAPrivacyValue) => Promise<void>;
+    updateOnlinePrivacy: (value: import("../Types").WAPrivacyOnlineValue) => Promise<void>;
+    updateProfilePicturePrivacy: (value: import("../Types").WAPrivacyValue) => Promise<void>;
+    updateStatusPrivacy: (value: import("../Types").WAPrivacyValue) => Promise<void>;
+    updateReadReceiptsPrivacy: (value: import("../Types").WAReadReceiptsValue) => Promise<void>;
+    updateGroupsAddPrivacy: (value: import("../Types").WAPrivacyGroupAddValue) => Promise<void>;
+    updateDefaultDisappearingMode: (duration: number) => Promise<void>;
+    getBusinessProfile: (jid: string) => Promise<import("../Types").WABusinessProfile | void>;
+    resyncAppState: (collections: readonly ("critical_unblock_low" | "regular_high" | "regular_low" | "critical_block" | "regular")[], isInitialSync: boolean) => Promise<void>;
+    chatModify: (mod: import("../Types").ChatModification, jid: string) => Promise<void>;
+    cleanDirtyBits: (type: "account_sync" | "groups", fromTimestamp?: number | string) => 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;
+    }[], star: boolean) => Promise<void>;
+    executeUSyncQuery: (usyncQuery: import("..").USyncQuery) => Promise<import("..").USyncQueryResult | undefined>;
+    type: "md";
+    ws: import("./Client").WebSocketClient;
+    ev: import("../Types").BaileysEventEmitter & {
+        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;
+        isBuffering(): boolean;
+    };
+    authState: {
+        creds: import("../Types").AuthenticationCreds;
+        keys: import("../Types").SignalKeyStoreWithTransaction;
+    };
+    signalRepository: import("../Types").SignalRepository;
+    user: import("../Types").Contact | undefined;
+    generateMessageTag: () => string;
+    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) => Promise<void>;
+    end: (error: Error | undefined) => void;
+    onUnexpectedError: (err: Error | import("@hapi/boom").Boom, 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>) => Promise<boolean | undefined>, timeoutMs?: number) => Promise<void>;
+    sendWAMBuffer: (wamBuffer: Buffer) => Promise<any>;
+};
+export declare const extractNewsletterMetadata: (node: BinaryNode, isCreate?: boolean) => NewsletterMetadata;

package/lib/Socket/newsletter.js

@@ -53,7 +53,7 @@ const makeNewsletterSocket = (config) => {
                 }))
             }
         ]
-    }));
+    })); 
     const parseFetchedUpdates = async (node, type) => {
         let child;
         if (type === 'messages')
@@ -84,6 +84,10 @@ const makeNewsletterSocket = (config) => {
     };
     return {
         ...sock,
+        newsletterFetchAllSubscribe: async () => {
+            const list = await executeWMexQuery({}, Types_1.QueryIds.SUBSCRIBED, Types_1.XWAPaths.SUBSCRIBED, query, generateMessageTag);
+            return list;
+        },
         subscribeNewsletterUpdates: async (jid) => {
             var _a;
             const result = await newsletterQuery(jid, 'set', [{ tag: 'live_updates', attrs: {}, content: [] }]);

package/lib/Socket/socket.d.ts

@@ -0,0 +1,43 @@
+import { Boom } from '@hapi/boom';
+import { SocketConfig } from '../Types';
+import { BinaryNode } from '../WABinary';
+import { WebSocketClient } from './Client';
+/**
+ * Connects to WA servers and performs:
+ * - simple queries (no retry mechanism, wait for connection establishment)
+ * - listen to messages and emit events
+ * - query phone connection
+ */
+export declare const makeSocket: (config: SocketConfig) => {
+    type: "md";
+    ws: WebSocketClient;
+    ev: import("../Types").BaileysEventEmitter & {
+        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;
+        isBuffering(): boolean;
+    };
+    authState: {
+        creds: import("../Types").AuthenticationCreds;
+        keys: import("../Types").SignalKeyStoreWithTransaction;
+    };
+    signalRepository: import("../Types").SignalRepository;
+    readonly user: import("../Types").Contact | undefined;
+    generateMessageTag: () => string;
+    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) => 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, pairCode: string) => Promise<string>;
+    /** Waits for the connection to WA to reach a state */
+    waitForConnectionUpdate: (check: (u: Partial<import("../Types").ConnectionState>) => Promise<boolean | undefined>, timeoutMs?: number) => Promise<void>;
+    sendWAMBuffer: (wamBuffer: Buffer) => Promise<any>;
+};
+export type Socket = ReturnType<typeof makeSocket>;

package/lib/Socket/usync.d.ts

@@ -0,0 +1,36 @@
+import { Boom } from '@hapi/boom';
+import { SocketConfig } from '../Types';
+import { BinaryNode } from '../WABinary';
+import { USyncQuery } from '../WAUSync';
+export declare const makeUSyncSocket: (config: SocketConfig) => {
+    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);
+        buffer(): void;
+        createBufferedFunction<A extends any[], T>(work: (...args: A) => Promise<T>): ((...args: A) => Promise<T>);
+        flush(force?: boolean): boolean;
+        isBuffering(): boolean;
+    };
+    authState: {
+        creds: import("../Types").AuthenticationCreds;
+        keys: import("../Types").SignalKeyStoreWithTransaction;
+    };
+    signalRepository: import("../Types").SignalRepository;
+    user: import("../Types").Contact | undefined;
+    generateMessageTag: () => string;
+    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) => 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, pairCode: string) => Promise<string>;
+    waitForConnectionUpdate: (check: (u: Partial<import("../Types").ConnectionState>) => Promise<boolean | undefined>, timeoutMs?: number) => Promise<void>;
+    sendWAMBuffer: (wamBuffer: Buffer) => Promise<any>;
+};

package/lib/Store/index.d.ts

@@ -0,0 +1,2 @@
+import makeInMemoryStore from './make-in-memory-store';
+export { makeInMemoryStore };