@langitdeveloper/baileys 2.0.7 → 2.0.9

package/lib/Utils/decode-wa-message.d.ts

@@ -1,19 +0,0 @@
-import { Logger } from 'pino';
-import { proto } from '../../WAProto';
-import { SignalRepository } from '../Types';
-import { BinaryNode } from '../WABinary';
-/**
- * Decode the received node as a message.
- * @note this will only parse the message, not decrypt it
- */
-export declare function decodeMessageNode(stanza: BinaryNode, meId: string, meLid: string): {
-    fullMessage: proto.IWebMessageInfo;
-    author: string;
-    sender: string;
-};
-export declare const decryptMessageNode: (stanza: BinaryNode, meId: string, meLid: string, repository: SignalRepository, logger: Logger) => {
-    fullMessage: proto.IWebMessageInfo;
-    category: string;
-    author: string;
-    decrypt(): Promise<void>;
-};

package/lib/Utils/event-buffer.d.ts

@@ -1,35 +0,0 @@
-import { Logger } from 'pino';
-import { BaileysEventEmitter, BaileysEventMap } from '../Types';
-/**
- * A map that contains a list of all events that have been triggered
- *
- * Note, this can contain different type of events
- * this can make processing events extremely efficient -- since everything
- * can be done in a single transaction
- */
-type BaileysEventData = Partial<BaileysEventMap>;
-type BaileysBufferableEventEmitter = BaileysEventEmitter & {
-    /** Use to process events in a batch */
-    process(handler: (events: BaileysEventData) => void | Promise<void>): (() => void);
-    /**
-     * starts buffering events, call flush() to release them
-     * */
-    buffer(): void;
-    /** buffers all events till the promise completes */
-    createBufferedFunction<A extends any[], T>(work: (...args: A) => Promise<T>): ((...args: A) => Promise<T>);
-    /**
-     * flushes all buffered events
-     * @param force if true, will flush all data regardless of any pending buffers
-     * @returns returns true if the flush actually happened, otherwise false
-     */
-    flush(force?: boolean): boolean;
-    /** is there an ongoing buffer */
-    isBuffering(): boolean;
-};
-/**
- * The event buffer logically consolidates different events into a single event
- * making the data processing more efficient.
- * @param ev the baileys event emitter
- */
-export declare const makeEventBuffer: (logger: Logger) => BaileysBufferableEventEmitter;
-export {};

package/lib/Utils/generics.d.ts

@@ -1,92 +0,0 @@
-/// <reference types="node" />
-import { AxiosRequestConfig } from 'axios';
-import { Logger } from 'pino';
-import { proto } from '../../WAProto';
-import { BaileysEventEmitter, BaileysEventMap, WACallUpdateType, WAVersion } from '../Types';
-import { BinaryNode } from '../WABinary';
-export declare const Browsers: {
-    ubuntu: (browser: any) => [string, string, string];
-    macOS: (browser: any) => [string, string, string];
-    baileys: (browser: any) => [string, string, string];
-    windows: (browser: any) => [string, string, string];
-    /** The appropriate browser based on your OS & release */
-    appropriate: (browser: any) => [string, string, string];
-};
-export declare const getPlatformId: (browser: string) => any;
-export declare const getKeyAuthor: (key: proto.IMessageKey | undefined | null, meId?: string) => string;
-export declare const writeRandomPadMax16: (msg: Uint8Array) => Buffer;
-export declare const unpadRandomMax16: (e: Uint8Array | Buffer) => Uint8Array;
-export declare const encodeWAMessage: (message: proto.IMessage) => Buffer;
-export declare const generateRegistrationId: () => number;
-export declare const encodeBigEndian: (e: number, t?: number) => Uint8Array;
-export declare const toNumber: (t: Long | number | null | undefined) => number;
-/** unix timestamp of a date in seconds */
-export declare const unixTimestampSeconds: (date?: Date) => number;
-export type DebouncedTimeout = ReturnType<typeof debouncedTimeout>;
-export declare const debouncedTimeout: (intervalMs?: number, task?: () => void) => {
-    start: (newIntervalMs?: number, newTask?: () => void) => void;
-    cancel: () => void;
-    setTask: (newTask: () => void) => () => void;
-    setInterval: (newInterval: number) => number;
-};
-export declare const delay: (ms: number) => Promise<void>;
-export declare const delayCancellable: (ms: number) => {
-    delay: Promise<void>;
-    cancel: () => void;
-};
-export declare function promiseTimeout<T>(ms: number | undefined, promise: (resolve: (v: T) => void, reject: (error: any) => void) => void): Promise<T>;
-export declare const generateMessageIDV2: (userId?: string) => string;
-export declare const generateMessageID: () => string;
-export declare function bindWaitForEvent<T extends keyof BaileysEventMap>(ev: BaileysEventEmitter, event: T): (check: (u: BaileysEventMap[T]) => boolean | undefined, timeoutMs?: number) => Promise<void>;
-export declare const bindWaitForConnectionUpdate: (ev: BaileysEventEmitter) => (check: (u: Partial<import("../Types").ConnectionState>) => boolean | undefined, timeoutMs?: number) => Promise<void>;
-export declare const printQRIfNecessaryListener: (ev: BaileysEventEmitter, logger: Logger) => void;
-/**
- * utility that fetches latest baileys version from the master branch.
- * Use to ensure your WA connection is always on the latest version
- */
-export declare const fetchLatestBaileysVersion: (options?: AxiosRequestConfig<any>) => Promise<{
-    version: WAVersion;
-    isLatest: boolean;
-    error?: undefined;
-} | {
-    version: WAVersion;
-    isLatest: boolean;
-    error: any;
-}>;
-/**
- * A utility that fetches the latest web version of whatsapp.
- * Use to ensure your WA connection is always on the latest version
- */
-export declare const fetchLatestWaWebVersion: (options: AxiosRequestConfig<any>) => Promise<{
-    version: WAVersion;
-    isLatest: boolean;
-    error?: undefined;
-} | {
-    version: WAVersion;
-    isLatest: boolean;
-    error: any;
-}>;
-/** unique message tag prefix for MD clients */
-export declare const generateMdTagPrefix: () => string;
-/**
- * Given a type of receipt, returns what the new status of the message should be
- * @param type type from receipt
- */
-export declare const getStatusFromReceiptType: (type: string | undefined) => proto.WebMessageInfo.Status;
-/**
- * Stream errors generally provide a reason, map that to a baileys DisconnectReason
- * @param reason the string reason given, eg. "conflict"
- */
-export declare const getErrorCodeFromStreamError: (node: BinaryNode) => {
-    reason: string;
-    statusCode: number;
-};
-export declare const getCallStatusFromNode: ({ tag, attrs }: BinaryNode) => WACallUpdateType;
-export declare const getCodeFromWSError: (error: Error) => number;
-/**
- * Is the given platform WA business
- * @param platform AuthenticationCreds.platform
- */
-export declare const isWABusinessPlatform: (platform: string) => boolean;
-export declare function trimUndefined(obj: any): any;
-export declare function bytesToCrockford(buffer: Buffer): string;

package/lib/Utils/history.d.ts

@@ -1,15 +0,0 @@
-import { AxiosRequestConfig } from 'axios';
-import { proto } from '../../WAProto';
-import { Chat, Contact } from '../Types';
-export declare const downloadHistory: (msg: proto.Message.IHistorySyncNotification, options: AxiosRequestConfig<any>) => Promise<proto.HistorySync>;
-export declare const processHistoryMessage: (item: proto.IHistorySync) => {
-    chats: Chat[];
-    contacts: Contact[];
-    messages: proto.IWebMessageInfo[];
-};
-export declare const downloadAndProcessHistorySyncNotification: (msg: proto.Message.IHistorySyncNotification, options: AxiosRequestConfig<any>) => Promise<{
-    chats: Chat[];
-    contacts: Contact[];
-    messages: proto.IWebMessageInfo[];
-}>;
-export declare const getHistoryMsg: (message: proto.IMessage) => proto.Message.IHistorySyncNotification | null | undefined;

package/lib/Utils/index.d.ts

@@ -1,17 +0,0 @@
-export * from './generics';
-export * from './decode-wa-message';
-export * from './messages';
-export * from './messages-media';
-export * from './validate-connection';
-export * from './crypto';
-export * from './signal';
-export * from './noise-handler';
-export * from './history';
-export * from './chat-utils';
-export * from './lt-hash';
-export * from './auth-utils';
-export * from './baileys-event-stream';
-export * from './use-multi-file-auth-state';
-export * from './link-preview';
-export * from './event-buffer';
-export * from './process-message';

package/lib/Utils/link-preview.d.ts

@@ -1,21 +0,0 @@
-import { AxiosRequestConfig } from 'axios';
-import { Logger } from 'pino';
-import { WAMediaUploadFunction, WAUrlInfo } from '../Types';
-export type URLGenerationOptions = {
-    thumbnailWidth: number;
-    fetchOpts: {
-        /** Timeout in ms */
-        timeout: number;
-        proxyUrl?: string;
-        headers?: AxiosRequestConfig<{}>['headers'];
-    };
-    uploadImage?: WAMediaUploadFunction;
-    logger?: Logger;
-};
-/**
- * Given a piece of text, checks for any URL present, generates link preview for the same and returns it
- * Return undefined if the fetch failed or no URL was found
- * @param text first matched URL in text
- * @returns the URL info required to generate link preview
- */
-export declare const getUrlInfo: (text: string, opts?: URLGenerationOptions) => Promise<WAUrlInfo | undefined>;

package/lib/Utils/logger.d.ts

@@ -1,4 +0,0 @@
-declare const _default: import("pino").Logger<{
-    timestamp: () => string;
-}>;
-export default _default;

package/lib/Utils/lt-hash.d.ts

@@ -1,12 +0,0 @@
-declare class d {
-    salt: string;
-    constructor(e: string);
-    add(e: any, t: any): any;
-    subtract(e: any, t: any): any;
-    subtractThenAdd(e: any, t: any, r: any): any;
-    _addSingle(e: any, t: any): ArrayBuffer;
-    _subtractSingle(e: any, t: any): ArrayBuffer;
-    performPointwiseWithOverflow(e: any, t: any, r: any): ArrayBuffer;
-}
-export declare const LT_HASH_ANTI_TAMPERING: d;
-export {};

package/lib/Utils/make-mutex.d.ts

@@ -1,7 +0,0 @@
-export declare const makeMutex: () => {
-    mutex<T>(code: () => T | Promise<T>): Promise<T>;
-};
-export type Mutex = ReturnType<typeof makeMutex>;
-export declare const makeKeyedMutex: () => {
-    mutex<T>(key: string, task: () => T | Promise<T>): Promise<T>;
-};

package/lib/Utils/message-retry-manager.js

@@ -1,134 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const { LRUCache: LRUCache } = require("lru-cache");
-const RECENT_MESSAGES_SIZE = 512;
-const MESSAGE_KEY_SEPARATOR = "\0";
-const RECREATE_SESSION_TIMEOUT = 60 * 60 * 1e3;
-const PHONE_REQUEST_DELAY = 3e3;
-class MessageRetryManager {
-    constructor(logger, maxMsgRetryCount) {
-        this.logger = logger;
-        this.recentMessagesMap = new LRUCache({
-            max: RECENT_MESSAGES_SIZE,
-            ttl: 5 * 60 * 1e3,
-            ttlAutopurge: true,
-            dispose: (_value, key) => {
-                const separatorIndex = key.lastIndexOf(MESSAGE_KEY_SEPARATOR);
-                if (separatorIndex > -1) {
-                    const messageId = key.slice(separatorIndex + MESSAGE_KEY_SEPARATOR.length);
-                    this.messageKeyIndex.delete(messageId);
-                }
-            },
-        });
-        this.messageKeyIndex = new Map();
-        this.sessionRecreateHistory = new LRUCache({
-            ttl: RECREATE_SESSION_TIMEOUT * 2,
-            ttlAutopurge: true,
-        });
-        this.retryCounters = new LRUCache({
-            ttl: 15 * 60 * 1e3,
-            ttlAutopurge: true,
-            updateAgeOnGet: true,
-        });
-        this.pendingPhoneRequests = {};
-        this.maxMsgRetryCount = 5;
-        this.statistics = {
-            totalRetries: 0,
-            successfulRetries: 0,
-            failedRetries: 0,
-            mediaRetries: 0,
-            sessionRecreations: 0,
-            phoneRequests: 0,
-        };
-        this.maxMsgRetryCount = maxMsgRetryCount;
-    }
-    addRecentMessage(to, id, message) {
-        const key = { to: to, id: id };
-        const keyStr = this.keyToString(key);
-        this.recentMessagesMap.set(keyStr, {
-            message: message,
-            timestamp: Date.now(),
-        });
-        this.messageKeyIndex.set(id, keyStr);
-        this.logger.debug(`Added message to retry cache: ${to}/${id}`);
-    }
-    getRecentMessage(to, id) {
-        const key = { to: to, id: id };
-        const keyStr = this.keyToString(key);
-        return this.recentMessagesMap.get(keyStr);
-    }
-    shouldRecreateSession(jid, retryCount, hasSession) {
-        if (!hasSession) {
-            this.sessionRecreateHistory.set(jid, Date.now());
-            this.statistics.sessionRecreations++;
-            return {
-                reason: "we don't have a Signal session with them",
-                recreate: true,
-            };
-        }
-        if (retryCount < 2) {
-            return { reason: "", recreate: false };
-        }
-        const now = Date.now();
-        const prevTime = this.sessionRecreateHistory.get(jid);
-        if (!prevTime || now - prevTime > RECREATE_SESSION_TIMEOUT) {
-            this.sessionRecreateHistory.set(jid, now);
-            this.statistics.sessionRecreations++;
-            return {
-                reason: "retry count > 1 and over an hour since last recreation",
-                recreate: true,
-            };
-        }
-        return { reason: "", recreate: false };
-    }
-    incrementRetryCount(messageId) {
-        this.retryCounters.set(messageId, (this.retryCounters.get(messageId) || 0) + 1);
-        this.statistics.totalRetries++;
-        return this.retryCounters.get(messageId);
-    }
-    getRetryCount(messageId) {
-        return this.retryCounters.get(messageId) || 0;
-    }
-    hasExceededMaxRetries(messageId) {
-        return this.getRetryCount(messageId) >= this.maxMsgRetryCount;
-    }
-    markRetrySuccess(messageId) {
-        this.statistics.successfulRetries++;
-        this.retryCounters.delete(messageId);
-        this.cancelPendingPhoneRequest(messageId);
-        this.removeRecentMessage(messageId);
-    }
-    markRetryFailed(messageId) {
-        this.statistics.failedRetries++;
-        this.retryCounters.delete(messageId);
-        this.cancelPendingPhoneRequest(messageId);
-        this.removeRecentMessage(messageId);
-    }
-    schedulePhoneRequest(messageId, callback, delay = PHONE_REQUEST_DELAY) {
-        this.cancelPendingPhoneRequest(messageId);
-        this.pendingPhoneRequests[messageId] = setTimeout(() => {
-            delete this.pendingPhoneRequests[messageId];
-            this.statistics.phoneRequests++;
-            callback();
-        }, delay);
-        this.logger.debug(`Scheduled phone request for message ${messageId} with ${delay}ms delay`);
-    }
-    cancelPendingPhoneRequest(messageId) {
-        const timeout = this.pendingPhoneRequests[messageId];
-        if (timeout) {
-            clearTimeout(timeout);
-            delete this.pendingPhoneRequests[messageId];
-            this.logger.debug(`Cancelled pending phone request for message ${messageId}`);
-        }
-    }
-    keyToString(key) {
-        return `${key.to}${MESSAGE_KEY_SEPARATOR}${key.id}`;
-    }
-    removeRecentMessage(messageId) {
-        const keyStr = this.messageKeyIndex.get(messageId);
-        if (!keyStr) return;
-        this.recentMessagesMap.delete(keyStr);
-        this.messageKeyIndex.delete(messageId);
-    }
-}
-module.exports = { MessageRetryManager: MessageRetryManager };

package/lib/Utils/messages-media.d.ts

@@ -1,116 +0,0 @@
-/// <reference types="node" />
-/// <reference types="node" />
-/// <reference types="node" />
-import { Boom } from '@hapi/boom';
-import { AxiosRequestConfig } from 'axios';
-import type { Logger } from 'pino';
-import { Readable, Transform } from 'stream';
-import { URL } from 'url';
-import { proto } from '../../WAProto';
-import { DownloadableMessage, MediaConnInfo, MediaDecryptionKeyInfo, MediaType, SocketConfig, WAMediaUpload, WAMediaUploadFunction, WAMessageContent } from '../Types';
-import { BinaryNode } from '../WABinary';
-export declare const hkdfInfoKey: (type: MediaType) => string;
-/** generates all the keys required to encrypt/decrypt & sign a media message */
-export declare function getMediaKeys(buffer: Uint8Array | string | null | undefined, mediaType: MediaType): MediaDecryptionKeyInfo;
-export declare const extractImageThumb: (bufferOrFilePath: Readable | Buffer | string, width?: number) => Promise<{
-    buffer: Buffer;
-    original: {
-        width: number | undefined;
-        height: number | undefined;
-    };
-}>;
-export declare const encodeBase64EncodedStringForUpload: (b64: string) => string;
-export declare const generateProfilePicture: (mediaUpload: WAMediaUpload) => Promise<{
-    img: Buffer;
-}>;
-/** gets the SHA256 of the given media message */
-export declare const mediaMessageSHA256B64: (message: WAMessageContent) => string | null | undefined;
-export declare function getAudioDuration(buffer: Buffer | string | Readable): Promise<number | undefined>;
-/**
-  referenced from and modifying https://github.com/wppconnect-team/wa-js/blob/main/src/chat/functions/prepareAudioWaveform.ts
- */
-export declare function getAudioWaveform(buffer: Buffer | string | Readable, logger?: Logger): Promise<Uint8Array | undefined>;
-export declare const toReadable: (buffer: Buffer) => Readable;
-export declare const toBuffer: (stream: Readable) => Promise<Buffer>;
-export declare const getStream: (item: WAMediaUpload, opts?: AxiosRequestConfig) => Promise<{
-    readonly stream: Readable;
-    readonly type: "buffer";
-} | {
-    readonly stream: Readable;
-    readonly type: "readable";
-} | {
-    readonly stream: Readable;
-    readonly type: "remote";
-} | {
-    readonly stream: import("fs").ReadStream;
-    readonly type: "file";
-}>;
-/** generates a thumbnail for a given media, if required */
-export declare function generateThumbnail(file: string, mediaType: 'video' | 'image', options: {
-    logger?: Logger;
-}): Promise<{
-    thumbnail: string | undefined;
-    originalImageDimensions: {
-        width: number;
-        height: number;
-    } | undefined;
-}>;
-export declare const getHttpStream: (url: string | URL, options?: AxiosRequestConfig & {
-    isStream?: true;
-}) => Promise<Readable>;
-type EncryptedStreamOptions = {
-    saveOriginalFileIfRequired?: boolean;
-    logger?: Logger;
-    opts?: AxiosRequestConfig;
-};
-export declare const prepareStream: (media: WAMediaUpload, mediaType: MediaType, { logger, saveOriginalFileIfRequired, opts }?: EncryptedStreamOptions) => Promise<{
-    mediaKey: undefined;
-    encWriteStream: Buffer;
-    fileLength: number;
-    fileSha256: Buffer;
-    fileEncSha256: undefined;
-    bodyPath: string | undefined;
-    didSaveToTmpPath: boolean;
-}>;
-export declare const encryptedStream: (media: WAMediaUpload, mediaType: MediaType, { logger, saveOriginalFileIfRequired, opts }?: EncryptedStreamOptions) => Promise<{
-    mediaKey: Buffer;
-    encWriteStream: Readable;
-    bodyPath: string | undefined;
-    mac: Buffer;
-    fileEncSha256: Buffer;
-    fileSha256: Buffer;
-    fileLength: number;
-    didSaveToTmpPath: boolean;
-}>;
-export type MediaDownloadOptions = {
-    startByte?: number;
-    endByte?: number;
-    options?: AxiosRequestConfig<any>;
-};
-export declare const getUrlFromDirectPath: (directPath: string) => string;
-export declare const downloadContentFromMessage: ({ mediaKey, directPath, url }: DownloadableMessage, type: MediaType, opts?: MediaDownloadOptions) => Promise<Transform>;
-/**
- * Decrypts and downloads an AES256-CBC encrypted file given the keys.
- * Assumes the SHA256 of the plaintext is appended to the end of the ciphertext
- * */
-export declare const downloadEncryptedContent: (downloadUrl: string, { cipherKey, iv }: MediaDecryptionKeyInfo, { startByte, endByte, options }?: MediaDownloadOptions) => Promise<Transform>;
-export declare function extensionForMediaMessage(message: WAMessageContent): string;
-export declare const getWAUploadToServer: ({ customUploadHosts, fetchAgent, logger, options }: SocketConfig, refreshMediaConn: (force: boolean) => Promise<MediaConnInfo>) => WAMediaUploadFunction;
-/**
- * Generate a binary node that will request the phone to re-upload the media & return the newly uploaded URL
- */
-export declare const encryptMediaRetryRequest: (key: proto.IMessageKey, mediaKey: Buffer | Uint8Array, meId: string) => BinaryNode;
-export declare const decodeMediaRetryNode: (node: BinaryNode) => {
-    key: proto.IMessageKey;
-    media?: {
-        ciphertext: Uint8Array;
-        iv: Uint8Array;
-    } | undefined;
-    error?: Boom<any> | undefined;
-};
-export declare const decryptMediaRetryData: ({ ciphertext, iv }: {
-    ciphertext: Uint8Array;
-    iv: Uint8Array;
-}, mediaKey: Uint8Array, msgId: string) => proto.MediaRetryNotification;
-export declare const getStatusCodeForMediaRetry: (code: number) => any;
-export {};

package/lib/Utils/messages.d.ts

@@ -1,77 +0,0 @@
-/// <reference types="node" />
-/// <reference types="node" />
-import { Logger } from 'pino';
-import { type Transform } from 'stream';
-import { proto } from '../../WAProto';
-import { AnyMediaMessageContent, AnyMessageContent, MediaGenerationOptions, MessageContentGenerationOptions, MessageGenerationOptions, MessageGenerationOptionsFromContent, MessageUserReceipt, WAMessage, WAMessageContent, WAProto } from '../Types';
-import { MediaDownloadOptions } from './messages-media';
-/**
- * Uses a regex to test whether the string contains a URL, and returns the URL if it does.
- * @param text eg. hello https://google.com
- * @returns the URL, eg. https://google.com
- */
-export declare const extractUrlFromText: (text: string) => string | undefined;
-export declare const generateLinkPreviewIfRequired: (text: string, getUrlInfo: MessageGenerationOptions['getUrlInfo'], logger: MessageGenerationOptions['logger']) => Promise<import("../Types").WAUrlInfo | undefined>;
-export declare const prepareWAMessageMedia: (message: AnyMediaMessageContent, options: MediaGenerationOptions) => Promise<proto.Message>;
-export declare const prepareDisappearingMessageSettingContent: (ephemeralExpiration?: number) => proto.Message;
-/**
- * Generate forwarded message content like WA does
- * @param message the message to forward
- * @param options.forceForward will show the message as forwarded even if it is from you
- */
-export declare const generateForwardMessageContent: (message: WAMessage, forceForward?: boolean) => proto.IMessage;
-export declare const generateWAMessageContent: (message: AnyMessageContent, options: MessageContentGenerationOptions) => Promise<proto.Message>;
-export declare const generateWAMessageFromContent: (jid: string, message: WAMessageContent, options: MessageGenerationOptionsFromContent) => proto.WebMessageInfo;
-export declare const generateWAMessage: (jid: string, content: AnyMessageContent, options: MessageGenerationOptions) => Promise<proto.WebMessageInfo>;
-/** Get the key to access the true type of content */
-export declare const getContentType: (content: WAProto.IMessage | undefined) => keyof proto.IMessage | undefined;
-/**
- * Normalizes ephemeral, view once messages to regular message content
- * Eg. image messages in ephemeral messages, in view once messages etc.
- * @param content
- * @returns
- */
-export declare const normalizeMessageContent: (content: WAMessageContent | null | undefined) => WAMessageContent | undefined;
-/**
- * Extract the true message content from a message
- * Eg. extracts the inner message from a disappearing message/view once message
- */
-export declare const extractMessageContent: (content: WAMessageContent | undefined | null) => WAMessageContent | undefined;
-/**
- * Returns the device predicted by message ID
- */
-export declare const getDevice: (id: string) => "android" | "unknown" | "web" | "ios" | "desktop";
-/** Upserts a receipt in the message */
-export declare const updateMessageWithReceipt: (msg: Pick<WAMessage, 'userReceipt'>, receipt: MessageUserReceipt) => void;
-/** Update the message with a new reaction */
-export declare const updateMessageWithReaction: (msg: Pick<WAMessage, 'reactions'>, reaction: proto.IReaction) => void;
-/** Update the message with a new poll update */
-export declare const updateMessageWithPollUpdate: (msg: Pick<WAMessage, 'pollUpdates'>, update: proto.IPollUpdate) => void;
-type VoteAggregation = {
-    name: string;
-    voters: string[];
-};
-/**
- * Aggregates all poll updates in a poll.
- * @param msg the poll creation message
- * @param meId your jid
- * @returns A list of options & their voters
- */
-export declare function getAggregateVotesInPollMessage({ message, pollUpdates }: Pick<WAMessage, 'pollUpdates' | 'message'>, meId?: string): VoteAggregation[];
-/** Given a list of message keys, aggregates them by chat & sender. Useful for sending read receipts in bulk */
-export declare const aggregateMessageKeysNotFromMe: (keys: proto.IMessageKey[]) => {
-    jid: string;
-    participant: string | undefined;
-    messageIds: string[];
-}[];
-type DownloadMediaMessageContext = {
-    reuploadRequest: (msg: WAMessage) => Promise<WAMessage>;
-    logger: Logger;
-};
-/**
- * Downloads the given message. Throws an error if it's not a media message
- */
-export declare const downloadMediaMessage: <Type extends "stream" | "buffer">(message: WAMessage, type: Type, options: MediaDownloadOptions, ctx?: DownloadMediaMessageContext) => Promise<Type extends "buffer" ? Buffer : Transform>;
-/** Checks whether the given message is a media message; if it is returns the inner content */
-export declare const assertMediaContent: (content: proto.IMessage | null | undefined) => proto.Message.IVideoMessage | proto.Message.IImageMessage | proto.Message.IAudioMessage | proto.Message.IDocumentMessage | proto.Message.IStickerMessage;
-export {};

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

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

package/lib/Utils/pre-key-manager.js

@@ -1,86 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const { default: PQueue } = require("p-queue");
-class PreKeyManager {
-    constructor(store, logger) {
-        this.store = store;
-        this.logger = logger;
-        this.queues = new Map();
-    }
-    getQueue(keyType) {
-        if (!this.queues.has(keyType)) {
-            this.queues.set(keyType, new PQueue({ concurrency: 1 }));
-        }
-        return this.queues.get(keyType);
-    }
-    async processOperations(data, keyType, transactionCache, mutations, isInTransaction) {
-        const keyData = data[keyType];
-        if (!keyData) return;
-        return this.getQueue(keyType).add(async () => {
-            transactionCache[keyType] = transactionCache[keyType] || {};
-            mutations[keyType] = mutations[keyType] || {};
-            const deletions = [];
-            const updates = {};
-            for (const keyId in keyData) {
-                if (keyData[keyId] === null) {
-                    deletions.push(keyId);
-                } else {
-                    updates[keyId] = keyData[keyId];
-                }
-            }
-            if (Object.keys(updates).length > 0) {
-                Object.assign(transactionCache[keyType], updates);
-                Object.assign(mutations[keyType], updates);
-            }
-            if (deletions.length > 0) {
-                await this.processDeletions(
-                    keyType,
-                    deletions,
-                    transactionCache,
-                    mutations,
-                    isInTransaction
-                );
-            }
-        });
-    }
-    async processDeletions(keyType, ids, transactionCache, mutations, isInTransaction) {
-        if (isInTransaction) {
-            for (const keyId of ids) {
-                if (transactionCache[keyType]?.[keyId]) {
-                    transactionCache[keyType][keyId] = null;
-                    mutations[keyType][keyId] = null;
-                } else {
-                    this.logger.warn(
-                        `Skipping deletion of non-existent ${keyType} in transaction: ${keyId}`
-                    );
-                }
-            }
-        } else {
-            const existingKeys = await this.store.get(keyType, ids);
-            for (const keyId of ids) {
-                if (existingKeys[keyId]) {
-                    transactionCache[keyType][keyId] = null;
-                    mutations[keyType][keyId] = null;
-                } else {
-                    this.logger.warn(`Skipping deletion of non-existent ${keyType}: ${keyId}`);
-                }
-            }
-        }
-    }
-    async validateDeletions(data, keyType) {
-        const keyData = data[keyType];
-        if (!keyData) return;
-        return this.getQueue(keyType).add(async () => {
-            const deletionIds = Object.keys(keyData).filter((id) => keyData[id] === null);
-            if (deletionIds.length === 0) return;
-            const existingKeys = await this.store.get(keyType, deletionIds);
-            for (const keyId of deletionIds) {
-                if (!existingKeys[keyId]) {
-                    this.logger.warn(`Skipping deletion of non-existent ${keyType}: ${keyId}`);
-                    delete data[keyType][keyId];
-                }
-            }
-        });
-    }
-}
-module.exports = { PreKeyManager: PreKeyManager };