@vanzxy/baileys 2.0.0

package/lib/Utils/media-set.js

@@ -0,0 +1,172 @@
+/**
+ * Vanz@Add --- ported from Bail-master addons/media-set.ts.
+ * Profile-picture setters (full/panoramic variants) and group-status /
+ * member-label senders. Depends on this fork's own media-messages.js
+ * (also ported this batch) and its existing generateWAMessageContent /
+ * generateWAMessageFromContent / unixTimestampSeconds / S_WHATSAPP_NET.
+ *
+ * NOTE ON DUPLICATE-LOOKING SETTERS: `updateProfilePictureFull` and
+ * `updateProfilePictureFull2` are genuinely different, not duplicates —
+ * the first sends the `img` buffer from `generateProfilePictureFP`
+ * (scaled-to-fit 720x720 main image), the second sends the `preview`
+ * buffer from `generatePP` (normalized preview). Both are kept.
+ */
+import { randomBytes } from 'node:crypto';
+// Vanz@Fix: unixTimestampSeconds is not re-exported by messages.js (it only imports
+// it internally from generics.js for its own use) — pull it from generics.js directly.
+import { generateWAMessageContent, generateWAMessageFromContent } from './messages.js';
+import { unixTimestampSeconds } from './generics.js';
+import { S_WHATSAPP_NET } from '../WABinary/index.js';
+import { generatePP, generateProfilePictureFP } from './media-messages.js';
+/** Update the profile picture for yourself or a group — sends the main (scaled-to-fit) image. */
+export const updateProfilePictureFull = async (jid, content, sock) => {
+    const { query } = sock;
+    const { img } = await generateProfilePictureFP(content);
+    const media = await query({
+        tag: 'iq',
+        attrs: {
+            target: jid,
+            to: S_WHATSAPP_NET,
+            type: 'set',
+            xmlns: 'w:profile:picture'
+        },
+        content: [
+            {
+                tag: 'picture',
+                attrs: { type: 'image' },
+                content: img
+            }
+        ]
+    });
+    return media;
+};
+/** Update the profile picture for yourself or a group — sends the normalized preview image. */
+export const updateProfilePictureFull2 = async (jid, content, sock) => {
+    const { query } = sock;
+    const { preview } = await generatePP(content);
+    const media = await query({
+        tag: 'iq',
+        attrs: {
+            target: jid,
+            to: S_WHATSAPP_NET,
+            type: 'set',
+            xmlns: 'w:profile:picture'
+        },
+        content: [
+            {
+                tag: 'picture',
+                attrs: { type: 'image' },
+                content: preview
+            }
+        ]
+    });
+    return media;
+};
+/** Send a group status (status update visible only within a group's members). */
+export const groupStatus = async (jid, content, sock) => {
+    const { backgroundColor, ...rest } = content;
+    const inside = await generateWAMessageContent(rest, {
+        upload: sock.waUploadToServer,
+        backgroundColor
+    });
+    const messageSecret = randomBytes(32);
+    const m = generateWAMessageFromContent(jid, {
+        messageContextInfo: { messageSecret },
+        groupStatusMessageV2: {
+            message: {
+                ...inside,
+                messageContextInfo: { messageSecret }
+            }
+        }
+    }, {});
+    await sock.relayMessage(jid, m.message, { messageId: m.key.id });
+    return m;
+};
+/** Send the same group status to multiple groups at once. */
+export const groupStatusV2 = async (jids, content, sock) => {
+    const { backgroundColor, ...rest } = content;
+    const inside = await generateWAMessageContent(rest, {
+        upload: sock.waUploadToServer,
+        backgroundColor
+    });
+    const messageSecret = randomBytes(32);
+    const results = [];
+    for (const id of jids) {
+        const m = generateWAMessageFromContent(id, {
+            messageContextInfo: { messageSecret },
+            groupStatusMessageV2: {
+                message: {
+                    ...inside,
+                    messageContextInfo: { messageSecret }
+                }
+            }
+        }, {});
+        await sock.relayMessage(id, m.message, { messageId: m.key.id });
+        results.push(m);
+    }
+    return results;
+};
+/**
+ * Set/update a member's label in a group (awaits the relay and returns the result).
+ * Label is truncated to 30 characters (WA's limit).
+ */
+export const groupSetMemberLabel = async (jid, memberLabel, sock) => {
+    const result = await sock.relayMessage(jid, {
+        protocolMessage: {
+            type: 30,
+            memberLabel: {
+                label: memberLabel.slice(0, 30),
+                labelTimestamp: unixTimestampSeconds() || Date.now()
+            }
+        }
+    }, {
+        additionalNodes: [
+            {
+                tag: 'meta',
+                attrs: {
+                    tag_reason: 'user_update',
+                    appdata: 'member_tag'
+                },
+                content: undefined
+            }
+        ]
+    });
+    return result;
+};
+/**
+ * Set/update a member's label in a group — fire-and-forget variant (errors
+ * are swallowed, matching the source's behavior; prefer
+ * `groupSetMemberLabel` if you need to await/observe failures).
+ */
+export const groupLabel = async (jid, text, sock) => {
+    try {
+        void sock.relayMessage(jid, {
+            protocolMessage: {
+                type: 30,
+                memberLabel: {
+                    label: text.slice(0, 30),
+                    // Vanz@Fix (bug 67): this used Date.now() (milliseconds) while the
+                    // sibling groupSetMemberLabel() correctly uses unixTimestampSeconds()
+                    // for the same proto field — WA's *Timestamp fields are unix-seconds,
+                    // so this was sending a timestamp ~1000x too large.
+                    labelTimestamp: unixTimestampSeconds() || Date.now()
+                }
+            }
+        }, {
+            additionalNodes: [
+                {
+                    tag: 'meta',
+                    attrs: {
+                        tag_reason: 'user_update',
+                        appdata: 'member_tag'
+                    },
+                    content: undefined
+                }
+            ]
+        });
+    }
+    catch {
+        // intentionally swallowed — matches source behavior
+    }
+};
+//# sourceMappingURL=media-set.js.map

package/lib/Utils/message-kind.js

@@ -0,0 +1,139 @@
+/**
+ * Evernight AI — lib/Utils/message-kind.js / Creator : Vanzxy🍃
+ *
+ * Addon-kind resolution logic adapted from zapo-js (MIT, © vinikjkkj)
+ * <https://github.com/vinikjkkj/zapo>, ported to this Baileys fork's
+ * message-content shape. The normalized reply parser below is original,
+ * written to cover this fork's own buttonsResponseMessage /
+ * listResponseMessage / interactiveResponseMessage / templateButtonReplyMessage
+ * send-side shapes (see messages.js).
+ */
+
+/**
+ * Unwraps ephemeral/viewOnce/edited wrappers to get at the real content.
+ * Mirrors the wrapper set already handled by normalizeMessageContent()
+ * in messages.js, kept local here to avoid a circular import.
+ */
+const unwrapMessage = (message) => {
+    let content = message;
+    for (let i = 0; i < 5; i++) {
+        const inner = content?.ephemeralMessage?.message ||
+            content?.viewOnceMessage?.message ||
+            content?.viewOnceMessageV2?.message ||
+            content?.viewOnceMessageV2Extension?.message ||
+            content?.documentWithCaptionMessage?.message ||
+            content?.editedMessage?.message;
+        if (!inner) {
+            break;
+        }
+        content = inner;
+    }
+    return content;
+};
+
+/**
+ * Companion "addon kind" for list / native-flow style messages.
+ * Ported from zapo-js's resolveButtonAddonKind (src/message/encode/content.ts).
+ * @typedef {'list' | 'interactive' | 'payment_info' | 'order_details'} WaButtonAddonKind
+ */
+
+const resolveNativeFlowAddonKind = (nativeFlow) => {
+    const firstButtonName = nativeFlow?.buttons?.[0]?.name;
+    if (firstButtonName === 'payment_info')
+        return 'payment_info';
+    if (firstButtonName === 'review_and_pay')
+        return 'order_details';
+    return 'interactive';
+};
+
+/**
+ * Resolves which kind of button/list addon an outgoing message carries.
+ * Returns null if the message has no button/list/native-flow content.
+ * @param {import('../../WAProto').proto.IMessage} message
+ * @returns {WaButtonAddonKind | null}
+ */
+export const resolveButtonAddonKind = (message) => {
+    const msg = unwrapMessage(message);
+    if (!msg)
+        return null;
+    if (msg.listMessage)
+        return 'list';
+    if (msg.buttonsMessage)
+        return 'interactive';
+    const nativeFlow = msg.interactiveMessage?.nativeFlowMessage;
+    if (nativeFlow)
+        return resolveNativeFlowAddonKind(nativeFlow);
+    return null;
+};
+
+/**
+ * Normalized shape returned by parseInteractiveReply, regardless of which
+ * underlying WhatsApp reply type produced it.
+ * @typedef {Object} NormalizedInteractiveReply
+ * @property {'buttons_response'|'list_response'|'native_flow_response'|'template_button_reply'|null} kind
+ * @property {string|null} id - the button/row/native-flow id the user selected
+ * @property {string|null} displayText - visible text of the selection, if present
+ * @property {Object|null} params - parsed paramsJson for native-flow responses, or null
+ */
+
+/**
+ * Reads whatever a user tapped (button, list row, or native-flow reply) and
+ * returns one consistent shape, so plugin authors don't need a different
+ * branch per response type. Safe against malformed paramsJson (returns null
+ * instead of throwing).
+ * @param {import('../../WAProto').proto.IMessage} message
+ * @returns {NormalizedInteractiveReply}
+ */
+export const parseInteractiveReply = (message) => {
+    const msg = unwrapMessage(message);
+    const empty = { kind: null, id: null, displayText: null, params: null };
+    if (!msg)
+        return empty;
+    if (msg.buttonsResponseMessage) {
+        const r = msg.buttonsResponseMessage;
+        return {
+            kind: 'buttons_response',
+            id: r.selectedButtonId || null,
+            displayText: r.selectedDisplayText || null,
+            params: null
+        };
+    }
+    if (msg.listResponseMessage) {
+        const r = msg.listResponseMessage;
+        return {
+            kind: 'list_response',
+            id: r.singleSelectReply?.selectedRowId || null,
+            displayText: r.title || r.description || null,
+            params: null
+        };
+    }
+    if (msg.interactiveResponseMessage) {
+        const r = msg.interactiveResponseMessage;
+        let params = null;
+        if (r.nativeFlowResponseMessage?.paramsJson) {
+            try {
+                params = JSON.parse(r.nativeFlowResponseMessage.paramsJson);
+            }
+            catch {
+                params = null;
+            }
+        }
+        return {
+            kind: 'native_flow_response',
+            id: params?.id ?? r.nativeFlowResponseMessage?.name ?? null,
+            displayText: r.body?.text || null,
+            params
+        };
+    }
+    if (msg.templateButtonReplyMessage) {
+        const r = msg.templateButtonReplyMessage;
+        return {
+            kind: 'template_button_reply',
+            id: r.selectedId || null,
+            displayText: r.selectedDisplayText || null,
+            params: null
+        };
+    }
+    return empty;
+};
+//# sourceMappingURL=message-kind.js.map

package/lib/Utils/message-retry-manager.d.ts

@@ -0,0 +1,79 @@
+export const RetryReason: any;
+export class MessageRetryManager {
+    constructor(logger: any, maxMsgRetryCount: any);
+    logger: any;
+    recentMessagesMap: any;
+    messageKeyIndex: Map<any, any>;
+    sessionRecreateHistory: any;
+    retryCounters: any;
+    baseKeys: any;
+    pendingPhoneRequests: {};
+    maxMsgRetryCount: any;
+    statistics: {
+        totalRetries: number;
+        successfulRetries: number;
+        failedRetries: number;
+        mediaRetries: number;
+        sessionRecreations: number;
+        phoneRequests: number;
+    };
+    /**
+     * Add a recent message to the cache for retry handling
+     */
+    addRecentMessage(to: any, id: any, message: any): void;
+    /**
+     * Get a recent message from the cache
+     */
+    getRecentMessage(to: any, id: any): any;
+    /**
+     * Check if a session should be recreated based on retry count, history, and error code.
+     * MAC errors (codes 4 and 7) trigger immediate session recreation regardless of timeout.
+     */
+    shouldRecreateSession(jid: any, hasSession: any, errorCode: any): {
+        reason: string;
+        recreate: boolean;
+    };
+    /**
+     * Parse error code from retry receipt's retry node.
+     * Returns undefined if no error code is present.
+     */
+    parseRetryErrorCode(errorAttr: any): any;
+    /**
+     * Check if an error code indicates a MAC failure
+     */
+    isMacError(errorCode: any): boolean;
+    /**
+     * Increment retry counter for a message
+     */
+    incrementRetryCount(messageId: any): any;
+    /**
+     * Get retry count for a message
+     */
+    getRetryCount(messageId: any): any;
+    /**
+     * Check if message has exceeded maximum retry attempts
+     */
+    hasExceededMaxRetries(messageId: any): boolean;
+    /**
+     * Mark retry as successful
+     */
+    markRetrySuccess(messageId: any): void;
+    /**
+     * Mark retry as failed
+     */
+    markRetryFailed(messageId: any): void;
+    /**
+     * Schedule a phone request with delay
+     */
+    schedulePhoneRequest(messageId: any, callback: any, delay?: number): void;
+    /**
+     * Cancel pending phone request
+     */
+    cancelPendingPhoneRequest(messageId: any): void;
+    clear(): void;
+    saveBaseKey(addr: any, msgId: any, baseKey: any): void;
+    hasSameBaseKey(addr: any, msgId: any, baseKey: any): boolean;
+    deleteBaseKey(addr: any, msgId: any): void;
+    keyToString(key: any): string;
+    removeRecentMessage(messageId: any): void;
+}

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

@@ -0,0 +1,265 @@
+import { LRUCache } from 'lru-cache';
+/** Number of sent messages to cache in memory for handling retry receipts */
+const RECENT_MESSAGES_SIZE = 1024;
+const MESSAGE_KEY_SEPARATOR = '\u0000';
+/** Timeout for session recreation - 1 hour */
+const RECREATE_SESSION_TIMEOUT = 60 * 60 * 1000; // 1 hour in milliseconds
+const PHONE_REQUEST_DELAY = 3000;
+// Retry reason codes matching WhatsApp Web's Signal error codes.
+export var RetryReason;
+(function (RetryReason) {
+    RetryReason[RetryReason["UnknownError"] = 0] = "UnknownError";
+    RetryReason[RetryReason["SignalErrorNoSession"] = 1] = "SignalErrorNoSession";
+    RetryReason[RetryReason["SignalErrorInvalidKey"] = 2] = "SignalErrorInvalidKey";
+    RetryReason[RetryReason["SignalErrorInvalidKeyId"] = 3] = "SignalErrorInvalidKeyId";
+    /** MAC verification failed - most common cause of decryption failures */
+    RetryReason[RetryReason["SignalErrorInvalidMessage"] = 4] = "SignalErrorInvalidMessage";
+    RetryReason[RetryReason["SignalErrorInvalidSignature"] = 5] = "SignalErrorInvalidSignature";
+    RetryReason[RetryReason["SignalErrorFutureMessage"] = 6] = "SignalErrorFutureMessage";
+    /** Explicit MAC failure - session is definitely out of sync */
+    RetryReason[RetryReason["SignalErrorBadMac"] = 7] = "SignalErrorBadMac";
+    RetryReason[RetryReason["SignalErrorInvalidSession"] = 8] = "SignalErrorInvalidSession";
+    RetryReason[RetryReason["SignalErrorInvalidMsgKey"] = 9] = "SignalErrorInvalidMsgKey";
+    RetryReason[RetryReason["BadBroadcastEphemeralSetting"] = 10] = "BadBroadcastEphemeralSetting";
+    RetryReason[RetryReason["UnknownCompanionNoPrekey"] = 11] = "UnknownCompanionNoPrekey";
+    RetryReason[RetryReason["AdvFailure"] = 12] = "AdvFailure";
+    RetryReason[RetryReason["StatusRevokeDelay"] = 13] = "StatusRevokeDelay";
+})(RetryReason || (RetryReason = {}));
+/** Error codes that indicate a MAC failure and require immediate session recreation */
+const MAC_ERROR_CODES = new Set([RetryReason.SignalErrorInvalidMessage, RetryReason.SignalErrorBadMac]);
+export class MessageRetryManager {
+    constructor(logger, maxMsgRetryCount) {
+        this.logger = logger;
+        this.recentMessagesMap = new LRUCache({
+            max: RECENT_MESSAGES_SIZE,
+            ttl: 5 * 60 * 1000,
+            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 * 1000,
+            ttlAutopurge: true,
+            updateAgeOnGet: true
+        }); // 15 minutes TTL
+        this.baseKeys = new LRUCache({
+            max: 1024,
+            ttl: 15 * 60 * 1000,
+            ttlAutopurge: true
+        });
+        this.pendingPhoneRequests = {};
+        this.maxMsgRetryCount = 5;
+        this.statistics = {
+            totalRetries: 0,
+            successfulRetries: 0,
+            failedRetries: 0,
+            mediaRetries: 0,
+            sessionRecreations: 0,
+            phoneRequests: 0
+        };
+        this.maxMsgRetryCount = maxMsgRetryCount;
+    }
+    /**
+     * Add a recent message to the cache for retry handling
+     */
+    addRecentMessage(to, id, message) {
+        const key = { to, id };
+        const keyStr = this.keyToString(key);
+        // Add new message
+        this.recentMessagesMap.set(keyStr, {
+            message,
+            timestamp: Date.now()
+        });
+        this.messageKeyIndex.set(id, keyStr);
+        this.logger.debug(`Added message to retry cache: ${to}/${id}`);
+    }
+    /**
+     * Get a recent message from the cache
+     */
+    getRecentMessage(to, id) {
+        const key = { to, id };
+        const keyStr = this.keyToString(key);
+        return this.recentMessagesMap.get(keyStr);
+    }
+    /**
+     * Check if a session should be recreated based on retry count, history, and error code.
+     * MAC errors (codes 4 and 7) trigger immediate session recreation regardless of timeout.
+     */
+    shouldRecreateSession(jid, hasSession, errorCode) {
+        // If we don't have a session, always recreate
+        if (!hasSession) {
+            this.sessionRecreateHistory.set(jid, Date.now());
+            this.statistics.sessionRecreations++;
+            return {
+                reason: "we don't have a Signal session with them",
+                recreate: true
+            };
+        }
+        // IMMEDIATE recreation for MAC errors - session is definitely out of sync
+        if (errorCode !== undefined && MAC_ERROR_CODES.has(errorCode)) {
+            this.sessionRecreateHistory.set(jid, Date.now());
+            this.statistics.sessionRecreations++;
+            this.logger.warn({ jid, errorCode: RetryReason[errorCode] }, 'MAC error detected, forcing immediate session recreation');
+            return {
+                reason: `MAC error (code ${errorCode}: ${RetryReason[errorCode]}), immediate session recreation`,
+                recreate: true
+            };
+        }
+        const now = Date.now();
+        const prevTime = this.sessionRecreateHistory.get(jid);
+        // If no previous recreation or it's been more than an hour
+        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 };
+    }
+    /**
+     * Parse error code from retry receipt's retry node.
+     * Returns undefined if no error code is present.
+     */
+    parseRetryErrorCode(errorAttr) {
+        if (errorAttr === undefined || errorAttr === '') {
+            return undefined;
+        }
+        const code = parseInt(errorAttr, 10);
+        if (Number.isNaN(code)) {
+            return undefined;
+        }
+        // Validate it's a known RetryReason
+        if (code >= RetryReason.UnknownError && code <= RetryReason.StatusRevokeDelay) {
+            return code;
+        }
+        return RetryReason.UnknownError;
+    }
+    /**
+     * Check if an error code indicates a MAC failure
+     */
+    isMacError(errorCode) {
+        return errorCode !== undefined && MAC_ERROR_CODES.has(errorCode);
+    }
+    /**
+     * Increment retry counter for a message
+     */
+    incrementRetryCount(messageId) {
+        this.retryCounters.set(messageId, (this.retryCounters.get(messageId) || 0) + 1);
+        this.statistics.totalRetries++;
+        return this.retryCounters.get(messageId);
+    }
+    /**
+     * Get retry count for a message
+     */
+    getRetryCount(messageId) {
+        return this.retryCounters.get(messageId) || 0;
+    }
+    /**
+     * Check if message has exceeded maximum retry attempts
+     */
+    hasExceededMaxRetries(messageId) {
+        return this.getRetryCount(messageId) >= this.maxMsgRetryCount;
+    }
+    /**
+     * Mark retry as successful
+     */
+    markRetrySuccess(messageId) {
+        this.statistics.successfulRetries++;
+        // Clean up retry counter for successful message
+        this.retryCounters.delete(messageId);
+        this.cancelPendingPhoneRequest(messageId);
+        this.removeRecentMessage(messageId);
+    }
+    /**
+     * Mark retry as failed
+     */
+    markRetryFailed(messageId) {
+        this.statistics.failedRetries++;
+        this.retryCounters.delete(messageId);
+        this.cancelPendingPhoneRequest(messageId);
+        this.removeRecentMessage(messageId);
+    }
+    /**
+     * Schedule a phone request with delay
+     */
+    schedulePhoneRequest(messageId, callback, delay = PHONE_REQUEST_DELAY) {
+        // Cancel any existing request for this message
+        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`);
+    }
+    /**
+     * Cancel pending phone request
+     */
+    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}`);
+        }
+    }
+    clear() {
+        this.recentMessagesMap.clear();
+        this.messageKeyIndex.clear();
+        this.sessionRecreateHistory.clear();
+        this.retryCounters.clear();
+        this.baseKeys.clear();
+        for (const messageId of Object.keys(this.pendingPhoneRequests)) {
+            this.cancelPendingPhoneRequest(messageId);
+        }
+        this.statistics = {
+            totalRetries: 0,
+            successfulRetries: 0,
+            failedRetries: 0,
+            mediaRetries: 0,
+            sessionRecreations: 0,
+            phoneRequests: 0
+        };
+    }
+    saveBaseKey(addr, msgId, baseKey) {
+        this.baseKeys.set(`${addr}:${msgId}`, baseKey);
+    }
+    hasSameBaseKey(addr, msgId, baseKey) {
+        const stored = this.baseKeys.get(`${addr}:${msgId}`);
+        if (!stored || stored.length !== baseKey.length) {
+            return false;
+        }
+        for (let i = 0; i < stored.length; i++) {
+            if (stored[i] !== baseKey[i])
+                return false;
+        }
+        return true;
+    }
+    deleteBaseKey(addr, msgId) {
+        this.baseKeys.delete(`${addr}:${msgId}`);
+    }
+    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);
+    }
+}
+//# sourceMappingURL=message-retry-manager.js.map

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

@@ -0,0 +1,44 @@
+import type { WAMessage } from '../Types/index.js';
+export type SearchMessageType = 'text' | 'image' | 'video' | 'document' | 'audio' | 'sticker' | 'location' | 'contact' | 'other';
+export interface SearchOptions {
+    jid?: string;
+    fromDate?: Date;
+    toDate?: Date;
+    fromSender?: string;
+    fromMe?: boolean;
+    messageTypes?: SearchMessageType[];
+    limit?: number;
+    caseSensitive?: boolean;
+}
+export interface SearchResult {
+    message: WAMessage;
+    matchedText: string;
+    matchPosition: number;
+    relevanceScore: number;
+}
+export interface RegexSearchOptions {
+    jid?: string;
+    fromSender?: string;
+    fromMe?: boolean;
+    messageTypes?: SearchMessageType[];
+    limit?: number;
+}
+export declare const extractMessageText: (message: WAMessage) => string;
+export declare const calculateRelevance: (query: string, text: string, position: number) => number;
+export declare const searchMessages: (messages: WAMessage[], query: string, options?: SearchOptions) => SearchResult[];
+export declare const searchMessagesRegex: (messages: WAMessage[], pattern: RegExp, options?: RegexSearchOptions) => SearchResult[];
+export declare class MessageSearchManager {
+    private messages;
+    private messageIndex;
+    addMessages(messages: WAMessage[]): void;
+    removeMessages(messageIds: string[]): void;
+    clear(): void;
+    get count(): number;
+    search(query: string, options?: SearchOptions): SearchResult[];
+    searchRegex(pattern: RegExp, options?: RegexSearchOptions): SearchResult[];
+    getByJid(jid: string): WAMessage[];
+    getBySender(sender: string): WAMessage[];
+    getByType(type: SearchMessageType): WAMessage[];
+    getById(id: string): WAMessage | undefined;
+}
+export declare const createMessageSearch: () => MessageSearchManager;