@bellaxchuu/flowred 0.8.6

package/lib/Utils/messages.js

@@ -0,0 +1,2904 @@
+'use strict'
+Object.defineProperty(exports, '__esModule', { value: true })
+exports.assertMediaContent =
+	exports.downloadMediaMessage =
+	exports.aggregateMessageKeysNotFromMe =
+	exports.updateMessageWithEventResponse =
+	exports.updateMessageWithPollUpdate =
+	exports.updateMessageWithReaction =
+	exports.updateMessageWithReceipt =
+	exports.getDevice =
+	exports.extractMessageContent =
+	exports.normalizeMessageContent =
+	exports.getContentType =
+	exports.generateWAMessage =
+	exports.generateWAMessageFromContent =
+	exports.generateWAMessageContent =
+	exports.hasNonNullishProperty =
+	exports.generateForwardMessageContent =
+	exports.prepareDisappearingMessageSettingContent =
+	exports.prepareWAMessageMedia =
+	exports.generateLinkPreviewIfRequired =
+	exports.extractUrlFromText =
+		void 0
+exports.getAggregateVotesInPollMessage = getAggregateVotesInPollMessage
+exports.getAggregateResponsesInEventMessage = getAggregateResponsesInEventMessage
+const boom_1 = require('@hapi/boom')
+const crypto_1 = require('crypto')
+const fs_1 = require('fs')
+const index_js_1 = require('../../WAProto/index.js')
+const WAProto_1 = require('../../WAProto/index.js')
+const Defaults_1 = require('../Defaults')
+const Types_1 = require('../Types')
+const WABinary_1 = require('../WABinary')
+const crypto_2 = require('./crypto')
+const generics_1 = require('./generics')
+const messages_media_1 = require('./messages-media')
+const reporting_utils_1 = require('./reporting-utils')
+const jid_display_normalization_1 = require('./jid-display-normalization')
+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'
+}
+const MessageTypeProto = {
+	image: WAProto_1.proto.Message.ImageMessage,
+	video: WAProto_1.proto.Message.VideoMessage,
+	audio: WAProto_1.proto.Message.AudioMessage,
+	sticker: WAProto_1.proto.Message.StickerMessage,
+	document: WAProto_1.proto.Message.DocumentMessage
+}
+
+// Input payloads can carry protobuf media message keys (e.g. imageMessage).
+const MEDIA_MESSAGE_TYPE_ALIASES = {
+	imageMessage: 'image',
+	videoMessage: 'video',
+	audioMessage: 'audio',
+	documentMessage: 'document',
+	stickerMessage: 'sticker',
+	// PTV = push-to-video (video note) payload.
+	ptvMessage: 'video'
+}
+const MEDIA_MESSAGE_TYPE_ALIAS_KEYS = Object.keys(MEDIA_MESSAGE_TYPE_ALIASES)
+const hasMediaPayload = message =>
+	Defaults_1.MEDIA_KEYS.some(key => key in message) || MEDIA_MESSAGE_TYPE_ALIAS_KEYS.some(key => key in message)
+
+const ButtonType = WAProto_1.proto.Message.ButtonsMessage.HeaderType
+
+const RICH_RESPONSE_CODE_KEYWORDS = new Set([
+	'break',
+	'case',
+	'catch',
+	'continue',
+	'debugger',
+	'default',
+	'delete',
+	'do',
+	'else',
+	'finally',
+	'for',
+	'function',
+	'if',
+	'in',
+	'instanceof',
+	'new',
+	'return',
+	'switch',
+	'this',
+	'throw',
+	'try',
+	'typeof',
+	'var',
+	'void',
+	'while',
+	'with',
+	'true',
+	'false',
+	'null',
+	'undefined',
+	'NaN',
+	'Infinity',
+	'class',
+	'const',
+	'let',
+	'super',
+	'extends',
+	'export',
+	'import',
+	'yield',
+	'static',
+	'constructor',
+	'of',
+	'async',
+	'await',
+	'get',
+	'set',
+	'implements',
+	'interface',
+	'package',
+	'private',
+	'protected',
+	'public',
+	'enum',
+	'throws',
+	'transient'
+])
+const tokenizeCode = code => {
+	const tokens = []
+	let i = 0
+	const len = code.length
+	while (i < len) {
+		if (/\s/.test(code[i])) {
+			const start = i
+			while (i < len && /\s/.test(code[i])) i++
+			tokens.push({ content: code.slice(start, i), type: 'DEFAULT' })
+			continue
+		}
+		if (code[i] === '"' || code[i] === "'" || code[i] === '`') {
+			const start = i
+			const quote = code[i]
+			i++
+			while (i < len && code[i] !== quote) {
+				if (code[i] === '\\') i++
+				i++
+			}
+			i++
+			tokens.push({ content: code.slice(start, i), type: 'STR' })
+			continue
+		}
+		if (code[i] === '/' && i + 1 < len && code[i + 1] === '/') {
+			const start = i
+			while (i < len && code[i] !== '\n') i++
+			tokens.push({ content: code.slice(start, i), type: 'COMMENT' })
+			continue
+		}
+		if (code[i] === '/' && i + 1 < len && code[i + 1] === '*') {
+			const start = i
+			i += 2
+			while (i + 1 < len && !(code[i] === '*' && code[i + 1] === '/')) i++
+			i += 2
+			tokens.push({ content: code.slice(start, i), type: 'COMMENT' })
+			continue
+		}
+		if (/[0-9]/.test(code[i])) {
+			const start = i
+			while (i < len && /[0-9.]/.test(code[i])) i++
+			tokens.push({ content: code.slice(start, i), type: 'NUMBER' })
+			continue
+		}
+		if (/[a-zA-Z_$]/.test(code[i])) {
+			const start = i
+			while (i < len && /[a-zA-Z0-9_$]/.test(code[i])) i++
+			const word = code.slice(start, i)
+			if (RICH_RESPONSE_CODE_KEYWORDS.has(word)) {
+				tokens.push({ content: word, type: 'KEYWORD' })
+			} else {
+				let j = i
+				while (j < len && /\s/.test(code[j])) j++
+				tokens.push({ content: word, type: j < len && code[j] === '(' ? 'METHOD' : 'DEFAULT' })
+			}
+			continue
+		}
+		tokens.push({ content: code[i], type: 'DEFAULT' })
+		i++
+	}
+	const merged = []
+	for (const t of tokens) {
+		if (merged.length && merged[merged.length - 1].type === 'DEFAULT' && t.type === 'DEFAULT') {
+			merged[merged.length - 1].content += t.content
+		} else {
+			merged.push(t)
+		}
+	}
+	return merged
+}
+
+/**
+ * Uses a regex to test whether the string contains a URL, and returns the URL if it does.
+ * @param text eg. hello https://google.com
+ * @returns the URL, eg. https://google.com
+ */
+const extractUrlFromText = text => text.match(Defaults_1.URL_REGEX)?.[0]
+exports.extractUrlFromText = extractUrlFromText
+const generateLinkPreviewIfRequired = async (text, getUrlInfo, logger) => {
+	const url = (0, exports.extractUrlFromText)(text)
+	if (!!getUrlInfo && url) {
+		try {
+			const urlInfo = await getUrlInfo(url)
+			return urlInfo
+		} catch (error) {
+			// ignore if fails
+			logger?.warn({ trace: error.stack }, 'url generation failed')
+		}
+	}
+}
+exports.generateLinkPreviewIfRequired = generateLinkPreviewIfRequired
+const assertColor = async color => {
+	let assertedColor
+	if (typeof color === 'number') {
+		assertedColor = color > 0 ? color : 0xffffffff + 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 Defaults_1.MEDIA_KEYS) {
+		if (key in message) {
+			mediaType = key
+		}
+	}
+	if (!mediaType) {
+		throw new boom_1.Boom('Invalid media type', { statusCode: 400 })
+	}
+	const uploadData = {
+		...message,
+		media: message[mediaType]
+	}
+	delete uploadData[mediaType]
+	// check if cacheable + generate cache key
+	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 }, 'got media cache hit')
+			const obj = index_js_1.proto.Message.decode(mediaBuff)
+			const key = `${mediaType}Message`
+			Object.assign(obj[key], { ...uploadData, media: undefined })
+			return obj
+		}
+	}
+	const isNewsletter = !!options.jid && (0, WABinary_1.isJidNewsletter)(options.jid)
+	if (isNewsletter) {
+		logger?.info({ key: cacheableKey }, 'Preparing raw media for newsletter')
+		const { filePath, fileSha256, fileLength } = await (0, messages_media_1.getRawMediaUploadData)(
+			uploadData.media,
+			options.mediaTypeOverride || mediaType,
+			logger
+		)
+		const fileSha256B64 = fileSha256.toString('base64')
+		const { mediaUrl, directPath } = await options.upload(filePath, {
+			fileEncSha256B64: fileSha256B64,
+			mediaType: mediaType,
+			timeoutMs: options.mediaUploadTimeoutMs
+		})
+		await fs_1.promises.unlink(filePath)
+		const obj = WAProto_1.proto.Message.fromObject({
+			// todo: add more support here
+			[`${mediaType}Message`]: MessageTypeProto[mediaType].fromObject({
+				url: mediaUrl,
+				directPath,
+				fileSha256,
+				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 }, 'set cache')
+			await options.mediaCache.set(cacheableKey, WAProto_1.proto.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 && typeof uploadData.waveform === 'undefined'
+	const requiresAudioBackground = options.backgroundColor && mediaType === 'audio' && uploadData.ptt === true
+	const requiresOriginalForSomeProcessing = requiresDurationComputation || requiresThumbnailComputation
+	const { mediaKey, encFilePath, originalFilePath, fileEncSha256, fileSha256, fileLength } = await (0,
+	messages_media_1.encryptedStream)(uploadData.media, options.mediaTypeOverride || mediaType, {
+		logger,
+		saveOriginalFileIfRequired: requiresOriginalForSomeProcessing,
+		opts: options.options
+	})
+	const fileEncSha256B64 = fileEncSha256.toString('base64')
+	const [{ mediaUrl, directPath }] = await Promise.all([
+		(async () => {
+			const result = await options.upload(encFilePath, {
+				fileEncSha256B64,
+				mediaType,
+				timeoutMs: options.mediaUploadTimeoutMs
+			})
+			logger?.debug({ mediaType, cacheableKey }, 'uploaded media')
+			return result
+		})(),
+		(async () => {
+			try {
+				if (requiresThumbnailComputation) {
+					const { thumbnail, originalImageDimensions } = await (0, messages_media_1.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 (0, messages_media_1.getAudioDuration)(originalFilePath)
+					logger?.debug('computed audio duration')
+				}
+				if (requiresWaveformProcessing) {
+					uploadData.waveform = await (0, messages_media_1.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 fs_1.promises.unlink(encFilePath)
+			if (originalFilePath) {
+				await fs_1.promises.unlink(originalFilePath)
+			}
+			logger?.debug('removed tmp files')
+		} catch (error) {
+			logger?.warn('failed to remove tmp file')
+		}
+	})
+	const obj = WAProto_1.proto.Message.fromObject({
+		[`${mediaType}Message`]: MessageTypeProto[mediaType].fromObject({
+			url: mediaUrl,
+			directPath,
+			mediaKey,
+			fileEncSha256,
+			fileSha256,
+			fileLength,
+			mediaKeyTimestamp: (0, generics_1.unixTimestampSeconds)(),
+			...uploadData,
+			media: undefined
+		})
+	})
+	if (uploadData.ptv) {
+		obj.ptvMessage = obj.videoMessage
+		delete obj.videoMessage
+	}
+	if (cacheableKey) {
+		logger?.debug({ cacheableKey }, 'set cache')
+		await options.mediaCache.set(cacheableKey, WAProto_1.proto.Message.encode(obj).finish())
+	}
+	return obj
+}
+exports.prepareWAMessageMedia = prepareWAMessageMedia
+const prepareDisappearingMessageSettingContent = ephemeralExpiration => {
+	ephemeralExpiration = ephemeralExpiration || 0
+	const content = {
+		ephemeralMessage: {
+			message: {
+				protocolMessage: {
+					type: WAProto_1.proto.Message.ProtocolMessage.Type.EPHEMERAL_SETTING,
+					ephemeralExpiration
+				}
+			}
+		}
+	}
+	return WAProto_1.proto.Message.fromObject(content)
+}
+exports.prepareDisappearingMessageSettingContent = prepareDisappearingMessageSettingContent
+/**
+ * Generate forwarded message content like WA does
+ * @param message the message to forward
+ * @param options.forceForward will show the message as forwarded even if it is from you
+ */
+const generateForwardMessageContent = (message, forceForward) => {
+	let content = message.message
+	if (!content) {
+		throw new boom_1.Boom('no content in message', { statusCode: 400 })
+	}
+	// hacky copy
+	content = (0, exports.normalizeMessageContent)(content)
+	content = index_js_1.proto.Message.decode(index_js_1.proto.Message.encode(content).finish())
+	let key = Object.keys(content)[0]
+	let score = content?.[key]?.contextInfo?.forwardingScore || 0
+	score += message.key.fromMe && !forceForward ? 0 : 1
+	if (key === 'conversation') {
+		content.extendedTextMessage = { text: content[key] }
+		delete content.conversation
+		key = 'extendedTextMessage'
+	}
+	const key_ = content?.[key]
+	if (score > 0) {
+		key_.contextInfo = { forwardingScore: score, isForwarded: true }
+	} else {
+		key_.contextInfo = {}
+	}
+	return content
+}
+exports.generateForwardMessageContent = generateForwardMessageContent
+const hasNonNullishProperty = (message, key) => {
+	return (
+		typeof message === 'object' &&
+		message !== null &&
+		key in message &&
+		message[key] !== null &&
+		message[key] !== undefined
+	)
+}
+exports.hasNonNullishProperty = hasNonNullishProperty
+function hasOptionalProperty(obj, key) {
+	return typeof obj === 'object' && obj !== null && key in obj && obj[key] !== null
+}
+const normalizeEarFields = ear => {
+	const result = { ...ear }
+	const applyAlias = (fromKey, toKey) => {
+		if (result[fromKey] !== undefined && result[toKey] === undefined) result[toKey] = result[fromKey]
+	}
+	applyAlias('thumbnail_url', 'thumbnailUrl')
+	applyAlias('thumbnailUrl', 'thumbnail')
+	applyAlias('source_url', 'sourceUrl')
+	applyAlias('media_type', 'mediaType')
+	applyAlias('show_ad_attribution', 'showAdAttribution')
+	applyAlias('render_larger_thumbnail', 'renderLargerThumbnail')
+	if (result.thumbnail && !result.jpegThumbnail) result.jpegThumbnail = result.thumbnail
+	if (result.largeThumbnail !== undefined && result.renderLargerThumbnail === undefined)
+		result.renderLargerThumbnail = result.largeThumbnail
+	if (result.url && !result.sourceUrl) result.sourceUrl = result.url
+	delete result.thumbnail
+	delete result.largeThumbnail
+	delete result.url
+	delete result.thumbnail_url
+	delete result.source_url
+	delete result.media_type
+	delete result.show_ad_attribution
+	delete result.render_larger_thumbnail
+	return result
+}
+const normalizeQuickReplyButton = button => {
+	var _a
+	if (button.name && typeof button.name === 'string') {
+		return {
+			name: button.name,
+			buttonParamsJson:
+				typeof button.buttonParamsJson === 'string'
+					? button.buttonParamsJson
+					: JSON.stringify(button.buttonParamsJson || {})
+		}
+	}
+	if (button.type === 4 && button.nativeFlowInfo) {
+		const { name, paramsJson } = button.nativeFlowInfo
+		return {
+			name: name || 'quick_reply',
+			buttonParamsJson: typeof paramsJson === 'string' ? paramsJson : JSON.stringify(paramsJson || {})
+		}
+	}
+	const buttonTextObject = button.buttonText && typeof button.buttonText === 'object' ? button.buttonText : undefined
+	const displayTextCandidates = [
+		button.text,
+		button.displayText,
+		button.display_text,
+		typeof button.buttonText === 'string' ? button.buttonText : undefined,
+		buttonTextObject === null || buttonTextObject === void 0 ? void 0 : buttonTextObject.displayText,
+		buttonTextObject === null || buttonTextObject === void 0 ? void 0 : buttonTextObject.display_text
+	]
+	const displayText = displayTextCandidates.find(value => typeof value === 'string' && value.length > 0) || ''
+	const id =
+		button.buttonId || button.id || ((_a = button.buttonParamsJson) === null || _a === void 0 ? void 0 : _a.id) || ''
+	return {
+		name: 'quick_reply',
+		buttonParamsJson: JSON.stringify({
+			display_text: displayText,
+			id
+		})
+	}
+}
+const asciiDecode = arr => arr.map(e => String.fromCharCode(e)).join('')
+
+const applyContextInfoAndMentions = (interactiveMessage, message) => {
+	if ('contextInfo' in message && !!message.contextInfo) {
+		interactiveMessage.contextInfo = message.contextInfo
+	}
+	if ('mentions' in message && !!message.mentions) {
+		interactiveMessage.contextInfo = {
+			...(interactiveMessage.contextInfo || {}),
+			mentionedJid: message.mentions
+		}
+	}
+}
+const buildPaymentNoteMessage = async (paymentPayload, options, fallbackText = '') => {
+	let notes
+	if (paymentPayload === null || paymentPayload === void 0 ? void 0 : paymentPayload.sticker) {
+		const stickerPrep = await (0, exports.prepareWAMessageMedia)({ sticker: paymentPayload.sticker }, options)
+		notes = {
+			stickerMessage: {
+				...(stickerPrep === null || stickerPrep === void 0 ? void 0 : stickerPrep.stickerMessage),
+				contextInfo: paymentPayload === null || paymentPayload === void 0 ? void 0 : paymentPayload.contextInfo
+			}
+		}
+	} else if (
+		typeof (paymentPayload === null || paymentPayload === void 0 ? void 0 : paymentPayload.note) === 'string'
+	) {
+		notes = {
+			extendedTextMessage: {
+				text: paymentPayload.note,
+				contextInfo: paymentPayload === null || paymentPayload === void 0 ? void 0 : paymentPayload.contextInfo
+			}
+		}
+	} else if (
+		(paymentPayload === null || paymentPayload === void 0 ? void 0 : paymentPayload.noteMessage) &&
+		typeof paymentPayload.noteMessage === 'object'
+	) {
+		const noteKeys = Object.keys(paymentPayload.noteMessage)
+		const allowedNoteMessageKeys = ['extendedTextMessage', 'stickerMessage']
+		const hasOnlyAllowedKeys = noteKeys.length > 0 && noteKeys.every(key => allowedNoteMessageKeys.includes(key))
+		if (!noteKeys.length || !hasOnlyAllowedKeys) {
+			throw new boom_1.Boom('Invalid payment noteMessage', { statusCode: 400 })
+		}
+		notes = paymentPayload.noteMessage
+	} else {
+		notes = { extendedTextMessage: { text: fallbackText } }
+	}
+	return notes
+}
+
+const generateWAMessageContent = async (message, options) => {
+	var _a, _b
+	let m = {}
+	const hasCaptionWithoutMedia = 'caption' in message && !hasMediaPayload(message)
+	const hasCaptionContainer =
+		('groupStatus' in message && !!message.groupStatus) || ('viewOnce' in message && !!message.viewOnce)
+	if ((0, exports.hasNonNullishProperty)(message, 'text')) {
+		const extContent = { text: message.text }
+		let urlInfo = message.linkPreview
+		if (typeof urlInfo === 'undefined') {
+			urlInfo = await (0, exports.generateLinkPreviewIfRequired)(message.text, options.getUrlInfo, options.logger)
+		}
+		if (urlInfo) {
+			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.font) {
+			extContent.font = options.font
+		}
+		if (
+			options.jid &&
+			(0, WABinary_1.isInteropUser)(options.jid) &&
+			!options.backgroundColor &&
+			!options.font &&
+			!urlInfo
+		) {
+			m.conversation = message.text
+		} else {
+			m.extendedTextMessage = extContent
+		}
+	} else if ((0, exports.hasNonNullishProperty)(message, 'contacts')) {
+		const contactLen = message.contacts.contacts.length
+		if (!contactLen) {
+			throw new boom_1.Boom('require atleast 1 contact', { statusCode: 400 })
+		}
+		if (contactLen === 1) {
+			m.contactMessage = WAProto_1.proto.Message.ContactMessage.create(message.contacts.contacts[0])
+		} else {
+			m.contactsArrayMessage = WAProto_1.proto.Message.ContactsArrayMessage.create(message.contacts)
+		}
+	} else if ((0, exports.hasNonNullishProperty)(message, 'location')) {
+		m.locationMessage = WAProto_1.proto.Message.LocationMessage.create(message.location)
+	} else if ((0, exports.hasNonNullishProperty)(message, 'react')) {
+		if (!message.react.senderTimestampMs) {
+			message.react.senderTimestampMs = Date.now()
+		}
+		m.reactionMessage = WAProto_1.proto.Message.ReactionMessage.create(message.react)
+	} else if ((0, exports.hasNonNullishProperty)(message, 'delete')) {
+		m.protocolMessage = {
+			key: message.delete,
+			type: WAProto_1.proto.Message.ProtocolMessage.Type.REVOKE
+		}
+	} else if ((0, exports.hasNonNullishProperty)(message, 'forward')) {
+		m = (0, exports.generateForwardMessageContent)(message.forward, message.force)
+	} else if ((0, exports.hasNonNullishProperty)(message, 'disappearingMessagesInChat')) {
+		const exp =
+			typeof message.disappearingMessagesInChat === 'boolean'
+				? message.disappearingMessagesInChat
+					? Defaults_1.WA_DEFAULT_EPHEMERAL
+					: 0
+				: message.disappearingMessagesInChat
+		m = (0, exports.prepareDisappearingMessageSettingContent)(exp)
+	} else if ((0, exports.hasNonNullishProperty)(message, 'groupInvite')) {
+		m.groupInviteMessage = {}
+		m.groupInviteMessage.inviteCode = message.groupInvite.inviteCode
+		m.groupInviteMessage.inviteExpiration = message.groupInvite.inviteExpiration
+		m.groupInviteMessage.caption = message.groupInvite.text
+		m.groupInviteMessage.groupJid = message.groupInvite.jid
+		m.groupInviteMessage.groupName = message.groupInvite.subject
+		//TODO: use built-in interface and get disappearing mode info etc.
+		//TODO: cache / use store!?
+		if (options.getProfilePicUrl) {
+			const pfpUrl = await options.getProfilePicUrl(message.groupInvite.jid, 'preview')
+			if (pfpUrl) {
+				const resp = await fetch(pfpUrl, { method: 'GET', dispatcher: options?.options?.dispatcher })
+				if (resp.ok) {
+					const buf = Buffer.from(await resp.arrayBuffer())
+					m.groupInviteMessage.jpegThumbnail = buf
+				}
+			}
+		}
+	} else if ((0, exports.hasNonNullishProperty)(message, 'pin')) {
+		m.pinInChatMessage = {}
+		m.messageContextInfo = {}
+		m.pinInChatMessage.key = message.pin
+		m.pinInChatMessage.type = message.type
+		m.pinInChatMessage.senderTimestampMs = Date.now()
+		m.messageContextInfo.messageAddOnDurationInSecs = message.type === 1 ? message.time || 86400 : 0
+	} else if ((0, exports.hasNonNullishProperty)(message, 'buttonReply')) {
+		switch (message.type) {
+			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: index_js_1.proto.Message.ButtonsResponseMessage.Type.DISPLAY_TEXT
+				}
+				break
+			case 'interactive':
+				m.interactiveResponseMessage = {
+					body: {
+						text: message.buttonReply.displayText,
+						format: WAProto_1.proto.Message.InteractiveResponseMessage.Body.Format.EXTENSIONS_1
+					},
+					nativeFlowResponseMessage: {
+						name: message.buttonReply.nativeFlows.name,
+						paramsJson: message.buttonReply.nativeFlows.paramsJson,
+						version: message.buttonReply.nativeFlows.version
+					}
+				}
+				break
+			case 'list':
+				m.listResponseMessage = {
+					title: message.buttonReply.title,
+					description: message.buttonReply.description,
+					singleSelectReply: {
+						selectedRowId: message.buttonReply.rowId
+					},
+					listType: WAProto_1.proto.Message.ListResponseMessage.ListType.SINGLE_SELECT
+				}
+				break
+		}
+	} else if (hasOptionalProperty(message, 'ptv') && message.ptv) {
+		const { videoMessage } = await (0, exports.prepareWAMessageMedia)({ video: message.video }, options)
+		m.ptvMessage = videoMessage
+	} else if ((0, exports.hasNonNullishProperty)(message, 'product')) {
+		const { imageMessage } = await (0, exports.prepareWAMessageMedia)({ image: message.product.productImage }, options)
+		m.productMessage = WAProto_1.proto.Message.ProductMessage.create({
+			...message,
+			product: {
+				...message.product,
+				productImage: imageMessage
+			}
+		})
+	} else if ((0, exports.hasNonNullishProperty)(message, 'listReply')) {
+		m.listResponseMessage = { ...message.listReply }
+	} else if ((0, exports.hasNonNullishProperty)(message, 'event')) {
+		m.eventMessage = {}
+		const startTime = Math.floor(message.event.startDate.getTime() / 1000)
+		if (message.event.call && options.getCallLink) {
+			const token = await options.getCallLink(message.event.call, { startTime })
+			m.eventMessage.joinLink =
+				(message.event.call === 'audio' ? Defaults_1.CALL_AUDIO_PREFIX : Defaults_1.CALL_VIDEO_PREFIX) + token
+		}
+		m.messageContextInfo = {
+			// encKey
+			messageSecret: message.event.messageSecret || (0, crypto_1.randomBytes)(32)
+		}
+		m.eventMessage.name = message.event.name
+		m.eventMessage.description = message.event.description
+		m.eventMessage.startTime = startTime
+		m.eventMessage.endTime = message.event.endDate ? message.event.endDate.getTime() / 1000 : undefined
+		m.eventMessage.isCanceled = message.event.isCancelled ?? false
+		m.eventMessage.extraGuestsAllowed = message.event.extraGuestsAllowed
+		m.eventMessage.isScheduleCall = message.event.isScheduleCall ?? false
+		m.eventMessage.location = message.event.location
+	} else if ((0, exports.hasNonNullishProperty)(message, 'poll')) {
+		;(_a = message.poll).selectableCount || (_a.selectableCount = 0)
+		;(_b = message.poll).toAnnouncementGroup || (_b.toAnnouncementGroup = false)
+		if (!Array.isArray(message.poll.values)) {
+			throw new boom_1.Boom('Invalid poll values', { statusCode: 400 })
+		}
+		if (message.poll.selectableCount < 0 || message.poll.selectableCount > message.poll.values.length) {
+			throw new boom_1.Boom(`poll.selectableCount in poll should be >= 0 and <= ${message.poll.values.length}`, {
+				statusCode: 400
+			})
+		}
+		m.messageContextInfo = {
+			messageSecret: message.poll.messageSecret || (0, crypto_1.randomBytes)(32)
+		}
+		const isQuiz = message.poll.type === 'quiz' || message.poll.pollType === WAProto_1.proto.Message.PollType.QUIZ
+		const pollTypeEnum = WAProto_1.proto.Message.PollType
+		const pollCreationMessage = {
+			name: message.poll.name,
+			selectableOptionsCount: message.poll.selectableCount,
+			options: message.poll.values.map(optionName => ({ optionName })),
+			pollType: isQuiz ? pollTypeEnum.QUIZ : pollTypeEnum.POLL,
+			...(isQuiz && message.poll.correctAnswer ? { correctAnswer: { optionName: message.poll.correctAnswer } } : {}),
+			...(message.poll.endTime
+				? {
+						endTime:
+							message.poll.endTime instanceof Date
+								? Math.floor(message.poll.endTime.getTime() / 1000)
+								: Number(message.poll.endTime)
+					}
+				: {}),
+			...(message.poll.hideParticipantName !== undefined
+				? { hideParticipantName: !!message.poll.hideParticipantName }
+				: {}),
+			...(message.poll.allowAddOption !== undefined ? { allowAddOption: !!message.poll.allowAddOption } : {})
+		}
+		if (message.poll.version === 6 || message.poll.v6) {
+			m.pollCreationMessageV6 = pollCreationMessage
+		} else if (message.poll.version === 5 || message.poll.v5) {
+			m.pollCreationMessageV5 = pollCreationMessage
+		} else if (message.poll.toAnnouncementGroup) {
+			// poll v2 is for community announcement groups (single select and multiple)
+			m.pollCreationMessageV2 = pollCreationMessage
+		} else {
+			if (message.poll.selectableCount === 1) {
+				//poll v3 is for single select polls
+				m.pollCreationMessageV3 = pollCreationMessage
+			} else {
+				// poll for multiple choice polls
+				m.pollCreationMessage = pollCreationMessage
+			}
+		}
+	} 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 || 'requestPaymentMessage' in message) {
+		if ('requestPayment' in message && 'requestPaymentMessage' in message) {
+			throw new boom_1.Boom('Use either requestPayment or requestPaymentMessage, not both', { statusCode: 400 })
+		}
+		const requestPayment = message.requestPayment || message.requestPaymentMessage
+		const notes = await buildPaymentNoteMessage(requestPayment, options)
+		const amountValue = requestPayment.amount ?? requestPayment.amount1000
+		const amount1000Raw =
+			typeof (amountValue === null || amountValue === void 0 ? void 0 : amountValue.toNumber) === 'function'
+				? amountValue.toNumber()
+				: Number(amountValue)
+		const amount1000 = Number.isFinite(amount1000Raw) ? Math.round(amount1000Raw) : amount1000Raw
+		const currencyCodeIso4217 = requestPayment.currency ?? requestPayment.currencyCodeIso4217
+		const requestFrom = requestPayment.from ?? requestPayment.requestFrom ?? options.recipientJid
+		const missingFields = []
+		if (amountValue === undefined) missingFields.push('amount/amount1000')
+		if (currencyCodeIso4217 === undefined) missingFields.push('currency/currencyCodeIso4217')
+		if (requestFrom === undefined) missingFields.push('from/requestFrom')
+		if (missingFields.length) {
+			throw new boom_1.Boom(`Invalid requestPayment fields: missing ${missingFields.join(', ')}`, { statusCode: 400 })
+		}
+		if (
+			typeof amount1000 !== 'number' ||
+			!Number.isFinite(amount1000) ||
+			!Number.isInteger(amount1000) ||
+			amount1000 <= 0
+		) {
+			throw new boom_1.Boom('Invalid requestPayment fields: amount/amount1000 must be a positive integer', {
+				statusCode: 400
+			})
+		}
+		const bg = requestPayment.background
+		m.requestPaymentMessage = WAProto_1.proto.Message.RequestPaymentMessage.fromObject({
+			expiryTimestamp: requestPayment.expiry ?? requestPayment.expiryTimestamp,
+			amount1000,
+			currencyCodeIso4217,
+			requestFrom,
+			noteMessage: notes,
+			...(bg != null ? { background: bg } : {})
+		})
+	} else if ('sendPayment' in message || 'sendPaymentMessage' in message) {
+		if ('sendPayment' in message && 'sendPaymentMessage' in message) {
+			throw new boom_1.Boom('Use either sendPayment or sendPaymentMessage, not both', { statusCode: 400 })
+		}
+		const sendPayment = message.sendPayment || message.sendPaymentMessage
+		const notes = await buildPaymentNoteMessage(sendPayment, options, message.text || '')
+		const requestMessageKey = sendPayment.requestMessageKey ?? sendPayment.requestKey ?? sendPayment.request
+		if (!requestMessageKey) {
+			throw new boom_1.Boom('Invalid sendPayment fields: missing requestMessageKey/requestKey/request', {
+				statusCode: 400
+			})
+		}
+		m.sendPaymentMessage = WAProto_1.proto.Message.SendPaymentMessage.fromObject({
+			noteMessage: notes,
+			requestMessageKey,
+			...(sendPayment.background != null ? { background: sendPayment.background } : {}),
+			...(sendPayment.transactionData != null ? { transactionData: sendPayment.transactionData } : {})
+		})
+	} else if ('declinePaymentRequest' in message || 'declinePaymentRequestMessage' in message) {
+		if ('declinePaymentRequest' in message && 'declinePaymentRequestMessage' in message) {
+			throw new boom_1.Boom('Use either declinePaymentRequest or declinePaymentRequestMessage, not both', {
+				statusCode: 400
+			})
+		}
+		const declinePayment = message.declinePaymentRequest || message.declinePaymentRequestMessage
+		const key = (declinePayment === null || declinePayment === void 0 ? void 0 : declinePayment.key) || declinePayment
+		if (!key) {
+			throw new boom_1.Boom('Invalid declinePaymentRequest fields: missing key', { statusCode: 400 })
+		}
+		m.declinePaymentRequestMessage = WAProto_1.proto.Message.DeclinePaymentRequestMessage.fromObject({ key })
+	} else if ('cancelPaymentRequest' in message || 'cancelPaymentRequestMessage' in message) {
+		if ('cancelPaymentRequest' in message && 'cancelPaymentRequestMessage' in message) {
+			throw new boom_1.Boom('Use either cancelPaymentRequest or cancelPaymentRequestMessage, not both', {
+				statusCode: 400
+			})
+		}
+		const cancelPayment = message.cancelPaymentRequest || message.cancelPaymentRequestMessage
+		const key = (cancelPayment === null || cancelPayment === void 0 ? void 0 : cancelPayment.key) || cancelPayment
+		if (!key) {
+			throw new boom_1.Boom('Invalid cancelPaymentRequest fields: missing key', { statusCode: 400 })
+		}
+		m.cancelPaymentRequestMessage = WAProto_1.proto.Message.CancelPaymentRequestMessage.fromObject({ key })
+	} else if ('requestPaymentFrom' in message && !!message.requestPaymentFrom) {
+		const noteText = message.text || ''
+		m.requestPaymentMessage = WAProto_1.proto.Message.RequestPaymentMessage.fromObject({
+			requestFrom: message.requestPaymentFrom,
+			noteMessage: { extendedTextMessage: { text: noteText } }
+		})
+	} else if ('invoiceNote' in message) {
+		const preparedInvoice = await (0, exports.prepareWAMessageMedia)(message, options)
+		const mediaType = Object.keys(preparedInvoice)[0]
+		const mediaMsg = preparedInvoice[mediaType] || {}
+		m.invoiceMessage = WAProto_1.proto.Message.InvoiceMessage.fromObject({
+			note: message.invoiceNote,
+			token: message.invoiceToken || '',
+			attachmentType: mediaType === 'imageMessage' ? 1 : 0,
+			attachmentMimetype: mediaMsg.mimetype,
+			attachmentMediaKey: mediaMsg.mediaKey,
+			attachmentMediaKeyTimestamp: mediaMsg.mediaKeyTimestamp,
+			attachmentFileSha256: mediaMsg.fileSha256,
+			attachmentFileEncSha256: mediaMsg.fileEncSha256,
+			attachmentDirectPath: mediaMsg.directPath,
+			attachmentJpegThumbnail: mediaMsg.jpegThumbnail
+		})
+	} else if ('orderText' in message) {
+		m.orderMessage = WAProto_1.proto.Message.OrderMessage.fromObject({
+			message: message.orderText,
+			thumbnail: message.thumbnail,
+			status: message.orderStatus || 1,
+			surface: message.orderSurface || 1
+		})
+	} else if ('paymentInviteServiceType' in message) {
+		m.paymentInviteMessage = {
+			serviceType: message.paymentInviteServiceType,
+			expiryTimestamp: message.paymentInviteExpiry
+		}
+	} else if ((0, exports.hasNonNullishProperty)(message, 'sharePhoneNumber')) {
+		m.protocolMessage = {
+			type: index_js_1.proto.Message.ProtocolMessage.Type.SHARE_PHONE_NUMBER
+		}
+	} else if ((0, exports.hasNonNullishProperty)(message, 'requestPhoneNumber')) {
+		m.requestPhoneNumberMessage = {}
+	} else if ((0, exports.hasNonNullishProperty)(message, 'limitSharing')) {
+		m.protocolMessage = {
+			type: index_js_1.proto.Message.ProtocolMessage.Type.LIMIT_SHARING,
+			limitSharing: {
+				sharingLimited: message.limitSharing === true,
+				trigger: 1,
+				limitSharingSettingTimestamp: Date.now(),
+				initiatedByMe: true
+			}
+		}
+	} else if ('album' in message) {
+		const imageMessages = message.album.filter(item => 'image' in item)
+		const videoMessages = message.album.filter(item => 'video' in item)
+		m.albumMessage = WAProto_1.proto.Message.AlbumMessage.fromObject({
+			expectedImageCount: imageMessages.length,
+			expectedVideoCount: videoMessages.length
+		})
+	} else if ('pollResult' in message) {
+		if (!Array.isArray(message.pollResult.values)) {
+			throw new boom_1.Boom('Invalid pollResult values', { statusCode: 400 })
+		}
+		const isQuizResult =
+			message.pollResult.type === 'quiz' || message.pollResult.pollType === WAProto_1.proto.Message.PollType.QUIZ
+		const pollVotes = message.pollResult.values.map(([optionName, optionVoteCount]) => ({
+			optionName,
+			optionVoteCount
+		}))
+		const snapshotPayload = {
+			name: message.pollResult.name,
+			pollVotes,
+			pollType: isQuizResult ? WAProto_1.proto.Message.PollType.QUIZ : WAProto_1.proto.Message.PollType.POLL
+		}
+		if (message.pollResult.version === 3 || message.pollResult.v3) {
+			m.pollResultSnapshotMessageV3 = WAProto_1.proto.Message.PollResultSnapshotMessage.fromObject(snapshotPayload)
+		} else {
+			m.pollResultSnapshotMessage = snapshotPayload
+		}
+	} else if ('stickerPack' in message || 'stickerPackMessage' in message) {
+		if ('stickerPack' in message && 'stickerPackMessage' in message) {
+			throw new boom_1.Boom('Cannot specify both stickerPack and stickerPackMessage; use only one property.', {
+				statusCode: 400
+			})
+		}
+		const stickerPackMessage = 'stickerPack' in message ? message.stickerPack : message.stickerPackMessage
+		m.stickerPackMessage = WAProto_1.proto.Message.StickerPackMessage.fromObject(stickerPackMessage)
+	} else if ('listMessage' in message) {
+		const lm = { ...message.listMessage }
+		if (lm.text !== undefined && lm.description === undefined) {
+			lm.description = lm.text
+			delete lm.text
+		}
+		m = { listMessage: lm }
+	} else if ('buttonsMessage' in message) {
+		m = {
+			buttonsMessage: WAProto_1.proto.Message.ButtonsMessage.fromObject(message.buttonsMessage)
+		}
+	} else if ('interactiveMessage' in message) {
+		m = { interactiveMessage: message.interactiveMessage }
+	} else if ('richResponse' in message) {
+		// handled in richResponse block below
+	} else if ('groupStatusMessage' in message) {
+		m = { groupStatusMessage: WAProto_1.proto.Message.GroupStatusMessage.fromObject(message.groupStatusMessage) }
+	} else if (hasCaptionWithoutMedia && !hasCaptionContainer) {
+		m.extendedTextMessage = { text: message.caption }
+	} else if (hasCaptionWithoutMedia && hasCaptionContainer) {
+		m = {}
+	} else if (!hasCaptionWithoutMedia && hasMediaPayload(message)) {
+		m = await (0, exports.prepareWAMessageMedia)(message, options)
+	}
+	if ('buttons' in message && !!message.buttons) {
+		const interactiveMessage = {
+			nativeFlowMessage: WAProto_1.proto.Message.InteractiveMessage.NativeFlowMessage.fromObject({
+				buttons: message.buttons.map(normalizeQuickReplyButton)
+			})
+		}
+		if ('text' in message) {
+			interactiveMessage.body = { text: message.text }
+		} else if ('caption' in message) {
+			interactiveMessage.body = { text: message.caption }
+			interactiveMessage.header = {
+				title: message.title || '',
+				subtitle: message.subtitle,
+				hasMediaAttachment: Boolean(message.hasMediaAttachment)
+			}
+			Object.assign(interactiveMessage.header, m)
+		}
+		if ('title' in message && !!message.title && !interactiveMessage.header) {
+			interactiveMessage.header = {
+				title: message.title,
+				subtitle: message.subtitle,
+				hasMediaAttachment: Boolean(message.hasMediaAttachment)
+			}
+		} else if ('title' in message && !!message.title && interactiveMessage.header) {
+			interactiveMessage.header.title = message.title
+			if (message.subtitle !== undefined) {
+				interactiveMessage.header.subtitle = message.subtitle
+			}
+		}
+		if ('footer' in message && !!message.footer) {
+			interactiveMessage.footer = { text: message.footer }
+		}
+		applyContextInfoAndMentions(interactiveMessage, message)
+		m = { interactiveMessage }
+	} else if ('templateButtons' in message && !!message.templateButtons) {
+		const msg = {
+			hydratedButtons: message.hasOwnProperty('templateButtons') ? message.templateButtons : message.templateButtons
+		}
+		if ('text' in message) {
+			msg.hydratedContentText = message.text
+		} else {
+			if ('caption' in message) {
+				msg.hydratedContentText = message.caption
+			}
+			Object.assign(msg, m)
+		}
+		if ('footer' in message && !!message.footer) {
+			msg.hydratedFooterText = message.footer
+		}
+		m = {
+			templateMessage: {
+				fourRowTemplate: msg,
+				hydratedTemplate: msg
+			}
+		}
+	}
+	if ('sections' in message && !!message.sections) {
+		const listMessage = {
+			sections: message.sections,
+			buttonText: message.buttonText,
+			title: message.title,
+			footerText: message.footer,
+			description: message.text,
+			listType: WAProto_1.proto.Message.ListMessage.ListType.SINGLE_SELECT
+		}
+		m = { listMessage }
+	} else if ('productList' in message && !!message.productList) {
+		if (
+			!Array.isArray(message.productList) ||
+			message.productList.length === 0 ||
+			!Array.isArray(message.productList[0].products) ||
+			message.productList[0].products.length === 0
+		) {
+			throw new boom_1.Boom('Invalid productList: must contain at least one section with one product', {
+				statusCode: 400
+			})
+		}
+		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
+				},
+				businessOwnerJid: message.businessOwnerJid
+			},
+			listType: WAProto_1.proto.Message.ListMessage.ListType.PRODUCT_LIST
+		}
+	}
+	if ('interactiveButtons' in message && !!message.interactiveButtons) {
+        const nativeFlow = WAProto_1.proto.Message.InteractiveMessage.NativeFlowMessage.fromObject({
+            buttons: message.interactiveButtons,
+            messageParamsJson: message.messageParams ?? "{}"
+        });
+        let interactiveMessage = { nativeFlowMessage: nativeFlow };
+        if ('text' in message) {
+            interactiveMessage.body = { text: message.text };
+        } else if ('caption' in message) {
+            interactiveMessage.body = { text: message.caption };
+        }
+        if ('title' in message && !!message.title) {
+            interactiveMessage.header = {
+                title: message.title,
+                subtitle: message.subtitle || "",
+                hasMediaAttachment: false
+            };
+            let media = null;
+            if ('image' in message && !!message.image) {
+                media = await prepareWAMessageMedia({ image: message.image }, options);
+                interactiveMessage.header.imageMessage = media.imageMessage;
+                if (message.image.caption) {
+                    interactiveMessage.header.imageMessage.caption = message.image.caption;
+                }
+            } else if ('video' in message && !!message.video) {
+                media = await prepareWAMessageMedia({ video: message.video }, options);
+                interactiveMessage.header.videoMessage = media.videoMessage;
+                if (message.video.caption) {
+                    interactiveMessage.header.videoMessage.caption = message.video.caption;
+                }
+            } else if ('gif' in message && !!message.gif) {
+                media = await prepareWAMessageMedia({ video: message.gif }, options);
+                interactiveMessage.header.videoMessage = media.videoMessage;
+                interactiveMessage.header.videoMessage.gifPlayback = true;
+                if (message.gif.caption) {
+                    interactiveMessage.header.videoMessage.caption = message.gif.caption;
+                }
+            } else if ('document' in message && !!message.document) {
+                media = await prepareWAMessageMedia({ document: message.document }, options);
+                interactiveMessage.header.documentMessage = media.documentMessage;
+                let docuR = interactiveMessage.header.documentMessage;
+                docuR.fileName = message.document.fileName || "Document";
+                docuR.mimetype = message.document.mimetype || docuR.mimetype;
+                if (message.document.caption) docuR.caption = message.document.caption;
+                if (message.document.jpegThumbnail) docuR.jpegThumbnail = message.document.jpegThumbnail;
+            } else if ('location' in message && !!message.location) {
+                let mLoc = message.location;
+                interactiveMessage.header.locationMessage = {
+                    degreesLongitude: mLoc.longitude || 0,
+                    degreesLatitude: mLoc.latitude || 0,
+                    name: mLoc.name || null,
+                    address: mLoc.address || null,
+                    url: mLoc.url || null
+                };
+                media = true;
+            } else if ('thumbnail' in message && !!message.thumbnail) {
+                interactiveMessage.header.jpegThumbnail = message.thumbnail;
+            }
+            if (media || ('thumbnail' in message && !!message.thumbnail)) {
+                interactiveMessage.header.hasMediaAttachment = true;
+            }
+        }
+        if ('footer' in message && !!message.footer) {
+            interactiveMessage.footer = { text: message.footer };
+        }
+        applyContextInfoAndMentions(interactiveMessage, message);
+        m = { interactiveMessage };
+    }
+	if ('shop' in message && !!message.shop) {
+		const interactiveMessage = {
+			shopStorefrontMessage: WAProto_1.proto.Message.InteractiveMessage.ShopMessage.fromObject({
+				surface: (_l = message.shop) === null || _l === void 0 ? void 0 : _l.surface,
+				id: (_m = message.shop) === null || _m === void 0 ? void 0 : _m.id
+			})
+		}
+		if ('text' in message) {
+			interactiveMessage.body = {
+				text: message.text
+			}
+		} else if ('caption' in message) {
+			interactiveMessage.body = {
+				text: message.caption
+			}
+			interactiveMessage.header = {
+				title: message.title,
+				subtitle: message.subtitle,
+				hasMediaAttachment: Boolean(message.hasMediaAttachment)
+			}
+			Object.assign(interactiveMessage.header, m)
+		}
+		if ('footer' in message && !!message.footer) {
+			interactiveMessage.footer = {
+				text: message.footer
+			}
+		}
+		if ('title' in message && !!message.title) {
+			interactiveMessage.header = {
+				title: message.title,
+				subtitle: message.subtitle,
+				hasMediaAttachment: Boolean(message.hasMediaAttachment)
+			}
+			Object.assign(interactiveMessage.header, m)
+		}
+		applyContextInfoAndMentions(interactiveMessage, message)
+		m = { interactiveMessage }
+		if ('interactiveAsTemplate' in message && message.interactiveAsTemplate !== false) {
+			m = { templateMessage: { interactiveMessageTemplate: interactiveMessage } }
+		}
+	}
+	if ('richResponse' in message) {
+		const {
+			text,
+			code,
+			language = 'javascript',
+			botJid = '259786046210223@bot',
+			table,
+			latex,
+			map,
+			imageUrl,
+			imageUrls,
+			responseId,
+			messageSecret: richSecret
+		} = message.richResponse
+		const sections = []
+		if (text) {
+			sections.push({
+				view_model: {
+					primitive: { text, __typename: 'GenAIMarkdownTextUXPrimitive' },
+					__typename: 'GenAISingleLayoutViewModel'
+				}
+			})
+		}
+		if (code) {
+			sections.push({
+				view_model: {
+					primitive: {
+						language,
+						code_blocks: tokenizeCode(String(code)),
+						__typename: 'GenAICodeUXPrimitive'
+					},
+					__typename: 'GenAISingleLayoutViewModel'
+				}
+			})
+		}
+		if (table) {
+			const isPlainArrayTable = Array.isArray(table)
+			const rows = isPlainArrayTable ? table : table.rows
+			if (!Array.isArray(rows)) {
+				throw new boom_1.Boom(
+					'richResponse.table must be an array of rows (e.g. [["h1","h2"],["a","b"]]) or { rows: [...] }',
+					{ statusCode: 400 }
+				)
+			}
+			sections.push({
+				view_model: {
+					primitive: {
+						rows: rows.map((row, idx) => ({
+							cells: Array.isArray(row) ? row.map(c => ({ text: String(c) })) : row.cells,
+							// when a plain 2D array is passed, the first row is treated as the table header
+							isHeading: Array.isArray(row) ? isPlainArrayTable && idx === 0 : row.isHeading
+						})),
+						__typename: 'GenAITableUXPrimitive'
+					},
+					__typename: 'GenAISingleLayoutViewModel'
+				}
+			})
+		}
+		if (latex) {
+			const expressions = Array.isArray(latex)
+				? latex.map(e => (typeof e === 'string' ? { expression: e } : e))
+				: [{ expression: String(latex) }]
+			sections.push({
+				view_model: {
+					primitive: { expressions, __typename: 'GenAILatexUXPrimitive' },
+					__typename: 'GenAISingleLayoutViewModel'
+				}
+			})
+		}
+		if (map) {
+			sections.push({
+				view_model: {
+					primitive: {
+						latitude: map.latitude,
+						longitude: map.longitude,
+						zoom: map.zoom,
+						title: map.title,
+						annotations: map.annotations || [],
+						__typename: 'GenAIMapUXPrimitive'
+					},
+					__typename: 'GenAISingleLayoutViewModel'
+				}
+			})
+		}
+		if (imageUrl) {
+			sections.push({
+				view_model: {
+					primitive: { url: imageUrl, __typename: 'GenAIInlineImageUXPrimitive' },
+					__typename: 'GenAISingleLayoutViewModel'
+				}
+			})
+		}
+		if (imageUrls && Array.isArray(imageUrls) && imageUrls.length > 0) {
+			sections.push({
+				view_model: {
+					primitive: {
+						urls: imageUrls.map(u => (typeof u === 'string' ? { url: u } : u)),
+						__typename: 'GenAIGridImageUXPrimitive'
+					},
+					__typename: 'GenAISingleLayoutViewModel'
+				}
+			})
+		}
+		if (!sections.length && !text) {
+			sections.push({
+				view_model: {
+					primitive: { text: '', __typename: 'GenAIMarkdownTextUXPrimitive' },
+					__typename: 'GenAISingleLayoutViewModel'
+				}
+			})
+		}
+		const unifiedData = {
+			response_id: responseId || (0, crypto_1.randomUUID)(),
+			sections
+		}
+		return WAProto_1.proto.Message.fromObject({
+			messageContextInfo: {
+				deviceListMetadata: {},
+				deviceListMetadataVersion: 2,
+				messageSecret: richSecret || (0, crypto_1.randomBytes)(32)
+			},
+			botForwardedMessage: {
+				message: {
+					richResponseMessage: {
+						submessages: [],
+						messageType: 1,
+						unifiedResponse: { data: Buffer.from(JSON.stringify(unifiedData)) },
+						contextInfo: {
+							forwardingScore: 2,
+							isForwarded: true,
+							forwardedAiBotMessageInfo: { botJid },
+							botMessageSharingInfo: {
+								botEntryPointOrigin: 1,
+								forwardScore: 2
+							}
+						}
+					}
+				}
+			}
+		})
+	}
+	if ('statusNotification' in message || 'statusNotificationMessage' in message) {
+		const notifData = 'statusNotification' in message ? message.statusNotification : message.statusNotificationMessage
+		m = { statusNotificationMessage: WAProto_1.proto.Message.StatusNotificationMessage.fromObject(notifData) }
+	} else if ('statusQuestionAnswer' in message || 'statusQuestionAnswerMessage' in message) {
+		const qaData =
+			'statusQuestionAnswer' in message ? message.statusQuestionAnswer : message.statusQuestionAnswerMessage
+		m = { statusQuestionAnswerMessage: WAProto_1.proto.Message.StatusQuestionAnswerMessage.fromObject(qaData) }
+	} else if ('questionResponse' in message || 'questionResponseMessage' in message) {
+		const qrData = 'questionResponse' in message ? message.questionResponse : message.questionResponseMessage
+		m = { questionResponseMessage: WAProto_1.proto.Message.QuestionResponseMessage.fromObject(qrData) }
+	} else if ('statusQuoted' in message || 'statusQuotedMessage' in message) {
+		const sqData = 'statusQuoted' in message ? message.statusQuoted : message.statusQuotedMessage
+		m = { statusQuotedMessage: WAProto_1.proto.Message.StatusQuotedMessage.fromObject(sqData) }
+	} else if ('statusStickerInteraction' in message || 'statusStickerInteractionMessage' in message) {
+		const ssiData =
+			'statusStickerInteraction' in message ? message.statusStickerInteraction : message.statusStickerInteractionMessage
+		m = { statusStickerInteractionMessage: WAProto_1.proto.Message.StatusStickerInteractionMessage.fromObject(ssiData) }
+	} else if ('newsletterFollowerInvite' in message || 'newsletterFollowerInviteMessageV2' in message) {
+		const nfiData =
+			'newsletterFollowerInvite' in message
+				? message.newsletterFollowerInvite
+				: message.newsletterFollowerInviteMessageV2
+		m = {
+			newsletterFollowerInviteMessageV2: WAProto_1.proto.Message.NewsletterFollowerInviteMessage.fromObject(nfiData)
+		}
+	} else if ('messageHistoryNotice' in message) {
+		m = { messageHistoryNotice: WAProto_1.proto.Message.MessageHistoryNotice.fromObject(message.messageHistoryNotice) }
+	} else if ('scheduledCall' in message || 'scheduledCallCreationMessage' in message) {
+		if ('scheduledCall' in message && 'scheduledCallCreationMessage' in message) {
+			throw new boom_1.Boom('Use either scheduledCall or scheduledCallCreationMessage, not both', { statusCode: 400 })
+		}
+		const sc = message.scheduledCall || message.scheduledCallCreationMessage
+		const scheduledTs =
+			sc.scheduledAt instanceof Date
+				? sc.scheduledAt.getTime()
+				: sc.scheduledAt
+					? Number(sc.scheduledAt)
+					: sc.scheduledTimestampMs
+						? Number(sc.scheduledTimestampMs)
+						: Date.now() + 3600000
+		const callTypeEnum = WAProto_1.proto.Message.ScheduledCallCreationMessage.CallType
+		let callType = callTypeEnum.UNKNOWN
+		if (sc.isVideo || sc.callType === 'video' || sc.callType === callTypeEnum.VIDEO) {
+			callType = callTypeEnum.VIDEO
+		} else if (sc.callType === 'voice' || sc.callType === callTypeEnum.VOICE || sc.callType === undefined) {
+			callType = callTypeEnum.VOICE
+		} else {
+			callType = sc.callType ?? callTypeEnum.VOICE
+		}
+		m.scheduledCallCreationMessage = WAProto_1.proto.Message.ScheduledCallCreationMessage.fromObject({
+			scheduledTimestampMs: scheduledTs,
+			callType,
+			title: sc.title || ''
+		})
+	} else if ('editScheduledCall' in message || 'scheduledCallEditMessage' in message) {
+		if ('editScheduledCall' in message && 'scheduledCallEditMessage' in message) {
+			throw new boom_1.Boom('Use either editScheduledCall or scheduledCallEditMessage, not both', { statusCode: 400 })
+		}
+		const esc = message.editScheduledCall || message.scheduledCallEditMessage
+		const key = esc.key || esc
+		if (!key || typeof key !== 'object' || !key.id) {
+			throw new boom_1.Boom('editScheduledCall requires a valid message key with id', { statusCode: 400 })
+		}
+		m.scheduledCallEditMessage = WAProto_1.proto.Message.ScheduledCallEditMessage.fromObject({
+			key,
+			editType: WAProto_1.proto.Message.ScheduledCallEditMessage.EditType.CANCEL
+		})
+	} else if ('eventInvite' in message || 'eventInviteMessage' in message) {
+		if ('eventInvite' in message && 'eventInviteMessage' in message) {
+			throw new boom_1.Boom('Use either eventInvite or eventInviteMessage, not both', { statusCode: 400 })
+		}
+		const ei = message.eventInvite || message.eventInviteMessage
+		const startTime =
+			ei.startDate instanceof Date
+				? Math.floor(ei.startDate.getTime() / 1000)
+				: ei.startTime
+					? Number(ei.startTime)
+					: undefined
+		const endTime =
+			ei.endDate instanceof Date ? Math.floor(ei.endDate.getTime() / 1000) : ei.endTime ? Number(ei.endTime) : undefined
+		if (!ei.eventId && !ei.id) {
+			throw new boom_1.Boom('eventInvite requires an eventId', { statusCode: 400 })
+		}
+		m.eventInviteMessage = WAProto_1.proto.Message.EventInviteMessage.fromObject({
+			eventId: ei.eventId || ei.id,
+			eventTitle: ei.title || ei.eventTitle || '',
+			caption: ei.text || ei.caption || '',
+			startTime,
+			endTime,
+			isCanceled: ei.isCancelled ?? ei.isCanceled ?? false,
+			jpegThumbnail: ei.thumbnail || ei.jpegThumbnail,
+			contextInfo: ei.contextInfo
+		})
+	} else if ('comment' in message || 'commentMessage' in message) {
+		if ('comment' in message && 'commentMessage' in message) {
+			throw new boom_1.Boom('Use either comment or commentMessage, not both', { statusCode: 400 })
+		}
+		const cm = message.comment || message.commentMessage
+		if (!cm.targetMessageKey && !cm.key) {
+			throw new boom_1.Boom('comment requires a targetMessageKey', { statusCode: 400 })
+		}
+		m.commentMessage = WAProto_1.proto.Message.CommentMessage.fromObject({
+			message: cm.message || cm.replyMessage,
+			targetMessageKey: cm.targetMessageKey || cm.key
+		})
+	} else if ('splitPayment' in message || 'splitPaymentMessage' in message) {
+		if ('splitPayment' in message && 'splitPaymentMessage' in message) {
+			throw new boom_1.Boom('Use either splitPayment or splitPaymentMessage, not both', { statusCode: 400 })
+		}
+		const sp = message.splitPayment || message.splitPaymentMessage
+		if (!sp.totalAmount || !sp.participants?.length) {
+			throw new boom_1.Boom('splitPayment requires totalAmount and at least one participant', { statusCode: 400 })
+		}
+		m.splitPaymentMessage = WAProto_1.proto.Message.SplitPaymentMessage.fromObject({
+			splitId: sp.splitId || (0, crypto_1.randomUUID)(),
+			totalAmount: sp.totalAmount,
+			description: sp.description || '',
+			requesterJid: sp.requesterJid || options.userJid,
+			participants: sp.participants.map(p => ({
+				jid: p.jid,
+				amount: p.amount,
+				status: p.status ?? WAProto_1.proto.Message.SplitPaymentParticipant.SplitPaymentStatus.PENDING
+			})),
+			createdAtMs: sp.createdAtMs || Date.now(),
+			contextInfo: sp.contextInfo
+		})
+	} else if ('p2pPaymentReminder' in message || 'p2PPaymentReminderNotification' in message) {
+		if ('p2pPaymentReminder' in message && 'p2PPaymentReminderNotification' in message) {
+			throw new boom_1.Boom('Use either p2pPaymentReminder or p2PPaymentReminderNotification, not both', {
+				statusCode: 400
+			})
+		}
+		const pr = message.p2pPaymentReminder || message.p2PPaymentReminderNotification
+		const freqEnum = WAProto_1.proto.Message.P2PPaymentReminderNotification.ReminderFrequency
+		const stateEnum = WAProto_1.proto.Message.P2PPaymentReminderNotification.ReminderState
+		const freqMap = {
+			weekly: freqEnum.WEEKLY,
+			biweekly: freqEnum.BIWEEKLY,
+			monthly: freqEnum.MONTHLY,
+			custom: freqEnum.CUSTOM
+		}
+		const stateMap = {
+			active: stateEnum.ACTIVE,
+			paused: stateEnum.PAUSED,
+			stopped: stateEnum.STOPPED,
+			expired: stateEnum.EXPIRED,
+			cancelled: stateEnum.CANCELLED
+		}
+		m.p2PPaymentReminderNotification = WAProto_1.proto.Message.P2PPaymentReminderNotification.fromObject({
+			reminderId: pr.reminderId || (0, crypto_1.randomUUID)(),
+			amount: pr.amount,
+			frequency:
+				typeof pr.frequency === 'string'
+					? (freqMap[pr.frequency.toLowerCase()] ?? freqEnum.UNKNOWN_FREQUENCY)
+					: (pr.frequency ?? freqEnum.UNKNOWN_FREQUENCY),
+			nextReminderTimestamp: pr.nextReminderTimestamp,
+			expiryTimestamp: pr.expiryTimestamp,
+			state:
+				typeof pr.state === 'string'
+					? (stateMap[pr.state.toLowerCase()] ?? stateEnum.ACTIVE)
+					: (pr.state ?? stateEnum.ACTIVE),
+			description: pr.description || '',
+			creatorJid: pr.creatorJid || options.userJid,
+			receiverJid: pr.receiverJid,
+			upiId: pr.upiId,
+			createdTimestamp: pr.createdTimestamp || Date.now()
+		})
+	} else if ('conditionalReveal' in message || 'conditionalRevealMessage' in message) {
+		if ('conditionalReveal' in message && 'conditionalRevealMessage' in message) {
+			throw new boom_1.Boom('Use either conditionalReveal or conditionalRevealMessage, not both', { statusCode: 400 })
+		}
+		const cr = message.conditionalReveal || message.conditionalRevealMessage
+		m.conditionalRevealMessage = WAProto_1.proto.Message.ConditionalRevealMessage.fromObject({
+			conditionalRevealMessageType:
+				WAProto_1.proto.Message.ConditionalRevealMessage.ConditionalRevealMessageType.SCHEDULED_MESSAGE,
+			revealKeyId: cr.revealKeyId || (0, crypto_1.randomUUID)()
+		})
+		m.messageContextInfo = {
+			messageSecret: cr.messageSecret || (0, crypto_1.randomBytes)(32)
+		}
+	} else if ('callLog' in message || 'callLogMessage' in message) {
+		if ('callLog' in message && 'callLogMessage' in message) {
+			throw new boom_1.Boom('Use either callLog or callLogMessage, not both', { statusCode: 400 })
+		}
+		const cl = message.callLog || message.callLogMessage
+		const outcomeEnum = WAProto_1.proto.Message.CallLogMessage.CallOutcome
+		const callTypeEnum = WAProto_1.proto.Message.CallLogMessage.CallType
+		const outcomeMap = {
+			connected: outcomeEnum.CONNECTED,
+			missed: outcomeEnum.MISSED,
+			failed: outcomeEnum.FAILED,
+			rejected: outcomeEnum.REJECTED,
+			accepted_elsewhere: outcomeEnum.ACCEPTED_ELSEWHERE,
+			ongoing: outcomeEnum.ONGOING,
+			silenced_by_dnd: outcomeEnum.SILENCED_BY_DND,
+			silenced_unknown_caller: outcomeEnum.SILENCED_UNKNOWN_CALLER
+		}
+		const callTypeMap = {
+			regular: callTypeEnum.REGULAR,
+			scheduled_call: callTypeEnum.SCHEDULED_CALL,
+			voice_chat: callTypeEnum.VOICE_CHAT
+		}
+		m.callLogMesssage = WAProto_1.proto.Message.CallLogMessage.fromObject({
+			isVideo: cl.isVideo ?? false,
+			callOutcome:
+				typeof cl.outcome === 'string'
+					? (outcomeMap[cl.outcome.toLowerCase()] ?? outcomeEnum.CONNECTED)
+					: (cl.outcome ?? outcomeEnum.CONNECTED),
+			durationSecs: cl.durationSecs || 0,
+			callType:
+				typeof cl.callType === 'string'
+					? (callTypeMap[cl.callType.toLowerCase()] ?? callTypeEnum.REGULAR)
+					: (cl.callType ?? callTypeEnum.REGULAR),
+			participants: (cl.participants || []).map(p => ({
+				jid: p.jid,
+				callOutcome:
+					typeof p.outcome === 'string'
+						? (outcomeMap[p.outcome.toLowerCase()] ?? outcomeEnum.CONNECTED)
+						: (p.outcome ?? p.callOutcome ?? outcomeEnum.CONNECTED)
+			}))
+		})
+	} else if ('statusMention' in message || 'statusMentionMsg' in message) {
+		const sm = message.statusMention || message.statusMentionMsg
+		if (!sm || typeof sm !== 'object') {
+			throw new boom_1.Boom('statusMention must be an object with a message property', { statusCode: 400 })
+		}
+		m.statusMentionMessage = WAProto_1.proto.Message.FutureProofMessage.fromObject({
+			message: sm.message || sm
+		})
+	} else if ('question' in message || 'questionMessage' in message) {
+		const q = message.question || message.questionMessage
+		m.questionMessage = WAProto_1.proto.Message.FutureProofMessage.fromObject({
+			message: q.message || (typeof q === 'object' && 'conversation' in q ? q : { conversation: String(q) })
+		})
+	} else if ('questionReply' in message || 'questionReplyMessage' in message) {
+		const qr = message.questionReply || message.questionReplyMessage
+		m.questionReplyMessage = WAProto_1.proto.Message.FutureProofMessage.fromObject({
+			message: qr.message || (typeof qr === 'object' && 'conversation' in qr ? qr : { conversation: String(qr) })
+		})
+	} else if ('statusAddYours' in message) {
+		const say = message.statusAddYours
+		m.statusAddYours = WAProto_1.proto.Message.FutureProofMessage.fromObject({
+			message: say.message || say
+		})
+	} else if ('eventCoverImage' in message) {
+		const eci = message.eventCoverImage
+		m.eventCoverImage = WAProto_1.proto.Message.FutureProofMessage.fromObject({
+			message: eci.message || eci
+		})
+	} else if ('spoilerMessage' in message || 'spoiler' in message) {
+		const sp = message.spoilerMessage || message.spoiler
+		m.spoilerMessage = WAProto_1.proto.Message.FutureProofMessage.fromObject({
+			message: sp.message || sp
+		})
+	} else if ('lottieStickerMessage' in message || 'lottieSticker' in message) {
+		const ls = message.lottieStickerMessage || message.lottieSticker
+		m.lottieStickerMessage = WAProto_1.proto.Message.FutureProofMessage.fromObject({
+			message: ls.message || ls
+		})
+	} else if ('groupStatusV2' in message || 'groupStatusMessageV2' in message) {
+		const gsv2 = message.groupStatusV2 || message.groupStatusMessageV2
+		m.groupStatusMessageV2 = WAProto_1.proto.Message.FutureProofMessage.fromObject({
+			message: gsv2.message || gsv2
+		})
+	} else if ('newsletterAdminProfile' in message || 'newsletterAdminProfileMessage' in message) {
+		const nap = message.newsletterAdminProfile || message.newsletterAdminProfileMessage
+		m.newsletterAdminProfileMessage = WAProto_1.proto.Message.FutureProofMessage.fromObject({
+			message: nap.message || nap
+		})
+	} else if ('newsletterAdminProfileV2' in message || 'newsletterAdminProfileMessageV2' in message) {
+		const nap2 = message.newsletterAdminProfileV2 || message.newsletterAdminProfileMessageV2
+		m.newsletterAdminProfileMessageV2 = WAProto_1.proto.Message.FutureProofMessage.fromObject({
+			message: nap2.message || nap2
+		})
+	} else if ('botTask' in message || 'botTaskMessage' in message) {
+		const bt = message.botTask || message.botTaskMessage
+		m.botTaskMessage = WAProto_1.proto.Message.FutureProofMessage.fromObject({
+			message: bt.message || bt
+		})
+	} else if ('botInvoke' in message || 'botInvokeMessage' in message) {
+		const bi = message.botInvoke || message.botInvokeMessage
+		m.botInvokeMessage = WAProto_1.proto.Message.FutureProofMessage.fromObject({
+			message: bi.message || bi
+		})
+	} else if ('associatedChild' in message || 'associatedChildMessage' in message) {
+		const ac = message.associatedChild || message.associatedChildMessage
+		m.associatedChildMessage = WAProto_1.proto.Message.FutureProofMessage.fromObject({
+			message: ac.message || ac
+		})
+	} else if ('groupStatusMention' in message || 'groupStatusMentionMessage' in message) {
+		const gsm = message.groupStatusMention || message.groupStatusMentionMessage
+		m.groupStatusMentionMessage = WAProto_1.proto.Message.FutureProofMessage.fromObject({
+			message: gsm.message || gsm
+		})
+	} else if ('pollCreationOptionImage' in message || 'pollCreationOptionImageMessage' in message) {
+		const pcoi = message.pollCreationOptionImage || message.pollCreationOptionImageMessage
+		m.pollCreationOptionImageMessage = WAProto_1.proto.Message.FutureProofMessage.fromObject({
+			message: pcoi.message || pcoi
+		})
+	} else if ('newsletterAdminProfileStatus' in message || 'newsletterAdminProfileStatusMessage' in message) {
+		const naps = message.newsletterAdminProfileStatus || message.newsletterAdminProfileStatusMessage
+		m.newsletterAdminProfileStatusMessage = WAProto_1.proto.Message.FutureProofMessage.fromObject({
+			message: naps.message || naps
+		})
+	} else if ('placeholder' in message || 'placeholderMessage' in message) {
+		const ph = message.placeholder || message.placeholderMessage
+		const phTypeEnum = WAProto_1.proto.Message.PlaceholderMessage.PlaceholderType
+		const phTypeMap = {
+			e2e_reenable: phTypeEnum.PLACEHOLDER_MESSAGE_TYPE_E2E_REENABLE_MSG,
+			linked_devices: phTypeEnum.PLACEHOLDER_MESSAGE_TYPE_LINKED_DEVICES_MESSAGE
+		}
+		m.placeholderMessage = WAProto_1.proto.Message.PlaceholderMessage.fromObject({
+			type:
+				typeof ph.type === 'string'
+					? (phTypeMap[ph.type.toLowerCase()] ?? phTypeEnum.PLACEHOLDER_MESSAGE_TYPE_E2E_REENABLE_MSG)
+					: (ph.type ?? phTypeEnum.PLACEHOLDER_MESSAGE_TYPE_E2E_REENABLE_MSG)
+		})
+	} else if ('tapLink' in message || 'tapLinkMessage' in message) {
+		const tl = message.tapLink || message.tapLinkMessage
+		const inner = {
+			extendedTextMessage: {
+				text: tl.text || tl.title || '',
+				matchedText: tl.url || tl.tapUrl,
+				title: tl.title || tl.text || '',
+				contextInfo: {
+					actionLink: {
+						url: tl.url || tl.tapUrl || '',
+						buttonTitle: tl.buttonTitle || 'Open'
+					}
+				}
+			}
+		}
+		Object.assign(m, inner)
+	} else if ('citation' in message) {
+		const cit = message.citation
+		m.extendedTextMessage = {
+			text: cit.text || cit.title || '',
+			title: cit.title || '',
+			description: cit.subtitle || cit.description || '',
+			...(cit.imageUrl ? { jpegThumbnail: undefined, previewType: 0 } : {})
+		}
+	} else if ('embeddedMusic' in message) {
+		const em = message.embeddedMusic
+		m.extendedTextMessage = {
+			text: em.text || `🎵 ${em.title || ''} — ${em.author || ''}`,
+			title: em.title || '',
+			description: em.author || em.artistAttribution || '',
+			previewType: 0
+		}
+	}
+	if ('keepInChat' in message || 'keepInChatMessage' in message) {
+		const kic = message.keepInChat || message.keepInChatMessage
+		const keepTypeEnum = WAProto_1.proto.KeepType
+		const keepTypeMap = { keep: keepTypeEnum.KEEP_FOR_ALL, undo: keepTypeEnum.UNDO_KEEP_FOR_ALL }
+		m.keepInChatMessage = WAProto_1.proto.Message.KeepInChatMessage.fromObject({
+			key: kic.key || kic,
+			keepType:
+				typeof kic.keepType === 'string'
+					? (keepTypeMap[kic.keepType.toLowerCase()] ?? keepTypeEnum.KEEP_FOR_ALL)
+					: (kic.keepType ?? keepTypeEnum.KEEP_FOR_ALL),
+			timestampMs: kic.timestampMs || Date.now()
+		})
+	}
+	if ('botFeedback' in message || 'botFeedbackMessage' in message) {
+		const bf = message.botFeedback || message.botFeedbackMessage
+		const kindEnum = WAProto_1.proto.BotFeedbackMessage.BotFeedbackKind
+		const kindMap = {
+			positive: kindEnum.BOT_FEEDBACK_POSITIVE,
+			negative: kindEnum.BOT_FEEDBACK_NEGATIVE,
+			negative_generic: kindEnum.BOT_FEEDBACK_NEGATIVE_GENERIC,
+			negative_helpful: kindEnum.BOT_FEEDBACK_NEGATIVE_HELPFUL,
+			negative_interesting: kindEnum.BOT_FEEDBACK_NEGATIVE_INTERESTING,
+			negative_accurate: kindEnum.BOT_FEEDBACK_NEGATIVE_ACCURATE,
+			negative_safe: kindEnum.BOT_FEEDBACK_NEGATIVE_SAFE,
+			negative_other: kindEnum.BOT_FEEDBACK_NEGATIVE_OTHER
+		}
+		m.protocolMessage = {
+			type: WAProto_1.proto.Message.ProtocolMessage.Type.BOT_FEEDBACK_MESSAGE,
+			key: bf.key,
+			botFeedbackMessage: WAProto_1.proto.BotFeedbackMessage.fromObject({
+				feedbackId: bf.feedbackId || bf.key?.id || '',
+				kind:
+					typeof bf.kind === 'string'
+						? (kindMap[bf.kind.toLowerCase()] ?? kindEnum.BOT_FEEDBACK_POSITIVE)
+						: (bf.kind ?? kindEnum.BOT_FEEDBACK_POSITIVE)
+			})
+		}
+	}
+	if ('pollAddOption' in message || 'pollAddOptionMessage' in message) {
+		const pao = message.pollAddOption || message.pollAddOptionMessage
+		if (!pao.pollCreationMessageKey && !pao.key) {
+			throw new boom_1.Boom('pollAddOption requires a pollCreationMessageKey', { statusCode: 400 })
+		}
+		m.pollAddOptionMessage = WAProto_1.proto.Message.PollAddOptionMessage.fromObject({
+			pollCreationMessageKey: pao.pollCreationMessageKey || pao.key,
+			addOption: { optionName: pao.optionName || pao.option }
+		})
+	}
+	if ('chatTheme' in message || 'chatThemeMessage' in message) {
+		const ct = message.chatTheme || message.chatThemeMessage
+		const themeSetting = {
+			settingTimestampMs: Date.now(),
+			clearTheme: ct.clear ?? false,
+			colorSchemeId: ct.colorSchemeId
+		}
+		if (ct.solidColor) {
+			const sc = typeof ct.solidColor === 'object' ? ct.solidColor : {}
+			themeSetting.solidColor = WAProto_1.proto.Message.ChatSolidColorWallpaper.fromObject({
+				colorLight: sc.colorLight || sc.color || '#FFFFFF',
+				colorDark: sc.colorDark || sc.color || '#000000',
+				isDoodleEnabled: sc.isDoodleEnabled ?? false
+			})
+		} else if (ct.stockImage) {
+			const si = typeof ct.stockImage === 'object' ? ct.stockImage : {}
+			themeSetting.stockImage = WAProto_1.proto.Message.ChatStockImageWallpaper.fromObject({
+				stockImageId: si.id || si.stockImageId || String(ct.stockImage),
+				dimLevel: (si.dimLevel ?? si.opacity != null) ? (si.opacity ?? 100) / 100 : 0
+			})
+		} else if (ct.defaultWallpaper) {
+			themeSetting.defaultWallpaper = WAProto_1.proto.Message.ChatDefaultWallpaper.fromObject({
+				isDoodleEnabled: ct.defaultWallpaper.isDoodleEnabled ?? false
+			})
+		} else if (ct.customImage) {
+			themeSetting.customImage = WAProto_1.proto.Message.ChatCustomImageWallpaper.fromObject({
+				directPath: ct.customImage.directPath,
+				mediaKey: ct.customImage.mediaKey,
+				fileEncSha256: ct.customImage.fileEncSha256,
+				fileSha256: ct.customImage.fileSha256,
+				dimLevel: ct.customImage.dimLevel ?? 0
+			})
+		}
+		m.protocolMessage = {
+			type: WAProto_1.proto.Message.ProtocolMessage.Type.CHAT_THEME_SETTING,
+			chatThemeSetting: WAProto_1.proto.Message.ChatThemeSetting.fromObject(themeSetting)
+		}
+	}
+	if ('stopGeneration' in message) {
+		const sg = message.stopGeneration
+		m.protocolMessage = {
+			type: WAProto_1.proto.Message.ProtocolMessage.Type.STOP_GENERATION_MESSAGE,
+			key: sg.key || sg
+		}
+	}
+	if ('unscheduleMessage' in message) {
+		const us = message.unscheduleMessage
+		m.protocolMessage = {
+			type: WAProto_1.proto.Message.ProtocolMessage.Type.MESSAGE_UNSCHEDULE,
+			key: us.key || us
+		}
+	}
+	if ('bcall' in message || 'bcallMessage' in message) {
+		const bc = message.bcall || message.bcallMessage
+		const mediaTypeEnum = WAProto_1.proto.Message.BCallMessage.MediaType
+		const mediaTypeMap = { audio: mediaTypeEnum.AUDIO, video: mediaTypeEnum.VIDEO }
+		m.bcallMessage = WAProto_1.proto.Message.BCallMessage.fromObject({
+			sessionId: bc.sessionId || (0, crypto_1.randomUUID)(),
+			mediaType:
+				typeof bc.mediaType === 'string'
+					? (mediaTypeMap[bc.mediaType.toLowerCase()] ?? mediaTypeEnum.AUDIO)
+					: (bc.mediaType ?? mediaTypeEnum.AUDIO),
+			masterKey: bc.masterKey || (0, crypto_1.randomBytes)(32),
+			caption: bc.caption || ''
+		})
+	}
+	if ('liveLocationUpdate' in message) {
+		const llu = message.liveLocationUpdate
+		m.liveLocationMessage = WAProto_1.proto.Message.LiveLocationMessage.fromObject({
+			degreesLatitude: llu.latitude,
+			degreesLongitude: llu.longitude,
+			accuracyInMeters: llu.accuracy,
+			speedInMps: llu.speed,
+			degreesClockwiseFromMagneticNorth: llu.heading,
+			sequenceNumber: llu.sequence || 1,
+			timeOffset: llu.timeOffset || 0,
+			jpegThumbnail: llu.thumbnail
+		})
+	}
+	if ('stopLiveLocation' in message) {
+		const sll = message.stopLiveLocation
+		m.protocolMessage = {
+			type: WAProto_1.proto.Message.ProtocolMessage.Type.REVOKE,
+			key: sll.key || sll
+		}
+	}
+	if ('carousel' in message || 'carouselMessage' in message) {
+		const c = message.carousel || message.carouselMessage
+		if (!Array.isArray(c.cards) || !c.cards.length) {
+			throw new boom_1.Boom('carousel requires at least one card', { statusCode: 400 })
+		}
+		const cardTypeEnum = WAProto_1.proto.Message.InteractiveMessage.CarouselMessage.CarouselCardType
+		const cardTypeMap = {
+			horizontal: cardTypeEnum.HSCROLL_CARDS,
+			album: cardTypeEnum.ALBUM_IMAGE,
+			hscroll: cardTypeEnum.HSCROLL_CARDS
+		}
+		m.interactiveMessage = {
+			carouselMessage: WAProto_1.proto.Message.InteractiveMessage.CarouselMessage.fromObject({
+				cards: c.cards.map(card => card.interactiveMessage || card),
+				messageVersion: c.messageVersion || 1,
+				carouselCardType:
+					typeof c.cardType === 'string'
+						? (cardTypeMap[c.cardType.toLowerCase()] ?? cardTypeEnum.HSCROLL_CARDS)
+						: (c.carouselCardType ?? cardTypeEnum.HSCROLL_CARDS)
+			})
+		}
+	}
+	if ('aiMediaCollection' in message || 'aiMediaCollectionMessage' in message) {
+		const amc = message.aiMediaCollection || message.aiMediaCollectionMessage
+		m.protocolMessage = {
+			type: WAProto_1.proto.Message.ProtocolMessage.Type.AI_MEDIA_COLLECTION_MESSAGE,
+			aiMediaCollectionMessage: WAProto_1.proto.AIMediaCollectionMessage.fromObject({
+				collectionId: amc.collectionId || (0, crypto_1.randomUUID)(),
+				expectedMediaCount: amc.expectedMediaCount || amc.count || 1,
+				hasGlobalCaption: amc.hasGlobalCaption ?? false
+			})
+		}
+	}
+	if ('botCapabilities' in message && Array.isArray(message.botCapabilities) && message.botCapabilities.length) {
+		const capEnum = WAProto_1.proto.BotCapabilityMetadata.BotCapabilityType
+		const capStrMap = Object.fromEntries(Object.entries(capEnum).map(([k, v]) => [k.toLowerCase(), v]))
+		const caps = message.botCapabilities
+			.map(c => (typeof c === 'string' ? (capStrMap[c.toLowerCase()] ?? capEnum.UNKNOWN) : c))
+			.filter(c => typeof c === 'number' && c !== capEnum.UNKNOWN)
+		m.messageContextInfo = m.messageContextInfo || {}
+		m.messageContextInfo.botMetadata = WAProto_1.proto.BotMetadata.fromObject({
+			capabilityMetadata: { capabilities: caps }
+		})
+	}
+	if ('botThreadInfo' in message && message.botThreadInfo) {
+		const bt = message.botThreadInfo
+		const threadTypeEnum = WAProto_1.proto.AIThreadInfo.AIThreadClientInfo.AIThreadType
+		const threadTypeMap = Object.fromEntries(Object.entries(threadTypeEnum).map(([k, v]) => [k.toLowerCase(), v]))
+		const existing = m.messageContextInfo?.botMetadata
+			? WAProto_1.proto.BotMetadata.toObject(m.messageContextInfo.botMetadata)
+			: {}
+		m.messageContextInfo = m.messageContextInfo || {}
+		m.messageContextInfo.botMetadata = WAProto_1.proto.BotMetadata.fromObject({
+			...existing,
+			botThreadInfo: {
+				clientInfo: {
+					type: typeof bt.type === 'string'
+						? (threadTypeMap[bt.type.toLowerCase()] ?? threadTypeEnum.UNKNOWN)
+						: (bt.type ?? threadTypeEnum.UNKNOWN),
+					sourceChatJid: bt.sourceChatJid || ''
+				}
+			}
+		})
+	}
+	if ('messageAssociation' in message && message.messageAssociation) {
+		const ma = message.messageAssociation
+		const assocTypeEnum = WAProto_1.proto.MessageAssociation.AssociationType
+		const assocTypeMap = Object.fromEntries(Object.entries(assocTypeEnum).map(([k, v]) => [k.toLowerCase(), v]))
+		m.messageContextInfo = m.messageContextInfo || {}
+		m.messageContextInfo.messageAssociation = WAProto_1.proto.MessageAssociation.fromObject({
+			associationType:
+				typeof ma.type === 'string'
+					? (assocTypeMap[ma.type.toLowerCase()] ?? assocTypeEnum.UNKNOWN)
+					: (ma.associationType ?? ma.type ?? assocTypeEnum.UNKNOWN),
+			parentMessageKey: ma.parentMessageKey || ma.parentKey,
+			messageIndex: ma.messageIndex || 0
+		})
+	}
+	if ('threadId' in message && message.threadId) {
+		const tid = message.threadId
+		const threadTypeEnum = WAProto_1.proto.ThreadID.ThreadType
+		m.messageContextInfo = m.messageContextInfo || {}
+		m.messageContextInfo.threadId = [
+			WAProto_1.proto.ThreadID.fromObject({
+				threadType:
+					tid.type === 'ai'
+						? threadTypeEnum.AI_THREAD
+						: tid.type === 'replies'
+							? threadTypeEnum.VIEW_REPLIES
+							: (tid.threadType ?? threadTypeEnum.UNKNOWN),
+				threadKey: tid.key || tid.threadKey
+			})
+		]
+	}
+	if ('featureEligibilities' in message && message.featureEligibilities) {
+		const fe = message.featureEligibilities
+		const [msgType] = Object.keys(m)
+		if (msgType && m[msgType] && typeof m[msgType] === 'object') {
+			m[msgType].contextInfo = {
+				...(m[msgType].contextInfo || {}),
+				featureEligibilities: {
+					cannotBeReactedTo: fe.cannotBeReactedTo ?? false,
+					cannotBeRanked: fe.cannotBeRanked ?? false,
+					canRequestFeedback: fe.canRequestFeedback ?? false,
+					canBeReshared: fe.canBeReshared ?? true,
+					canReceiveMultiReact: fe.canReceiveMultiReact ?? true
+				}
+			}
+		}
+	}
+	if ('forwardOrigin' in message) {
+		const [msgType] = Object.keys(m)
+		if (msgType && m[msgType] && typeof m[msgType] === 'object') {
+			const foEnum = WAProto_1.proto.ContextInfo.ForwardOrigin
+			const foMap = {
+				chat: foEnum.CHAT,
+				status: foEnum.STATUS,
+				channels: foEnum.CHANNELS,
+				meta_ai: foEnum.META_AI,
+				ugc: foEnum.UGC
+			}
+			m[msgType].contextInfo = {
+				...(m[msgType].contextInfo || {}),
+				forwardOrigin:
+					typeof message.forwardOrigin === 'string'
+						? (foMap[message.forwardOrigin.toLowerCase()] ?? foEnum.CHAT)
+						: (message.forwardOrigin ?? foEnum.CHAT)
+			}
+		}
+	}
+	if ('statusAudienceMetadata' in message && message.statusAudienceMetadata) {
+		const [msgType] = Object.keys(m)
+		if (msgType && m[msgType] && typeof m[msgType] === 'object') {
+			const audType = WAProto_1.proto.ContextInfo.StatusAudienceMetadata.AudienceType
+			const sam = message.statusAudienceMetadata
+			m[msgType].contextInfo = {
+				...(m[msgType].contextInfo || {}),
+				statusAudienceMetadata: {
+					audienceType: sam.closeFriends ? audType.CLOSE_FRIENDS : audType.UNKNOWN,
+					listName: sam.listName,
+					listEmoji: sam.listEmoji
+				}
+			}
+		}
+	}
+	if ('aiGenerated' in message && message.aiGenerated === true) {
+		if (m.videoMessage) {
+			m.videoMessage.videoSourceType = WAProto_1.proto.Message.VideoMessage.VideoSourceType.AI_GENERATED
+		}
+		if (m.imageMessage) {
+			m.imageMessage.imageSourceType = WAProto_1.proto.Message.ImageMessage.ImageSourceType.AI_GENERATED
+		}
+	}
+	if ('aiModified' in message && message.aiModified === true) {
+		if (m.imageMessage) {
+			m.imageMessage.imageSourceType = WAProto_1.proto.Message.ImageMessage.ImageSourceType.AI_MODIFIED
+		}
+	}
+	if ('imageSourceType' in message) {
+		if (m.imageMessage) {
+			const istEnum = WAProto_1.proto.Message.ImageMessage.ImageSourceType
+			const istMap = {
+				user: istEnum.USER_IMAGE,
+				ai_generated: istEnum.AI_GENERATED,
+				ai_modified: istEnum.AI_MODIFIED,
+				rasterized: istEnum.RASTERIZED_TEXT_STATUS
+			}
+			m.imageMessage.imageSourceType =
+				typeof message.imageSourceType === 'string'
+					? (istMap[message.imageSourceType.toLowerCase()] ?? istEnum.USER_IMAGE)
+					: (message.imageSourceType ?? istEnum.USER_IMAGE)
+		}
+	}
+	if ('qrUrl' in message && message.qrUrl && m.imageMessage) {
+		m.imageMessage.qrUrl = message.qrUrl
+	}
+	if ('videoContentUrl' in message && message.videoContentUrl && m.extendedTextMessage) {
+		m.extendedTextMessage.videoContentUrl = message.videoContentUrl
+	}
+	if ('endCardTiles' in message && Array.isArray(message.endCardTiles) && m.extendedTextMessage) {
+		m.extendedTextMessage.endCardTiles = message.endCardTiles.map(tile =>
+			WAProto_1.proto.Message.VideoEndCard.fromObject({
+				username: tile.username || tile.user,
+				caption: tile.caption || tile.text,
+				thumbnailImageUrl: tile.thumbnailUrl || tile.thumbnail,
+				profilePictureUrl: tile.profilePictureUrl || tile.avatar
+			})
+		)
+	}
+	if ('musicMetadata' in message && message.musicMetadata && m.extendedTextMessage) {
+		const mm = message.musicMetadata
+		m.extendedTextMessage.musicMetadata = WAProto_1.proto.EmbeddedMusic.fromObject({
+			songId: mm.songId,
+			author: mm.author || mm.artist,
+			title: mm.title,
+			artistAttribution: mm.artistAttribution,
+			isExplicit: mm.isExplicit ?? false,
+			musicSongStartTimeInMs: mm.startTimeMs || 0,
+			derivedContentStartTimeInMs: mm.derivedStartTimeMs || 0,
+			overlapDurationInMs: mm.overlapDurationMs || 0
+		})
+	}
+	if ('businessInteractionPills' in message && message.businessInteractionPills) {
+		const bip = message.businessInteractionPills
+		const pillTypeEnum = WAProto_1.proto.ContextInfo.BusinessInteractionPills.PillType
+		const entryEnum = WAProto_1.proto.ContextInfo.BusinessInteractionPills.EntryPoint
+		const pillMap = Object.fromEntries(Object.entries(pillTypeEnum).map(([k, v]) => [k.toLowerCase(), v]))
+		const entryMap = Object.fromEntries(Object.entries(entryEnum).map(([k, v]) => [k.toLowerCase(), v]))
+		const [msgType] = Object.keys(m)
+		if (msgType && m[msgType] && typeof m[msgType] === 'object') {
+			m[msgType].contextInfo = {
+				...(m[msgType].contextInfo || {}),
+				businessInteractionPills: WAProto_1.proto.ContextInfo.BusinessInteractionPills.fromObject({
+					businessJid: bip.businessJid,
+					entryPoint:
+						typeof bip.entryPoint === 'string'
+							? (entryMap[bip.entryPoint.toLowerCase()] ?? entryEnum.ENTRY_POINT_UNKNOWN)
+							: bip.entryPoint,
+					pills: (bip.pills || []).map(p => ({
+						pillType:
+							typeof p.type === 'string'
+								? (pillMap[p.type.toLowerCase()] ?? pillTypeEnum.UNKNOWN)
+								: (p.pillType ?? pillTypeEnum.UNKNOWN),
+						actionUrl: p.url || p.actionUrl
+					}))
+				})
+			}
+		}
+	}
+	if ('dataSharingContext' in message && message.dataSharingContext) {
+		const dsc = message.dataSharingContext
+		const [msgType] = Object.keys(m)
+		if (msgType && m[msgType] && typeof m[msgType] === 'object') {
+			m[msgType].contextInfo = {
+				...(m[msgType].contextInfo || {}),
+				dataSharingContext: WAProto_1.proto.ContextInfo.DataSharingContext.fromObject({
+					showMmDisclosure: dsc.showMmDisclosure ?? false,
+					encryptedSignalTokenConsented: dsc.encryptedToken,
+					dataSharingFlags: dsc.flags || 0
+				})
+			}
+		}
+	}
+	if ('botSession' in message && message.botSession) {
+		const bs = message.botSession
+		const srcEnum = WAProto_1.proto.BotSessionSource
+		const srcMap = Object.fromEntries(Object.entries(srcEnum).map(([k, v]) => [k.toLowerCase(), v]))
+		m.messageContextInfo = m.messageContextInfo || {}
+		const existing = m.messageContextInfo.botMetadata
+			? WAProto_1.proto.BotMetadata.toObject(m.messageContextInfo.botMetadata)
+			: {}
+		m.messageContextInfo.botMetadata = WAProto_1.proto.BotMetadata.fromObject({
+			...existing,
+			sessionMetadata: {
+				sessionId: bs.sessionId,
+				sessionSource:
+					typeof bs.source === 'string'
+						? (srcMap[bs.source.toLowerCase()] ?? srcEnum.NONE)
+						: (bs.sessionSource ?? srcEnum.NONE)
+			}
+		})
+	}
+	if ('botReminder' in message && message.botReminder) {
+		const br = message.botReminder
+		const actionEnum = WAProto_1.proto.BotReminderMetadata.ReminderAction
+		const freqEnum = WAProto_1.proto.BotReminderMetadata.ReminderFrequency
+		const actionMap = {
+			notify: actionEnum.NOTIFY,
+			create: actionEnum.CREATE,
+			delete: actionEnum.DELETE,
+			update: actionEnum.UPDATE
+		}
+		const freqMap = {
+			once: freqEnum.ONCE,
+			daily: freqEnum.DAILY,
+			weekly: freqEnum.WEEKLY,
+			biweekly: freqEnum.BIWEEKLY,
+			monthly: freqEnum.MONTHLY
+		}
+		m.messageContextInfo = m.messageContextInfo || {}
+		const existing = m.messageContextInfo.botMetadata
+			? WAProto_1.proto.BotMetadata.toObject(m.messageContextInfo.botMetadata)
+			: {}
+		m.messageContextInfo.botMetadata = WAProto_1.proto.BotMetadata.fromObject({
+			...existing,
+			reminderMetadata: {
+				requestMessageKey: br.requestMessageKey || br.key,
+				action:
+					typeof br.action === 'string'
+						? (actionMap[br.action.toLowerCase()] ?? actionEnum.NOTIFY)
+						: (br.action ?? actionEnum.NOTIFY),
+				name: br.name,
+				nextTriggerTimestamp: br.nextTriggerTimestamp || br.timestamp,
+				frequency:
+					typeof br.frequency === 'string'
+						? (freqMap[br.frequency.toLowerCase()] ?? freqEnum.ONCE)
+						: (br.frequency ?? freqEnum.ONCE)
+			}
+		})
+	}
+	if ('botPlugin' in message && message.botPlugin) {
+		const bp = message.botPlugin
+		const ptEnum = WAProto_1.proto.BotPluginMetadata.PluginType
+		const spEnum = WAProto_1.proto.BotPluginMetadata.SearchProvider
+		const ptMap = { reels: ptEnum.REELS, search: ptEnum.SEARCH }
+		const spMap = { bing: spEnum.BING, google: spEnum.GOOGLE, support: spEnum.SUPPORT }
+		m.messageContextInfo = m.messageContextInfo || {}
+		const existing = m.messageContextInfo.botMetadata
+			? WAProto_1.proto.BotMetadata.toObject(m.messageContextInfo.botMetadata)
+			: {}
+		m.messageContextInfo.botMetadata = WAProto_1.proto.BotMetadata.fromObject({
+			...existing,
+			pluginMetadata: WAProto_1.proto.BotPluginMetadata.fromObject({
+				provider:
+					typeof bp.provider === 'string'
+						? (spMap[bp.provider.toLowerCase()] ?? spEnum.UNKNOWN)
+						: (bp.provider ?? spEnum.UNKNOWN),
+				pluginType:
+					typeof bp.pluginType === 'string'
+						? (ptMap[bp.pluginType.toLowerCase()] ?? ptEnum.UNKNOWN_PLUGIN)
+						: (bp.pluginType ?? ptEnum.UNKNOWN_PLUGIN),
+				searchProviderUrl: bp.searchProviderUrl,
+				searchQuery: bp.searchQuery,
+				thumbnailCdnUrl: bp.thumbnailCdnUrl,
+				profilePhotoCdnUrl: bp.profilePhotoCdnUrl,
+				expectedLinksCount: bp.expectedLinksCount || 0,
+				referenceIndex: bp.referenceIndex || 0
+			})
+		})
+	}
+	if ('isSpoiler' in message && message.isSpoiler === true) {
+		const [msgType] = Object.keys(m)
+		if (msgType && m[msgType] && typeof m[msgType] === 'object') {
+			m[msgType].contextInfo = {
+				...(m[msgType].contextInfo || {}),
+				isSpoiler: true
+			}
+		}
+	}
+	if ('expiration' in message && typeof message.expiration === 'number') {
+		const [msgType] = Object.keys(m)
+		if (msgType && m[msgType] && typeof m[msgType] === 'object') {
+			m[msgType].contextInfo = {
+				...(m[msgType].contextInfo || {}),
+				expiration: message.expiration
+			}
+		}
+	}
+	if ('ephemeralSettingTimestamp' in message) {
+		const [msgType] = Object.keys(m)
+		if (msgType && m[msgType] && typeof m[msgType] === 'object') {
+			m[msgType].contextInfo = {
+				...(m[msgType].contextInfo || {}),
+				ephemeralSettingTimestamp: message.ephemeralSettingTimestamp
+			}
+		}
+	}
+	if ('groupSubject' in message && message.groupSubject) {
+		const [msgType] = Object.keys(m)
+		if (msgType && m[msgType] && typeof m[msgType] === 'object') {
+			m[msgType].contextInfo = {
+				...(m[msgType].contextInfo || {}),
+				groupSubject: message.groupSubject
+			}
+		}
+	}
+	if ('parentGroupJid' in message && message.parentGroupJid) {
+		const [msgType] = Object.keys(m)
+		if (msgType && m[msgType] && typeof m[msgType] === 'object') {
+			m[msgType].contextInfo = {
+				...(m[msgType].contextInfo || {}),
+				parentGroupJid: message.parentGroupJid
+			}
+		}
+	}
+	if ('memberLabel' in message && message.memberLabel) {
+		const [msgType] = Object.keys(m)
+		if (msgType && m[msgType] && typeof m[msgType] === 'object') {
+			m[msgType].contextInfo = {
+				...(m[msgType].contextInfo || {}),
+				memberLabel: message.memberLabel
+			}
+		}
+	}
+	if ('trustBanner' in message && message.trustBanner) {
+		const tb = message.trustBanner
+		const [msgType] = Object.keys(m)
+		if (msgType && m[msgType] && typeof m[msgType] === 'object') {
+			m[msgType].contextInfo = {
+				...(m[msgType].contextInfo || {}),
+				...(tb.type != null ? { trustBannerType: tb.type } : {}),
+				...(tb.action != null ? { trustBannerAction: tb.action } : {})
+			}
+		}
+	}
+	if ('entryPoint' in message && message.entryPoint) {
+		const ep = message.entryPoint
+		const [msgType] = Object.keys(m)
+		if (msgType && m[msgType] && typeof m[msgType] === 'object') {
+			m[msgType].contextInfo = {
+				...(m[msgType].contextInfo || {}),
+				...(ep.source ? { entryPointConversionSource: ep.source } : {}),
+				...(ep.app ? { entryPointConversionApp: ep.app } : {}),
+				...(ep.delaySecs != null ? { entryPointConversionDelaySeconds: ep.delaySecs } : {}),
+				...(ep.externalSource ? { entryPointConversionExternalSource: ep.externalSource } : {}),
+				...(ep.externalMedium ? { entryPointConversionExternalMedium: ep.externalMedium } : {})
+			}
+		}
+	}
+	if ('utm' in message && message.utm) {
+		const [msgType] = Object.keys(m)
+		if (msgType && m[msgType] && typeof m[msgType] === 'object') {
+			m[msgType].contextInfo = {
+				...(m[msgType].contextInfo || {}),
+				utm: WAProto_1.proto.ContextInfo.UTMInfo.fromObject({
+					utmSource: message.utm.source,
+					utmCampaign: message.utm.campaign
+				})
+			}
+		}
+	}
+	if ('partiallySelectedContent' in message && message.partiallySelectedContent) {
+		const [msgType] = Object.keys(m)
+		if (msgType && m[msgType] && typeof m[msgType] === 'object') {
+			m[msgType].contextInfo = {
+				...(m[msgType].contextInfo || {}),
+				partiallySelectedContent: message.partiallySelectedContent
+			}
+		}
+	}
+	if ('crossAppSource' in message && message.crossAppSource) {
+		const [msgType] = Object.keys(m)
+		if (msgType && m[msgType] && typeof m[msgType] === 'object') {
+			m[msgType].contextInfo = {
+				...(m[msgType].contextInfo || {}),
+				crossAppSource: message.crossAppSource
+			}
+		}
+	}
+	if ('isQuestion' in message && message.isQuestion === true) {
+		const [msgType] = Object.keys(m)
+		if (msgType && m[msgType] && typeof m[msgType] === 'object') {
+			m[msgType].contextInfo = {
+				...(m[msgType].contextInfo || {}),
+				isQuestion: true
+			}
+		}
+	}
+	if ('afterReadDuration' in message && typeof message.afterReadDuration === 'number') {
+		const [msgType] = Object.keys(m)
+		if (msgType && m[msgType] && typeof m[msgType] === 'object') {
+			m[msgType].contextInfo = {
+				...(m[msgType].contextInfo || {}),
+				afterReadDuration: message.afterReadDuration
+			}
+		}
+		m.messageContextInfo = {
+			...(m.messageContextInfo || {}),
+			messageAddOnDurationInSecs: message.afterReadDuration,
+			messageAddOnExpiryType: index_js_1.proto.MessageContextInfo.MessageAddonExpiryType.DEPENDENT_ON_PARENT
+		}
+	}
+	if ('raw' in message && !!message.raw) {
+		const { raw: _, externalAdReply: _ear, ...rawMsg } = message
+		if ('externalAdReply' in message && !!message.externalAdReply) {
+			const ear = normalizeEarFields(message.externalAdReply)
+			const [rawType] = Object.keys(rawMsg)
+			if (rawType && rawMsg[rawType]) {
+				rawMsg[rawType].contextInfo = {
+					...(rawMsg[rawType].contextInfo || {}),
+					externalAdReply: ear
+				}
+			}
+		}
+		return WAProto_1.proto.Message.fromObject(rawMsg)
+	} else if (Object.keys(m).length === 0) {
+		m = await (0, exports.prepareWAMessageMedia)(message, options)
+	}
+
+	if (hasOptionalProperty(message, 'viewOnce') && !!message.viewOnce) {
+		const viewOnceVersion = message.viewOnceVersion || message.viewOnce
+		if (viewOnceVersion === 'v2' || viewOnceVersion === 2) {
+			m = { viewOnceMessageV2: { message: m } }
+		} else if (viewOnceVersion === 'v2ext' || viewOnceVersion === 'v2extension') {
+			m = { viewOnceMessageV2Extension: { message: m } }
+		} else {
+			m = { viewOnceMessage: { message: m } }
+		}
+	}
+	if (hasOptionalProperty(message, 'documentWithCaption') && !!message.documentWithCaption) {
+		m = { documentWithCaptionMessage: { message: m } }
+	}
+	if (hasOptionalProperty(message, 'ephemeral') && !!message.ephemeral) {
+		m = { ephemeralMessage: { message: m } }
+	}
+	if (hasOptionalProperty(message, 'groupMentioned') && !!message.groupMentioned) {
+		m = { groupMentionedMessage: { message: m } }
+	}
+	if ('groupStatus' in message && !!message.groupStatus) {
+		m = { groupStatusMessage: { message: m } }
+	}
+	if (
+		(hasOptionalProperty(message, 'mentions') && message.mentions?.length) ||
+		(hasOptionalProperty(message, 'mentionAll') && message.mentionAll)
+	) {
+		const normalizedMentions = await (0, jid_display_normalization_1.normalizeMentionedJidsForSend)(
+			message.mentions,
+			options.groupData,
+			options.signalRepository,
+			options.logger
+		)
+		const messageType = Object.keys(m)[0]
+		const key = m[messageType]
+		if (key && 'contextInfo' in key) {
+			key.contextInfo = key.contextInfo || {}
+			if (normalizedMentions?.length) {
+				key.contextInfo.mentionedJid = normalizedMentions
+			}
+			if (message.mentionAll) {
+				key.contextInfo.nonJidMentions = 1
+			} else if (!key) {
+				key.contextInfo = {
+					mentionedJid: normalizedMentions,
+					nonJidMentions: message.mentionAll ? 1 : 0
+				}
+			}
+		}
+	}
+	if (hasOptionalProperty(message, 'edit')) {
+		m = {
+			protocolMessage: {
+				key: message.edit,
+				editedMessage: m,
+				timestampMs: Date.now(),
+				type: WAProto_1.proto.Message.ProtocolMessage.Type.MESSAGE_EDIT
+			}
+		}
+	}
+	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 ((0, reporting_utils_1.shouldIncludeReportingToken)(m) && !(0, WABinary_1.isInteropUser)(options.jid)) {
+		m.messageContextInfo = m.messageContextInfo || {}
+		if (!m.messageContextInfo.messageSecret) {
+			m.messageContextInfo.messageSecret = (0, crypto_1.randomBytes)(32)
+		}
+	}
+
+	if ('externalAdReply' in message && !!message.externalAdReply) {
+		const wrappers = [
+			'viewOnceMessage',
+			'viewOnceMessageV2',
+			'viewOnceMessageV2Extension',
+			'ephemeralMessage',
+			'groupStatusMessage',
+			'templateMessage'
+		]
+		const [outerType] = Object.keys(m)
+		const inner = wrappers.includes(outerType) ? m[outerType].message : m
+		const [innerType] = Object.keys(inner)
+		const innerPayload = innerType ? inner[innerType] : undefined
+		if (innerType && innerType !== 'carouselMessage' && innerPayload && typeof innerPayload === 'object') {
+			const ear = normalizeEarFields(message.externalAdReply)
+			innerPayload.contextInfo = {
+				...(innerPayload.contextInfo || {}),
+				externalAdReply: ear
+			}
+		}
+	}
+	if ('secureMetaServiceLabel' in message && !!message.secureMetaServiceLabel) {
+		const [messageType] = Object.keys(m)
+		m[messageType] = m[messageType] || {}
+		m[messageType].contextInfo = {
+			...(m[messageType].contextInfo || {}),
+			secureMetaServiceLabel: 1
+		}
+	}
+
+	return WAProto_1.proto.Message.create(m)
+}
+exports.generateWAMessageContent = generateWAMessageContent
+const generateWAMessageFromContent = (jid, message, options) => {
+	// set timestamp to now
+	// if not specified
+	if (!options.timestamp) {
+		options.timestamp = new Date()
+	}
+	const innerMessage = (0, exports.normalizeMessageContent)(message)
+	const key = (0, exports.getContentType)(innerMessage)
+	const timestamp = (0, generics_1.unixTimestampSeconds)(options.timestamp)
+	const { quoted, userJid } = options
+	if (quoted && !(0, WABinary_1.isJidNewsletter)(jid)) {
+		const participant = quoted.key.fromMe
+			? userJid // TODO: Add support for LIDs
+			: quoted.participant || quoted.key.participant || quoted.key.remoteJid
+		let quotedMsg = (0, exports.normalizeMessageContent)(quoted.message)
+		const msgType = (0, exports.getContentType)(quotedMsg)
+		// strip any redundant properties
+		quotedMsg = index_js_1.proto.Message.create({ [msgType]: quotedMsg[msgType] })
+		const quotedContent = quotedMsg[msgType]
+		if (typeof quotedContent === 'object' && quotedContent && 'contextInfo' in quotedContent) {
+			delete quotedContent.contextInfo
+		}
+		const contextInfo = ('contextInfo' in innerMessage[key] && innerMessage[key]?.contextInfo) || {}
+		contextInfo.participant = (0, WABinary_1.jidNormalizedUser)(participant)
+		contextInfo.stanzaId = quoted.key.id
+		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) {
+			contextInfo.remoteJid = quoted.key.remoteJid
+		}
+		if (contextInfo && innerMessage[key]) {
+			/* @ts-ignore */
+			innerMessage[key].contextInfo = contextInfo
+		}
+	}
+	if (
+		// if we want to send a disappearing message
+		!!options.ephemeralExpiration &&
+		// and it's not a protocol message -- delete, toggle disappear message
+		key !== 'protocolMessage' &&
+		// already not converted to disappearing message
+		key !== 'ephemeralMessage' &&
+		// newsletters don't support ephemeral messages
+		!(0, WABinary_1.isJidNewsletter)(jid)
+	) {
+		/* @ts-ignore */
+		innerMessage[key].contextInfo = {
+			...(innerMessage[key].contextInfo || {}),
+			expiration: options.ephemeralExpiration || Defaults_1.WA_DEFAULT_EPHEMERAL
+			//ephemeralSettingTimestamp: options.ephemeralOptions.eph_setting_ts?.toString()
+		}
+	}
+	message = WAProto_1.proto.Message.create(message)
+	const iosBros = options?.browser?.[0] === 'iOS' || options?.browser?.[1] === 'Safari'
+	const androidBros = options?.browser?.[0] === 'Android'
+	const pickedMessageId =
+		options?.messageId ||
+		(iosBros
+			? (0, generics_1.generateIOSMessageID)()
+			: androidBros
+				? (0, generics_1.generateAndroMessageID)()
+				: (0, generics_1.generateMessageIDV2)(userJid))
+	const messageJSON = {
+		key: {
+			remoteJid: jid,
+			fromMe: true,
+			id: pickedMessageId
+		},
+		message: message,
+		messageTimestamp: timestamp,
+		messageStubParameters: [],
+		participant: (0, WABinary_1.isJidGroup)(jid) || (0, WABinary_1.isJidStatusBroadcast)(jid) ? userJid : undefined, // TODO: Add support for LIDs
+		status: Types_1.WAMessageStatus.PENDING
+	}
+	return WAProto_1.proto.WebMessageInfo.fromObject(messageJSON)
+}
+exports.generateWAMessageFromContent = generateWAMessageFromContent
+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 (0, exports.generateWAMessageFromContent)(
+		jid,
+		await (0, exports.generateWAMessageContent)(content, { ...options, jid }),
+		options
+	)
+}
+exports.generateWAMessage = generateWAMessage
+/** Get the key to access the true type of content */
+const getContentType = content => {
+	if (content) {
+		const keys = Object.keys(content)
+		const key = keys.find(k => (k === 'conversation' || k.includes('Message')) && k !== 'senderKeyDistributionMessage')
+		return key
+	}
+}
+exports.getContentType = getContentType
+/**
+ * Normalizes ephemeral, view once messages to regular message content
+ * Eg. image messages in ephemeral messages, in view once messages etc.
+ * @param content
+ * @returns
+ */
+const normalizeMessageContent = content => {
+	if (!content) {
+		return undefined
+	}
+	// set max iterations to prevent an infinite loop
+	for (let i = 0; i < 5; i++) {
+		const inner = getFutureProofMessage(content)
+		if (!inner) {
+			break
+		}
+		content = inner.message
+	}
+	return content
+	function getFutureProofMessage(message) {
+		return (
+			message.ephemeralMessage ||
+			message.viewOnceMessage ||
+			message.documentWithCaptionMessage ||
+			message.viewOnceMessageV2 ||
+			message.viewOnceMessageV2Extension ||
+			message.editedMessage ||
+			message.groupMentionedMessage ||
+			message.botInvokeMessage ||
+			message.lottieStickerMessage ||
+			message.eventCoverImage ||
+			message.statusMentionMessage ||
+			message.pollCreationOptionImageMessage ||
+			message.associatedChildMessage ||
+			message.groupStatusMentionMessage ||
+			message.pollCreationMessageV4 ||
+			message.pollCreationMessageV5 ||
+			message.statusAddYours ||
+			message.groupStatusMessage ||
+			message.limitSharingMessage ||
+			message.botTaskMessage ||
+			message.questionMessage ||
+			message.groupStatusMessageV2 ||
+			message.botForwardedMessage ||
+			message.questionReplyMessage ||
+			message.newsletterAdminProfileMessage ||
+			message.newsletterAdminProfileMessageV2 ||
+			message.newsletterAdminProfileStatusMessage ||
+			message.spoilerMessage ||
+			message.groupStatusV3Message ||
+			message.pollCreationMessageV6
+		)
+	}
+}
+exports.normalizeMessageContent = normalizeMessageContent
+/**
+ * Extract the true message content from a message
+ * Eg. extracts the inner message from a disappearing message/view once message
+ */
+const extractMessageContent = content => {
+	const extractFromTemplateMessage = msg => {
+		if (msg.imageMessage) {
+			return { imageMessage: msg.imageMessage }
+		} else if (msg.documentMessage) {
+			return { documentMessage: msg.documentMessage }
+		} else if (msg.videoMessage) {
+			return { videoMessage: msg.videoMessage }
+		} else if (msg.locationMessage) {
+			return { locationMessage: msg.locationMessage }
+		} else {
+			return {
+				conversation:
+					'contentText' in msg ? msg.contentText : 'hydratedContentText' in msg ? msg.hydratedContentText : ''
+			}
+		}
+	}
+	content = (0, exports.normalizeMessageContent)(content)
+	if (content?.buttonsMessage) {
+		return extractFromTemplateMessage(content.buttonsMessage)
+	}
+	if (content?.templateMessage?.hydratedFourRowTemplate) {
+		return extractFromTemplateMessage(content?.templateMessage?.hydratedFourRowTemplate)
+	}
+	if (content?.templateMessage?.hydratedTemplate) {
+		return extractFromTemplateMessage(content?.templateMessage?.hydratedTemplate)
+	}
+	if (content?.templateMessage?.fourRowTemplate) {
+		return extractFromTemplateMessage(content?.templateMessage?.fourRowTemplate)
+	}
+	return content
+}
+exports.extractMessageContent = extractMessageContent
+/**
+ * Returns the device predicted by message ID
+ */
+const getDevice = id =>
+	/^3A.{18}$/.test(id)
+		? 'ios'
+		: /^3E.{20}$/.test(id)
+			? 'web'
+			: /^(.{21}|.{32})$/.test(id)
+				? 'android'
+				: /^(3F|.{18}$)/.test(id)
+					? 'desktop'
+					: 'api/baileys'
+exports.getDevice = getDevice
+/** Upserts a receipt in the message */
+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)
+	}
+}
+exports.updateMessageWithReceipt = updateMessageWithReceipt
+/** Update the message with a new reaction */
+const updateMessageWithReaction = (msg, reaction) => {
+	const authorID = (0, generics_1.getKeyAuthor)(reaction.key)
+	const reactions = (msg.reactions || []).filter(r => (0, generics_1.getKeyAuthor)(r.key) !== authorID)
+	reaction.text = reaction.text || ''
+	reactions.push(reaction)
+	msg.reactions = reactions
+}
+exports.updateMessageWithReaction = updateMessageWithReaction
+/** Update the message with a new poll update */
+const updateMessageWithPollUpdate = (msg, update) => {
+	const authorID = (0, generics_1.getKeyAuthor)(update.pollUpdateMessageKey)
+	const reactions = (msg.pollUpdates || []).filter(
+		r => (0, generics_1.getKeyAuthor)(r.pollUpdateMessageKey) !== authorID
+	)
+	if (update.vote?.selectedOptions?.length) {
+		reactions.push(update)
+	}
+	msg.pollUpdates = reactions
+}
+exports.updateMessageWithPollUpdate = updateMessageWithPollUpdate
+/** Update the message with a new event response */
+const updateMessageWithEventResponse = (msg, update) => {
+	const authorID = (0, generics_1.getKeyAuthor)(update.eventResponseMessageKey)
+	const responses = (msg.eventResponses || []).filter(
+		r => (0, generics_1.getKeyAuthor)(r.eventResponseMessageKey) !== authorID
+	)
+	responses.push(update)
+	msg.eventResponses = responses
+}
+exports.updateMessageWithEventResponse = updateMessageWithEventResponse
+/**
+ * Aggregates all poll updates in a poll.
+ * @param msg the poll creation message
+ * @param meId your jid
+ * @returns A list of options & their voters
+ */
+function getAggregateVotesInPollMessage({ message, pollUpdates }, meId) {
+	const opts =
+		message?.pollCreationMessage?.options ||
+		message?.pollCreationMessageV2?.options ||
+		message?.pollCreationMessageV3?.options ||
+		message?.pollCreationMessageV5?.options ||
+		message?.pollCreationMessageV6?.options ||
+		message?.pollCreationMessageV4?.message?.pollCreationMessage?.options ||
+		message?.pollCreationMessageV4?.message?.pollCreationMessageV3?.options ||
+		[]
+	const voteHashMap = opts.reduce((acc, opt) => {
+		const hash = (0, crypto_2.sha256)(Buffer.from(opt.optionName || '')).toString()
+		acc[hash] = {
+			name: opt.optionName || '',
+			voters: []
+		}
+		return acc
+	}, {})
+	for (const update of pollUpdates || []) {
+		const { 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((0, generics_1.getKeyAuthor)(update.pollUpdateMessageKey, meId))
+		}
+	}
+	return Object.values(voteHashMap)
+}
+/** Given a list of message keys, aggregates them by chat & sender. Useful for sending read receipts in bulk */
+const aggregateMessageKeysNotFromMe = keys => {
+	const keyMap = {}
+	for (const { remoteJid, id, participant, fromMe, sts } of keys) {
+		if (!fromMe) {
+			const uqKey = `${remoteJid}:${participant || ''}`
+			if (!keyMap[uqKey]) {
+				keyMap[uqKey] = {
+					jid: remoteJid,
+					participant: participant,
+					messageIds: [],
+					// sts is per-message; kept only for single-message interop receipts
+					sts: sts
+				}
+			} else if (keyMap[uqKey].sts !== sts) {
+				// Multiple messages with different sts — can't aggregate a single sts
+				keyMap[uqKey].sts = undefined
+			}
+			keyMap[uqKey].messageIds.push(id)
+		}
+	}
+	return Object.values(keyMap)
+}
+exports.aggregateMessageKeysNotFromMe = aggregateMessageKeysNotFromMe
+
+/**
+ * Check if a WebMessageInfo has a scheduled reveal time (ConditionalRevealMessage)
+ */
+const isScheduledMessage = msg => !!msg?.scheduledMessageMetadata?.scheduledTime
+exports.isScheduledMessage = isScheduledMessage
+
+/**
+ * Get scheduled reveal time of a message as a Date, or null
+ */
+const getScheduledMessageTime = msg => {
+	const t = msg?.scheduledMessageMetadata?.scheduledTime
+	if (!t) return null
+	return new Date(Number(t) * 1000)
+}
+exports.getScheduledMessageTime = getScheduledMessageTime
+
+/**
+ * Extract PaymentInfo from a WebMessageInfo (the payment status field, not the message content)
+ */
+const getMessagePaymentInfo = msg => msg?.paymentInfo || msg?.quotedPaymentInfo || null
+exports.getMessagePaymentInfo = getMessagePaymentInfo
+
+/**
+ * Get all comment metadata from a WebMessageInfo
+ */
+const getMessageCommentMetadata = msg => msg?.commentMetadata || null
+exports.getMessageCommentMetadata = getMessageCommentMetadata
+
+/**
+ * Get all message add-ons (reactions, poll updates, pins) from a WebMessageInfo
+ */
+const getMessageAddOns = msg => msg?.messageAddOns || []
+exports.getMessageAddOns = getMessageAddOns
+
+/**
+ * Get the quiz correct answer from a poll creation message, if it's a quiz
+ */
+const getPollCorrectAnswer = pollMsg => {
+	const poll =
+		pollMsg?.pollCreationMessage ||
+		pollMsg?.pollCreationMessageV2 ||
+		pollMsg?.pollCreationMessageV3 ||
+		pollMsg?.pollCreationMessageV5 ||
+		pollMsg?.pollCreationMessageV6
+	if (!poll) return null
+	const isQuiz = poll.pollType === WAProto_1.proto.Message.PollType?.QUIZ || poll.pollType === 1
+	return isQuiz ? poll.correctAnswer?.optionName || null : null
+}
+exports.getPollCorrectAnswer = getPollCorrectAnswer
+
+/**
+ * Aggregates all event responses in an event message.
+ * @param msg the event creation message
+ * @param meLid your lid
+ * @returns A list of response types & their responders
+ */
+function getAggregateResponsesInEventMessage({ 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 } = update.response || {}
+		const responseType = index_js_1.proto.Message.EventResponseMessage.EventResponseType[response]
+		if (responseType !== 'UNKNOWN' && responseMap[responseType]) {
+			responseMap[responseType].responders.push(generics_1.getKeyAuthor(update.eventResponseMessageKey, meLid))
+		}
+	}
+
+	return Object.values(responseMap)
+}
+
+exports.getAggregateResponsesInEventMessage = getAggregateResponsesInEventMessage
+
+const REUPLOAD_REQUIRED_STATUS = [410, 404]
+/**
+ * Downloads the given message. Throws an error if it's not a media message
+ */
+const downloadMediaMessage = async (message, type, options, ctx) => {
+	const result = await downloadMsg().catch(async error => {
+		if (
+			ctx &&
+			typeof error?.status === 'number' && // treat errors with status as HTTP failures requiring reupload
+			REUPLOAD_REQUIRED_STATUS.includes(error.status)
+		) {
+			ctx.logger.info({ key: message.key }, 'sending reupload media request...')
+			// request reupload
+			message = await ctx.reuploadRequest(message)
+			const result = await downloadMsg()
+			return result
+		}
+		throw error
+	})
+	return result
+	async function downloadMsg() {
+		const mContent = (0, exports.extractMessageContent)(message.message)
+		if (!mContent) {
+			throw new boom_1.Boom('No message present', { statusCode: 400, data: message })
+		}
+		const contentType = (0, exports.getContentType)(mContent)
+		let mediaType = contentType?.replace('Message', '')
+		const media = mContent[contentType]
+		if (!media || typeof media !== 'object' || (!('url' in media) && !('thumbnailDirectPath' in media))) {
+			throw new boom_1.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 (0, messages_media_1.downloadContentFromMessage)(download, mediaType, options)
+		if (type === 'buffer') {
+			const bufferArray = []
+			for await (const chunk of stream) {
+				bufferArray.push(chunk)
+			}
+			return Buffer.concat(bufferArray)
+		}
+		return stream
+	}
+}
+exports.downloadMediaMessage = downloadMediaMessage
+/** Checks whether the given message is a media message; if it is returns the inner content */
+const assertMediaContent = content => {
+	content = (0, exports.extractMessageContent)(content)
+	const mediaContent =
+		content?.documentMessage ||
+		content?.imageMessage ||
+		content?.videoMessage ||
+		content?.audioMessage ||
+		content?.stickerMessage
+	if (!mediaContent) {
+		throw new boom_1.Boom('given message is not a media message', { statusCode: 400, data: content })
+	}
+	return mediaContent
+}
+exports.assertMediaContent = assertMediaContent
+/**
+ * Normalizes a bare user id to @s.whatsapp.net. Does not convert LID↔PN; use lidMapping / PN in key.remoteJidAlt when needed.
+ */
+const toJid = id => {
+	if (!id) return ''
+	if (id.includes('@')) return id
+	return `${id}@s.whatsapp.net`
+}
+exports.toJid = toJid
+/**
+ * Returns the peer LID JID when the key is LID-primary (decode sets remoteJid/participant to @lid when WA sends LID).
+ */
+const getSenderLid = message => {
+	const k = message.key
+	if (!k) {
+		return { jid: '', lid: '' }
+	}
+	const jid = k.participant || k.remoteJid || ''
+	if (jid.endsWith('@lid') || jid.endsWith('@hosted.lid')) {
+		return { jid, lid: jid }
+	}
+	if (k.lid && typeof k.lid === 'string') {
+		const lid = k.lid.includes('@') ? k.lid : (0, WABinary_1.jidEncode)(k.lid, 'lid')
+		return { jid, lid }
+	}
+	if (k.participantLid && (0, WABinary_1.isLidUser)(k.participantLid)) {
+		return { jid, lid: k.participantLid }
+	}
+	return { jid, lid: '' }
+}
+exports.getSenderLid = getSenderLid