@hbmodsofc/baileys 1.5.2 → 1.7.7

package/lib/Utils/link-preview.js

@@ -1,4 +1,37 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getUrlInfo = void 0;
 const messages_1 = require("./messages");
@@ -20,12 +53,11 @@ const getUrlInfo = async (text, opts = {
     thumbnailWidth: THUMBNAIL_WIDTH_PX,
     fetchOpts: { timeout: 3000 }
 }) => {
-    var _a;
     try {
         // retries
         const retries = 0;
         const maxRetry = 5;
-        const { getLinkPreview } = await import('link-preview-js');
+        const { getLinkPreview } = await Promise.resolve().then(() => __importStar(require('link-preview-js')));
         let previewLink = text;
         if (!text.startsWith('https://') && !text.startsWith('http://')) {
             previewLink = 'https://' + previewLink;
@@ -39,9 +71,9 @@ const getUrlInfo = async (text, opts = {
                 if (retries >= maxRetry) {
                     return false;
                 }
-                if (forwardedURLObj.hostname === urlObj.hostname
-                    || forwardedURLObj.hostname === 'www.' + urlObj.hostname
-                    || 'www.' + forwardedURLObj.hostname === urlObj.hostname) {
+                if (forwardedURLObj.hostname === urlObj.hostname ||
+                    forwardedURLObj.hostname === 'www.' + urlObj.hostname ||
+                    'www.' + forwardedURLObj.hostname === urlObj.hostname) {
                     retries + 1;
                     return true;
                 }
@@ -66,19 +98,15 @@ const getUrlInfo = async (text, opts = {
                     mediaTypeOverride: 'thumbnail-link',
                     options: opts.fetchOpts
                 });
-                urlInfo.jpegThumbnail = (imageMessage === null || imageMessage === void 0 ? void 0 : imageMessage.jpegThumbnail)
-                    ? Buffer.from(imageMessage.jpegThumbnail)
-                    : undefined;
+                urlInfo.jpegThumbnail = imageMessage?.jpegThumbnail ? Buffer.from(imageMessage.jpegThumbnail) : undefined;
                 urlInfo.highQualityThumbnail = imageMessage || undefined;
             }
             else {
                 try {
-                    urlInfo.jpegThumbnail = image
-                        ? (await getCompressedJpegThumbnail(image, opts)).buffer
-                        : undefined;
+                    urlInfo.jpegThumbnail = image ? (await getCompressedJpegThumbnail(image, opts)).buffer : undefined;
                 }
                 catch (error) {
-                    (_a = opts.logger) === null || _a === void 0 ? void 0 : _a.debug({ err: error.stack, url: previewLink }, 'error in generating thumbnail');
+                    opts.logger?.debug({ err: error.stack, url: previewLink }, 'error in generating thumbnail');
                 }
             }
             return urlInfo;

package/lib/Utils/logger.d.ts

@@ -1,4 +1,12 @@
-declare const _default: import("pino").Logger<{
-    timestamp: () => string;
-}>;
+import P from 'pino';
+export interface ILogger {
+    level: string;
+    child(obj: Record<string, unknown>): ILogger;
+    trace(obj: unknown, msg?: string): void;
+    debug(obj: unknown, msg?: string): void;
+    info(obj: unknown, msg?: string): void;
+    warn(obj: unknown, msg?: string): void;
+    error(obj: unknown, msg?: string): void;
+}
+declare const _default: P.Logger<never, boolean>;
 export default _default;

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

@@ -1,12 +1,12 @@
-declare class d {
+declare class LTHash {
     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;
+    add(e: ArrayBuffer, t: ArrayBuffer[]): Promise<ArrayBuffer>;
+    subtract(e: ArrayBuffer, t: ArrayBuffer[]): Promise<ArrayBuffer>;
+    subtractThenAdd(e: ArrayBuffer, addList: ArrayBuffer[], subtractList: ArrayBuffer[]): Promise<ArrayBuffer>;
+    private _addSingle;
+    private _subtractSingle;
+    private performPointwiseWithOverflow;
 }
-export declare const LT_HASH_ANTI_TAMPERING: d;
+export declare const LT_HASH_ANTI_TAMPERING: LTHash;
 export {};

package/lib/Utils/lt-hash.js

@@ -8,44 +8,43 @@ const crypto_1 = require("./crypto");
  * if the same series of mutations was made sequentially.
  */
 const o = 128;
-class d {
+class LTHash {
     constructor(e) {
         this.salt = e;
     }
-    add(e, t) {
-        var r = this;
+    async add(e, t) {
         for (const item of t) {
-            e = r._addSingle(e, item);
+            e = await this._addSingle(e, item);
         }
         return e;
     }
-    subtract(e, t) {
-        var r = this;
+    async subtract(e, t) {
         for (const item of t) {
-            e = r._subtractSingle(e, item);
+            e = await this._subtractSingle(e, item);
         }
         return e;
     }
-    subtractThenAdd(e, t, r) {
-        var n = this;
-        return n.add(n.subtract(e, r), t);
+    async subtractThenAdd(e, addList, subtractList) {
+        const subtracted = await this.subtract(e, subtractList);
+        return this.add(subtracted, addList);
     }
-    _addSingle(e, t) {
-        var r = this;
-        const n = new Uint8Array((0, crypto_1.hkdf)(Buffer.from(t), o, { info: r.salt })).buffer;
-        return r.performPointwiseWithOverflow(e, n, ((e, t) => e + t));
+    async _addSingle(e, t) {
+        const derived = new Uint8Array(await (0, crypto_1.hkdf)(Buffer.from(t), o, { info: this.salt })).buffer;
+        return this.performPointwiseWithOverflow(e, derived, (a, b) => a + b);
     }
-    _subtractSingle(e, t) {
-        var r = this;
-        const n = new Uint8Array((0, crypto_1.hkdf)(Buffer.from(t), o, { info: r.salt })).buffer;
-        return r.performPointwiseWithOverflow(e, n, ((e, t) => e - t));
+    async _subtractSingle(e, t) {
+        const derived = new Uint8Array(await (0, crypto_1.hkdf)(Buffer.from(t), o, { info: this.salt })).buffer;
+        return this.performPointwiseWithOverflow(e, derived, (a, b) => a - b);
     }
-    performPointwiseWithOverflow(e, t, r) {
-        const n = new DataView(e), i = new DataView(t), a = new ArrayBuffer(n.byteLength), s = new DataView(a);
-        for (let e = 0; e < n.byteLength; e += 2) {
-            s.setUint16(e, r(n.getUint16(e, !0), i.getUint16(e, !0)), !0);
+    performPointwiseWithOverflow(e, t, op) {
+        const n = new DataView(e);
+        const i = new DataView(t);
+        const out = new ArrayBuffer(n.byteLength);
+        const s = new DataView(out);
+        for (let offset = 0; offset < n.byteLength; offset += 2) {
+            s.setUint16(offset, op(n.getUint16(offset, true), i.getUint16(offset, true)), true);
         }
-        return a;
+        return out;
     }
 }
-exports.LT_HASH_ANTI_TAMPERING = new d('WhatsApp Patch Integrity');
+exports.LT_HASH_ANTI_TAMPERING = new LTHash('WhatsApp Patch Integrity');

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

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

package/lib/Utils/make-mutex.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.makeKeyedMutex = exports.makeMutex = void 0;
 const makeMutex = () => {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     let task = Promise.resolve();
     let taskTimeout;
     return {
@@ -12,7 +13,7 @@ const makeMutex = () => {
                 try {
                     await task;
                 }
-                catch (_a) { }
+                catch { }
                 try {
                     // execute the current task
                     const result = await code();
@@ -25,7 +26,7 @@ const makeMutex = () => {
             // we replace the existing task, appending the new piece of execution to it
             // so the next task will have to wait for this one to finish
             return task;
-        },
+        }
     };
 };
 exports.makeMutex = makeMutex;

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

@@ -0,0 +1,81 @@
+import type { proto } from '../../WAProto/index.js';
+import type { ILogger } from './logger';
+export interface RecentMessageKey {
+    to: string;
+    id: string;
+}
+export interface RecentMessage {
+    message: proto.IMessage;
+    timestamp: number;
+}
+export interface SessionRecreateHistory {
+    [jid: string]: number;
+}
+export interface RetryCounter {
+    [messageId: string]: number;
+}
+export interface PendingPhoneRequest {
+    [messageId: string]: NodeJS.Timeout;
+}
+export interface RetryStatistics {
+    totalRetries: number;
+    successfulRetries: number;
+    failedRetries: number;
+    mediaRetries: number;
+    sessionRecreations: number;
+    phoneRequests: number;
+}
+export declare class MessageRetryManager {
+    private logger;
+    private recentMessagesMap;
+    private sessionRecreateHistory;
+    private retryCounters;
+    private pendingPhoneRequests;
+    private readonly maxMsgRetryCount;
+    private statistics;
+    constructor(logger: ILogger, maxMsgRetryCount: number);
+    /**
+     * Add a recent message to the cache for retry handling
+     */
+    addRecentMessage(to: string, id: string, message: proto.IMessage): void;
+    /**
+     * Get a recent message from the cache
+     */
+    getRecentMessage(to: string, id: string): RecentMessage | undefined;
+    /**
+     * Check if a session should be recreated based on retry count and history
+     */
+    shouldRecreateSession(jid: string, retryCount: number, hasSession: boolean): {
+        reason: string;
+        recreate: boolean;
+    };
+    /**
+     * Increment retry counter for a message
+     */
+    incrementRetryCount(messageId: string): number;
+    /**
+     * Get retry count for a message
+     */
+    getRetryCount(messageId: string): number;
+    /**
+     * Check if message has exceeded maximum retry attempts
+     */
+    hasExceededMaxRetries(messageId: string): boolean;
+    /**
+     * Mark retry as successful
+     */
+    markRetrySuccess(messageId: string): void;
+    /**
+     * Mark retry as failed
+     */
+    markRetryFailed(messageId: string): void;
+    /**
+     * Schedule a phone request with delay
+     */
+    schedulePhoneRequest(messageId: string, callback: () => void, delay?: number): void;
+    /**
+     * Cancel pending phone request
+     */
+    cancelPendingPhoneRequest(messageId: string): void;
+    private keyToString;
+}

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

@@ -0,0 +1,152 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MessageRetryManager = void 0;
+const lru_cache_1 = require("lru-cache");
+/** Number of sent messages to cache in memory for handling retry receipts */
+const RECENT_MESSAGES_SIZE = 512;
+/** Timeout for session recreation - 1 hour */
+const RECREATE_SESSION_TIMEOUT = 60 * 60 * 1000; // 1 hour in milliseconds
+const PHONE_REQUEST_DELAY = 3000;
+class MessageRetryManager {
+    constructor(logger, maxMsgRetryCount) {
+        this.logger = logger;
+        this.recentMessagesMap = new lru_cache_1.LRUCache({
+            max: RECENT_MESSAGES_SIZE
+        });
+        this.sessionRecreateHistory = new lru_cache_1.LRUCache({
+            ttl: RECREATE_SESSION_TIMEOUT * 2,
+            ttlAutopurge: true
+        });
+        this.retryCounters = new lru_cache_1.LRUCache({
+            ttl: 15 * 60 * 1000,
+            ttlAutopurge: true,
+            updateAgeOnGet: true
+        }); // 15 minutes TTL
+        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.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 and history
+     */
+    shouldRecreateSession(jid, retryCount, hasSession) {
+        // 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
+            };
+        }
+        // Only consider recreation if retry count > 1
+        if (retryCount < 2) {
+            return { reason: '', recreate: false };
+        }
+        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 };
+    }
+    /**
+     * 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);
+    }
+    /**
+     * Mark retry as failed
+     */
+    markRetryFailed(messageId) {
+        this.statistics.failedRetries++;
+        this.retryCounters.delete(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}`);
+        }
+    }
+    keyToString(key) {
+        return `${key.to}:${key.id}`;
+    }
+}
+exports.MessageRetryManager = MessageRetryManager;

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

@@ -1,27 +1,33 @@
-/// <reference types="node" />
-/// <reference types="node" />
-/// <reference types="node" />
 import { Boom } from '@hapi/boom';
-import { AxiosRequestConfig } from 'axios';
-import type { Logger } from 'pino';
+import { type AxiosRequestConfig } from 'axios';
 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';
+import { proto } from '../../WAProto/index.js';
+import { type MediaType } from '../Defaults';
+import type { DownloadableMessage, MediaConnInfo, MediaDecryptionKeyInfo, SocketConfig, WAMediaUpload, WAMediaUploadFunction, WAMessageContent } from '../Types';
+import { type BinaryNode } from '../WABinary';
+import type { ILogger } from './logger';
 export declare const hkdfInfoKey: (type: MediaType) => string;
+export declare const getRawMediaUploadData: (media: WAMediaUpload, mediaType: MediaType, logger?: ILogger) => Promise<{
+    filePath: string;
+    fileSha256: Buffer<ArrayBufferLike>;
+    fileLength: number;
+}>;
 /** 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 function getMediaKeys(buffer: Uint8Array | string | null | undefined, mediaType: MediaType): Promise<MediaDecryptionKeyInfo>;
 export declare const extractImageThumb: (bufferOrFilePath: Readable | Buffer | string, width?: number) => Promise<{
-    buffer: Buffer;
+    buffer: any;
     original: {
-        width: number | undefined;
-        height: number | undefined;
+        width: any;
+        height: any;
     };
 }>;
 export declare const encodeBase64EncodedStringForUpload: (b64: string) => string;
-export declare const generateProfilePicture: (mediaUpload: WAMediaUpload) => Promise<{
-    img: Buffer;
+export declare const generateProfilePicture: (mediaUpload: WAMediaUpload, dimensions?: {
+    width: number;
+    height: number;
+}) => Promise<{
+    img: Buffer<ArrayBufferLike>;
 }>;
 /** gets the SHA256 of the given media message */
 export declare const mediaMessageSHA256B64: (message: WAMessageContent) => string | null | undefined;
@@ -29,9 +35,9 @@ export declare function getAudioDuration(buffer: Buffer | string | Readable): Pr
 /**
   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 function getAudioWaveform(buffer: Buffer | string | Readable, logger?: ILogger): Promise<Uint8Array<ArrayBuffer> | undefined>;
 export declare const toReadable: (buffer: Buffer) => Readable;
-export declare const toBuffer: (stream: Readable) => Promise<Buffer>;
+export declare const toBuffer: (stream: Readable) => Promise<Buffer<ArrayBuffer>>;
 export declare const getStream: (item: WAMediaUpload, opts?: AxiosRequestConfig) => Promise<{
     readonly stream: Readable;
     readonly type: "buffer";
@@ -47,7 +53,7 @@ export declare const getStream: (item: WAMediaUpload, opts?: AxiosRequestConfig)
 }>;
 /** generates a thumbnail for a given media, if required */
 export declare function generateThumbnail(file: string, mediaType: 'video' | 'image', options: {
-    logger?: Logger;
+    logger?: ILogger;
 }): Promise<{
     thumbnail: string | undefined;
     originalImageDimensions: {
@@ -60,32 +66,22 @@ export declare const getHttpStream: (url: string | URL, options?: AxiosRequestCo
 }) => Promise<Readable>;
 type EncryptedStreamOptions = {
     saveOriginalFileIfRequired?: boolean;
-    logger?: Logger;
+    logger?: ILogger;
     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;
+    mediaKey: Buffer<ArrayBufferLike>;
+    originalFilePath: string | undefined;
+    encFilePath: string;
+    mac: Buffer<ArrayBuffer>;
+    fileEncSha256: Buffer<ArrayBufferLike>;
+    fileSha256: Buffer<ArrayBufferLike>;
     fileLength: number;
-    didSaveToTmpPath: boolean;
 }>;
 export type MediaDownloadOptions = {
     startByte?: number;
     endByte?: number;
-    options?: AxiosRequestConfig<any>;
+    options?: AxiosRequestConfig<{}>;
 };
 export declare const getUrlFromDirectPath: (directPath: string) => string;
 export declare const downloadContentFromMessage: ({ mediaKey, directPath, url }: DownloadableMessage, type: MediaType, opts?: MediaDownloadOptions) => Promise<Transform>;
@@ -99,18 +95,18 @@ export declare const getWAUploadToServer: ({ customUploadHosts, fetchAgent, logg
 /**
  * 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 encryptMediaRetryRequest: (key: proto.IMessageKey, mediaKey: Buffer | Uint8Array, meId: string) => Promise<BinaryNode>;
 export declare const decodeMediaRetryNode: (node: BinaryNode) => {
-    key: proto.IMessageKey;
+    key: import("../Types").WAMessageKey;
     media?: {
         ciphertext: Uint8Array;
         iv: Uint8Array;
-    } | undefined;
-    error?: Boom<any> | undefined;
+    };
+    error?: Boom;
 };
 export declare const decryptMediaRetryData: ({ ciphertext, iv }: {
     ciphertext: Uint8Array;
     iv: Uint8Array;
-}, mediaKey: Uint8Array, msgId: string) => proto.MediaRetryNotification;
-export declare const getStatusCodeForMediaRetry: (code: number) => any;
+}, mediaKey: Uint8Array, msgId: string) => Promise<proto.MediaRetryNotification>;
+export declare const getStatusCodeForMediaRetry: (code: number) => 200 | 412 | 404 | 418;
 export {};