@elrayyxml/baileys 1.0.3 → 1.0.7

package/lib/Utils/messages.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.assertMediaContent = exports.downloadMediaMessage = exports.aggregateMessageKeysNotFromMe = exports.updateMessageWithPollUpdate = exports.updateMessageWithReaction = exports.updateMessageWithReceipt = exports.getDevice = exports.extractMessageContent = exports.normalizeMessageContent = exports.getContentType = exports.generateWAMessage = exports.generateWAMessageFromContent = exports.generateWAMessageContent = exports.generateForwardMessageContent = exports.prepareDisappearingMessageSettingContent = exports.prepareWAMessageMedia = exports.generateLinkPreviewIfRequired = exports.extractUrlFromText = void 0;
+exports.prepareAlbumMessageContent = exports.assertMediaContent = exports.downloadMediaMessage = exports.aggregateMessageKeysNotFromMe = exports.updateMessageWithPollUpdate = exports.updateMessageWithReaction = exports.updateMessageWithReceipt = exports.getDevice = exports.extractMessageContent = exports.normalizeMessageContent = exports.getContentType = exports.generateWAMessage = exports.generateWAMessageFromContent = exports.generateWAMessageContent = exports.generateForwardMessageContent = exports.prepareDisappearingMessageSettingContent = exports.prepareWAMessageMedia = exports.generateLinkPreviewIfRequired = exports.extractUrlFromText = void 0;
 exports.getAggregateVotesInPollMessage = getAggregateVotesInPollMessage;
 const boom_1 = require("@hapi/boom");
 const axios_1 = __importDefault(require("axios"));
@@ -16,6 +16,7 @@ const WABinary_1 = require("../WABinary");
 const crypto_2 = require("./crypto");
 const generics_1 = require("./generics");
 const messages_media_1 = require("./messages-media");
+const fflate_1 = require("fflate");
 const MIMETYPE_MAP = {
     image: 'image/jpeg',
     video: 'video/mp4',
@@ -79,38 +80,6 @@ const prepareWAMessageMedia = async (message, options) => {
     }
     const uploadData = {
         ...message,
-        ...(message.annotations ? {
-            annotations: message.annotations
-        } : {
-            annotations: [
-                {
-                    polygonVertices: [
-                        {
-                            x: 60.71664810180664,
-                            y: -36.39784622192383
-                        },
-                        {
-                            x: -16.710189819335938,
-                            y: 49.263675689697266
-                        },
-                        {
-                            x: -56.585853576660156,
-                            y: 37.85963439941406
-                        },
-                        {
-                            x: 20.840980529785156,
-                            y: -47.80188751220703
-                        }
-                    ],
-                    newsletter: {
-                        newsletterJid: "120363402530588049@newsletter",
-                        serverMessageId: 0,
-                        newsletterName: "𓅯 ᴇʟʀᴀʏʏxᴍʟ ɴᴏᴛɪꜰɪᴇʀ 🫟",
-                        contentType: "UPDATE",
-                    }
-                }
-            ]
-        }),
         media: message[mediaType]
     };
     delete uploadData[mediaType];
@@ -227,6 +196,51 @@ const prepareWAMessageMedia = async (message, options) => {
     return obj;
 };
 exports.prepareWAMessageMedia = prepareWAMessageMedia;
+const prepareAlbumMessageContent = async (jid, albums, options) => {
+    const array = albums;
+    
+    const albumContent = {
+        messageContextInfo: {
+            messageSecret: crypto_1.randomBytes(32),
+        },
+        albumMessage: {
+            expectedImageCount: array.filter((a) => a.hasOwnProperty("image")).length,
+            expectedVideoCount: array.filter((a) => a.hasOwnProperty("video")).length,
+        },
+    };
+    const albumMsg = await generateWAMessageFromContent(jid, albumContent, {
+        userJid: options.userJid,
+        quoted: options.quoted,
+        ephemeralExpiration: options.ephemeralExpiration,
+        upload: options.sock.waUploadToServer
+    });
+    
+    await options.sock.relayMessage(jid, albumMsg.message, {
+        messageId: albumMsg.key.id,
+    });
+
+    for (let contentItem of array) {
+        const mediaMsg = await generateWAMessage(jid, contentItem, {
+            upload: options.sock.waUploadToServer,
+            userJid: options.userJid
+        });
+        
+        mediaMsg.message.messageContextInfo = {
+            messageSecret: crypto_1.randomBytes(32),
+            messageAssociation: {
+                associationType: 1,
+                parentMessageKey: albumMsg.key,
+            }
+        };
+
+        await options.sock.relayMessage(jid, mediaMsg.message, {
+            messageId: mediaMsg.key.id,
+        });
+    }
+    
+    return albumMsg;
+};
+exports.prepareAlbumMessageContent = prepareAlbumMessageContent;
 const prepareDisappearingMessageSettingContent = (ephemeralExpiration) => {
     ephemeralExpiration = ephemeralExpiration || 0;
     const content = {
@@ -276,7 +290,7 @@ exports.generateForwardMessageContent = generateForwardMessageContent;
 const generateWAMessageContent = async (message, options) => {
     var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o;
     var _p, _q;
-    let m = {};
+    let m = {};    
     if ('text' in message) {
         const extContent = { text: message.text };
         let urlInfo = message.linkPreview;
@@ -408,6 +422,19 @@ const generateWAMessageContent = async (message, options) => {
                     type: WAProto_1.proto.Message.ButtonsResponseMessage.Type.DISPLAY_TEXT,
                 };
                 break;
+            case 'interactive':
+                m.interactiveResponseMessage = {
+                    body: {
+                       text: message.buttonReply.displayText,
+                       format: WAProto_1.proto.Message.InteractiveResponseMessage.Body.Format.EXTENSIONS_1 
+                    }, 
+                    nativeFlowResponseMessage: {
+                            name: message.buttonReply.nativeFlows.name, 
+                        paramsJson: message.buttonReply.nativeFlows.paramsJson, 
+                        version: message.buttonReply.nativeFlows.version
+                    }
+                }
+                break;
         }
     }
     else if ('ptv' in message && message.ptv) {
@@ -442,6 +469,26 @@ const generateWAMessageContent = async (message, options) => {
     else if ('listReply' in message) {
         m.listResponseMessage = { ...message.listReply };
     }
+    else if ('pollResult' in message) {
+            if (!Array.isArray(message.pollResult.values)) {
+            throw new boom_1.Boom('Invalid pollResult values', { statusCode: 400 })
+        }
+
+            const pollResultSnapshotMessage = {
+           name: message.pollResult.name,
+           pollVotes: message.pollResult.values.map(([optionName, optionVoteCount]) => ({
+               optionName,
+               optionVoteCount
+           }))
+       }
+
+       pollResultSnapshotMessage.contextInfo = {
+            ...(message.contextInfo || {}),
+            ...(message.mentions ? { mentionedJid: message.mentions } : {})
+        }
+
+        m.pollResultSnapshotMessage = pollResultSnapshotMessage
+    } 
     else if ('poll' in message) {
         (_p = message.poll).selectableCount || (_p.selectableCount = 0);
         (_q = message.poll).toAnnouncementGroup || (_q.toAnnouncementGroup = false);
@@ -455,8 +502,8 @@ const generateWAMessageContent = async (message, options) => {
         m.messageContextInfo = {
             // encKey
             messageSecret: message.poll.messageSecret || (0, crypto_1.randomBytes)(32),
-        };
-        const pollCreationMessage = {
+            };
+            const pollCreationMessage = {
             name: message.poll.name,
             selectableOptionsCount: message.poll.selectableCount,
             options: message.poll.values.map(optionName => ({ optionName })),
@@ -476,11 +523,132 @@ const generateWAMessageContent = async (message, options) => {
             }
         }
     }
+    else if ('stickerPack' in message) {
+    const { stickers, cover, name, publisher, packId, description } = message.stickerPack;
+    const { Readable } = require('stream');
+    const Jimp = require('jimp');
+    const stickerData = {};
+    const stickerPackId = packId || (0, generics_1.generateMessageID)();
+    const trayIconFileName = `${stickerPackId}.webp`;
+
+    const stickerPromises = stickers.map(async (s, i) => {
+        const { stream } = await (0, messages_media_1.getStream)(s.sticker);
+        const buffer = await (0, messages_media_1.toBuffer)(stream);
+        const hash = (0, crypto_2.sha256)(buffer).toString('base64url');
+        const fileName = `${i.toString().padStart(2, '0')}_${hash}.webp`;
+        stickerData[fileName] = [new Uint8Array(buffer), { level: 0 }];
+        return {
+            fileName,
+            mimetype: 'image/webp',
+            isAnimated: s.isAnimated || false,
+            isLottie: s.isLottie || false,
+            emojis: s.emojis || [],
+            accessibilityLabel: s.accessibilityLabel || ''
+        };
+    });
+
+    const stickerMetadata = await Promise.all(stickerPromises);
+
+    const coverBuffer = await (0, messages_media_1.toBuffer)((await (0, messages_media_1.getStream)(cover)).stream);
+    stickerData[trayIconFileName] = [new Uint8Array(coverBuffer), { level: 0 }];
+
+    const zipBuffer = await new Promise((resolve, reject) => {
+        (0, fflate_1.zip)(stickerData, (err, data) => {
+            if (err) reject(err);
+            else resolve(Buffer.from(data));
+        });
+    });
+
+    const stickerPackUpload = await (0, messages_media_1.encryptedStream)(
+        { stream: Readable.from(zipBuffer) },
+        'sticker-pack', {
+            logger: options.logger,
+            opts: options.options
+        }
+    );
+
+    const stickerPackUploadResult = await options.upload(stickerPackUpload.encWriteStream, {
+        fileEncSha256B64: stickerPackUpload.fileEncSha256.toString('base64'),
+        mediaType: 'sticker-pack',
+        timeoutMs: options.mediaUploadTimeoutMs
+    });
+
+    let thumbnailDirectPath, thumbnailSha256, thumbnailEncSha256, imageDataHash;
+
+    try {
+        const jimpImage = await Jimp.read(coverBuffer);
+        const thumbnailBuffer = await jimpImage.resize(252, 252).getBufferAsync(Jimp.MIME_JPEG);
+
+        const thumbUpload = await (0, messages_media_1.encryptedStream)(
+            { stream: Readable.from(thumbnailBuffer) },
+            'thumbnail-sticker-pack', {
+                logger: options.logger,
+                opts: options.options,
+                mediaKey: stickerPackUpload.mediaKey
+            }
+        );
+
+        const thumbUploadResult = await options.upload(thumbUpload.encWriteStream, {
+            fileEncSha256B64: thumbUpload.fileEncSha256.toString('base64'),
+            mediaType: 'thumbnail-sticker-pack',
+            timeoutMs: options.mediaUploadTimeoutMs
+        });
+
+        thumbnailDirectPath = thumbUploadResult.directPath;
+        thumbnailSha256 = thumbUpload.fileSha256;
+        thumbnailEncSha256 = thumbUpload.fileEncSha256;
+        imageDataHash = (0, crypto_2.sha256)(thumbnailBuffer).toString('base64');
+    } catch (e) {
+        options.logger?.warn?.(`Thumbnail generation failed: ${e}`);
+    }
+
+    m.stickerPackMessage = {
+        name: name,
+        publisher: publisher,
+        stickerPackId: stickerPackId,
+        packDescription: description,
+        stickerPackOrigin: WAProto_1.proto.Message.StickerPackMessage.StickerPackOrigin.USER_CREATED,
+        stickerPackSize: zipBuffer.length,
+        stickers: stickerMetadata,
+        fileSha256: stickerPackUpload.fileSha256,
+        fileEncSha256: stickerPackUpload.fileEncSha256,
+        mediaKey: stickerPackUpload.mediaKey,
+        directPath: stickerPackUploadResult.directPath,
+        fileLength: zipBuffer.length,
+        mediaKeyTimestamp: (0, generics_1.unixTimestampSeconds)(),
+        trayIconFileName: trayIconFileName,
+        imageDataHash,
+        thumbnailDirectPath,
+        thumbnailSha256,
+        thumbnailEncSha256,
+        thumbnailHeight: 252,
+        thumbnailWidth: 252
+    };
+
+    m.stickerPackMessage.contextInfo = {
+        ...(message.contextInfo || {}),
+        ...(message.mentions ? { mentionedJid: message.mentions } : {})
+        };
+    }
     else if ('event' in message) {
+        m.eventMessage = {};
+        const startTime = Math.floor(message.event.startDate.getTime() / 1000);
+        if (message.event.call && options.getCallLink) {
+            const token = await options.getCallLink(message.event.call, { startTime });
+            m.eventMessage.joinLink = (message.event.call === 'audio' ? CALL_AUDIO_PREFIX : CALL_VIDEO_PREFIX) + token;
+        }
         m.messageContextInfo = {
-            messageSecret: message.event.messageSecret || (0, crypto_1.randomBytes)(32),
+            // encKey
+            messageSecret: message.event.messageSecret || randomBytes(32)
         };
-        m.eventMessage = { ...message.event };
+        m.eventMessage.name = message.event.name;
+        m.eventMessage.description = message.event.description;
+        m.eventMessage.startTime = startTime;
+        m.eventMessage.endTime = message.event.endDate ? message.event.endDate.getTime() / 1000 : undefined;
+        m.eventMessage.isCanceled = message.event.isCancelled ?? false;
+        m.eventMessage.extraGuestsAllowed = message.event.extraGuestsAllowed;
+        m.eventMessage.isScheduleCall = message.event.isScheduleCall ?? false;
+        m.eventMessage.location = message.event.location;
     }
     else if ('inviteAdmin' in message) {
         m.newsletterAdminInviteMessage = {};
@@ -607,6 +775,29 @@ const generateWAMessageContent = async (message, options) => {
         };
         m = { listMessage };
     }
+    if ('productList' in message && !!message.productList) {
+        const thumbnail = message.thumbnail ? await (0, messages_media_1.generateThumbnail)(message.thumbnail, 'image') : null;
+        const listMessage = {
+            title: message.title,
+            buttonText: message.buttonText,
+            footerText: message.footer,
+            description: message.text,
+            productListInfo: {
+                productSections: message.productList,
+                headerImage: {
+                    productId: message.productList[0].products[0].productId,
+                    jpegThumbnail: (thumbnail === null || thumbnail === void 0 ? void 0 : thumbnail.thumbnail) || null
+                },
+                businessOwnerJid: message.businessOwnerJid
+            },
+            listType: WAProto_1.proto.Message.ListMessage.ListType.PRODUCT_LIST
+        };
+        listMessage.contextInfo = {
+            ...(message.contextInfo || {}),
+            ...(message.mentions ? { mentionedJid: message.mentions } : {})
+        };
+        m = { listMessage };
+    }
     if ('interactiveButtons' in message && !!message.interactiveButtons) {
         const interactiveMessage = {
             nativeFlowMessage: Types_1.WAProto.Message.InteractiveMessage.NativeFlowMessage.fromObject({
@@ -694,9 +885,180 @@ const generateWAMessageContent = async (message, options) => {
         }
         m = { interactiveMessage };
     }
+    if ('nativeFlowMessage' in message && !!message.nativeFlowMessage) {
+        const { nativeFlowMessage } = message;
+        let paramsJson = nativeFlowMessage.messageParamsJson;
+        if (typeof paramsJson === 'object' && paramsJson !== null) {
+            paramsJson = JSON.stringify(paramsJson);
+        }
+        const interactiveMessage = {
+            nativeFlowMessage: Types_1.WAProto.Message.InteractiveMessage.NativeFlowMessage.fromObject({
+                buttons: nativeFlowMessage.buttons,
+                messageParamsJson: paramsJson
+            })
+        };
+        if ('text' in message) {
+            interactiveMessage.body = { text: message.text };
+        } else if ('caption' in message) {
+            interactiveMessage.body = { text: message.caption };
+        }
+        interactiveMessage.header = {
+            title: message.title || message.header,
+            subtitle: message.subtitle,
+            hasMediaAttachment: false
+        };
+        if ('footer' in message) {
+            interactiveMessage.footer = { text: message.footer };
+        }
+        if ('contextInfo' in message && !!message.contextInfo) {
+            interactiveMessage.contextInfo = message.contextInfo;
+        }
+        if ('mentions' in message && !!message.mentions) {
+            interactiveMessage.contextInfo = { ...interactiveMessage.contextInfo, mentionedJid: message.mentions };
+        }
+        const contentKeys = Object.keys(m);
+        if (contentKeys.length > 0) {
+            const mediaType = contentKeys[0];
+            interactiveMessage.header[mediaType] = m[mediaType];
+            interactiveMessage.header.hasMediaAttachment = true;
+            if (interactiveMessage.header[mediaType].contextInfo) {
+            }
+        }
+
+        m = { interactiveMessage };
+    }
+    else if ('collection' in message && !!message.collection) {
+            const interactiveMessage = {
+               collectionMessage: {
+                 bizJid: message.collection.bizJid, 
+             id: message.collection.id, 
+             messageVersion: message?.collection?.version
+          }
+      } 
+
+      if ('text' in message) {
+              interactiveMessage.body = {
+             text: message.text
+          }, 
+          interactiveMessage.header = {
+             title: message.title,
+             subtitle: message.subtitle, 
+             hasMediaAttachment: false            
+          }
+      }
+
+      else {
+              if ('caption' in message) {
+              interactiveMessage.body = {
+              text: message.caption
+           }
+           interactiveMessage.header = {
+             title: message.title, 
+             subtitle: message.subtitle, 
+             hasMediaAttachment: message.hasMediaAttachment ? message.hasMediaAttachment : false, 
+             ...Object.assign(interactiveMessage, m)
+            }
+         }
+      } 
+
+      if ('footer' in message && !message.footer) {
+              interactiveMessage.footer = {
+             text: message.footer
+          }
+      }
+
+      interactiveMessage.contextInfo = {
+          ...(message.contextInfo || {}),
+          ...(message.mentions ? { mentionedJid: message.mentions } : {})
+      }
+
+      m = { interactiveMessage }
+    }
+    else if ('cards' in message && !!message.cards) {
+        const slides = await Promise.all(message.cards.map(async (slide) => {
+            const { image, video, product, title, body, footer, buttons } = slide
+            let header
+
+            if (product) {
+                const { imageMessage } = await prepareWAMessageMedia({ image: product.productImage, ...options }, options)
+                header = {
+                    productMessage: {
+                        product: {
+                            ...product,
+                            productImage: imageMessage,
+                        },
+                        ...slide
+                    }
+                }
+            }
+
+            else if (image) {
+                header = await prepareWAMessageMedia({ image: image, ...options }, options)
+            }
+
+            else if (video) {
+                header = await prepareWAMessageMedia({ video: video, ...options }, options)
+            }
+
+            const msg = {
+                header: {
+                    title,
+                    hasMediaAttachment: true,
+                    ...header
+                },
+                body: {
+                    text: body
+                },
+                footer: {
+                    text: footer
+                },
+                nativeFlowMessage: {
+                    buttons,
+                }
+            }
+
+            return msg
+        }))
+
+        const interactiveMessage = {
+            carouselMessage: {
+                cards: slides
+            }
+        }
+
+        if ('text' in message) {
+                interactiveMessage.body = {
+               text: message.text
+            }, 
+            interactiveMessage.header = {
+               title: message.title,
+               subtitle: message.subtitle, 
+               hasMediaAttachment: false            
+            }
+        }
+
+        if ('footer' in message && !!message.footer) {
+                interactiveMessage.footer = {
+               text: message.footer
+            }
+        }
+
+        interactiveMessage.contextInfo = {
+            ...(message.contextInfo || {}),
+            ...(message.mentions ? { mentionedJid: message.mentions } : {})
+        }
+
+        m = { interactiveMessage }
+    }
+    if ('ephemeral' in message && !!message.ephemeral) {
+        m = { ephemeralMessage: { message: m } }
+    }
     if ('viewOnce' in message && !!message.viewOnce) {
         m = { viewOnceMessage: { message: m } };
     }
+    if ('viewOnceExt' in message && !!message.viewOnceExt) {
+        m = { viewOnceMessageV2Extension: { message: m } }
+    }
     if ('mentions' in message && ((_o = message.mentions) === null || _o === void 0 ? void 0 : _o.length)) {
         const [messageType] = Object.keys(m);
         m[messageType].contextInfo = m[messageType] || {};

package/lib/Utils/noise-handler.d.ts

@@ -0,0 +1,19 @@
+import { ILogger } from './logger';
+import { proto } from '../../WAProto';
+import { KeyPair } from '../Types';
+import { BinaryNode } from '../WABinary';
+export declare const makeNoiseHandler: ({ keyPair: { private: privateKey, public: publicKey }, NOISE_HEADER, logger, routingInfo }: {
+    keyPair: KeyPair;
+    NOISE_HEADER: Uint8Array;
+    logger: ILogger;
+    routingInfo?: Buffer | undefined;
+}) => {
+    encrypt: (plaintext: Uint8Array) => Buffer<ArrayBuffer>;
+    decrypt: (ciphertext: Uint8Array) => Buffer<ArrayBuffer>;
+    authenticate: (data: Uint8Array) => void;
+    mixIntoKey: (data: Uint8Array) => Promise<void>;
+    finishInit: () => Promise<void>;
+    processHandshake: ({ serverHello }: proto.HandshakeMessage, noiseKey: KeyPair) => Promise<Buffer<ArrayBuffer>>;
+    encodeFrame: (data: Buffer | Uint8Array) => Buffer<ArrayBuffer>;
+    decodeFrame: (newData: Buffer | Uint8Array, onFrame: (buff: Uint8Array | BinaryNode) => void) => Promise<void>;
+};

package/lib/Utils/process-message.d.ts

@@ -0,0 +1,42 @@
+import { AxiosRequestConfig } from 'axios';
+import { proto } from '../../WAProto';
+import { AuthenticationCreds, BaileysEventEmitter, CacheStore, SignalKeyStoreWithTransaction, SocketConfig } from '../Types';
+import { ILogger } from './logger';
+type ProcessMessageContext = {
+    shouldProcessHistoryMsg: boolean;
+    placeholderResendCache?: CacheStore;
+    creds: AuthenticationCreds;
+    keyStore: SignalKeyStoreWithTransaction;
+    ev: BaileysEventEmitter;
+    getMessage: SocketConfig['getMessage'];
+    logger?: ILogger;
+    options: AxiosRequestConfig<{}>;
+};
+/** Cleans a received message to further processing */
+export declare const cleanMessage: (message: proto.IWebMessageInfo, meId: string) => void;
+export declare const isRealMessage: (message: proto.IWebMessageInfo, meId: string) => boolean | undefined;
+export declare const shouldIncrementChatUnread: (message: proto.IWebMessageInfo) => boolean;
+/**
+ * Get the ID of the chat from the given key.
+ * Typically -- that'll be the remoteJid, but for broadcasts, it'll be the participant
+ */
+export declare const getChatId: ({ remoteJid, participant, fromMe }: proto.IMessageKey) => string;
+type PollContext = {
+    /** normalised jid of the person that created the poll */
+    pollCreatorJid: string;
+    /** ID of the poll creation message */
+    pollMsgId: string;
+    /** poll creation message enc key */
+    pollEncKey: Uint8Array;
+    /** jid of the person that voted */
+    voterJid: string;
+};
+/**
+ * Decrypt a poll vote
+ * @param vote encrypted vote
+ * @param ctx additional info about the poll required for decryption
+ * @returns list of SHA256 options
+ */
+export declare function decryptPollVote({ encPayload, encIv }: proto.Message.IPollEncValue, { pollCreatorJid, pollMsgId, pollEncKey, voterJid, }: PollContext): proto.Message.PollVoteMessage;
+declare const processMessage: (message: proto.IWebMessageInfo, { shouldProcessHistoryMsg, placeholderResendCache, ev, creds, keyStore, logger, options, getMessage }: ProcessMessageContext) => Promise<void>;
+export default processMessage;

package/lib/Utils/signal.d.ts

@@ -0,0 +1,33 @@
+import { SignalRepository } from '../Types';
+import { AuthenticationCreds, AuthenticationState, KeyPair, SignalIdentity, SignalKeyStore, SignedKeyPair } from '../Types/Auth';
+import { BinaryNode, JidWithDevice } from '../WABinary';
+import { USyncQueryResultList } from '../WAUSync';
+export declare const createSignalIdentity: (wid: string, accountSignatureKey: Uint8Array) => SignalIdentity;
+export declare const getPreKeys: ({ get }: SignalKeyStore, min: number, limit: number) => Promise<{
+    [id: string]: KeyPair;
+}>;
+export declare const generateOrGetPreKeys: (creds: AuthenticationCreds, range: number) => {
+    newPreKeys: {
+        [id: number]: KeyPair;
+    };
+    lastPreKeyId: number;
+    preKeysRange: readonly [number, number];
+};
+export declare const xmppSignedPreKey: (key: SignedKeyPair) => BinaryNode;
+export declare const xmppPreKey: (pair: KeyPair, id: number) => BinaryNode;
+export declare const parseAndInjectE2ESessions: (node: BinaryNode, repository: SignalRepository) => Promise<void>;
+export declare const extractDeviceJids: (result: USyncQueryResultList[], myJid: string, excludeZeroDevices: boolean) => JidWithDevice[];
+/**
+ * get the next N keys for upload or processing
+ * @param count number of pre-keys to get or generate
+ */
+export declare const getNextPreKeys: ({ creds, keys }: AuthenticationState, count: number) => Promise<{
+    update: Partial<AuthenticationCreds>;
+    preKeys: {
+        [id: string]: KeyPair;
+    };
+}>;
+export declare const getNextPreKeysNode: (state: AuthenticationState, count: number) => Promise<{
+    update: Partial<AuthenticationCreds>;
+    node: BinaryNode;
+}>;

package/lib/Utils/use-multi-file-auth-state.d.ts

@@ -0,0 +1,12 @@
+import { AuthenticationState } from '../Types';
+/**
+ * stores the full authentication state in a single folder.
+ * Far more efficient than singlefileauthstate
+ *
+ * Again, I wouldn't endorse this for any production level use other than perhaps a bot.
+ * Would recommend writing an auth state for use with a proper SQL or No-SQL DB
+ * */
+export declare const useMultiFileAuthState: (folder: string) => Promise<{
+    state: AuthenticationState;
+    saveCreds: () => Promise<void>;
+}>;

package/lib/Utils/validate-connection.d.ts

@@ -0,0 +1,10 @@
+import { proto } from '../../WAProto';
+import type { AuthenticationCreds, SignalCreds, SocketConfig } from '../Types';
+import { BinaryNode } from '../WABinary';
+export declare const generateLoginNode: (userJid: string, config: SocketConfig) => proto.IClientPayload;
+export declare const generateRegistrationNode: ({ registrationId, signedPreKey, signedIdentityKey }: SignalCreds, config: SocketConfig) => proto.ClientPayload;
+export declare const configureSuccessfulPairing: (stanza: BinaryNode, { advSecretKey, signedIdentityKey, signalIdentities }: Pick<AuthenticationCreds, "advSecretKey" | "signedIdentityKey" | "signalIdentities">) => {
+    creds: Partial<AuthenticationCreds>;
+    reply: BinaryNode;
+};
+export declare const encodeSignedDeviceIdentity: (account: proto.IADVSignedDeviceIdentity, includeSignatureKey: boolean) => Uint8Array<ArrayBufferLike>;