@blckrose/baileys 1.1.1 → 1.2.6

package/lib/Utils/messages-media.js

@@ -1,10 +1,7 @@
-import { spawn } from 'child_process';
 import { once } from 'events';
-import { unlink as unlinkFs } from 'fs/promises';
 import { Boom } from '@hapi/boom';
-import { exec } from 'child_process';
 import * as Crypto from 'crypto';
-import { createReadStream, createWriteStream, promises as fs, WriteStream } from 'fs';
+import { createReadStream, createWriteStream, promises as fs } from 'fs';
 import { tmpdir } from 'os';
 import { join } from 'path';
 import { Readable, Transform } from 'stream';
@@ -38,7 +35,7 @@ export const getRawMediaUploadData = async (media, mediaType, logger) => {
     const fileWriteStream = createWriteStream(filePath);
     let fileLength = 0;
     try {
-        for await (const data of finalStream) {
+        for await (const data of stream) {
             fileLength += data.length;
             hasher.update(data);
             if (!fileWriteStream.write(data)) {
@@ -84,18 +81,7 @@ export async function getMediaKeys(buffer, mediaType) {
         macKey: expandedMediaKey.slice(48, 80)
     };
 }
-/** Extracts video thumb using FFMPEG */
-const extractVideoThumb = async (path, destPath, time, size) => new Promise((resolve, reject) => {
-    const cmd = `ffmpeg -ss ${time} -i ${path} -y -vf scale=${size.width}:-1 -vframes 1 -f image2 ${destPath}`;
-    exec(cmd, err => {
-        if (err) {
-            reject(err);
-        }
-        else {
-            resolve();
-        }
-    });
-});
+
 export const extractImageThumb = async (bufferOrFilePath, width = 32) => {
     // TODO: Move entirely to sharp, removing jimp as it supports readable streams
     // This will have positive speed and performance impacts as well as minimizing RAM usage.
@@ -175,22 +161,34 @@ export const mediaMessageSHA256B64 = (message) => {
     const media = Object.values(message)[0];
     return media?.fileSha256 && Buffer.from(media.fileSha256).toString('base64');
 };
-export async function getAudioDuration(buffer) {
+export async function getAudioDuration(buffer, mimeType) {
     const musicMetadata = await import('music-metadata');
     let metadata;
     const options = {
-        duration: true
+        duration: true,
+        ...(mimeType ? { mimeType } : {})
     };
     if (Buffer.isBuffer(buffer)) {
-        metadata = await musicMetadata.parseBuffer(buffer, undefined, options);
+        metadata = await musicMetadata.parseBuffer(buffer, mimeType || undefined, options);
     }
     else if (typeof buffer === 'string') {
-        metadata = await musicMetadata.parseFile(buffer, options);
+        // parseFile tidak support mimeType langsung, tapi kita bisa baca sebagai buffer
+        // supaya mimeType hint bisa dipass — penting untuk m4a/aac yang nama filenya tanpa ekstensi
+        try {
+            metadata = await musicMetadata.parseFile(buffer, options);
+        } catch (_) {
+            // fallback: baca file sebagai buffer lalu parse dengan mimeType
+            const { readFileSync } = await import('fs');
+            const buf = readFileSync(buffer);
+            metadata = await musicMetadata.parseBuffer(buf, mimeType || undefined, options);
+        }
     }
     else {
-        metadata = await musicMetadata.parseStream(buffer, undefined, options);
+        metadata = await musicMetadata.parseStream(buffer, mimeType || undefined, options);
     }
-    return metadata.format.duration;
+    const dur = metadata.format.duration;
+    // Jangan return NaN/undefined — WhatsApp akan tampilkan "Loading..." kalau seconds invalid
+    return (typeof dur === 'number' && !isNaN(dur) && isFinite(dur)) ? Math.round(dur) : 0;
 }
 /**
   referenced from and modifying https://github.com/wppconnect-team/wa-js/blob/main/src/chat/functions/prepareAudioWaveform.ts
@@ -210,23 +208,26 @@ export async function getAudioWaveform(buffer, logger) {
         else {
             audioData = await toBuffer(buffer);
         }
+        // Skip audio-decode for large buffers (> 3MB)
+        if (audioData.length > 3 * 1024 * 1024) {
+            logger?.debug('audio buffer too large for waveform decode, skipping');
+            return undefined;
+        }
         const audioBuffer = await decoder(audioData);
-        const rawData = audioBuffer.getChannelData(0); // We only need to work with one channel of data
-        const samples = 64; // Number of samples we want to have in our final data set
-        const blockSize = Math.floor(rawData.length / samples); // the number of samples in each subdivision
+        const rawData = audioBuffer.getChannelData(0);
+        const samples = 64;
+        const blockSize = Math.floor(rawData.length / samples);
         const filteredData = [];
         for (let i = 0; i < samples; i++) {
-            const blockStart = blockSize * i; // the location of the first sample in the block
+            const blockStart = blockSize * i;
             let sum = 0;
             for (let j = 0; j < blockSize; j++) {
-                sum = sum + Math.abs(rawData[blockStart + j]); // find the sum of all the samples in the block
+                sum = sum + Math.abs(rawData[blockStart + j]);
             }
-            filteredData.push(sum / blockSize); // divide the sum by the block size to get the average
+            filteredData.push(sum / blockSize);
         }
-        // This guarantees that the largest data point will be set to 1, and the rest of the data will scale proportionally.
         const multiplier = Math.pow(Math.max(...filteredData), -1);
         const normalizedData = filteredData.map(n => n * multiplier);
-        // Generate waveform like WhatsApp
         const waveform = new Uint8Array(normalizedData.map(n => Math.floor(100 * n)));
         return waveform;
     }
@@ -234,8 +235,9 @@ export async function getAudioWaveform(buffer, logger) {
         logger?.debug('Failed to generate waveform: ' + e);
     }
 }
+
 export const toReadable = (buffer) => {
-    const readable = new Readable({ read: () => { } });
+    const readable = new Readable({ read: () => { }, highWaterMark: 64 * 1024 });
     readable.push(buffer);
     readable.push(null);
     return readable;
@@ -248,6 +250,46 @@ export const toBuffer = async (stream) => {
     stream.destroy();
     return Buffer.concat(chunks);
 };
+/**
+ * Convert audio buffer ke MP3 menggunakan ffmpeg.
+ * Return buffer MP3 baru, atau buffer asli jika ffmpeg tidak tersedia / gagal.
+ */
+export const convertAudioToMp3 = async (inputBuffer, logger) => {
+    const { spawn } = await import('child_process');
+    return new Promise((resolve) => {
+        const ff = spawn('ffmpeg', [
+            '-hide_banner', '-loglevel', 'error',
+            '-i', 'pipe:0',          // input dari stdin
+            '-vn',                    // no video
+            '-ar', '44100',           // sample rate
+            '-ac', '2',               // stereo
+            '-b:a', '128k',           // bitrate
+            '-f', 'mp3',              // output format
+            'pipe:1'                  // output ke stdout
+        ], { stdio: ['pipe', 'pipe', 'pipe'] });
+
+        const chunks = [];
+        ff.stdout.on('data', chunk => chunks.push(chunk));
+        ff.stderr.on('data', d => logger?.debug('[ffmpeg] ' + d.toString().trim()));
+
+        ff.on('close', code => {
+            if (code === 0 && chunks.length > 0) {
+                resolve(Buffer.concat(chunks));
+            } else {
+                logger?.warn(`ffmpeg exited with code ${code}, using original audio`);
+                resolve(inputBuffer); // fallback ke original
+            }
+        });
+        ff.on('error', (err) => {
+            logger?.warn('ffmpeg not found or failed: ' + err.message + ', using original audio');
+            resolve(inputBuffer); // fallback
+        });
+
+        ff.stdin.write(inputBuffer);
+        ff.stdin.end();
+    });
+};
+
 export const getStream = async (item, opts) => {
     if (Buffer.isBuffer(item)) {
         return { stream: toReadable(item), type: 'buffer' };
@@ -280,16 +322,8 @@ export async function generateThumbnail(file, mediaType, options) {
         }
     }
     else if (mediaType === 'video') {
-        const imgFilename = join(getTmpFilesDirectory(), generateMessageIDV2() + '.jpg');
-        try {
-            await extractVideoThumb(file, imgFilename, '00:00:00', { width: 32, height: 32 });
-            const buff = await fs.readFile(imgFilename);
-            thumbnail = buff.toString('base64');
-            await fs.unlink(imgFilename);
-        }
-        catch (err) {
-            options.logger?.debug('could not generate video thumb: ' + err);
-        }
+        // Video thumbnail generation skipped (ffmpeg removed)
+        options.logger?.debug('video thumbnail generation skipped (no ffmpeg)');
     }
     return {
         thumbnail,
@@ -309,77 +343,68 @@ export const getHttpStream = async (url, options = {}) => {
     return response.body instanceof Readable ? response.body : Readable.fromWeb(response.body);
 };
 
-// ── convertToOpusBuffer (ported from elaina) ─────────────────────────────────
-const convertToOpusBuffer = (buffer, logger) => new Promise((resolve, reject) => {
-    const args = [
-        '-i', 'pipe:0',
-        '-c:a', 'libopus',
-        '-b:a', '64k',
-        '-vbr', 'on',
-        '-compression_level', '10',
-        '-frame_duration', '20',
-        '-application', 'voip',
-        '-f', 'ogg',
-        'pipe:1'
-    ];
-    const ffmpeg = spawn('ffmpeg', args);
-    const chunks = [];
-    ffmpeg.stdin.write(buffer);
-    ffmpeg.stdin.end();
-    ffmpeg.stdout.on('data', chunk => chunks.push(chunk));
-    ffmpeg.stderr.on('data', () => {});
-    ffmpeg.on('close', code => {
-        if (code === 0) resolve(Buffer.concat(chunks));
-        else reject(new Error(`FFmpeg Opus conversion exited with code ${code}`));
-    });
-    ffmpeg.on('error', err => reject(err));
-});
-// ── End convertToOpusBuffer ───────────────────────────────────────────────────
-
 export const encryptedStream = async (media, mediaType, { logger, saveOriginalFileIfRequired, opts, isPtt, forceOpus } = {}) => {
     const { stream, type } = await getStream(media, opts);
     logger?.debug('fetched media stream');
+
     let finalStream = stream;
     let opusConverted = false;
-    // Auto-convert to Opus if PTT or forceOpus
-    if (mediaType === 'audio' && (isPtt === true || forceOpus === true)) {
+
+    // ── Auto-convert semua audio ke MP3 ─────────────────────────────────────
+    // Kecuali: ptt (voice note) tetap ogg/opus, dan yang sudah MP3
+    if (mediaType === 'audio' && !isPtt && !forceOpus) {
         try {
-            const buf = await toBuffer(finalStream);
-            const opusBuf = await convertToOpusBuffer(buf, logger);
-            finalStream = toReadable(opusBuf);
-            opusConverted = true;
-            logger?.debug('converted audio to Opus for PTT');
-        } catch (error) {
-            logger?.error('failed to convert audio to Opus, fallback to original');
-            const { stream: newStream } = await getStream(media, opts);
-            finalStream = newStream;
+            const rawBuf = await toBuffer(finalStream);
+            // Cek apakah sudah MP3 (magic bytes: ID3 atau FF E*)
+            const isAlreadyMp3 = (rawBuf[0] === 0x49 && rawBuf[1] === 0x44 && rawBuf[2] === 0x33)
+                || (rawBuf[0] === 0xFF && (rawBuf[1] & 0xE0) === 0xE0);
+            if (!isAlreadyMp3) {
+                logger?.debug('converting audio to MP3 via ffmpeg');
+                const mp3Buf = await convertAudioToMp3(rawBuf, logger);
+                finalStream = toReadable(mp3Buf);
+                logger?.debug('audio converted to MP3 successfully');
+            } else {
+                finalStream = toReadable(rawBuf);
+                logger?.debug('audio already MP3, skipping conversion');
+            }
+        } catch (err) {
+            logger?.warn('audio conversion failed, using original: ' + err.message);
+            // finalStream sudah di-consume, perlu re-fetch — re-use dari getStream
+            const { stream: s2 } = await getStream(media, opts);
+            finalStream = s2;
         }
     }
+    // ── End auto-convert ─────────────────────────────────────────────────────
+
     const mediaKey = Crypto.randomBytes(32);
     const { cipherKey, iv, macKey } = await getMediaKeys(mediaKey, mediaType);
-    const encFilePath = join(getTmpFilesDirectory(), mediaType + generateMessageIDV2() + '-enc');
-    const encFileWriteStream = createWriteStream(encFilePath);
-    let originalFileStream;
-    let originalFilePath;
-    if (saveOriginalFileIfRequired) {
-        originalFilePath = join(getTmpFilesDirectory(), mediaType + generateMessageIDV2() + '-original');
-        originalFileStream = createWriteStream(originalFilePath);
+    const encWriteStream = new Readable({ read: () => {}, highWaterMark: 64 * 1024 });
+    let bodyPath;
+    let writeStream;
+    let didSaveToTmpPath = false;
+
+    if (type === 'file') {
+        bodyPath = media.url?.toString?.() || media.url;
+    } else if (saveOriginalFileIfRequired) {
+        bodyPath = join(getTmpFilesDirectory(), mediaType + generateMessageIDV2());
+        writeStream = createWriteStream(bodyPath);
+        didSaveToTmpPath = true;
     }
+
     let fileLength = 0;
     const aes = Crypto.createCipheriv('aes-256-cbc', cipherKey, iv);
-    const hmac = Crypto.createHmac('sha256', macKey).update(iv);
-    const sha256Plain = Crypto.createHash('sha256');
-    const sha256Enc = Crypto.createHash('sha256');
-    const onChunk = async (buff) => {
-        sha256Enc.update(buff);
-        hmac.update(buff);
-        // Handle backpressure: if write returns false, wait for drain
-        if (!encFileWriteStream.write(buff)) {
-            await once(encFileWriteStream, 'drain');
-        }
+    let hmac = Crypto.createHmac('sha256', macKey).update(iv);
+    let sha256Plain = Crypto.createHash('sha256');
+    let sha256Enc = Crypto.createHash('sha256');
+
+    const onChunk = (buff) => {
+        sha256Enc = sha256Enc.update(buff);
+        hmac = hmac.update(buff);
+        encWriteStream.push(buff);
     };
+
     try {
-        for await (const data of stream) {
+        for await (const data of finalStream) {
             fileLength += data.length;
             if (type === 'remote' &&
                 opts?.maxContentLength &&
@@ -388,58 +413,50 @@ export const encryptedStream = async (media, mediaType, { logger, saveOriginalFi
                     data: { media, type }
                 });
             }
-            if (originalFileStream) {
-                if (!originalFileStream.write(data)) {
-                    await once(originalFileStream, 'drain');
+            sha256Plain = sha256Plain.update(data);
+            if (writeStream) {
+                if (!writeStream.write(data)) {
+                    await once(writeStream, 'drain');
                 }
             }
-            sha256Plain.update(data);
-            await onChunk(aes.update(data));
+            onChunk(aes.update(data));
         }
-        await onChunk(aes.final());
+
+        onChunk(aes.final());
         const mac = hmac.digest().slice(0, 10);
-        sha256Enc.update(mac);
+        sha256Enc = sha256Enc.update(mac);
         const fileSha256 = sha256Plain.digest();
         const fileEncSha256 = sha256Enc.digest();
-        encFileWriteStream.write(mac);
-        const encFinishPromise = once(encFileWriteStream, 'finish');
-        const originalFinishPromise = originalFileStream ? once(originalFileStream, 'finish') : Promise.resolve();
-        encFileWriteStream.end();
-        originalFileStream?.end?.();
-        stream.destroy();
-        // Wait for write streams to fully flush to disk
-        // This helps reduce memory pressure by allowing OS to release buffers
-        await encFinishPromise;
-        await originalFinishPromise;
+
+        encWriteStream.push(mac);
+        encWriteStream.push(null);
+        writeStream?.end();
+        if (writeStream) await once(writeStream, 'finish');
+        finalStream.destroy();
+
         logger?.debug('encrypted data successfully');
+
         return {
             mediaKey,
-            originalFilePath,
-            encFilePath,
+            encWriteStream,
+            bodyPath,
             mac,
             fileEncSha256,
             fileSha256,
             fileLength,
+            didSaveToTmpPath,
             opusConverted
         };
-    }
-    catch (error) {
-        // destroy all streams with error
-        encFileWriteStream.destroy();
-        originalFileStream?.destroy?.();
+    } catch (error) {
+        encWriteStream.destroy();
+        writeStream?.destroy();
         aes.destroy();
         hmac.destroy();
         sha256Plain.destroy();
         sha256Enc.destroy();
         stream.destroy();
-        try {
-            await fs.unlink(encFilePath);
-            if (originalFilePath) {
-                await fs.unlink(originalFilePath);
-            }
-        }
-        catch (err) {
-            logger?.error({ err }, 'failed deleting tmp files');
+        if (didSaveToTmpPath) {
+            try { await fs.unlink(bodyPath); } catch (_) {}
         }
         throw error;
     }
@@ -674,7 +691,7 @@ const uploadMedia = async (params, logger) => {
     }
 };
 export const getWAUploadToServer = ({ customUploadHosts, fetchAgent, logger, options }, refreshMediaConn) => {
-    return async (filePath, { mediaType, fileEncSha256B64, timeoutMs }) => {
+    return async (streamOrPath, { mediaType, fileEncSha256B64, timeoutMs, newsletter }) => {
         // send a query JSON to obtain the url & auth token to upload our media
         let uploadInfo = await refreshMediaConn(false);
         let urls;
@@ -692,27 +709,56 @@ export const getWAUploadToServer = ({ customUploadHosts, fetchAgent, logger, opt
             'Content-Type': 'application/octet-stream',
             Origin: DEFAULT_ORIGIN
         };
-        for (const { hostname } of hosts) {
-            logger.debug(`uploading to "${hostname}"`);
+        // Collect buffer from Readable stream or read from file path
+        let reqBuffer;
+        if (Buffer.isBuffer(streamOrPath)) {
+            reqBuffer = streamOrPath;
+        } else if (typeof streamOrPath === 'string') {
+            reqBuffer = await fs.readFile(streamOrPath);
+        } else {
+            // Readable stream
+            const chunks = [];
+            for await (const chunk of streamOrPath) chunks.push(chunk);
+            reqBuffer = Buffer.concat(chunks);
+        }
+        // Newsletter uses different upload path
+        let mediaPath = MEDIA_PATH_MAP[mediaType];
+        if (newsletter) {
+            mediaPath = mediaPath?.replace('/mms/', '/newsletter/newsletter-');
+            logger.debug(`[blckrose-debug] newsletter upload | mediaType=${mediaType} path=${mediaPath} bufferLen=${reqBuffer?.length}`);
+        }
+        for (const { hostname, maxContentLengthBytes } of hosts) {
             const auth = encodeURIComponent(uploadInfo.auth);
-            const url = `https://${hostname}${MEDIA_PATH_MAP[mediaType]}/${fileEncSha256B64}?auth=${auth}&token=${fileEncSha256B64}`;
+            const url = `https://${hostname}${mediaPath}/${fileEncSha256B64}?auth=${auth}&token=${fileEncSha256B64}`;
+            logger.debug(`[blckrose-debug] uploading to url=${url.slice(0, 80)}...`);
+
             let result;
             try {
-                result = await uploadMedia({
-                    url,
-                    filePath,
-                    headers,
-                    timeoutMs,
-                    agent: fetchAgent
-                }, logger);
+                // Upload buffer directly like wiley (avoids file I/O issues)
+                const axios = (await import('axios')).default;
+                const body = await axios.post(url, reqBuffer, {
+                    ...options,
+                    headers: {
+                        ...headers,
+                    },
+                    httpsAgent: fetchAgent,
+                    timeout: timeoutMs,
+                    responseType: 'json',
+                    maxBodyLength: Infinity,
+                    maxContentLength: Infinity,
+                });
+                result = body.data;
+
                 if (result?.url || result?.direct_path) {
                     urls = {
                         mediaUrl: result.url,
                         directPath: result.direct_path,
+                        handle: result.handle,
                         meta_hmac: result.meta_hmac,
                         fbid: result.fbid,
                         ts: result.ts
                     };
+                    logger.debug({ mediaUrl: result.url, directPath: result.direct_path, handle: result.handle }, '[blckrose-debug] upload success');
                     break;
                 }
                 else {
@@ -722,6 +768,7 @@ export const getWAUploadToServer = ({ customUploadHosts, fetchAgent, logger, opt
             }
             catch (error) {
                 const isLast = hostname === hosts[uploadInfo.hosts.length - 1]?.hostname;
+
                 logger.warn({ trace: error?.stack, uploadResult: result }, `Error in uploading to ${hostname} ${isLast ? '' : ', retrying...'}`);
             }
         }
@@ -822,51 +869,39 @@ const MEDIA_RETRY_STATUS_MAP = {
 export const prepareStream = async (media, mediaType, { logger, saveOriginalFileIfRequired, opts, isPtt, forceOpus } = {}) => {
     const { stream, type } = await getStream(media, opts);
     logger?.debug('fetched media stream');
-    let opusConverted = false;
+
     let buffer = await toBuffer(stream);
-    // Auto-convert to Opus if PTT or forceOpus
-    if (mediaType === 'audio' && (isPtt === true || forceOpus === true)) {
-        try {
-            const opusBuf = await convertToOpusBuffer(buffer, logger);
-            buffer = opusBuf;
-            opusConverted = true;
-            logger?.debug('converted audio to Opus for newsletter PTT');
-        } catch (e) {
-            logger?.error('failed to convert audio for newsletter PTT');
-        }
-    }
-    const encFilePath = join(tmpdir(), mediaType + generateMessageID() + '-plain');
-    const encFileWriteStream = createWriteStream(encFilePath);
-    let originalFilePath;
-    let originalFileStream;
-    if (type === 'file') {
-        originalFilePath = media.url.toString();
-    } else if (saveOriginalFileIfRequired) {
-        originalFilePath = join(tmpdir(), mediaType + generateMessageID() + '-original');
-        originalFileStream = createWriteStream(originalFilePath);
-    }
-    let fileLength = 0;
-    const hashCtx = createHashCrypto('sha256');
+
+    let opusConverted = false;
+
+    let bodyPath;
+    let didSaveToTmpPath = false;
     try {
-        // Use buffer (possibly opus-converted) directly
-        fileLength = buffer.length;
-        hashCtx.update(buffer);
-        encFileWriteStream.write(buffer);
-        if (originalFileStream) {
-            originalFileStream.write(buffer);
+        if (type === 'file') {
+            bodyPath = media.url?.toString?.() || media.url;
+        } else if (saveOriginalFileIfRequired) {
+            bodyPath = join(getTmpFilesDirectory(), mediaType + generateMessageIDV2());
+            const { writeFileSync } = await import('fs');
+            writeFileSync(bodyPath, buffer);
+            didSaveToTmpPath = true;
         }
-        const fileSha256 = hashCtx.digest();
-        encFileWriteStream.end();
-        originalFileStream?.end?.call(originalFileStream);
+        const fileLength = buffer.length;
+        const fileSha256 = Crypto.createHash('sha256').update(buffer).digest();
         logger?.debug('prepared plain stream successfully');
-        return { mediaKey: undefined, originalFilePath, encFilePath, mac: undefined, fileEncSha256: undefined, fileSha256, fileLength, opusConverted };
+        return {
+            mediaKey: undefined,
+            encWriteStream: buffer,
+            fileLength,
+            fileSha256,
+            fileEncSha256: undefined,
+            bodyPath,
+            didSaveToTmpPath,
+            opusConverted
+        };
     } catch (error) {
-        encFileWriteStream.destroy();
-        originalFileStream?.destroy?.call(originalFileStream);
-        stream.destroy();
-        try {
-            await unlinkFs(encFilePath);
-        } catch (err) { logger?.error({ err }, 'failed deleting tmp files'); }
+        if (didSaveToTmpPath && bodyPath) {
+            try { await fs.unlink(bodyPath); } catch (_) {}
+        }
         throw error;
     }
 };

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

@@ -0,0 +1,84 @@
+import type { WASocket } from '../Types/index.js';
+import type { WAMediaUpload } from '../Types/Message.js';
+
+export interface NewsletterButtonItem {
+    id: string;
+    text?: string;
+    displayText?: string;
+}
+
+export interface NewsletterListRow {
+    id: string;
+    title: string;
+    description?: string;
+    rowId?: string;
+}
+
+export interface NewsletterListSection {
+    title?: string;
+    rows: NewsletterListRow[];
+}
+
+export interface NewsletterButtonsParams {
+    body: string;
+    buttons: NewsletterButtonItem[];
+    title?: string;
+    footer?: string;
+}
+
+export interface NewsletterListParams {
+    body: string;
+    buttonText: string;
+    sections: NewsletterListSection[];
+    title?: string;
+    footer?: string;
+}
+
+export interface NewsletterCtaUrlParams {
+    body: string;
+    buttonText: string;
+    url: string;
+    title?: string;
+    footer?: string;
+}
+
+export interface NewsletterUtils {
+    /** Kirim teks ke newsletter */
+    sendNewsletterText(jid: string, text: string, options?: object): Promise<any>;
+    /** Kirim gambar ke newsletter */
+    sendNewsletterImage(jid: string, image: WAMediaUpload, options?: { caption?: string; mimetype?: string; jpegThumbnail?: string }): Promise<any>;
+    /** Kirim video ke newsletter */
+    sendNewsletterVideo(jid: string, video: WAMediaUpload, options?: { caption?: string; mimetype?: string; gifPlayback?: boolean }): Promise<any>;
+    /** Kirim PTV (video note lingkaran) ke newsletter */
+    sendNewsletterPtv(jid: string, video: WAMediaUpload, options?: { mimetype?: string }): Promise<any>;
+    /** Kirim audio ke newsletter */
+    sendNewsletterAudio(jid: string, audio: WAMediaUpload, options?: { mimetype?: string; seconds?: number; ptt?: boolean }): Promise<any>;
+    /** Kirim dokumen ke newsletter */
+    sendNewsletterDocument(jid: string, document: WAMediaUpload, options?: { mimetype?: string; fileName?: string; caption?: string }): Promise<any>;
+    /** Kirim sticker ke newsletter */
+    sendNewsletterSticker(jid: string, sticker: WAMediaUpload, options?: { isAnimated?: boolean }): Promise<any>;
+    /** Kirim pesan dengan quick_reply buttons ke newsletter */
+    sendNewsletterButtons(jid: string, params: NewsletterButtonsParams, options?: object): Promise<any>;
+    /** Kirim pesan dengan single_select list ke newsletter */
+    sendNewsletterList(jid: string, params: NewsletterListParams, options?: object): Promise<any>;
+    /** Kirim pesan dengan CTA URL button ke newsletter */
+    sendNewsletterCtaUrl(jid: string, params: NewsletterCtaUrlParams, options?: object): Promise<any>;
+    /** React ke server message ID newsletter */
+    sendNewsletterReact(jid: string, serverId: string, emoji?: string): Promise<any>;
+    /** Edit pesan newsletter */
+    editNewsletterMessage(jid: string, messageId: string, newText: string): Promise<any>;
+    /** Hapus pesan newsletter */
+    deleteNewsletterMessage(jid: string, messageId: string): Promise<any>;
+}
+
+/**
+ * Buat object utilities newsletter terikat ke conn.
+ *
+ * @example
+ * const nl = makeNewsletterUtils(conn);
+ * await nl.sendNewsletterButtons('120363...@newsletter', {
+ *   body: 'Pilih opsi:',
+ *   buttons: [{ id: 'a', text: 'Opsi A' }, { id: 'b', text: 'Opsi B' }]
+ * });
+ */
+export declare function makeNewsletterUtils(conn: WASocket): NewsletterUtils;