@nuiisweety/baileys 0.1.16 → 0.1.18

package/lib/Utils/messages.js.bak

@@ -1,15 +1,18 @@
 import { Boom } from '@hapi/boom';
 import { randomBytes } from 'crypto';
+import { zip } from 'fflate';
 import { promises as fs } from 'fs';
 import {} from 'stream';
 import { proto } from '../../WAProto/index.js';
-import { CALL_AUDIO_PREFIX, CALL_VIDEO_PREFIX, MEDIA_KEYS, URL_REGEX, WA_DEFAULT_EPHEMERAL } from '../Defaults/index.js';
-import { WAMessageStatus, WAProto } from '../Types/index.js';
-import { isJidGroup, isJidNewsletter, isJidStatusBroadcast, jidNormalizedUser } from '../WABinary/index.js';
+import { CALL_AUDIO_PREFIX, CALL_VIDEO_PREFIX, DONATE_URL, LIBRARY_NAME, MEDIA_KEYS, URL_REGEX, WA_DEFAULT_EPHEMERAL } from '../Defaults/index.js';
+import { AssociationType, ButtonHeaderType, ButtonType, CarouselCardType, ListType, ProtocolType, WAMessageStatus, WAProto } from '../Types/index.js';
+import { isJidGroup, isJidNewsletter, isJidStatusBroadcast, isLidUser, isPnUser, jidNormalizedUser } from '../WABinary/index.js';
 import { sha256 } from './crypto.js';
 import { generateMessageIDV2, getKeyAuthor, unixTimestampSeconds } from './generics.js';
-import { downloadContentFromMessage, encryptedStream, generateThumbnail, getAudioDuration, getAudioWaveform, getRawMediaUploadData } from './messages-media.js';
+import { downloadContentFromMessage, encryptedStream, generateThumbnail, getAudioDuration, getAudioWaveform, getImageProcessingLibrary, getRawMediaUploadData, getStream, toBuffer } from './messages-media.js';
+import { prepareRichResponseMessage } from './rich-message-utils.js';
 import { shouldIncludeReportingToken } from './reporting-utils.js';
+const CONCURRENCY_LIMIT = 10;
 const MIMETYPE_MAP = {
     image: 'image/jpeg',
     video: 'video/mp4',
@@ -261,19 +264,322 @@ export const generateForwardMessageContent = (message, forceForward) => {
     return content;
 };
 export const hasNonNullishProperty = (message, key) => {
-    return (typeof message === 'object' &&
-        message !== null &&
+    return message != null &&
+        typeof message === 'object' &&
         key in message &&
-        message[key] !== null &&
-        message[key] !== undefined);
+        message[key] != null;
+};
+export const hasOptionalProperty = (obj, key) => {
+    return obj != null &&
+        typeof obj === 'object' &&
+        key in obj &&
+        obj[key] != null;
+};
+// Validate album message media to avoid bug
+export const hasValidAlbumMedia = (message) => {
+    return message.imageMessage ||
+        message.videoMessage;
+};
+export const hasValidInteractiveHeader = (message) => {
+    return message.imageMessage ||
+        message.videoMessage ||
+        message.documentMessage ||
+        message.productMessage ||
+        message.locationMessage;
+};
+// Validate carousel cards header to avoid bug
+export const hasValidCarouselHeader = (message) => {
+    return message.imageMessage ||
+        message.videoMessage ||
+        message.productMessage;
+};
+// Extract product message into a standalone function so it can also be reused as the header for interactive messages
+const prepareProductMessage = async (message, options) => {
+    if (!message.businessOwnerJid) {
+        throw new Boom('"businessOwnerJid" is missing from the content', { statusCode: 400 });
+    }
+    const { imageMessage } = await prepareWAMessageMedia({ image: message.image || message.product.productImage }, options);
+    const content = {
+        ...message,
+        product: {
+            currencyCode: 'IDR',
+            priceAmount1000: 1000,
+            title: LIBRARY_NAME,
+            ...message.product,
+            productImage: imageMessage
+        }
+    };
+    delete content.image;
+    return content;
+};
+const prepareStickerPackMessage = async (message, options) => {
+    const { cover, stickers = [], name = '📦 Sticker Pack', publisher = 'GitHub: nuiisweety', description = '🏷️ nuiisweety/baileys' } = message;
+    if (stickers.length > 60) {
+        throw new Boom('Sticker pack exceeds the maximum limit of 60 stickers', { statusCode: 400 });
+    }
+    if (stickers.length === 0) {
+        throw new Boom('Sticker pack must contain at least one sticker', { statusCode: 400 });
+    }
+    if (!cover) {
+        throw new Boom('Sticker pack must contain a cover', { statusCode: 400 });
+    }
+    const logger = options.logger;
+    let cacheableKey = false;
+    if (Array.isArray(stickers) && stickers.length && options.mediaCache) {
+        const urls = [];
+        for (let i = 0; i < stickers.length; i++) {
+            const data = stickers[i].data;
+            if (typeof data === 'object' && data?.url) {
+                urls.push(data.url);
+            }
+        }
+        if (urls.length > 0) {
+            cacheableKey = 'sticker:' + urls.join('@');
+        }
+    }
+    if (cacheableKey) {
+        const mediaBuff = await options.mediaCache.get(cacheableKey);
+        if (mediaBuff) {
+            logger?.debug({ cacheableKey }, 'got media cache hit');
+            return proto.Message.StickerPackMessage.decode(mediaBuff);
+        }
+    }
+    const lib = await getImageProcessingLibrary();
+    const hasSharp = 'sharp' in lib && !!lib.sharp?.default;
+    const hasImage = 'image' in lib && !!lib.image?.Transformer;
+    const hasJimp = 'jimp' in lib && !!lib.jimp?.Jimp;
+    if (!hasSharp && !hasImage) {
+        throw new Boom('No image processing library (sharp or @napi-rs/image) available for converting sticker to WebP.');
+    }
+    const stickerPackIdValue = generateMessageIDV2();
+    const stickerData = {};
+    const stickerMetadata = new Array(stickers.length);
+    for (let i = 0; i < stickers.length; i += CONCURRENCY_LIMIT) {
+        const promises = [];
+        const chunkEnd = Math.min(i + CONCURRENCY_LIMIT, stickers.length);
+        for (let j = i; j < chunkEnd; j++) {
+            promises.push((async (index) => {
+                const sticker = stickers[index];
+                const { stream } = await getStream(sticker.data);
+                const buffer = await toBuffer(stream);
+                let webpBuffer;
+                let isAnimated = false;
+                if (isWebPBuffer(buffer)) {
+                    webpBuffer = buffer;
+                    isAnimated = isAnimatedWebP(buffer);
+                }
+                else if (hasSharp) {
+                    webpBuffer = await lib.sharp.default(buffer)
+                        .resize(512, 512, { fit: 'inside' })
+                        .webp({ quality: 80 })
+                        .toBuffer();
+                }
+                else {
+                    webpBuffer = await new lib.image.Transformer(buffer)
+                        .resize(512, 512)
+                        .webp(80);
+                }
+                if (webpBuffer.length > 1024 * 1024) {
+                    throw new Boom(`Sticker at index ${index} exceeds the 1MB size limit`, { statusCode: 400 });
+                }
+                const hash = sha256(webpBuffer).toString('base64').replace(/\//g, '-');
+                const fileName = `${hash}.webp`;
+                stickerData[fileName] = [new Uint8Array(webpBuffer), { level: 0 }];
+                stickerMetadata[index] = {
+                    fileName,
+                    mimetype: 'image/webp',
+                    isAnimated,
+                    emojis: sticker.emojis || ['✨'],
+                    accessibilityLabel: sticker.accessibilityLabel || '‎'
+                };
+            })(j));
+        }
+        await Promise.all(promises);
+    }
+    const trayIconFileName = `${stickerPackIdValue}.webp`;
+    const { stream: coverStream } = await getStream(cover);
+    const coverBuffer = await toBuffer(coverStream);
+    let coverWebpBuffer;
+    if (isWebPBuffer(coverBuffer)) {
+        coverWebpBuffer = coverBuffer;
+    }
+    else if (hasSharp) {
+        coverWebpBuffer = await lib.sharp.default(coverBuffer)
+            .resize(512, 512, { fit: 'inside' })
+            .webp({ quality: 80 })
+            .toBuffer();
+    }
+    else {
+        coverWebpBuffer = await new lib.image.Transformer(coverBuffer)
+            .resize(512, 512)
+            .webp(80);
+    }
+    stickerData[trayIconFileName] = [new Uint8Array(coverWebpBuffer), { level: 0 }];
+    const zipBuffer = await new Promise((resolve, reject) => {
+        zip(stickerData, (error, data) => error ? reject(error) : resolve(Buffer.from(data)));
+    });
+    const stickerPackUpload = await encryptedStream(zipBuffer, 'sticker-pack', {
+        logger,
+        opts: options.options
+    });
+    let stickerPackUploadResult;
+    try {
+        stickerPackUploadResult = await options.upload(stickerPackUpload.encFilePath, {
+            fileEncSha256B64: stickerPackUpload.fileEncSha256.toString('base64'),
+            mediaType: 'sticker-pack',
+            timeoutMs: options.mediaUploadTimeoutMs
+        });
+    }
+    finally {
+        fs.unlink(stickerPackUpload.encFilePath).catch(() => logger?.warn('failed to remove tmp file'));
+    }
+    const obj = {
+        name,
+        publisher,
+        stickerPackId: stickerPackIdValue,
+        packDescription: description,
+        stickerPackOrigin: proto.Message.StickerPackMessage.StickerPackOrigin.USER_CREATED,
+        stickerPackSize: zipBuffer.length,
+        stickers: stickerMetadata,
+        fileSha256: stickerPackUpload.fileSha256,
+        fileEncSha256: stickerPackUpload.fileEncSha256,
+        mediaKey: stickerPackUpload.mediaKey,
+        directPath: stickerPackUploadResult.directPath,
+        fileLength: stickerPackUpload.fileLength,
+        mediaKeyTimestamp: unixTimestampSeconds(),
+        trayIconFileName
+    };
+    try {
+        let thumbnailBuffer;
+        if (hasSharp) {
+            thumbnailBuffer = await lib.sharp.default(coverBuffer).resize(252, 252).jpeg().toBuffer();
+        }
+        else if (hasImage) {
+            thumbnailBuffer = await new lib.image.Transformer(coverBuffer).resize(252, 252).jpeg();
+        }
+        else if (hasJimp) {
+            const jimpImage = await lib.jimp.Jimp.read(coverBuffer);
+            thumbnailBuffer = await jimpImage.resize({ w: 252, h: 252 }).getBuffer('image/jpeg');
+        }
+        else {
+            throw new Error('No image processing library available for thumbnail generation');
+        }
+        if (!thumbnailBuffer || thumbnailBuffer.length === 0) {
+            throw new Error('Failed to generate thumbnail buffer');
+        }
+        const thumbUpload = await encryptedStream(thumbnailBuffer, 'thumbnail-sticker-pack', {
+            logger,
+            opts: options.options,
+            mediaKey: stickerPackUpload.mediaKey
+        });
+        let thumbUploadResult;
+        try {
+            thumbUploadResult = await options.upload(thumbUpload.encFilePath, {
+                fileEncSha256B64: thumbUpload.fileEncSha256.toString('base64'),
+                mediaType: 'thumbnail-sticker-pack',
+                timeoutMs: options.mediaUploadTimeoutMs
+            });
+        }
+        finally {
+            fs.unlink(thumbUpload.encFilePath).catch(() => logger?.warn('failed to remove tmp file'));
+        }
+        Object.assign(obj, {
+            thumbnailDirectPath: thumbUploadResult.directPath,
+            thumbnailSha256: thumbUpload.fileSha256,
+            thumbnailEncSha256: thumbUpload.fileEncSha256,
+            thumbnailHeight: 252,
+            thumbnailWidth: 252,
+            imageDataHash: sha256(thumbnailBuffer).toString('base64')
+        });
+    }
+    catch (error) {
+        logger?.warn(`Thumbnail generation failed: ${error}`);
+    }
+    if (cacheableKey) {
+        logger?.debug({ cacheableKey }, 'set cache (background)');
+        options.mediaCache.set(cacheableKey, WAProto.Message.StickerPackMessage.encode(obj).finish());
+    }
+    return WAProto.Message.StickerPackMessage.fromObject(obj);
+};
+const prepareNativeFlowButtons = (message) => {
+    const buttons = message.nativeFlow;
+    const isButtonsFieldArray = Array.isArray(buttons);
+    const correctedField = isButtonsFieldArray ? buttons : buttons.buttons;
+    const messageParamsJson = {};
+    if (hasOptionalProperty(message, 'offerText') && !!message.offerText) {
+        Object.assign(messageParamsJson, {
+            limited_time_offer: {
+                text: message.offerText || LIBRARY_NAME,
+                url: message.offerUrl || DONATE_URL,
+                copy_code: message.offerCode,
+                expiration_time: message.offerExpiration
+            }
+        });
+    }
+    if (hasOptionalProperty(message, 'optionText') && !!message.optionText) {
+        Object.assign(messageParamsJson, {
+            bottom_sheet: {
+                in_thread_buttons_limit: 1,
+                divider_indices: Array.from({ length: correctedField.length }, (_, index) => index),
+                list_title: message.optionTitle || '📄 Select Options',
+                button_title: message.optionText
+            }
+        });
+    }
+    return {
+        buttons: correctedField.map(button => {
+            const buttonText = button.text || button.buttonText;
+            const buttonIcon = button.icon?.toUpperCase();
+            if (hasOptionalProperty(button, 'id') && !!button.id) {
+                return { name: 'quick_reply', buttonParamsJson: JSON.stringify({ display_text: buttonText || '👉🏻 Click', id: button.id, icon: buttonIcon }) };
+            }
+            else if (hasOptionalProperty(button, 'copy') && !!button.copy) {
+                return { name: 'cta_copy', buttonParamsJson: JSON.stringify({ display_text: buttonText || '📋 Copy', copy_code: button.copy, icon: buttonIcon }) };
+            }
+            else if (hasOptionalProperty(button, 'url') && !!button.url) {
+                return { name: 'cta_url', buttonParamsJson: JSON.stringify({ display_text: buttonText || '🌐 Visit', url: button.url, merchant_url: button.url, webview_interaction: button.useWebview, icon: buttonIcon }) };
+            }
+            else if (hasOptionalProperty(button, 'call') && !!button.call) {
+                return { name: 'cta_call', buttonParamsJson: JSON.stringify({ display_text: buttonText || '📞 Call', phone_number: button.call, icon: buttonIcon }) };
+            }
+            else if (hasOptionalProperty(button, 'sections') && !!button.sections) {
+                return { name: 'single_select', buttonParamsJson: JSON.stringify({ title: buttonText || '📋 Select', sections: button.sections, icon: buttonIcon }) };
+            }
+            return button;
+        }),
+        messageParamsJson: JSON.stringify(messageParamsJson),
+        messageVersion: 3
+    };
 };
-function hasOptionalProperty(obj, key) {
-    return typeof obj === 'object' && obj !== null && key in obj && obj[key] !== null;
-}
 export const generateWAMessageContent = async (message, options) => {
     var _a, _b;
     let m = {};
-    if (hasNonNullishProperty(message, 'text')) {
+    if (hasNonNullishProperty(message, 'raw')) {
+        delete message.raw;
+        return message;
+    }
+    else if (hasNonNullishProperty(message, 'code') ||
+        hasNonNullishProperty(message, 'links') ||
+        hasNonNullishProperty(message, 'table') ||
+        hasNonNullishProperty(message, 'richResponse') ||
+        hasNonNullishProperty(message, 'latex') ||
+        hasNonNullishProperty(message, 'gridImage') ||
+        hasNonNullishProperty(message, 'inlineImage') ||
+        hasNonNullishProperty(message, 'dynamic') ||
+        hasNonNullishProperty(message, 'map') ||
+        hasNonNullishProperty(message, 'contentItems') ||
+        // tipe baru (nama prefixed 'rich' agar tidak konflik dengan media biasa)
+        hasNonNullishProperty(message, 'richImage') ||
+        hasNonNullishProperty(message, 'richVideo') ||
+        hasNonNullishProperty(message, 'reels') ||
+        hasNonNullishProperty(message, 'source') ||
+        hasNonNullishProperty(message, 'richProduct') ||
+        hasNonNullishProperty(message, 'richPost') ||
+        hasNonNullishProperty(message, 'tip') ||
+        hasNonNullishProperty(message, 'suggest')) {
+        m = prepareRichResponseMessage(message);
+    }
+    else if (hasNonNullishProperty(message, 'text')) {
         const extContent = { text: message.text };
         let urlInfo = message.linkPreview;
         if (typeof urlInfo === 'undefined') {
@@ -362,6 +668,9 @@ export const generateWAMessageContent = async (message, options) => {
             }
         }
     }
+    else if (hasNonNullishProperty(message, 'stickers')) {
+        m.stickerPackMessage = await prepareStickerPackMessage(message, options);
+    }
     else if (hasNonNullishProperty(message, 'pin')) {
         m.pinInChatMessage = {};
         m.messageContextInfo = {};
@@ -370,6 +679,25 @@ export const generateWAMessageContent = async (message, options) => {
         m.pinInChatMessage.senderTimestampMs = Date.now();
         m.messageContextInfo.messageAddOnDurationInSecs = message.type === 1 ? message.time || 86400 : 0;
     }
+    else if (hasNonNullishProperty(message, 'keep')) {
+        m.keepInChatMessage = {};
+        m.keepInChatMessage.key = message.keep;
+        m.keepInChatMessage.keepType = message.type;
+        m.keepInChatMessage.timestampMs = Date.now();
+    }
+    else if (hasNonNullishProperty(message, 'flowReply')) {
+        m.interactiveResponseMessage = {
+            body: {
+                format: message.flowReply.format || proto.Message.InteractiveResponseMessage.Body.Format.DEFAULT,
+                text: message.flowReply.text
+            },
+            nativeFlowResponseMessage: {
+                name: message.flowReply.name,
+                paramsJson: message.flowReply.paramsJson || '{}',
+                version: message.flowReply.version || 1
+            }
+        };
+    }
     else if (hasNonNullishProperty(message, 'buttonReply')) {
         switch (message.type) {
             case 'template':
@@ -393,17 +721,32 @@ export const generateWAMessageContent = async (message, options) => {
         m.ptvMessage = videoMessage;
     }
     else if (hasNonNullishProperty(message, 'product')) {
-        const { imageMessage } = await prepareWAMessageMedia({ image: message.product.productImage }, options);
-        m.productMessage = WAProto.Message.ProductMessage.create({
+        if (!message.businessOwnerJid) {
+            throw new Boom('"businessOwnerJid" is missing from the content', { statusCode: 400 });
+        }
+        const { imageMessage } = await prepareWAMessageMedia({ image: message.image || message.product.productImage }, options);
+        const content = {
             ...message,
             product: {
+                currencyCode: 'IDR',
+                priceAmount1000: 1000,
+                title: LIBRARY_NAME,
                 ...message.product,
                 productImage: imageMessage
             }
-        });
+        };
+        delete content.image;
+        m.productMessage = WAProto.Message.ProductMessage.create(content);
     }
     else if (hasNonNullishProperty(message, 'listReply')) {
-        m.listResponseMessage = { ...message.listReply };
+        m.listResponseMessage = {
+            description: message.listReply.description,
+            listType: proto.Message.ListResponseMessage.ListType.SINGLE_SELECT,
+            singleSelectReply: {
+                selectedRowId: message.listReply.id
+            },
+            title: message.listReply.title
+        };
     }
     else if (hasNonNullishProperty(message, 'event')) {
         m.eventMessage = {};
@@ -436,21 +779,35 @@ export const generateWAMessageContent = async (message, options) => {
                 statusCode: 400
             });
         }
-        m.messageContextInfo = {
-            // encKey
-            messageSecret: message.poll.messageSecret || randomBytes(32)
-        };
         const pollCreationMessage = {
             name: message.poll.name,
             selectableOptionsCount: message.poll.selectableCount,
-            options: message.poll.values.map(optionName => ({ optionName }))
+            options: message.poll.values.map(optionName => ({ optionName })),
+            endTime: message.poll.endDate ? message.poll.endDate.getTime() : undefined,
+            hideParticipantName: message.poll.hideVoter ?? false,
+            allowAddOption: message.poll.canAddOption ?? false
         };
         if (message.poll.toAnnouncementGroup) {
             // poll v2 is for community announcement groups (single select and multiple)
             m.pollCreationMessageV2 = pollCreationMessage;
         }
         else {
-            if (message.poll.selectableCount === 1) {
+            // Add quiz message support
+            if (message.poll.pollType === 1) {
+                if (!message.poll.correctAnswer) {
+                    throw new Boom('No "correctAnswer" provided for quiz', { statusCode: 400 });
+                }
+                m.pollCreationMessageV5 = {
+                    // quiz for newsletter only
+                    ...pollCreationMessage,
+                    correctAnswer: {
+                        optionName: message.poll.correctAnswer.toString()
+                    },
+                    pollType: 1,
+                    selectableOptionsCount: 1
+                };
+            }
+            else if (message.poll.selectableCount === 1) {
                 //poll v3 is for single select polls
                 m.pollCreationMessageV3 = pollCreationMessage;
             }
@@ -459,11 +816,88 @@ export const generateWAMessageContent = async (message, options) => {
                 m.pollCreationMessage = pollCreationMessage;
             }
         }
+        m.messageContextInfo = {
+            // encKey
+            messageSecret: message.poll.messageSecret || randomBytes(32)
+        };
+    }
+    else if (hasNonNullishProperty(message, 'pollResult')) {
+        const pollResultSnapshotMessage = {
+            name: message.pollResult.name,
+            pollVotes: message.pollResult.votes.map(vote => ({
+                optionName: vote.name,
+                optionVoteCount: parseInt(vote.voteCount)
+            }))
+        };
+        if (message.pollResult.pollType === 1) {
+            pollResultSnapshotMessage.pollType = proto.Message.PollType.QUIZ;
+            m.pollResultSnapshotMessageV3 = pollResultSnapshotMessage;
+        }
+        else {
+            pollResultSnapshotMessage.pollType = proto.Message.PollType.POLL;
+            m.pollResultSnapshotMessage = pollResultSnapshotMessage;
+        }
+    }
+    else if (hasNonNullishProperty(message, 'pollUpdate')) {
+        if (!message.pollUpdate.key) {
+            throw new Boom('Message key is required', { statusCode: 400 });
+        }
+        if (!message.pollUpdate.vote) {
+            throw new Boom('Encrypted vote payload is required', { statusCode: 400 });
+        }
+        m.pollUpdateMessage = {
+            metadata: message.pollUpdate.metadata,
+            pollCreationMessageKey: message.pollUpdate.key,
+            senderTimestampMs: Date.now(),
+            vote: message.pollUpdate.vote
+        };
+    }
+    else if (hasNonNullishProperty(message, 'paymentInviteServiceType')) {
+        m.paymentInviteMessage = {
+            expiryTimestamp: Date.now(),
+            serviceType: message.paymentInviteServiceType
+        };
+    }
+    else if (hasNonNullishProperty(message, 'orderText')) {
+        if (!Buffer.isBuffer(message.thumbnail)) {
+            throw new Boom('Must provide thumbnail buffer in order message', { statusCode: 400 });
+        }
+        m.orderMessage = {
+            itemCount: 1,
+            messageVersion: 1,
+            orderTitle: LIBRARY_NAME,
+            status: proto.Message.OrderMessage.OrderStatus.INQUIRY,
+            surface: proto.Message.OrderMessage.OrderSurface.CATALOG,
+            token: generateMessageIDV2(),
+            totalAmount1000: 1000,
+            totalCurrencyCode: 'IDR',
+            ...message,
+            message: message.orderText
+        };
+        delete m.orderMessage.orderText;
     }
     else if (hasNonNullishProperty(message, 'album')) {
+        if (!Array.isArray(message.album)) {
+            throw new Boom('Invalid album type. Expected an array.', { statusCode: 400 });
+        }
+        let videoCount = 0;
+        for (let i = 0; i < message.album.length; i++) {
+            if (message.album[i].video)
+                videoCount++;
+        }
+        ;
+        let imageCount = 0;
+        for (let i = 0; i < message.album.length; i++) {
+            if (message.album[i].image)
+                imageCount++;
+        }
+        ;
+        if ((videoCount + imageCount) < 2) {
+            throw new Boom('Minimum provide 2 media to upload album message', { statusCode: 400 });
+        }
         m.albumMessage = {
-            expectedImageCount: message.album.expectedImageCount,
-            expectedVideoCount: message.album.expectedVideoCount
+            expectedImageCount: imageCount,
+            expectedVideoCount: videoCount
         };
     }
     else if (hasNonNullishProperty(message, 'sharePhoneNumber')) {
@@ -485,287 +919,336 @@ export const generateWAMessageContent = async (message, options) => {
             }
         };
     }
-    else if ('keep' in message) {
-        m.keepInChatMessage = {};
-        m.keepInChatMessage.key = message.keep;
-        m.keepInChatMessage.keepType = message.type;
-        m.keepInChatMessage.timestampMs = Date.now();
-    }
-    else if ('call' in message) {
-        m = {
-            scheduledCallCreationMessage: {
-                scheduledTimestampMs: message.call?.time ?? Date.now(),
-                callType: message.call?.type ?? 1,
-                title: message.call?.title
+    else if (hasNonNullishProperty(message, 'buttonsMessage')) {
+        // Direct buttonsMessage passthrough — supports headerType 6 (locationMessage), etc.
+        const btnMsg = { ...message.buttonsMessage };
+        if (btnMsg.locationMessage?.jpegThumbnail && !Buffer.isBuffer(btnMsg.locationMessage.jpegThumbnail)) {
+            const lib = await getImageProcessingLibrary();
+            const hasSharp = 'sharp' in lib && !!lib.sharp?.default;
+            if (hasSharp) {
+                const rawBuf = typeof btnMsg.locationMessage.jpegThumbnail === 'string'
+                    ? (await fs.readFile(btnMsg.locationMessage.jpegThumbnail))
+                    : btnMsg.locationMessage.jpegThumbnail;
+                btnMsg.locationMessage.jpegThumbnail = await lib.sharp.default(rawBuf)
+                    .resize(300, 300, { fit: 'inside', withoutEnlargement: true })
+                    .jpeg({ quality: 80 })
+                    .toBuffer();
             }
-        };
-    }
-    else if ('paymentInvite' in message) {
-        m.paymentInviteMessage = {
-            serviceType: message.paymentInvite?.type,
-            expiryTimestamp: message.paymentInvite?.expiry
-        };
-    }
-    else if ('order' in message) {
-        m.orderMessage = WAProto.Message.OrderMessage.fromObject({
-            orderId: message.order.id,
-            thumbnail: message.order.thumbnail,
-            itemCount: message.order.itemCount,
-            status: message.order.status,
-            surface: message.order.surface,
-            orderTitle: message.order.title,
-            message: message.order.text,
-            sellerJid: message.order.seller,
-            token: message.order.token,
-            totalAmount1000: message.order.amount,
-            totalCurrencyCode: message.order.currency
-        });
-    }
-    else if ('inviteAdmin' in message) {
-        m.newsletterAdminInviteMessage = {};
-        m.newsletterAdminInviteMessage.inviteExpiration = message.inviteAdmin?.inviteExpiration;
-        m.newsletterAdminInviteMessage.caption = message.inviteAdmin?.text;
-        m.newsletterAdminInviteMessage.newsletterJid = message.inviteAdmin?.jid;
-        m.newsletterAdminInviteMessage.newsletterName = message.inviteAdmin?.subject;
-        m.newsletterAdminInviteMessage.jpegThumbnail = message.inviteAdmin?.thumbnail;
-    }
-    else if ('requestPayment' in message) {
-        const _rp = message.requestPayment;
-        const sticker = _rp?.sticker
-            ? await prepareWAMessageMedia({ sticker: _rp.sticker }, options)
-            : null;
-        let notes = {};
-        if (_rp?.sticker) {
-            notes = {
-                stickerMessage: {
-                    ...sticker?.stickerMessage,
-                    contextInfo: _rp?.contextInfo
-                }
-            };
-        }
-        else if (_rp?.note) {
-            notes = {
-                extendedTextMessage: {
-                    text: _rp.note,
-                    contextInfo: _rp?.contextInfo
-                }
-            };
         }
-        else {
-            throw new Boom('Invalid media type', { statusCode: 400 });
-        }
-        m.requestPaymentMessage = WAProto.Message.RequestPaymentMessage.fromObject({
-            expiryTimestamp: _rp?.expiry,
-            amount1000: _rp?.amount,
-            currencyCodeIso4217: _rp?.currency,
-            requestFrom: _rp?.from,
-            noteMessage: { ...notes },
-            background: _rp?.background ?? null
-        });
+        m = { buttonsMessage: btnMsg };
     }
     else {
         m = await prepareWAMessageMedia(message, options);
     }
-    if ('buttons' in message && !!message.buttons) {
-        const nativeButtons = message.buttons.map(b => ({
-            name: 'quick_reply',
-            buttonParamsJson: JSON.stringify({
-                display_text: b.buttonText?.displayText || b.displayText || '',
-                id: b.buttonId || b.id || ''
-            })
-        }));
-        const interactiveMessage = {
-            nativeFlowMessage: WAProto.Message.InteractiveMessage.NativeFlowMessage.fromObject({
-                buttons: nativeButtons
+    if (hasNonNullishProperty(message, 'buttons')) {
+        const buttonsMessage = {
+            buttons: message.buttons.map(button => {
+                const buttonText = button.text || button.buttonText;
+                if (hasOptionalProperty(button, 'sections')) {
+                    return {
+                        nativeFlowInfo: {
+                            name: 'single_select',
+                            paramsJson: JSON.stringify({
+                                title: buttonText,
+                                sections: button.sections
+                            })
+                        },
+                        type: ButtonType.NATIVE_FLOW
+                    };
+                }
+                else if (hasOptionalProperty(button, 'name')) {
+                    return {
+                        nativeFlowInfo: {
+                            name: button.name,
+                            paramsJson: button.paramsJson
+                        },
+                        type: ButtonType.NATIVE_FLOW
+                    };
+                }
+                return {
+                    buttonId: button.id || button.buttonId,
+                    buttonText: typeof buttonText === 'string' ? { displayText: buttonText } : buttonText,
+                    type: button.type || ButtonType.RESPONSE
+                };
             })
         };
-        if ('text' in message) {
-            interactiveMessage.body = { text: message.text };
-        }
-        else if ('caption' in message) {
-            interactiveMessage.body = { text: message.caption };
-            interactiveMessage.header = { hasMediaAttachment: true };
-            Object.assign(interactiveMessage.header, m);
-        }
-        if ('title' in message && !!message.title) {
-            interactiveMessage.header = interactiveMessage.header || {};
-            interactiveMessage.header.title = message.title;
-            interactiveMessage.header.hasMediaAttachment = false;
-        }
-        if ('footer' in message && !!message.footer) {
-            interactiveMessage.footer = { text: message.footer };
+        if (hasOptionalProperty(message, 'text')) {
+            buttonsMessage.contentText = message.text;
+            buttonsMessage.headerType = ButtonHeaderType.EMPTY;
         }
-        if ('contextInfo' in message && !!message.contextInfo) {
-            interactiveMessage.contextInfo = message.contextInfo;
-        }
-        if ('mentions' in message && !!message.mentions) {
-            interactiveMessage.contextInfo = { mentionedJid: message.mentions };
-        }
-        m = { interactiveMessage };
-    }
-    else if ('templateButtons' in message && !!message.templateButtons) {
-        const nativeButtons = message.templateButtons.map(b => {
-            if (b.quickReplyButton) {
-                return {
-                    name: 'quick_reply',
-                    buttonParamsJson: JSON.stringify({
-                        display_text: b.quickReplyButton.displayText || '',
-                        id: b.quickReplyButton.id || ''
-                    })
-                };
-            }
-            if (b.urlButton) {
-                return {
-                    name: 'cta_url',
-                    buttonParamsJson: JSON.stringify({
-                        display_text: b.urlButton.displayText || '',
-                        url: b.urlButton.url || '',
-                        merchant_url: b.urlButton.url || ''
-                    })
-                };
-            }
-            if (b.callButton) {
-                return {
-                    name: 'cta_call',
-                    buttonParamsJson: JSON.stringify({
-                        display_text: b.callButton.displayText || '',
-                        phone_number: b.callButton.phoneNumber || ''
-                    })
-                };
+        else {
+            if (hasOptionalProperty(message, 'caption')) {
+                buttonsMessage.contentText = message.caption;
             }
-            return {
-                name: 'quick_reply',
-                buttonParamsJson: JSON.stringify({ display_text: '', id: '' })
-            };
-        });
-        const interactiveMessage = {
-            nativeFlowMessage: WAProto.Message.InteractiveMessage.NativeFlowMessage.fromObject({
-                buttons: nativeButtons
+            const type = Object.keys(m)[0].replace('Message', '').toUpperCase();
+            buttonsMessage.headerType = ButtonHeaderType[type];
+            Object.assign(buttonsMessage, m);
+        }
+        if (hasOptionalProperty(message, 'footer')) {
+            buttonsMessage.footerText = message.footer;
+        }
+        m = { buttonsMessage };
+    }
+    else if (hasNonNullishProperty(message, 'sections')) {
+        const listMessage = {
+            sections: message.sections,
+            buttonText: message.buttonText,
+            title: message.title,
+            footerText: message.footer,
+            description: message.text,
+            listType: ListType.SINGLE_SELECT
+        };
+        m = { listMessage };
+    }
+    else if (hasNonNullishProperty(message, 'templateButtons')) {
+        const hydratedTemplate = {
+            hydratedButtons: message.templateButtons.map((button, i) => {
+                const buttonText = button.text || button.buttonText;
+                if (hasOptionalProperty(button, 'id')) {
+                    return {
+                        index: i,
+                        quickReplyButton: {
+                            displayText: buttonText || '👉🏻 Click',
+                            id: button.id
+                        }
+                    };
+                }
+                else if (hasOptionalProperty(button, 'url')) {
+                    return {
+                        index: i,
+                        urlButton: {
+                            displayText: buttonText || '🌐 Visit',
+                            url: button.url
+                        }
+                    };
+                }
+                else if (hasOptionalProperty(button, 'call')) {
+                    return {
+                        index: i,
+                        callButton: {
+                            displayText: buttonText || '📞 Call',
+                            phoneNumber: button.call
+                        }
+                    };
+                }
+                button.index = button.index || i;
+                return button;
             })
         };
-        if ('text' in message) {
-            interactiveMessage.body = { text: message.text };
-        }
-        else if ('caption' in message) {
-            interactiveMessage.body = { text: message.caption };
-            interactiveMessage.header = { hasMediaAttachment: true };
-            Object.assign(interactiveMessage.header, m);
+        if (hasOptionalProperty(message, 'text')) {
+            hydratedTemplate.hydratedContentText = message.text;
         }
-        if ('footer' in message && !!message.footer) {
-            interactiveMessage.footer = { text: message.footer };
-        }
-        if ('contextInfo' in message && !!message.contextInfo) {
-            interactiveMessage.contextInfo = message.contextInfo;
+        else {
+            if (hasOptionalProperty(message, 'caption')) {
+                hydratedTemplate.hydratedTitleText = message.title;
+                hydratedTemplate.hydratedContentText = message.caption;
+            }
+            ;
+            Object.assign(hydratedTemplate, m);
         }
-        if ('mentions' in message && !!message.mentions) {
-            interactiveMessage.contextInfo = { mentionedJid: message.mentions };
+        if (hasOptionalProperty(message, 'footer')) {
+            hydratedTemplate.hydratedFooterText = message.footer;
         }
-        m = { interactiveMessage };
-    }
-    if ('sections' in message && !!message.sections) {
-        const interactiveMessage = {
-            nativeFlowMessage: WAProto.Message.InteractiveMessage.NativeFlowMessage.fromObject({
-                buttons: [{
-                    name: 'single_select',
-                    buttonParamsJson: JSON.stringify({
-                        title: message.buttonText || 'Lihat Pilihan',
-                        sections: message.sections.map(s => ({
-                            title: s.title || '',
-                            highlight_label: s.highlight_label || '',
-                            rows: (s.rows || []).map(r => ({
-                                header: r.title || '',
-                                title: r.description || '',
-                                id: r.rowId || r.id || ''
-                            }))
-                        }))
-                    })
-                }]
-            })
+        hydratedTemplate.templateId = message.id || 'template-' + Date.now();
+        m = {
+            templateMessage: {
+                hydratedFourRowTemplate: hydratedTemplate,
+                hydratedTemplate: hydratedTemplate
+            }
         };
-        if (message.text) interactiveMessage.body = { text: message.text };
-        if (message.footer) interactiveMessage.footer = { text: message.footer };
-        if (message.title) interactiveMessage.header = { title: message.title, hasMediaAttachment: false };
-        if (message.contextInfo) interactiveMessage.contextInfo = message.contextInfo;
-        if (message.mentions) interactiveMessage.contextInfo = { mentionedJid: message.mentions };
-        m = { interactiveMessage };
     }
-    if ('interactiveButtons' in message && !!message.interactiveButtons) {
+    else if (hasNonNullishProperty(message, 'nativeFlow')) {
         const interactiveMessage = {
-            nativeFlowMessage: WAProto.Message.InteractiveMessage.NativeFlowMessage.fromObject({
-                buttons: message.interactiveButtons
-            })
+            nativeFlowMessage: prepareNativeFlowButtons(message)
         };
-        if ('text' in message) {
-            interactiveMessage.body = { text: message.text };
+        if (hasOptionalProperty(message, 'bizJid')) {
+            interactiveMessage.collectionMessage = {
+                bizJid: message.bizJid,
+                id: message.id,
+                messageVersion: 1
+            };
         }
-        else if ('caption' in message) {
-            interactiveMessage.body = { text: message.caption };
-            interactiveMessage.header = {
-                title: message.title,
-                subtitle: message.subtitle,
-                hasMediaAttachment: message?.media ?? false
+        else if (hasOptionalProperty(message, 'shopSurface')) {
+            interactiveMessage.shopStorefrontMessage = {
+                surface: message.shopSurface,
+                id: message.id,
+                messageVersion: 1
             };
-            Object.assign(interactiveMessage.header, m);
         }
-        if ('footer' in message && !!message.footer) {
-            interactiveMessage.footer = { text: message.footer };
+        if (hasOptionalProperty(message, 'text')) {
+            interactiveMessage.body = { text: message.text };
         }
-        if ('title' in message && !!message.title) {
-            interactiveMessage.header = {
-                title: message.title,
-                subtitle: message.subtitle,
-                hasMediaAttachment: message?.media ?? false
-            };
+        else {
+            if (hasOptionalProperty(message, 'caption')) {
+                const isValidHeader = hasValidInteractiveHeader(m);
+                if (!isValidHeader) {
+                    throw new Boom('Invalid media type for interactive message header', { statusCode: 400 });
+                }
+                interactiveMessage.header = {
+                    title: message.title || '',
+                    subtitle: message.subtitle || '',
+                    hasMediaAttachment: isValidHeader
+                };
+                interactiveMessage.body = { text: message.caption };
+            }
+            if (hasOptionalProperty(message, 'thumbnail') && !!message.thumbnail) {
+                interactiveMessage.jpegThumbnail = message.thumbnail;
+            }
             Object.assign(interactiveMessage.header, m);
         }
-        if ('contextInfo' in message && !!message.contextInfo) {
-            interactiveMessage.contextInfo = message.contextInfo;
+        if (hasOptionalProperty(message, 'audioFooter')) {
+            const { audioMessage } = await prepareWAMessageMedia({
+                audio: message.audioFooter
+            }, options);
+            interactiveMessage.footer = {
+                audioMessage,
+                hasMediaAttachment: true
+            };
         }
-        if ('mentions' in message && !!message.mentions) {
-            interactiveMessage.contextInfo = { mentionedJid: message.mentions };
+        else if (hasOptionalProperty(message, 'footer')) {
+            interactiveMessage.footer = { text: message.footer };
         }
         m = { interactiveMessage };
     }
-    if ('shop' in message && !!message.shop) {
+    else if (hasNonNullishProperty(message, 'cards')) {
         const interactiveMessage = {
-            shopStorefrontMessage: WAProto.Message.InteractiveMessage.ShopMessage.fromObject({
-                surface: message.shop,
-                id: message.id
-            })
+            carouselMessage: {
+                cards: await Promise.all(message.cards.map(async (card) => {
+                    let carouselHeader = {};
+                    if (hasNonNullishProperty(card, 'product')) {
+                        carouselHeader.productMessage = await prepareProductMessage(card, options);
+                    }
+                    else {
+                        carouselHeader = await prepareWAMessageMedia(card, options).catch(() => ({}));
+                    }
+                    const isValidHeader = hasValidCarouselHeader(carouselHeader);
+                    if (!isValidHeader) {
+                        throw new Boom('Invalid media type for carousel card', { statusCode: 400 });
+                    }
+                    const carouselCard = {
+                        nativeFlowMessage: prepareNativeFlowButtons(card.nativeFlow ? card : [])
+                    };
+                    if (hasOptionalProperty(card, 'text')) {
+                        carouselCard.body = { text: card.text };
+                    }
+                    else {
+                        if (hasOptionalProperty(card, 'caption')) {
+                            carouselCard.header = {
+                                title: card.title || '',
+                                subtitle: card.subtitle || '',
+                                hasMediaAttachment: isValidHeader
+                            };
+                            carouselCard.body = { text: card.caption };
+                        }
+                        if (hasOptionalProperty(card, 'thumbnail') && !!card.thumbnail) {
+                            carouselCard.jpegThumbnail = card.thumbnail;
+                        }
+                        Object.assign(carouselCard.header, carouselHeader);
+                    }
+                    if (hasOptionalProperty(card, 'audioFooter')) {
+                        const { audioMessage } = await prepareWAMessageMedia({
+                            audio: card.audioFooter
+                        }, options);
+                        carouselCard.footer = {
+                            audioMessage,
+                            hasMediaAttachment: true
+                        };
+                    }
+                    else if (hasOptionalProperty(card, 'footer')) {
+                        carouselCard.footer = { text: card.footer };
+                    }
+                    return carouselCard;
+                })),
+                carouselCardType: CarouselCardType.UNKNOWN,
+                messageVersion: 1
+            }
         };
-        if ('text' in message) {
+        if (hasOptionalProperty(message, 'text')) {
             interactiveMessage.body = { text: message.text };
         }
-        else if ('caption' in message) {
-            interactiveMessage.body = { text: message.caption };
-            interactiveMessage.header = {
-                title: message.title,
-                subtitle: message.subtitle,
-                hasMediaAttachment: message?.media ?? false
-            };
-            Object.assign(interactiveMessage.header, m);
-        }
-        if ('footer' in message && !!message.footer) {
+        if (hasOptionalProperty(message, 'footer')) {
             interactiveMessage.footer = { text: message.footer };
         }
-        if ('title' in message && !!message.title) {
-            interactiveMessage.header = {
-                title: message.title,
-                subtitle: message.subtitle,
-                hasMediaAttachment: message?.media ?? false
-            };
-            Object.assign(interactiveMessage.header, m);
+        m = { interactiveMessage };
+    }
+    else if (hasNonNullishProperty(message, 'requestPaymentFrom')) {
+        const requestPaymentMessage = {
+            amount: {
+                currencyCode: 'IDR',
+                offset: 1000,
+                value: 1000
+            },
+            amount1000: 1000,
+            currencyCodeIso4217: 'IDR',
+            expiryTimestamp: Date.now(),
+            noteMessage: m,
+            requestFrom: message.requestPaymentFrom,
+            ...message
+        };
+        delete requestPaymentMessage.requestPaymentFrom;
+        if (hasNonNullishProperty(m, 'extendedTextMessage') || hasNonNullishProperty(m, 'stickerMessage')) {
+            Object.assign(requestPaymentMessage.noteMessage, m);
         }
-        if ('contextInfo' in message && !!message.contextInfo) {
-            interactiveMessage.contextInfo = message.contextInfo;
+        else {
+            throw new Boom('Invalid message type for request payment note message', { statusCode: 400 });
         }
-        if ('mentions' in message && !!message.mentions) {
-            interactiveMessage.contextInfo = { mentionedJid: message.mentions };
+        m = { requestPaymentMessage };
+    }
+    else if (hasNonNullishProperty(message, 'invoiceNote')) {
+        const attachment = m.imageMessage || m.documentMessage;
+        const type = Object.keys(m)[0].replace('Message', '').toUpperCase();
+        const invoiceMessage = {
+            attachmentType: proto.Message.InvoiceMessage.AttachmentType[type === 'DOCUMENT' ? 'PDF' : 'IMAGE'],
+            note: message.invoiceNote
+        };
+        if (attachment) {
+            const { directPath, fileEncSha256, fileSha256, jpegThumbnail = undefined, mediaKey, mediaKeyTimestamp, mimetype } = attachment;
+            Object.assign(invoiceMessage, {
+                attachmentDirectPath: directPath,
+                attachmentFileEncSha256: fileEncSha256,
+                attachmentFileSha256: fileSha256,
+                attachmentJpegThumbnail: jpegThumbnail,
+                attachmentMediaKey: mediaKey,
+                attachmentMediaKeyTimestamp: mediaKeyTimestamp,
+                attachmentMimetype: mimetype,
+                token: generateMessageIDV2()
+            });
         }
-        m = { interactiveMessage };
+        else {
+            throw new Boom('Invalid media type for invoice message', { statusCode: 400 });
+        }
+        m = { invoiceMessage };
     }
-    if (hasOptionalProperty(message, 'viewOnce') && !!message.viewOnce) {
-        m = { viewOnceMessage: { message: m } };
+    if (hasOptionalProperty(message, 'externalAdReply') && !!message.externalAdReply) {
+        const messageType = Object.keys(m)[0];
+        const key = m[messageType];
+        const content = message.externalAdReply;
+        if ('thumbnail' in content && !Buffer.isBuffer(content.thumbnail)) {
+            throw new Boom('Thumbnail must in buffer type', { statusCode: 400 });
+        }
+        if (!content.url || typeof content.url !== 'string') {
+            content.url = DONATE_URL;
+        }
+        const externalAdReply = {
+            ...content,
+            body: content.body,
+            mediaType: content.mediaType || 1,
+            mediaUrl: content.url,
+            renderLargerThumbnail: content.largeThumbnail,
+            sourceUrl: content.url,
+            thumbnail: content.thumbnail,
+            thumbnailUrl: content.url + '?update=' + Date.now(),
+            title: content.title || LIBRARY_NAME
+        };
+        delete externalAdReply.subTitle;
+        delete externalAdReply.largeThumbnail;
+        delete externalAdReply.url;
+        if ('contextInfo' in key && !!key.contextInfo) {
+            key.contextInfo.externalAdReply = { ...key.contextInfo.externalAdReply, ...externalAdReply };
+        }
+        else if (key) {
+            key.contextInfo = { externalAdReply };
+        }
     }
     if ((hasOptionalProperty(message, 'mentions') && message.mentions?.length) ||
         (hasOptionalProperty(message, 'mentionAll') && message.mentionAll)) {
@@ -787,16 +1270,6 @@ export const generateWAMessageContent = async (message, options) => {
             };
         }
     }
-    if (hasOptionalProperty(message, 'edit')) {
-        m = {
-            protocolMessage: {
-                key: message.edit,
-                editedMessage: m,
-                timestampMs: Date.now(),
-                type: WAProto.Message.ProtocolMessage.Type.MESSAGE_EDIT
-            }
-        };
-    }
     if (hasOptionalProperty(message, 'contextInfo') && !!message.contextInfo) {
         const messageType = Object.keys(m)[0];
         const key = m[messageType];
@@ -807,12 +1280,71 @@ export const generateWAMessageContent = async (message, options) => {
             key.contextInfo = message.contextInfo;
         }
     }
-    if (hasOptionalProperty(message, 'albumParentKey') && !!message.albumParentKey) {
-        m.messageContextInfo = {
-            ...m.messageContextInfo,
-            messageAssociation: {
-                associationType: WAProto.MessageAssociation.AssociationType.MEDIA_ALBUM,
-                parentMessageKey: message.albumParentKey
+    if (hasOptionalProperty(message, 'groupStatus') && !!message.groupStatus) {
+        const messageType = Object.keys(m)[0];
+        const key = m[messageType];
+        if ('contextInfo' in key && !!key.contextInfo) {
+            key.contextInfo.isGroupStatus = message.groupStatus;
+        }
+        else if (key) {
+            key.contextInfo = {
+                isGroupStatus: message.groupStatus
+            };
+        }
+        m = { groupStatusMessageV2: { message: m } };
+        delete message.groupStatus;
+    }
+    if (hasOptionalProperty(message, 'spoiler') && !!message.spoiler) {
+        const messageType = Object.keys(m)[0];
+        const key = m[messageType];
+        if ('contextInfo' in key && !!key.contextInfo) {
+            key.contextInfo.isSpoiler = message.spoiler;
+        }
+        else if (key) {
+            key.contextInfo = {
+                isSpoiler: message.spoiler
+            };
+        }
+        m = { spoilerMessage: { message: m } };
+        delete message.spoiler;
+    }
+    else if (hasOptionalProperty(message, 'interactiveAsTemplate') && !!message.interactiveAsTemplate) {
+        if (!m.interactiveMessage) {
+            throw new Boom('Invalid message type for template', { statusCode: 400 });
+        }
+        m = {
+            templateMessage: {
+                interactiveMessageTemplate: m.interactiveMessage,
+                templateId: message.id || 'template-' + Date.now()
+            }
+        };
+        delete message.interactiveAsTemplate;
+    }
+    if (hasOptionalProperty(message, 'ephemeral') && !!message.ephemeral) {
+        m = { ephemeralMessage: { message: m } };
+        delete message.ephemeral;
+    }
+    if (hasOptionalProperty(message, 'isLottie') && !!message.isLottie) {
+        m = { lottieStickerMessage: { message: m } };
+    }
+    else if (hasOptionalProperty(message, 'viewOnce') && !!message.viewOnce) {
+        m = { viewOnceMessage: { message: m } };
+    }
+    else if (hasOptionalProperty(message, 'viewOnceV2') && !!message.viewOnceV2) {
+        m = { viewOnceMessageV2: { message: m } };
+        delete message.viewOnceV2;
+    }
+    else if (hasOptionalProperty(message, 'viewOnceV2Extension') && !!message.viewOnceV2Extension) {
+        m = { viewOnceMessageV2Extension: { message: m } };
+        delete message.viewOnceV2Extension;
+    }
+    if (hasOptionalProperty(message, 'edit')) {
+        m = {
+            protocolMessage: {
+                key: message.edit,
+                editedMessage: m,
+                timestampMs: Date.now(),
+                type: WAProto.Message.ProtocolMessage.Type.MESSAGE_EDIT
             }
         };
     }
@@ -831,10 +1363,12 @@ export const generateWAMessageFromContent = (jid, message, options) => {
         options.timestamp = new Date();
     }
     const innerMessage = normalizeMessageContent(message);
+    const messageContextInfo = message.messageContextInfo;
     const key = getContentType(innerMessage);
     const timestamp = unixTimestampSeconds(options.timestamp);
+    const isNewsletter = isJidNewsletter(jid);
     const { quoted, userJid } = options;
-    if (quoted && !isJidNewsletter(jid)) {
+    if (quoted) {
         const participant = quoted.key.fromMe
             ? userJid // TODO: Add support for LIDs
             : quoted.participant || quoted.key.participant || quoted.key.remoteJid;
@@ -852,7 +1386,7 @@ export const generateWAMessageFromContent = (jid, message, options) => {
         contextInfo.quotedMessage = quotedMsg;
         // if a participant is quoted, then it must be a group
         // hence, remoteJid of group must also be entered
-        if (jid !== quoted.key.remoteJid) {
+        if (!isNewsletter && jid !== quoted.key.remoteJid) {
             contextInfo.remoteJid = quoted.key.remoteJid;
         }
         if (contextInfo && innerMessage[key]) {
@@ -868,7 +1402,7 @@ export const generateWAMessageFromContent = (jid, message, options) => {
         // already not converted to disappearing message
         key !== 'ephemeralMessage' &&
         // newsletters don't support ephemeral messages
-        !isJidNewsletter(jid)) {
+        !isNewsletter) {
         /* @ts-ignore */
         innerMessage[key].contextInfo = {
             ...(innerMessage[key].contextInfo || {}),
@@ -876,6 +1410,13 @@ export const generateWAMessageFromContent = (jid, message, options) => {
             //ephemeralSettingTimestamp: options.ephemeralOptions.eph_setting_ts?.toString()
         };
     }
+    if (messageContextInfo?.messageSecret && (isPnUser(jid) || isLidUser(jid))) {
+        messageContextInfo.deviceListMetadata = {
+            recipientKeyHash: randomBytes(10),
+            recipientTimestamp: unixTimestampSeconds()
+        };
+        messageContextInfo.deviceListMetadataVersion = 2;
+    }
     message = WAProto.Message.create(message);
     const messageJSON = {
         key: {
@@ -895,7 +1436,10 @@ export const generateWAMessage = async (jid, content, options) => {
     // ensure msg ID is with every log
     options.logger = options?.logger?.child({ msgId: options.messageId });
     // Pass jid in the options to generateWAMessageContent
-    return generateWAMessageFromContent(jid, await generateWAMessageContent(content, { ...options, jid }), options);
+    if (jid) {
+        options.jid = jid;
+    }
+    return generateWAMessageFromContent(jid, await generateWAMessageContent(content, options), options);
 };
 /** Get the key to access the true type of content */
 export const getContentType = (content) => {
@@ -905,12 +1449,6 @@ export const getContentType = (content) => {
         return key;
     }
 };
-/**
- * Normalizes ephemeral, view once messages to regular message content
- * Eg. image messages in ephemeral messages, in view once messages etc.
- * @param content
- * @returns
- */
 export const normalizeMessageContent = (content) => {
     if (!content) {
         return undefined;
@@ -925,29 +1463,33 @@ export const normalizeMessageContent = (content) => {
     }
     return content;
     function getFutureProofMessage(message) {
-        return (message?.ephemeralMessage ||
-            message?.viewOnceMessage ||
+        return (message?.associatedChildMessage ||
+            message?.botForwardedMessage ||
+            message?.botInvokeMessage ||
+            message?.botTaskMessage ||
             message?.documentWithCaptionMessage ||
-            message?.viewOnceMessageV2 ||
-            message?.viewOnceMessageV2Extension ||
             message?.editedMessage ||
-            message?.groupMentionedMessage ||
-            message?.botInvokeMessage ||
-            message?.lottieStickerMessage ||
+            message?.ephemeralMessage ||
             message?.eventCoverImage ||
-            message?.statusMentionMessage ||
-            message?.pollCreationOptionImageMessage ||
-            message?.associatedChildMessage ||
+            message?.groupMentionedMessage ||
             message?.groupStatusMentionMessage ||
-            message?.pollCreationMessageV4 ||
-            message?.pollCreationMessageV5 ||
-            message?.statusAddYours ||
             message?.groupStatusMessage ||
+            message?.groupStatusMessageV2 ||
             message?.limitSharingMessage ||
-            message?.botTaskMessage ||
+            message?.lottieStickerMessage ||
+            message?.newsletterAdminProfileMessage ||
+            message?.newsletterAdminProfileMessageV2 ||
+            message?.newsletterAdminProfileStatusMessage ||
+            message?.pollCreationMessageV4 ||
+            message?.pollCreationOptionImageMessage ||
             message?.questionMessage ||
-            message?.groupStatusMessageV2 ||
-            message?.botForwardedMessage);
+            message?.questionReplyMessage ||
+            message?.spoilerMessage ||
+            message?.statusAddYours ||
+            message?.statusMentionMessage ||
+            message?.viewOnceMessage ||
+            message?.viewOnceMessageV2 ||
+            message?.viewOnceMessageV2Extension);
     }
 };
 /**
@@ -1180,4 +1722,74 @@ export const assertMediaContent = (content) => {
     }
     return mediaContent;
 };
-//# sourceMappingURL=messages.js.map
+/**
+ * Checks if a WebP buffer is animated by looking for VP8X chunk with animation flag
+ * or ANIM/ANMF chunks
+ */
+const isAnimatedWebP = (buffer) => {
+    // WebP must start with RIFF....WEBP
+    if (buffer.length < 12 ||
+        buffer[0] !== 0x52 ||
+        buffer[1] !== 0x49 ||
+        buffer[2] !== 0x46 ||
+        buffer[3] !== 0x46 ||
+        buffer[8] !== 0x57 ||
+        buffer[9] !== 0x45 ||
+        buffer[10] !== 0x42 ||
+        buffer[11] !== 0x50) {
+        return false;
+    }
+    ;
+    // Parse chunks starting after RIFF header (12 bytes)
+    let offset = 12;
+    while (offset < buffer.length - 8) {
+        const chunkFourCC = buffer.toString('ascii', offset, offset + 4);
+        const chunkSize = buffer.readUInt32LE(offset + 4);
+        if (chunkFourCC === 'VP8X') {
+            // VP8X extended header, check animation flag (bit 1 at offset+8)
+            const flagsOffset = offset + 8;
+            if (flagsOffset < buffer.length) {
+                const flags = buffer[flagsOffset];
+                if (flags & 0x02) {
+                    return true;
+                }
+                ;
+            }
+            ;
+        }
+        else if (chunkFourCC === 'ANIM' || chunkFourCC === 'ANMF') {
+            // ANIM or ANMF chunks indicate animation
+            return true;
+        }
+        ;
+        // Move to next chunk (chunk size + 8 bytes header, padded to even)
+        offset += 8 + chunkSize + (chunkSize % 2);
+    }
+    ;
+    return false;
+};
+/**
+ * Checks if a buffer is a WebP file
+ */
+const isWebPBuffer = (buffer) => {
+    return (buffer.length >= 12 &&
+        buffer[0] === 0x52 &&
+        buffer[1] === 0x49 &&
+        buffer[2] === 0x46 &&
+        buffer[3] === 0x46 &&
+        buffer[8] === 0x57 &&
+        buffer[9] === 0x45 &&
+        buffer[10] === 0x42 &&
+        buffer[11] === 0x50);
+};
+export const shouldIncludeBizBinaryNode = (message) => {
+    const hasValidInteractive = message.interactiveMessage &&
+        !message.interactiveMessage.carouselMessage &&
+        !message.interactiveMessage.collectionMessage &&
+        !message.interactiveMessage.shopStorefrontMessage;
+    return (message.buttonsMessage ||
+        message.interactiveMessage ||
+        message.listMessage ||
+        hasValidInteractive);
+};
+//# sourceMappingURL=messages.js.map