@aseppxyzz12/baileys 1.1.8

package/lib/Utils/messages.js

@@ -0,0 +1,1908 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const { Boom: Boom } = require("@hapi/boom");
+const { randomBytes: randomBytes } = require("crypto");
+const { promises: promises } = require("fs");
+const sharp = require("sharp");
+const { proto: proto } = require("../../WAProto");
+const {
+    URL_REGEX: URL_REGEX,
+    WA_DEFAULT_EPHEMERAL: WA_DEFAULT_EPHEMERAL,
+} = require("../Defaults/constants");
+const { MEDIA_KEYS: MEDIA_KEYS } = require("../Defaults/media");
+const { WAProto: WAProto, WAMessageStatus: WAMessageStatus } = require("../Types");
+const {
+    isJidGroup: isJidGroup,
+    isJidNewsletter: isJidNewsletter,
+    isJidStatusBroadcast: isJidStatusBroadcast,
+    jidNormalizedUser: jidNormalizedUser,
+} = require("../WABinary");
+const { sha256: sha256 } = require("./crypto");
+const {
+    generateMessageID: generateMessageID,
+    getKeyAuthor: getKeyAuthor,
+    unixTimestampSeconds: unixTimestampSeconds,
+} = require("./generics");
+const {
+    downloadContentFromMessage: downloadContentFromMessage,
+    encryptedStream: encryptedStream,
+    generateThumbnail: generateThumbnail,
+    getAudioDuration: getAudioDuration,
+    getAudioWaveform: getAudioWaveform,
+    getRawMediaUploadData: getRawMediaUploadData,
+    getStream: getStream,
+    toBuffer: toBuffer,
+} = require("./messages-media");
+const MIMETYPE_MAP = {
+    image: "image/jpeg",
+    video: "video/mp4",
+    document: "application/pdf",
+    audio: "audio/ogg codecs=opus",
+    sticker: "image/webp",
+    "product-catalog-image": "image/jpeg",
+};
+async function processLocationThumbnail(input, options = {}) {
+    const {
+        maxWidth = 300,
+        maxHeight = 300,
+        quality = 80
+    } = options
+
+    let buffer
+
+    if (
+        typeof input === "string" &&
+        (input.startsWith("http://") || input.startsWith("https://"))
+    ) {
+
+        const stream = await getStream(input)
+        buffer = await toBuffer(stream)
+
+    } else if (typeof input === "string") {
+
+        buffer = await promises.readFile(input)
+
+    } else if (Buffer.isBuffer(input)) {
+
+        buffer = input
+
+    } else {
+
+        throw new Error("thumbnail must be URL, path or Buffer")
+
+    }
+
+    return await sharp(buffer)
+        .resize(maxWidth, maxHeight, {
+            fit: "inside",
+            withoutEnlargement: true
+        })
+        .jpeg({ quality })
+        .toBuffer()
+}
+const MessageTypeProto = {
+    image: WAProto.Message.ImageMessage,
+    video: WAProto.Message.VideoMessage,
+    audio: WAProto.Message.AudioMessage,
+    sticker: WAProto.Message.StickerMessage,
+    document: WAProto.Message.DocumentMessage,
+};
+const extractUrlFromText = (text) => text.match(URL_REGEX)?.[0];
+const generateLinkPreviewIfRequired = async (text, getUrlInfo, logger) => {
+    const url = extractUrlFromText(text);
+    if (!!getUrlInfo && url) {
+        try {
+            const urlInfo = await getUrlInfo(url);
+            return urlInfo;
+        } catch (error) {
+            logger?.warn({ trace: error.stack }, "url generation failed");
+        }
+    }
+};
+const assertColor = async (color) => {
+    let assertedColor;
+    if (typeof color === "number") {
+        assertedColor = color > 0 ? color : 4294967295 + Number(color) + 1;
+    } else {
+        let hex = color.trim().replace("#", "");
+        if (hex.length <= 6) {
+            hex = "FF" + hex.padStart(6, "0");
+        }
+        assertedColor = parseInt(hex, 16);
+        return assertedColor;
+    }
+};
+const prepareWAMessageMedia = async (message, options) => {
+    const logger = options.logger;
+    let mediaType;
+    for (const key of MEDIA_KEYS) {
+        if (key in message) {
+            mediaType = key;
+        }
+    }
+    if (!mediaType) {
+        throw new Boom("Invalid media type", { statusCode: 400 });
+    }
+    const uploadData = { ...message, media: message[mediaType] };
+    delete uploadData[mediaType];
+    const cacheableKey =
+        typeof uploadData.media === "object" &&
+        "url" in uploadData.media &&
+        !!uploadData.media.url &&
+        !!options.mediaCache &&
+        mediaType + ":" + uploadData.media.url.toString();
+    if (mediaType === "document" && !uploadData.fileName) {
+        uploadData.fileName = "file";
+    }
+    if (!uploadData.mimetype) {
+        uploadData.mimetype = MIMETYPE_MAP[mediaType];
+    }
+    if (cacheableKey) {
+        const mediaBuff = await options.mediaCache.get(cacheableKey);
+        if (mediaBuff) {
+            logger?.debug({ cacheableKey: cacheableKey }, "got media cache hit");
+            const obj = proto.Message.decode(mediaBuff);
+            const key = `${mediaType}Message`;
+            Object.assign(obj[key], { ...uploadData, media: undefined });
+            return obj;
+        }
+    }
+    const isNewsletter = !!options.jid && isJidNewsletter(options.jid);
+    if (isNewsletter) {
+        logger?.info({ key: cacheableKey }, "Preparing raw media for newsletter");
+        const {
+            filePath: filePath,
+            fileSha256: fileSha256,
+            fileLength: fileLength,
+        } = await getRawMediaUploadData(
+            uploadData.media,
+            options.mediaTypeOverride || mediaType,
+            logger
+        );
+        const fileSha256B64 = fileSha256.toString("base64");
+        const { mediaUrl: mediaUrl, directPath: directPath } = await options.upload(filePath, {
+            fileEncSha256B64: fileSha256B64,
+            mediaType: mediaType,
+            timeoutMs: options.mediaUploadTimeoutMs,
+        });
+        await promises.unlink(filePath);
+        const obj = WAProto.Message.fromObject({
+            [`${mediaType}Message`]: MessageTypeProto[mediaType].fromObject({
+                url: mediaUrl,
+                directPath: directPath,
+                fileSha256: fileSha256,
+                fileLength: fileLength,
+                ...uploadData,
+                media: undefined,
+            }),
+        });
+        if (uploadData.ptv) {
+            obj.ptvMessage = obj.videoMessage;
+            delete obj.videoMessage;
+        }
+        if (obj.stickerMessage) {
+            obj.stickerMessage.stickerSentTs = Date.now();
+        }
+        if (cacheableKey) {
+            logger?.debug({ cacheableKey: cacheableKey }, "set cache");
+            await options.mediaCache.set(cacheableKey, WAProto.Message.encode(obj).finish());
+        }
+        return obj;
+    }
+    const requiresDurationComputation =
+        mediaType === "audio" && typeof uploadData.seconds === "undefined";
+    const requiresThumbnailComputation =
+        (mediaType === "image" || mediaType === "video") &&
+        typeof uploadData["jpegThumbnail"] === "undefined";
+    const requiresWaveformProcessing = mediaType === "audio" && uploadData.ptt === true;
+    const requiresAudioBackground =
+        options.backgroundColor && mediaType === "audio" && uploadData.ptt === true;
+    const requiresOriginalForSomeProcessing =
+        requiresDurationComputation || requiresThumbnailComputation;
+    const {
+        mediaKey: mediaKey,
+        encFilePath: encFilePath,
+        originalFilePath: originalFilePath,
+        fileEncSha256: fileEncSha256,
+        fileSha256: fileSha256,
+        fileLength: fileLength,
+    } = await encryptedStream(uploadData.media, options.mediaTypeOverride || mediaType, {
+        logger: logger,
+        saveOriginalFileIfRequired: requiresOriginalForSomeProcessing,
+        opts: options.options,
+    });
+    const fileEncSha256B64 = fileEncSha256.toString("base64");
+    const [{ mediaUrl: mediaUrl, directPath: directPath }] = await Promise.all([
+        (async () => {
+            const result = await options.upload(encFilePath, {
+                fileEncSha256B64: fileEncSha256B64,
+                mediaType: mediaType,
+                timeoutMs: options.mediaUploadTimeoutMs,
+            });
+            logger?.debug({ mediaType: mediaType, cacheableKey: cacheableKey }, "uploaded media");
+            return result;
+        })(),
+        (async () => {
+            try {
+                if (requiresThumbnailComputation) {
+                    const {
+                        thumbnail: thumbnail,
+                        originalImageDimensions: originalImageDimensions,
+                    } = await generateThumbnail(originalFilePath, mediaType, options);
+                    uploadData.jpegThumbnail = thumbnail;
+                    if (!uploadData.width && originalImageDimensions) {
+                        uploadData.width = originalImageDimensions.width;
+                        uploadData.height = originalImageDimensions.height;
+                        logger?.debug("set dimensions");
+                    }
+                    logger?.debug("generated thumbnail");
+                }
+                if (requiresDurationComputation) {
+                    uploadData.seconds = await getAudioDuration(originalFilePath);
+                    logger?.debug("computed audio duration");
+                }
+                if (requiresWaveformProcessing) {
+                    uploadData.waveform = await getAudioWaveform(originalFilePath, logger);
+                    logger?.debug("processed waveform");
+                }
+                if (requiresAudioBackground) {
+                    uploadData.backgroundArgb = await assertColor(options.backgroundColor);
+                    logger?.debug("computed backgroundColor audio status");
+                }
+            } catch (error) {
+                logger?.warn({ trace: error.stack }, "failed to obtain extra info");
+            }
+        })(),
+    ]).finally(async () => {
+        try {
+            await promises.unlink(encFilePath);
+            if (originalFilePath) {
+                await promises.unlink(originalFilePath);
+            }
+            logger?.debug("removed tmp files");
+        } catch (error) {
+            logger?.warn("failed to remove tmp file");
+        }
+    });
+    const obj = WAProto.Message.fromObject({
+        [`${mediaType}Message`]: MessageTypeProto[mediaType].fromObject({
+            url: mediaUrl,
+            directPath: directPath,
+            mediaKey: mediaKey,
+            fileEncSha256: fileEncSha256,
+            fileSha256: fileSha256,
+            fileLength: fileLength,
+            mediaKeyTimestamp: unixTimestampSeconds(),
+            ...uploadData,
+            media: undefined,
+        }),
+    });
+    if (uploadData.ptv) {
+        obj.ptvMessage = obj.videoMessage;
+        delete obj.videoMessage;
+    }
+    if (cacheableKey) {
+        logger?.debug({ cacheableKey: cacheableKey }, "set cache");
+        await options.mediaCache.set(cacheableKey, WAProto.Message.encode(obj).finish());
+    }
+    return obj;
+};
+const prepareAlbumMessageContent = async (jid, albums, options) => {
+    if (!Array.isArray(albums)) {
+        throw new Error("albums must be an array containing media objects.");
+    }
+    if (albums.length === 0) {
+        throw new Error("albums cannot be empty. At least one media item is required.");
+    }
+    const validCount = albums.filter((m) => "image" in m || "video" in m).length;
+    if (validCount === 0) {
+        throw new Error("albums contains no valid media. Use 'image' or 'video' keys.");
+    }
+    let mediaHandle;
+    let mediaMsg;
+    const message = [];
+    const albumMsg = generateWAMessageFromContent(
+        jid,
+        {
+            albumMessage: {
+                expectedImageCount: albums.filter((item) => "image" in item).length,
+                expectedVideoCount: albums.filter((item) => "video" in item).length,
+            },
+        },
+        options
+    );
+    await options.conn.relayMessage(jid, albumMsg.message, {
+        messageId: albumMsg.key.id,
+    });
+    for (const media of albums) {
+        let content = {};
+        if ("image" in media) {
+            content = { image: media.image };
+        } else if ("video" in media) {
+            content = { video: media.video };
+        } else {
+            continue;
+        }
+        mediaMsg = await generateWAMessage(
+            jid,
+            { ...content, ...media },
+            {
+                userJid: options.userJid,
+                upload: async (encFilePath, opts) => {
+                    const up = await options.conn.waUploadToServer(encFilePath, {
+                        ...opts,
+                        newsletter: isJidNewsletter(jid),
+                    });
+                    mediaHandle = up.handle;
+                    return up;
+                },
+                ...options,
+            }
+        );
+        if (mediaMsg) {
+            mediaMsg.message.messageContextInfo = {
+                messageSecret: randomBytes(32),
+                messageAssociation: {
+                    associationType: proto.MessageAssociation.AssociationType.MEDIA_ALBUM,
+                    parentMessageKey: albumMsg.key,
+                },
+            };
+        }
+        message.push(mediaMsg);
+    }
+    return message;
+};
+const prepareDisappearingMessageSettingContent = (expiration) => {
+    const content = {
+        ephemeralMessage: {
+            message: {
+                protocolMessage: {
+                    type: WAProto.Message.ProtocolMessage.Type.EPHEMERAL_SETTING,
+                    ephemeralExpiration: expiration ? expiration : 0,
+                },
+            },
+        },
+    };
+    return WAProto.Message.fromObject(content);
+};
+const generateForwardMessageContent = (message, forceForward) => {
+    let content = message.message;
+    if (!content) {
+        throw new Boom("no content in message", { statusCode: 400 });
+    }
+    content = normalizeMessageContent(content);
+    content = proto.Message.decode(proto.Message.encode(content).finish());
+    let key = Object.keys(content)[0];
+    let score = content[key].contextInfo?.forwardingScore || 0;
+    if (forceForward) score += forceForward ? forceForward : 1;
+    if (key === "conversation") {
+        content.extendedTextMessage = { text: content[key] };
+        delete content.conversation;
+        key = "extendedTextMessage";
+    }
+    if (score > 0) {
+        content[key].contextInfo = { forwardingScore: score, isForwarded: true };
+    } else {
+        content[key].contextInfo = {};
+    }
+    return content;
+};
+const hasNonNullishProperty = (message, key) =>
+    typeof message === "object" &&
+    message !== null &&
+    key in message &&
+    message[key] !== null &&
+    message[key] !== undefined;
+function hasOptionalProperty(obj, key) {
+    return typeof obj === "object" && obj !== null && key in obj && obj[key] !== null;
+}
+const generateWAMessageContent = async (message, options) => {
+    let m = {};
+    if (hasNonNullishProperty(message, "text")) {
+        const extContent = { text: message.text };
+        let urlInfo = message.linkPreview;
+        if (typeof urlInfo === "undefined") {
+            urlInfo = await generateLinkPreviewIfRequired(
+                message.text,
+                options.getUrlInfo,
+                options.logger
+            );
+        }
+        if (urlInfo) {
+            extContent.canonicalUrl = urlInfo["canonical-url"];
+            extContent.matchedText = urlInfo["matched-text"];
+            extContent.jpegThumbnail = urlInfo.jpegThumbnail;
+            extContent.description = urlInfo.description;
+            extContent.title = urlInfo.title;
+            extContent.previewType = 0;
+            const img = urlInfo.highQualityThumbnail;
+            if (img) {
+                extContent.thumbnailDirectPath = img.directPath;
+                extContent.mediaKey = img.mediaKey;
+                extContent.mediaKeyTimestamp = img.mediaKeyTimestamp;
+                extContent.thumbnailWidth = img.width;
+                extContent.thumbnailHeight = img.height;
+                extContent.thumbnailSha256 = img.fileSha256;
+                extContent.thumbnailEncSha256 = img.fileEncSha256;
+            }
+        }
+        if (options.backgroundColor) {
+            extContent.backgroundArgb = await assertColor(options.backgroundColor);
+        }
+        if (options.textColor) {
+            extContent.textArgb = await assertColor(options.textColor);
+        }
+        if (options.font) {
+            extContent.font = options.font;
+        }
+        m.extendedTextMessage = extContent;
+    } else if (hasNonNullishProperty(message, "contacts")) {
+        const contactLen = message.contacts.contacts.length;
+        let contactMessage;
+        if (!contactLen) {
+            throw new Boom("require atleast 1 contact", { statusCode: 400 });
+        }
+        if (contactLen === 1) {
+            contactMessage = {
+                contactMessage: WAProto.Message.ContactMessage.fromObject(
+                    message.contacts.contacts[0]
+                ),
+            };
+        } else {
+            contactMessage = {
+                contactsArrayMessage: WAProto.Message.ContactsArrayMessage.fromObject(
+                    message.contacts
+                ),
+            };
+        }
+        m = contactMessage;
+
+    }  else if (hasNonNullishProperty(message, "location")) {
+
+    if (
+        message.location?.jpegThumbnail &&
+        !Buffer.isBuffer(message.location.jpegThumbnail)
+    ) {
+        message.location.jpegThumbnail = await processLocationThumbnail(
+            message.location.jpegThumbnail
+        );
+    }
+
+    let locationMessage;
+
+    if (message.live) {
+        locationMessage = {
+            liveLocationMessage: WAProto.Message.LiveLocationMessage.fromObject(
+                message.location
+            ),
+        };
+    } else {
+        locationMessage = {
+            locationMessage: WAProto.Message.LocationMessage.fromObject(
+                message.location
+            ),
+        };
+    }
+
+    m = locationMessage;
+
+    }else if (hasNonNullishProperty(message, "buttonsMessage")) {
+    const btnMsg = { ...message.buttonsMessage };
+    if (btnMsg.locationMessage?.jpegThumbnail && !Buffer.isBuffer(btnMsg.locationMessage.jpegThumbnail)) {
+        btnMsg.locationMessage.jpegThumbnail = await processLocationThumbnail(btnMsg.locationMessage.jpegThumbnail);
+    }
+    m = { buttonsMessage: btnMsg };
+} else if (hasNonNullishProperty(message, "react")) {
+        if (!message.react.senderTimestampMs) {
+            message.react.senderTimestampMs = Date.now();
+        }
+        m.reactionMessage = WAProto.Message.ReactionMessage.fromObject(message.react);
+    } else if (hasNonNullishProperty(message, "delete")) {
+        m.protocolMessage = {
+            key: message.delete,
+            type: WAProto.Message.ProtocolMessage.Type.REVOKE,
+        };
+    } else if (hasNonNullishProperty(message, "sharePhoneNumber")) {
+        m.protocolMessage = {
+            type: WAProto.Message.ProtocolMessage.Type.SHARE_PHONE_NUMBER,
+        };
+    } else if (hasNonNullishProperty(message, "requestPhoneNumber")) {
+        m.requestPhoneNumberMessage = {};
+    } else if (hasNonNullishProperty(message, "forward")) {
+        m = generateForwardMessageContent(message.forward, message.force);
+    } else if (hasNonNullishProperty(message, "disappearingMessagesInChat")) {
+        const exp =
+            typeof message.disappearingMessagesInChat === "boolean"
+                ? message.disappearingMessagesInChat
+                    ? WA_DEFAULT_EPHEMERAL
+                    : 0
+                : message.disappearingMessagesInChat;
+        m = prepareDisappearingMessageSettingContent(exp);
+    } else if (hasNonNullishProperty(message, "groupInvite")) {
+        m.groupInviteMessage = {};
+        m.groupInviteMessage.inviteCode = message.groupInvite.code;
+        m.groupInviteMessage.inviteExpiration = message.groupInvite.expiration;
+        m.groupInviteMessage.caption = message.groupInvite.caption;
+        m.groupInviteMessage.groupJid = message.groupInvite.jid;
+        m.groupInviteMessage.groupName = message.groupInvite.name;
+        m.groupInviteMessage.contextInfo = message.contextInfo;
+        if (options.getProfilePicUrl) {
+            const pfpUrl = await options.getProfilePicUrl(message.groupInvite.jid);
+            const { thumbnail: thumbnail } = await generateThumbnail(pfpUrl, "image");
+            m.groupInviteMessage.jpegThumbnail = thumbnail;
+        }
+    } else if (hasNonNullishProperty(message, "adminInvite")) {
+        m.newsletterAdminInviteMessage = {};
+        m.newsletterAdminInviteMessage.newsletterJid = message.adminInvite.jid;
+        m.newsletterAdminInviteMessage.newsletterName = message.adminInvite.name;
+        m.newsletterAdminInviteMessage.caption = message.adminInvite.caption;
+        m.newsletterAdminInviteMessage.inviteExpiration = message.adminInvite.expiration;
+        m.newsletterAdminInviteMessage.contextInfo = message.contextInfo;
+        if (options.getProfilePicUrl) {
+            const pfpUrl = await options.getProfilePicUrl(message.adminInvite.jid);
+            const { thumbnail: thumbnail } = await generateThumbnail(pfpUrl, "image");
+            m.newsletterAdminInviteMessage.jpegThumbnail = thumbnail;
+        }
+    } else if (hasNonNullishProperty(message, "keep")) {
+        m.keepInChatMessage = {};
+        m.keepInChatMessage.key = message.keep.key;
+        m.keepInChatMessage.keepType = message.keep?.type || 1;
+        m.keepInChatMessage.timestampMs = message.keep?.time || Date.now();
+    } else if (hasNonNullishProperty(message, "call")) {
+        m.scheduledCallCreationMessage = {};
+        m.scheduledCallCreationMessage.scheduledTimestampMs = message.call?.time || Date.now();
+        m.scheduledCallCreationMessage.callType = message.call?.type || 1;
+        m.scheduledCallCreationMessage.title = message.call?.name || "Call Creation";
+    } else if (hasNonNullishProperty(message, "paymentInvite")) {
+        m.messageContextInfo = {};
+        m.paymentInviteMessage = {};
+        m.paymentInviteMessage.expiryTimestamp = message.paymentInvite?.expiry || 0;
+        m.paymentInviteMessage.serviceType = message.paymentInvite?.type || 2;
+    } else if (hasNonNullishProperty(message, "orderStatus")) {
+    const os = message.orderStatus;
+    if (!os.image) throw new Error("image is required for orderStatus");
+
+    let imageInput = os.image;
+    if (typeof imageInput === 'string' && !imageInput.startsWith('http://') && !imageInput.startsWith('https://')) {
+        imageInput = await promises.readFile(imageInput);
+    }
+
+    const media = await prepareWAMessageMedia(
+        { image: imageInput },
+        { upload: options.upload, ...options }
+    );
+
+    m = {
+        viewOnceMessage: {
+            message: {
+                messageContextInfo: {
+                    deviceListMetadata: {},
+                    deviceListMetadataVersion: 2
+                },
+                interactiveMessage: proto.Message.InteractiveMessage.create({
+                    header: {
+                        title: os.title || "Order Status",
+                        hasMediaAttachment: true,
+                        ...media
+                    },
+                    body: {
+                        text: os.text || "Silakan cek status pesanan Anda."
+                    },
+                    footer: {
+                        text: os.footer || "Powered by AsepXyz"
+                    },
+                    nativeFlowMessage: {
+                        buttons: [
+                            {
+                                name: "order_status",
+                                buttonParamsJson: JSON.stringify({
+                                    reference_id: os.referenceId || "LV-001",
+                                    order: {
+                                        status: os.status || "PROCESSING",
+                                        subtotal: {
+                                            value: os.subtotalValue || 0,
+                                            offset: os.subtotalOffset || 100
+                                        },
+                                        tax: {
+                                            value: os.taxValue || 0,
+                                            offset: os.taxOffset || 100
+                                        },
+                                        currency: os.currency || "IDR"
+                                    }
+                                })
+                            }
+                        ]
+                    }
+                })
+            }
+        }
+    };
+}
+    else if (hasNonNullishProperty(message, "ptv")) {
+        const { videoMessage: videoMessage } = await prepareWAMessageMedia(
+            { video: message.video },
+            options
+        );
+        m.ptvMessage = videoMessage;
+    } else if (hasNonNullishProperty(message, "order")) {
+        m.orderMessage = WAProto.Message.OrderMessage.fromObject(message.order);
+    } else if (hasNonNullishProperty(message, "product")) {
+        const { imageMessage: imageMessage } = await prepareWAMessageMedia(
+            { image: message.product.productImage },
+            options
+        );
+        m.productMessage = WAProto.Message.ProductMessage.fromObject({
+            ...message,
+            product: { ...message.product, productImage: imageMessage },
+        });
+    } else if (hasNonNullishProperty(message, "album")) {
+        const imageMessages = message.album.filter((item) => "image" in item);
+        const videoMessages = message.album.filter((item) => "video" in item);
+        m.albumMessage = WAProto.Message.AlbumMessage.fromObject({
+            expectedImageCount: imageMessages.length,
+            expectedVideoCount: videoMessages.length,
+        });
+    } else if (hasNonNullishProperty(message, "event")) {
+        m.eventMessage = WAProto.Message.EventMessage.fromObject(message.event);
+        if (!message.event.startTime) {
+            m.eventMessage.startTime = unixTimestampSeconds() + 86400;
+        }
+        if (options.getCallLink && message.event.call) {
+            const link = await options.getCallLink(message.event.call, m.eventMessage.startTime);
+            m.eventMessage.joinLink = link;
+        }
+    } else if (hasNonNullishProperty(message, "pollResult")) {
+        if (!Array.isArray(message.pollResult.values)) {
+            throw new Boom("Invalid pollResult values", { statusCode: 400 });
+        }
+        const pollResultSnapshotMessage = {
+            name: message.pollResult.name,
+            pollVotes: message.pollResult.values.map(([optionName, optionVoteCount]) => ({
+                optionName: optionName,
+                optionVoteCount: optionVoteCount,
+            })),
+        };
+        m.pollResultSnapshotMessage = pollResultSnapshotMessage;
+    } else if (hasNonNullishProperty(message, "poll")) {
+        if (!Array.isArray(message.poll.values)) {
+            throw new Boom("Invalid poll values", { statusCode: 400 });
+        }
+        if (
+            message.poll.selectableCount < 0 ||
+            message.poll.selectableCount > message.poll.values.length
+        ) {
+            throw new Boom(
+                `poll.selectableCount in poll should be >= 0 and <= ${message.poll.values.length}`,
+                { statusCode: 400 }
+            );
+        }
+        const pollCreationMessage = {
+            name: message.poll.name,
+            selectableOptionsCount: message.poll?.selectableCount || 0,
+            options: message.poll.values.map((optionName) => ({
+                optionName: optionName,
+            })),
+        };
+        if (message.poll?.toAnnouncementGroup) {
+            m.pollCreationMessageV2 = pollCreationMessage;
+        } else {
+            if (message.poll.selectableCount > 0) {
+                m.pollCreationMessageV3 = pollCreationMessage;
+            } else {
+                m.pollCreationMessage = pollCreationMessage;
+            }
+        }
+    } else if (hasNonNullishProperty(message, "payment")) {
+        const requestPaymentMessage = {
+            amount: {
+                currencyCode: message.payment?.currency || "IDR",
+                offset: message.payment?.offset || 0,
+                value: message.payment?.amount || 999999999,
+            },
+            expiryTimestamp: message.payment?.expiry || 0,
+            amount1000: message.payment?.amount || 999999999 * 1e3,
+            currencyCodeIso4217: message.payment?.currency || "IDR",
+            requestFrom: message.payment?.from || "0@s.whatsapp.net",
+            noteMessage: {
+                extendedTextMessage: { text: message.payment?.note || "Notes" },
+            },
+            background: {
+                placeholderArgb: message.payment?.image?.placeholderArgb || 4278190080,
+                textArgb: message.payment?.image?.textArgb || 4294967295,
+                subtextArgb: message.payment?.image?.subtextArgb || 4294967295,
+                type: 1,
+            },
+        };
+        m.requestPaymentMessage = requestPaymentMessage;
+    } else if (hasNonNullishProperty(message, "stickerPack")) {
+        const {
+            stickers: stickers,
+            cover: cover,
+            name: name,
+            publisher: publisher,
+            packId: packId,
+            description: description,
+        } = message.stickerPack;
+        const { zip: zip } = require("fflate");
+        const stickerData = {};
+        const stickerPromises = stickers.map(async (s, i) => {
+            const { stream: stream } = await getStream(s.sticker);
+            const buffer = await toBuffer(stream);
+            const hash = sha256(buffer).toString("base64url");
+            const fileName = `${i.toString().padStart(2, "0")}_${hash}.webp`;
+            stickerData[fileName] = [new Uint8Array(buffer), { level: 0 }];
+            return {
+                fileName: fileName,
+                mimetype: "image/webp",
+                isAnimated: s.isAnimated || false,
+                isLottie: s.isLottie || false,
+                emojis: s.emojis || [],
+                accessibilityLabel: s.accessibilityLabel || "",
+            };
+        });
+        const stickerMetadata = await Promise.all(stickerPromises);
+        const zipBuffer = await new Promise((resolve, reject) => {
+            zip(stickerData, (err, data) => {
+                if (err) {
+                    reject(err);
+                } else {
+                    resolve(Buffer.from(data));
+                }
+            });
+        });
+        const coverBuffer = await toBuffer((await getStream(cover)).stream);
+        const [stickerPackUpload, coverUpload] = await Promise.all([
+            encryptedStream(zipBuffer, "sticker-pack", {
+                logger: options.logger,
+                opts: options.options,
+            }),
+            prepareWAMessageMedia(
+                { image: coverBuffer },
+                { ...options, mediaTypeOverride: "image" }
+            ),
+        ]);
+        const stickerPackUploadResult = await options.upload(stickerPackUpload.encFilePath, {
+            fileEncSha256B64: stickerPackUpload.fileEncSha256.toString("base64"),
+            mediaType: "sticker-pack",
+            timeoutMs: options.mediaUploadTimeoutMs,
+        });
+        const coverImage = coverUpload.imageMessage;
+        const imageDataHash = sha256(coverBuffer).toString("base64");
+        const stickerPackId = packId || generateMessageID();
+        m.stickerPackMessage = {
+            name: name,
+            publisher: publisher,
+            stickerPackId: stickerPackId,
+            packDescription: description,
+            stickerPackOrigin: proto.Message.StickerPackMessage.StickerPackOrigin.THIRD_PARTY,
+            stickerPackSize: stickerPackUpload.fileLength,
+            stickers: stickerMetadata,
+            fileSha256: stickerPackUpload.fileSha256,
+            fileEncSha256: stickerPackUpload.fileEncSha256,
+            mediaKey: stickerPackUpload.mediaKey,
+            directPath: stickerPackUploadResult.directPath,
+            fileLength: stickerPackUpload.fileLength,
+            mediaKeyTimestamp: unixTimestampSeconds(),
+            trayIconFileName: `${stickerPackId}.png`,
+            imageDataHash: imageDataHash,
+            thumbnailDirectPath: coverImage.directPath,
+            thumbnailFileSha256: coverImage.fileSha256,
+            thumbnailFileEncSha256: coverImage.fileEncSha256,
+            thumbnailHeight: coverImage.height,
+            thumbnailWidth: coverImage.width,
+        };
+    }     
+    
+ else if (hasNonNullishProperty(message, "richMessage")) {
+    const { randomUUID } = require('crypto');
+    const rich = message.richMessage;
+    const submessages = [];
+    const sections = [];
+    const richResponseSources = [];
+
+    const extractIE = (text) => {
+        let ie = [], result = '', last = 0, citation_index = 1, hyperlink_index = 0, latex_index = 0, stack = [];
+        for (let i = 0; i < text.length; i++) {
+            if (text[i] == '[' && text[i - 1] != '\\') {
+                stack.push(i);
+            } else if (text[i] == ']' && (text[i + 1] == '(' || text[i + 1] == '<')) {
+                let start = stack.pop();
+                if (start == null) continue;
+                let open = text[i + 1], close = open == '(' ? ')' : '>', type = open == '(' ? 'link' : 'latex', end = i + 2, depth = 1;
+                while (end < text.length && depth) {
+                    if (text[end] == open && text[end - 1] != '\\') depth++;
+                    else if (text[end] == close && text[end - 1] != '\\') depth--;
+                    end++;
+                }
+                if (depth) continue;
+                let raw = text.slice(start + 1, i).trim(), url = text.slice(i + 2, end - 1).trim(), key, tag, data;
+                if (type == 'latex') {
+                    let [txt = '', width = null, height = null, font_height = null, padding = null] = raw.split('|');
+                    key = `LATEX_${latex_index++}`;
+                    tag = `{{${key}}}${txt || 'image'}{{/${key}}}`;
+                    data = { type: 'latex', ie: { key, text: txt, url, width, height, font_height, padding } };
+                } else if (raw) {
+                    key = `HLINK_${hyperlink_index++}`;
+                    tag = `{{${key}}}${url}{{/${key}}}`;
+                    data = { type: 'hyperlink', ie: { key, text: raw, url } };
+                } else {
+                    key = `CITE_${citation_index - 1}`;
+                    tag = `{{${key}}}${url}{{/${key}}}`;
+                    data = { type: 'citation', ie: { reference_id: citation_index++, key, text: '', url } };
+                }
+                result += text.slice(last, start) + tag;
+                last = end;
+                ie.push(data);
+                i = end - 1;
+            }
+        }
+        result += text.slice(last);
+        return { text: result, ie };
+    };
+
+    const tokenizer = (code, lang = 'javascript') => {
+        const keywordsMap = {
+            javascript: new Set(['break','case','catch','continue','debugger','delete','do','else','finally','for','function','if','in','instanceof','new','return','switch','this','throw','try','typeof','var','void','while','with','true','false','null','undefined','class','const','let','super','extends','export','import','yield','static','constructor','async','await','get','set'])
+        };
+        const TYPE_MAP = { 0:'DEFAULT', 1:'KEYWORD', 2:'METHOD', 3:'STR', 4:'NUMBER', 5:'COMMENT' };
+        const keywords = keywordsMap[lang] || new Set();
+        const tokens = [];
+        let i = 0;
+        const push = (content, type) => {
+            if (!content) return;
+            const last = tokens[tokens.length - 1];
+            if (last && last.highlightType === type) last.codeContent += content;
+            else tokens.push({ codeContent: content, highlightType: type });
+        };
+        while (i < code.length) {
+            const c = code[i];
+            if (/\s/.test(c)) { let s = i; while (i < code.length && /\s/.test(code[i])) i++; push(code.slice(s, i), 0); continue; }
+            if (c === '/' && code[i + 1] === '/') { let s = i; i += 2; while (i < code.length && code[i] !== '\n') i++; push(code.slice(s, i), 5); continue; }
+            if (c === '"' || c === "'" || c === '`') { let s = i; const q = c; i++; while (i < code.length) { if (code[i] === '\\' && i + 1 < code.length) i += 2; else if (code[i] === q) { i++; break; } else i++; } push(code.slice(s, i), 3); continue; }
+            if (/[0-9]/.test(c)) { let s = i; while (i < code.length && /[0-9.]/.test(code[i])) i++; push(code.slice(s, i), 4); continue; }
+            if (/[a-zA-Z_$]/.test(c)) { let s = i; while (i < code.length && /[a-zA-Z0-9_$]/.test(code[i])) i++; const word = code.slice(s, i); let type = 0; if (keywords.has(word)) type = 1; else { let j = i; while (j < code.length && /\s/.test(code[j])) j++; if (code[j] === '(') type = 2; } push(word, type); continue; }
+            push(c, 0); i++;
+        }
+        return { codeBlock: tokens, unified_codeBlock: tokens.map(t => ({ content: t.codeContent, type: TYPE_MAP[t.highlightType] })) };
+    };
+
+    const toTableMetadata = (arr) => {
+        const [header, ...rows] = arr;
+        const maxLen = Math.max(header.length, ...rows.map(r => r.length));
+        const normalize = (r) => [...r, ...Array(maxLen - r.length).fill('')];
+        const unified_rows = [{ is_header: true, cells: normalize(header) }, ...rows.map(r => ({ is_header: false, cells: normalize(r) }))];
+        const rowsMeta = unified_rows.map(r => ({ items: r.cells, ...(r.is_header ? { isHeading: true } : {}) }));
+        return { title: '', rows: rowsMeta, unified_rows };
+    };
+
+    if (rich.text) {
+        const parsed = typeof rich.text === 'string' ? extractIE(rich.text) : rich.text;
+        const text = parsed.text || parsed;
+        const inline_entities = parsed.ie ? parsed.ie.map(({ type, ie }) => {
+            if (type === 'hyperlink') return { key: ie.key, metadata: { display_name: ie.text, is_trusted: true, url: ie.url, __typename: 'GenAIInlineLinkItem' } };
+            if (type === 'citation') return { key: ie.key, metadata: { reference_id: ie.reference_id, reference_url: ie.url, reference_title: ie.url, reference_display_name: ie.url, sources: [], __typename: 'GenAISearchCitationItem' } };
+            if (type === 'latex') return { key: ie.key, metadata: { latex_expression: ie.text || '', latex_image: { url: ie.url, width: Number(ie.width) || 100, height: Number(ie.height) || 100 }, font_height: Number(ie.font_height) || 83.33, padding: Number(ie.padding) || 15, __typename: 'GenAILatexItem' } };
+            return null;
+        }).filter(Boolean) : [];
+        submessages.push({ messageType: 2, messageText: text });
+        sections.push({
+            view_model: {
+                primitive: { text, inline_entities, __typename: 'GenAIMarkdownTextUXPrimitive' },
+                __typename: 'GenAISingleLayoutViewModel'
+            }
+        });
+    }
+
+    if (rich.code) {
+        const { language, code } = rich.code;
+        const tok = tokenizer(code, language);
+        submessages.push({ messageType: 5, codeMetadata: { codeLanguage: language, codeBlocks: tok.codeBlock } });
+        sections.push({
+            view_model: {
+                primitive: { language, code_blocks: tok.unified_codeBlock, __typename: 'GenAICodeUXPrimitive' },
+                __typename: 'GenAISingleLayoutViewModel'
+            }
+        });
+    }
+
+    if (rich.table) {
+        const meta = toTableMetadata(rich.table);
+        submessages.push({ messageType: 4, tableMetadata: { title: meta.title, rows: meta.rows } });
+        sections.push({
+            view_model: {
+                primitive: { rows: meta.unified_rows, __typename: 'GenATableUXPrimitive' },
+                __typename: 'GenAISingleLayoutViewModel'
+            }
+        });
+    }
+
+    if (rich.images) {
+        const urls = Array.isArray(rich.images) ? rich.images : [rich.images];
+        submessages.push({
+            messageType: 1,
+            gridImageMetadata: {
+                gridImageUrl: { imagePreviewUrl: urls[0] },
+                imageUrls: urls.map(url => ({ imagePreviewUrl: url, imageHighResUrl: url, sourceUrl: url }))
+            }
+        });
+        urls.forEach(url => {
+            sections.push({
+                view_model: {
+                    primitive: { media: { url, mime_type: 'image/jpeg' }, imagine_type: 3, status: { status: 'READY' }, __typename: 'GenAIImaginePrimitive' },
+                    __typename: 'GenAISingleLayoutViewModel'
+                }
+            });
+        });
+    }
+
+    if (rich.video) {
+        submessages.push({ messageType: 2, messageText: '[ CANNOT_LOAD_VIDEO - AsepXyz ]' });
+        sections.push({
+            view_model: {
+                primitive: {
+                    media: { url: rich.video, mime_type: 'video/mp4', duration: 10 },
+                    imagine_type: 'ANIMATE',
+                    status: { status: 'READY' },
+                    __typename: 'GenAIImaginePrimitive'
+                },
+                __typename: 'GenAISingleLayoutViewModel'
+            }
+        });
+    }
+
+    if (rich.productSingle) {
+        submessages.push({ messageType: 2, messageText: '[ CANNOT_LOAD_PRODUCT - AsepXyz ]' });
+        sections.push({
+            view_model: {
+                primitive: { ...rich.productSingle, __typename: 'GenAIProductItemCardPrimitive' },
+                __typename: 'GenAISingleLayoutViewModel'
+            }
+        });
+    }
+
+    if (rich.productMultiple) {
+        submessages.push({ messageType: 2, messageText: '[ CANNOT_LOAD_PRODUCT - AsepXyz ]' });
+        sections.push({
+            view_model: {
+                primitives: rich.productMultiple.map(p => ({ ...p, __typename: 'GenAIProductItemCardPrimitive' })),
+                __typename: 'GenAIHScrollLayoutViewModel'
+            }
+        });
+    }
+
+    if (rich.product && !rich.productSingle && !rich.productMultiple) {
+        submessages.push({ messageType: 2, messageText: '[ CANNOT_LOAD_PRODUCT - AsepXyz ]' });
+        if (Array.isArray(rich.product)) {
+            sections.push({
+                view_model: {
+                    primitives: rich.product.map(p => ({ ...p, __typename: 'GenAIProductItemCardPrimitive' })),
+                    __typename: 'GenAIHScrollLayoutViewModel'
+                }
+            });
+        } else {
+            sections.push({
+                view_model: {
+                    primitive: { ...rich.product, __typename: 'GenAIProductItemCardPrimitive' },
+                    __typename: 'GenAISingleLayoutViewModel'
+                }
+            });
+        }
+    }
+
+    if (rich.post) {
+        submessages.push({ messageType: 2, messageText: '[ CANNOT_LOAD_POST - AsepXyz ]' });
+        if (Array.isArray(rich.post)) {
+            sections.push({
+                view_model: {
+                    primitives: rich.post.map(p => ({ ...p, __typename: 'GenAIPostPrimitive' })),
+                    __typename: 'GenAIHScrollLayoutViewModel'
+                }
+            });
+        } else {
+            sections.push({
+                view_model: {
+                    primitive: { ...rich.post, __typename: 'GenAIPostPrimitive' },
+                    __typename: 'GenAISingleLayoutViewModel'
+                }
+            });
+        }
+    }
+
+    if (rich.reels) {
+        const items = Array.isArray(rich.reels) ? rich.reels : [rich.reels];
+        submessages.push({
+            messageType: 9,
+            contentItemsMetadata: {
+                contentType: 1,
+                itemsMetadata: items.map(i => ({
+                    reelItem: { title: i.title, profileIconUrl: i.profileIconUrl, thumbnailUrl: i.thumbnailUrl, videoUrl: i.videoUrl }
+                }))
+            }
+        });
+        sections.push({
+            view_model: {
+                primitives: items.map(i => ({
+                    reels_url: i.videoUrl,
+                    thumbnail_url: i.thumbnailUrl,
+                    creator: i.title,
+                    avatar_url: i.profileIconUrl,
+                    reels_title: i.reels_title || '',
+                    likes_count: i.likes_count || 0,
+                    shares_count: i.shares_count || 0,
+                    view_count: i.view_count || 0,
+                    reel_source: i.reel_source || 'IG',
+                    is_verified: i.is_verified || false,
+                    __typename: 'GenAIReelPrimitive'
+                })),
+                __typename: 'GenAIHScrollLayoutViewModel'
+            }
+        });
+        items.forEach((i, idx) => richResponseSources.push({
+            provider: 'AsepXyz',
+            thumbnailCDNURL: i.thumbnailUrl,
+            sourceProviderURL: i.videoUrl,
+            sourceQuery: '',
+            faviconCDNURL: i.profileIconUrl,
+            citationNumber: idx + 1,
+            sourceTitle: i.title
+        }));
+    }
+
+    if (rich.sources) {
+        const sourceArr = Array.isArray(rich.sources) ? rich.sources : [rich.sources];
+        sections.push({
+            view_model: {
+                primitive: {
+                    sources: sourceArr.map(s => typeof s === 'object' ? s : {
+                        source_type: 'THIRD_PARTY',
+                        source_display_name: s[2] || '',
+                        source_subtitle: 'AI',
+                        source_url: s[1] || '',
+                        favicon: { url: s[0] || '', mime_type: 'image/jpeg', width: 16, height: 16 }
+                    }),
+                    __typename: 'GenAISearchResultPrimitive'
+                },
+                __typename: 'GenAISingleLayoutViewModel'
+            }
+        });
+    }
+
+    if (rich.tip) {
+        submessages.push({ messageType: 2, messageText: rich.tip });
+        sections.push({
+            view_model: {
+                primitive: { text: rich.tip, __typename: 'GenAIMetadataTextPrimitive' },
+                __typename: 'GenAISingleLayoutViewModel'
+            }
+        });
+    }
+
+    if (rich.suggestions) {
+        sections.push({
+            view_model: {
+                primitives: rich.suggestions.map(s => ({
+                    prompt_text: s,
+                    prompt_type: 'SUGGESTED_PROMPT',
+                    __typename: 'GenAIFollowUpSuggestionPillPrimitive'
+                })),
+                __typename: 'GenAIActionRowLayoutViewModel'
+            }
+        });
+    }
+
+    if (rich.footer) {
+        sections.push({
+            view_model: {
+                primitive: { text: rich.footer, __typename: 'GenAIMetadataTextPrimitive' },
+                __typename: 'GenAISingleLayoutViewModel'
+            }
+        });
+    }
+
+    const unifiedData = { response_id: randomUUID(), sections };
+
+    m = {
+        messageContextInfo: {
+            deviceListMetadata: {},
+            deviceListMetadataVersion: 2,
+            botMetadata: {
+                messageDisclaimerText: rich.title || '',
+                richResponseSourcesMetadata: { sources: richResponseSources }
+            }
+        },
+        botForwardedMessage: {
+            message: {
+                richResponseMessage: {
+                    messageType: 1,
+                    submessages,
+                    unifiedResponse: {
+                        data: Buffer.from(JSON.stringify(unifiedData)).toString('base64')
+                    },
+                    contextInfo: {
+                        forwardingScore: 1,
+                        isForwarded: true,
+                        forwardedAiBotMessageInfo: { botJid: '0@bot' },
+                        forwardOrigin: 4
+                    }
+                }
+            }
+        }
+    };
+}
+
+
+
+ else {
+    m = await prepareWAMessageMedia(message, options);
+}    
+    
+    if (hasNonNullishProperty(message, "buttonReply")) {
+        switch (message.type) {
+            case "list":
+                m.listResponseMessage = {
+                    title: message.buttonReply.title,
+                    description: message.buttonReply.description,
+                    singleSelectReply: { selectedRowId: message.buttonReply.rowId },
+                    lisType: proto.Message.ListResponseMessage.ListType.SINGLE_SELECT,
+                };
+                break;
+            case "template":
+                m.templateButtonReplyMessage = {
+                    selectedDisplayText: message.buttonReply.displayText,
+                    selectedId: message.buttonReply.id,
+                    selectedIndex: message.buttonReply.index,
+                };
+                break;
+            case "plain":
+                m.buttonsResponseMessage = {
+                    selectedButtonId: message.buttonReply.id,
+                    selectedDisplayText: message.buttonReply.displayText,
+                    type: proto.Message.ButtonsResponseMessage.Type.DISPLAY_TEXT,
+                };
+                break;
+            case "interactive":
+                m.interactiveResponseMessage = {
+                    body: {
+                        text: message.buttonReply.displayText,
+                        format: proto.Message.InteractiveResponseMessage.Body.Format.EXTENSIONS_1,
+                    },
+                    nativeFlowResponseMessage: {
+                        name: message.buttonReply.nativeFlows.name,
+                        paramsJson: message.buttonReply.nativeFlows.paramsJson,
+                        version: message.buttonReply.nativeFlows.version,
+                    },
+                };
+                break;
+        }
+    } else if (hasNonNullishProperty(message, "sections")) {
+        m.listMessage = {
+            title: message.title,
+            buttonText: message.buttonText,
+            footerText: message.footer,
+            description: message.text,
+            sections: message.sections,
+            listType: proto.Message.ListMessage.ListType.SINGLE_SELECT,
+        };
+    } else if (hasNonNullishProperty(message, "productList")) {
+        const thumbnail = message.thumbnail
+            ? await generateThumbnail(message.thumbnail, "image")
+            : null;
+        m.listMessage = {
+            title: message.title,
+            buttonText: message.buttonText,
+            footerText: message.footer,
+            description: message.text,
+            productListInfo: {
+                productSections: message.productList,
+                headerImage: {
+                    productId: message.productList[0].products[0].productId,
+                    jpegThumbnail: thumbnail?.thumbnail || null,
+                },
+                businessOwnerJid: message.businessOwnerJid,
+            },
+            listType: proto.Message.ListMessage.ListType.PRODUCT_LIST,
+        };
+    }  
+else if (hasNonNullishProperty(message, "buttons")) {
+        const buttonsMessage = {
+            buttons: message.buttons.map((b) => ({
+                ...b,
+                type: proto.Message.ButtonsMessage.Button.Type.RESPONSE,
+            })),
+        };
+        if (hasNonNullishProperty(message, "text")) {
+            buttonsMessage.contentText = message.text;
+            buttonsMessage.headerType = proto.Message.ButtonsMessage.HeaderType.EMPTY;
+        } else {
+            if (hasNonNullishProperty(message, "caption")) {
+                buttonsMessage.contentText = message.caption;
+            }
+            const type = Object.keys(m)[0].replace("Message", "").toUpperCase();
+            buttonsMessage.headerType = proto.Message.ButtonsMessage.HeaderType[type];
+            Object.assign(buttonsMessage, m);
+        }
+        if (hasNonNullishProperty(message, "title")) {
+            buttonsMessage.text = message.title;
+            buttonsMessage.headerType = proto.Message.ButtonsMessage.HeaderType.TEXT;
+        }
+        if (hasNonNullishProperty(message, "footer")) {
+            buttonsMessage.footerText = message.footer;
+        }
+        m = { buttonsMessage: buttonsMessage };
+
+
+
+    } else if (hasNonNullishProperty(message, "templateButtons")) {
+        const hydratedTemplate = { hydratedButtons: message.templateButtons };
+        if (hasNonNullishProperty(message, "text")) {
+            hydratedTemplate.hydratedContentText = message.text;
+        } else {
+            if (hasNonNullishProperty(message, "caption")) {
+                hydratedTemplate.hydratedContentText = message.caption;
+            }
+            Object.assign(msg, m);
+        }
+        if (hasNonNullishProperty(message, "footer")) {
+            hydratedTemplate.hydratedFooterText = message.footer;
+        }
+        m = { templateMessage: { hydratedTemplate: hydratedTemplate } };
+    } else if (hasNonNullishProperty(message, "interactiveButtons")) {
+        const interactiveMessage = {
+            nativeFlowMessage: { buttons: message.interactiveButtons },
+        };
+        if (hasNonNullishProperty(message, "text")) {
+            interactiveMessage.body = { text: message.text };
+        }
+        if (hasNonNullishProperty(message, "title")) {
+            interactiveMessage.header = {
+                title: message.title,
+                subtitle: null,
+                hasMediaAttachment: false,
+            };
+            if (hasNonNullishProperty(message, "subtitle")) {
+                interactiveMessage.header.subtitle = message.subtitle;
+            }
+        } else {
+            if (hasNonNullishProperty(message, "caption")) {
+                interactiveMessage.body = { text: message.caption };
+                interactiveMessage.header = {
+                    title: null,
+                    subtitle: null,
+                    hasMediaAttachment: false,
+                    ...Object.assign(interactiveMessage, m),
+                };
+                if (hasNonNullishProperty(message, "title")) {
+                    interactiveMessage.header.title = message.title;
+                }
+                if (hasNonNullishProperty(message, "subtitle")) {
+                    interactiveMessage.header.subtitle = message.subtitle;
+                }
+                if (hasNonNullishProperty(message, "hasMediaAttachment")) {
+                    interactiveMessage.header.hasMediaAttachment = Boolean(
+                        message.hasMediaAttachment
+                    );
+                }
+            }
+        }
+        if (hasNonNullishProperty(message, "footer")) {
+            interactiveMessage.footer = { text: message.footer };
+        }
+        m = { interactiveMessage: interactiveMessage };
+    } else if (hasNonNullishProperty(message, "shop")) {
+        const interactiveMessage = {
+            shopStorefrontMessage: {
+                surface: message.shop.surface,
+                id: message.shop.id,
+            },
+        };
+        if (hasNonNullishProperty(message, "text")) {
+            interactiveMessage.body = { text: message.text };
+        }
+        if (hasNonNullishProperty(message, "title")) {
+            interactiveMessage.header = {
+                title: message.title,
+                subtitle: null,
+                hasMediaAttachment: false,
+            };
+            if (hasNonNullishProperty(message, "subtitle")) {
+                interactiveMessage.header.subtitle = message.subtitle;
+            }
+        } else {
+            if (hasNonNullishProperty(message, "caption")) {
+                interactiveMessage.body = { text: message.caption };
+                interactiveMessage.header = {
+                    title: null,
+                    subtitle: null,
+                    hasMediaAttachment: false,
+                    ...Object.assign(interactiveMessage, m),
+                };
+                if (hasNonNullishProperty(message, "title")) {
+                    interactiveMessage.header.title = message.title;
+                }
+                if (hasNonNullishProperty(message, "subtitle")) {
+                    interactiveMessage.header.subtitle = message.subtitle;
+                }
+                if (hasNonNullishProperty(message, "hasMediaAttachment")) {
+                    interactiveMessage.header.hasMediaAttachment = Boolean(
+                        message.hasMediaAttachment
+                    );
+                }
+            }
+        }
+        if (hasNonNullishProperty(message, "footer")) {
+            interactiveMessage.footer = { text: message.footer };
+        }
+        m = { interactiveMessage: interactiveMessage };
+    } else if (hasNonNullishProperty(message, "collection")) {
+        const interactiveMessage = {
+            collectionMessage: {
+                bizJid: message.collection.bizJid,
+                id: message.collection.id,
+                messageVersion: message?.collection?.version,
+            },
+        };
+        if (hasNonNullishProperty(message, "text")) {
+            interactiveMessage.body = { text: message.text };
+        }
+        if (hasNonNullishProperty(message, "title")) {
+            interactiveMessage.header = {
+                title: message.title,
+                subtitle: null,
+                hasMediaAttachment: false,
+            };
+            if (hasNonNullishProperty(message, "subtitle")) {
+                interactiveMessage.header.subtitle = message.subtitle;
+            }
+        } else {
+            if (hasNonNullishProperty(message, "caption")) {
+                interactiveMessage.body = { text: message.caption };
+                interactiveMessage.header = {
+                    title: null,
+                    subtitle: null,
+                    hasMediaAttachment: false,
+                    ...Object.assign(interactiveMessage, m),
+                };
+                if (hasNonNullishProperty(message, "title")) {
+                    interactiveMessage.header.title = message.title;
+                }
+                if (hasNonNullishProperty(message, "subtitle")) {
+                    interactiveMessage.header.subtitle = message.subtitle;
+                }
+                if (hasNonNullishProperty(message, "hasMediaAttachment")) {
+                    interactiveMessage.header.hasMediaAttachment = Boolean(
+                        message.hasMediaAttachment
+                    );
+                }
+            }
+        }
+        if (hasNonNullishProperty(message, "footer")) {
+            interactiveMessage.footer = { text: message.footer };
+        }
+        m = { interactiveMessage: interactiveMessage };
+    } else if (hasNonNullishProperty(message, "cards")) {
+        const slides = await Promise.all(
+            message.cards.map(async (slide) => {
+                const {
+                    image: image,
+                    video: video,
+                    product: product,
+                    title: title,
+                    body: body,
+                    footer: footer,
+                    buttons: buttons,
+                } = slide;
+                let header;
+                if (product) {
+                    const { imageMessage: imageMessage } = await prepareWAMessageMedia(
+                        { image: product.productImage, ...options },
+                        options
+                    );
+                    header = {
+                        productMessage: {
+                            product: { ...product, productImage: imageMessage },
+                            ...slide,
+                        },
+                    };
+                } else if (image) {
+                    header = await prepareWAMessageMedia({ image: image, ...options }, options);
+                } else if (video) {
+                    header = await prepareWAMessageMedia({ video: video, ...options }, options);
+                }
+                const msg = {
+                    header: { title: title, hasMediaAttachment: true, ...header },
+                    body: { text: body },
+                    footer: { text: footer },
+                    nativeFlowMessage: { buttons: buttons },
+                };
+                return msg;
+            })
+        );
+        const interactiveMessage = { carouselMessage: { cards: slides } };
+        if (hasNonNullishProperty(message, "text")) {
+            interactiveMessage.body = { text: message.text };
+        }
+        if (hasNonNullishProperty(message, "title")) {
+            interactiveMessage.header = {
+                title: message.title,
+                subtitle: null,
+                hasMediaAttachment: false,
+            };
+            if (hasNonNullishProperty(message, "subtitle")) {
+                interactiveMessage.header.subtitle = message.subtitle;
+            }
+        } else {
+            if (hasNonNullishProperty(message, "caption")) {
+                interactiveMessage.body = { text: message.caption };
+                interactiveMessage.header = {
+                    title: null,
+                    subtitle: null,
+                    hasMediaAttachment: false,
+                    ...Object.assign(interactiveMessage, m),
+                };
+                if (hasNonNullishProperty(message, "title")) {
+                    interactiveMessage.header.title = message.title;
+                }
+                if (hasNonNullishProperty(message, "subtitle")) {
+                    interactiveMessage.header.subtitle = message.subtitle;
+                }
+                if (hasNonNullishProperty(message, "hasMediaAttachment")) {
+                    interactiveMessage.header.hasMediaAttachment = Boolean(
+                        message.hasMediaAttachment
+                    );
+                }
+            }
+        }
+        if (hasNonNullishProperty(message, "footer")) {
+            interactiveMessage.footer = { text: message.footer };
+        }
+        m = { interactiveMessage: interactiveMessage };
+    }
+    if (hasOptionalProperty(message, "ephemeral")) {
+        m = { ephemeralMessage: { message: m } };
+    }
+    if (hasOptionalProperty(message, "mentions") && message.mentions?.length) {
+        const messageType = Object.keys(m)[0];
+        const key = m[messageType];
+        if ("contextInfo" in key && !!key.contextInfo) {
+            key.contextInfo.mentionedJid = message.mentions;
+        } else if (key) {
+            key.contextInfo = { mentionedJid: message.mentions };
+        }
+    }
+    if (hasOptionalProperty(message, "contextInfo") && !!message.contextInfo) {
+        const messageType = Object.keys(m)[0];
+        const key = m[messageType];
+        if ("contextInfo" in key && !!key.contextInfo) {
+            key.contextInfo = { ...key.contextInfo, ...message.contextInfo };
+        } else if (key) {
+            key.contextInfo = message.contextInfo;
+        }
+    }
+    if (hasOptionalProperty(message, "edit")) {
+        m = {
+            protocolMessage: {
+                key: message.edit,
+                editedMessage: m,
+                timestampMs: Date.now(),
+                type: WAProto.Message.ProtocolMessage.Type.MESSAGE_EDIT,
+            },
+        };
+    }
+    return WAProto.Message.fromObject(m);
+};
+const generateWAMessageFromContent = (jid, message, options) => {
+    if (!options.timestamp) {
+        options.timestamp = new Date();
+    }
+    const innerMessage = normalizeMessageContent(message);
+    const key = getContentType(innerMessage);
+    const timestamp = unixTimestampSeconds(options.timestamp);
+    const threadId = [];
+    const { quoted: quoted, userJid: userJid } = options;
+    if (quoted && !isJidNewsletter(jid)) {
+        const participant = quoted.key.fromMe
+            ? userJid
+            : quoted.participant || quoted.key.participant || quoted.key.remoteJid;
+        let quotedMsg = normalizeMessageContent(quoted.message);
+        const msgType = getContentType(quotedMsg);
+        quotedMsg = proto.Message.fromObject({ [msgType]: quotedMsg[msgType] });
+        const quotedContent = quotedMsg[msgType];
+        if (typeof quotedContent === "object" && quotedContent && "contextInfo" in quotedContent) {
+            delete quotedContent.contextInfo;
+        }
+        let requestPayment;
+        if (key === "requestPaymentMessage") {
+            if (
+                innerMessage?.requestPaymentMessage &&
+                innerMessage?.requestPaymentMessage?.noteMessage?.extendedTextMessage
+            ) {
+                requestPayment =
+                    innerMessage?.requestPaymentMessage?.noteMessage?.extendedTextMessage;
+            } else if (
+                innerMessage?.requestPaymentMessage &&
+                innerMessage?.requestPaymentMessage?.noteMessage?.stickerMessage
+            ) {
+                requestPayment = innerMessage.requestPaymentMessage?.noteMessage?.stickerMessage;
+            }
+        }
+        const contextInfo =
+            (key === "requestPaymentMessage"
+                ? requestPayment?.contextInfo
+                : innerMessage[key].contextInfo) || {};
+        contextInfo.participant = jidNormalizedUser(participant);
+        contextInfo.stanzaId = quoted.key.id;
+        contextInfo.quotedMessage = quotedMsg;
+        if (jid !== quoted.key.remoteJid) {
+            contextInfo.remoteJid = quoted.key.remoteJid;
+        }
+        if (contextInfo.quotedMessage) {
+            contextInfo.quotedType = proto.ContextInfo.QuotedType.EXPLICIT;
+        }
+        if (contextInfo.quotedMessage && isJidGroup(jid)) {
+            threadId.push({
+                threadType: proto.ThreadID.ThreadType.VIEW_REPLIES,
+                threadKey: {
+                    remoteJid: quoted?.key?.remoteJid,
+                    fromMe: quoted?.key?.fromMe,
+                    id: generateMessageID(),
+                    ...(quoted?.key?.fromMe ? {} : { participant: quoted?.key?.participant }),
+                },
+            });
+        }
+        if (key === "requestPaymentMessage" && requestPayment) {
+            requestPayment.contextInfo = contextInfo;
+        } else {
+            innerMessage[key].contextInfo = contextInfo;
+        }
+    }
+    if (key !== "protocolMessage" && key !== "ephemeralMessage" && !isJidNewsletter(jid)) {
+        message.messageContextInfo = {
+            threadId: threadId.length > 0 ? threadId : [],
+            messageSecret: randomBytes(32),
+            ...message.messageContextInfo,
+        };
+        innerMessage[key].contextInfo = {
+            ...(innerMessage[key].contextInfo || {}),
+            expiration: options.ephemeralExpiration ? options.ephemeralExpiration : 0,
+        };
+    }
+    message = WAProto.Message.fromObject(message);
+    const messageJSON = {
+        key: {
+            remoteJid: jid,
+            fromMe: true,
+            id: options?.messageId || generateMessageID(),
+        },
+        message: message,
+        messageTimestamp: timestamp,
+        messageStubParameters: [],
+        participant: isJidGroup(jid) || isJidStatusBroadcast(jid) ? userJid : undefined,
+        status: WAMessageStatus.PENDING,
+    };
+    return WAProto.WebMessageInfo.fromObject(messageJSON);
+};
+const generateWAMessage = async (jid, content, options) => {
+    options.logger = options?.logger?.child({ msgId: options.messageId });
+    return generateWAMessageFromContent(
+        jid,
+        await generateWAMessageContent(content, {
+            newsletter: isJidNewsletter(jid),
+            ...options,
+        }),
+        options
+    );
+};
+const getContentType = (content) => {
+    if (content) {
+        const keys = Object.keys(content);
+        const key = keys.find(
+            (k) =>
+                (k === "conversation" ||
+                    k.endsWith("Message") ||
+                    k.endsWith("V2") ||
+                    k.endsWith("V3") ||
+                    k.endsWith("V4")) &&
+                k !== "senderKeyDistributionMessage" &&
+                k !== "messageContextInfo"
+        );
+        return key;
+    }
+};
+const normalizeMessageContent = (content) => {
+    if (!content) {
+        return undefined;
+    }
+    for (let i = 0; i < 5; i++) {
+        const inner = getFutureProofMessage(content);
+        if (!inner) {
+            break;
+        }
+        content = inner.message;
+    }
+    return content;
+    function getFutureProofMessage(message) {
+        return (
+            message?.editedMessage ||
+            message?.statusAddYours ||
+            message?.botTaskMessage ||
+            message?.eventCoverImage ||
+            message?.questionMessage ||
+            message?.viewOnceMessage ||
+            message?.botInvokeMessage ||
+            message?.ephemeralMessage ||
+            message?.limitSharingMessage ||
+            message?.viewOnceMessageV2 ||
+            message?.lottieStickerMessage ||
+            message?.questionReplyMessage ||
+            message?.botForwardedMessage ||
+            message?.statusMentionMessage ||
+            message?.pollCreationMessageV4 ||
+            message?.associatedChildMessage ||
+            message?.groupMentionedMessage ||
+            message?.groupStatusMentionMessage ||
+            message?.viewOnceMessageV2Extension ||
+            message?.documentWithCaptionMessage ||
+            message?.pollCreationOptionImageMessage
+        );
+    }
+};
+const extractMessageContent = (content) => {
+    const extractFromButtonsMessage = (msg) => {
+        const header = typeof msg.header === "object" && msg.header !== null;
+        if (header ? msg.header?.imageMessage : msg.imageMessage) {
+            return {
+                imageMessage: header ? msg.header.imageMessage : msg.imageMessage,
+            };
+        } else if (header ? msg.header?.documentMessage : msg.documentMessage) {
+            return {
+                documentMessage: header ? msg.header.documentMessage : msg.documentMessage,
+            };
+        } else if (header ? msg.header?.videoMessage : msg.videoMessage) {
+            return {
+                videoMessage: header ? msg.header.videoMessage : msg.videoMessage,
+            };
+        } else if (header ? msg.header?.locationMessage : msg.locationMessage) {
+            return {
+                locationMessage: header ? msg.header.locationMessage : msg.locationMessage,
+            };
+        } else if (header ? msg.header?.productMessage : msg.productMessage) {
+            return {
+                productMessage: header ? msg.header.productMessage : msg.productMessage,
+            };
+        } else {
+            return {
+                conversation:
+                    "contentText" in msg
+                        ? msg.contentText
+                        : "hydratedContentText" in msg
+                          ? msg.hydratedContentText
+                          : "body" in msg
+                            ? msg.body.text
+                            : "",
+            };
+        }
+    };
+    content = normalizeMessageContent(content);
+    if (content?.buttonsMessage) {
+        return extractFromButtonsMessage(content.buttonsMessage);
+    }
+    if (content?.interactiveMessage) {
+        return extractFromButtonsMessage(content.interactiveMessage);
+    }
+    if (content?.templateMessage?.interactiveMessageTemplate) {
+        return extractFromButtonsMessage(content?.templateMessage?.interactiveMessageTemplate);
+    }
+    if (content?.templateMessage?.hydratedFourRowTemplate) {
+        return extractFromButtonsMessage(content?.templateMessage?.hydratedFourRowTemplate);
+    }
+    if (content?.templateMessage?.hydratedTemplate) {
+        return extractFromButtonsMessage(content?.templateMessage?.hydratedTemplate);
+    }
+    if (content?.templateMessage?.fourRowTemplate) {
+        return extractFromButtonsMessage(content?.templateMessage?.fourRowTemplate);
+    }
+    return content;
+};
+const getDevice = (id) =>
+    /^3A.{18}$/.test(id)
+        ? "ios"
+        : /^3E.{20}$/.test(id)
+          ? "web"
+          : /^(.{21}|.{32})$/.test(id)
+            ? "android"
+            : /^(3F|.{18}$)/.test(id)
+              ? "desktop"
+              : "baileys";
+const updateMessageWithReceipt = (msg, receipt) => {
+    msg.userReceipt = msg.userReceipt || [];
+    const recp = msg.userReceipt.find((m) => m.userJid === receipt.userJid);
+    if (recp) {
+        Object.assign(recp, receipt);
+    } else {
+        msg.userReceipt.push(receipt);
+    }
+};
+const updateMessageWithReaction = (msg, reaction) => {
+    const authorID = getKeyAuthor(reaction.key);
+    const reactions = (msg.reactions || []).filter((r) => getKeyAuthor(r.key) !== authorID);
+    reaction.text = reaction.text || "";
+    reactions.push(reaction);
+    msg.reactions = reactions;
+};
+const updateMessageWithPollUpdate = (msg, update) => {
+    const authorID = getKeyAuthor(update.pollUpdateMessageKey);
+    const votes = (msg.pollUpdates || []).filter(
+        (r) => getKeyAuthor(r.pollUpdateMessageKey) !== authorID
+    );
+    if (update.vote?.selectedOptions?.length) {
+        votes.push(update);
+    }
+    msg.pollUpdates = votes;
+};
+const updateMessageWithEventResponse = (msg, update) => {
+    const authorID = getKeyAuthor(update.eventResponseMessageKey);
+    const responses = (msg.eventResponses || []).filter(
+        (r) => getKeyAuthor(r.eventResponseMessageKey) !== authorID
+    );
+    responses.push(update);
+    msg.eventResponses = responses;
+};
+function getAggregateVotesInPollMessage({ message: message, pollUpdates: pollUpdates }, meId) {
+    message = normalizeMessageContent(message);
+    const opts =
+        message?.pollCreationMessage?.options ||
+        message?.pollCreationMessageV2?.options ||
+        message?.pollCreationMessageV3?.options ||
+        [];
+    const voteHashMap = opts.reduce((acc, opt) => {
+        const hash = sha256(Buffer.from(opt.optionName || "")).toString();
+        acc[hash] = { name: opt.optionName || "", voters: [] };
+        return acc;
+    }, {});
+    for (const update of pollUpdates || []) {
+        const { vote: vote } = update;
+        if (!vote) {
+            continue;
+        }
+        for (const option of vote.selectedOptions || []) {
+            const hash = option.toString();
+            let data = voteHashMap[hash];
+            if (!data) {
+                voteHashMap[hash] = { name: "Unknown", voters: [] };
+                data = voteHashMap[hash];
+            }
+            voteHashMap[hash].voters.push(getKeyAuthor(update.pollUpdateMessageKey, meId));
+        }
+    }
+    return Object.values(voteHashMap);
+}
+function getAggregateResponsesInEventMessage({ eventResponses: eventResponses }, meLid) {
+    const responseTypes = ["GOING", "NOT_GOING", "MAYBE"];
+    const responseMap = {};
+    for (const type of responseTypes) {
+        responseMap[type] = { response: type, responders: [] };
+    }
+    for (const update of eventResponses) {
+        const { response: response } = update.response || 0;
+        const responseType = proto.Message.EventResponseMessage.EventResponseType[response];
+        if (responseType !== "UNKNOWN" && responseMap[responseType]) {
+            responseMap[responseType].responders.push(
+                getKeyAuthor(update.eventResponseMessageKey, meLid)
+            );
+        }
+    }
+    return Object.values(responseMap);
+}
+const aggregateMessageKeysNotFromMe = (keys) => {
+    const keyMap = {};
+    for (const { remoteJid: remoteJid, id: id, participant: participant, fromMe: fromMe } of keys) {
+        if (!fromMe) {
+            const uqKey = `${remoteJid}:${participant || ""}`;
+            if (!keyMap[uqKey]) {
+                keyMap[uqKey] = {
+                    jid: remoteJid,
+                    participant: participant,
+                    messageIds: [],
+                };
+            }
+            keyMap[uqKey].messageIds.push(id);
+        }
+    }
+    return Object.values(keyMap);
+};
+const REUPLOAD_REQUIRED_STATUS = [410, 404];
+const downloadMediaMessage = async (message, type, options, ctx) => {
+    const result = await downloadMsg().catch(async (error) => {
+        if (
+            ctx &&
+            typeof error?.status === "number" &&
+            REUPLOAD_REQUIRED_STATUS.includes(error.status)
+        ) {
+            ctx.logger.info({ key: message.key }, "sending reupload media request...");
+            message = await ctx.reuploadRequest(message);
+            const result = await downloadMsg();
+            return result;
+        }
+        throw error;
+    });
+    return result;
+    async function downloadMsg() {
+        const mContent = extractMessageContent(message.message);
+        if (!mContent) {
+            throw new Boom("No message present", { statusCode: 400, data: message });
+        }
+        const contentType = getContentType(mContent);
+        let mediaType = contentType?.replace("Message", "");
+        const media =
+            contentType === "productMessage"
+                ? mContent[contentType]?.product?.productImage
+                : mContent[contentType];
+        if (
+            !media ||
+            typeof media !== "object" ||
+            (!("url" in media) && !("thumbnailDirectPath" in media))
+        ) {
+            throw new Boom(`"${contentType}" message is not a media message`);
+        }
+        let download;
+        if ("thumbnailDirectPath" in media && !("url" in media)) {
+            download = {
+                directPath: media.thumbnailDirectPath,
+                mediaKey: media.mediaKey,
+            };
+            mediaType = "thumbnail-link";
+        } else {
+            download = media;
+        }
+        const stream = await downloadContentFromMessage(download, mediaType, options);
+        if (type === "buffer") {
+            const bufferArray = [];
+            for await (const chunk of stream) {
+                bufferArray.push(chunk);
+            }
+            return Buffer.concat(bufferArray);
+        }
+        return stream;
+    }
+};
+const assertMediaContent = (content) => {
+    content = extractMessageContent(content);
+    const mediaContent =
+        content?.documentMessage ||
+        content?.imageMessage ||
+        content?.videoMessage ||
+        content?.audioMessage ||
+        content?.stickerMessage;
+    if (!mediaContent) {
+        throw new Boom("given message is not a media message", {
+            statusCode: 400,
+            data: content,
+        });
+    }
+    return mediaContent;
+};
+module.exports = {
+    extractUrlFromText: extractUrlFromText,
+    generateLinkPreviewIfRequired: generateLinkPreviewIfRequired,
+    prepareWAMessageMedia: prepareWAMessageMedia,
+    prepareAlbumMessageContent: prepareAlbumMessageContent,
+    prepareDisappearingMessageSettingContent: prepareDisappearingMessageSettingContent,
+    generateForwardMessageContent: generateForwardMessageContent,
+    generateWAMessageContent: generateWAMessageContent,
+    generateWAMessageFromContent: generateWAMessageFromContent,
+    generateWAMessage: generateWAMessage,
+    getContentType: getContentType,
+    hasNonNullishProperty: hasNonNullishProperty,
+    normalizeMessageContent: normalizeMessageContent,
+    extractMessageContent: extractMessageContent,
+    getDevice: getDevice,
+    updateMessageWithReceipt: updateMessageWithReceipt,
+    updateMessageWithReaction: updateMessageWithReaction,
+    updateMessageWithPollUpdate: updateMessageWithPollUpdate,
+    updateMessageWithEventResponse: updateMessageWithEventResponse,
+    getAggregateVotesInPollMessage: getAggregateVotesInPollMessage,
+    getAggregateResponsesInEventMessage: getAggregateResponsesInEventMessage,
+    aggregateMessageKeysNotFromMe: aggregateMessageKeysNotFromMe,
+    downloadMediaMessage: downloadMediaMessage,
+    assertMediaContent: assertMediaContent,
+};