n8n-nodes-new-evolution-api 2.0.0

package/dist/nodes/EvolutionApi/EvolutionApiTrigger.node.js

@@ -0,0 +1,835 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EvolutionApiTrigger = void 0;
+const loadOptions_1 = require("./loadOptions");
+const messageDedupeCache = new Map();
+const DEDUPE_TTL_MS = 30000;
+function cleanDedupeCache() {
+    const now = Date.now();
+    for (const [key, timestamp] of messageDedupeCache.entries()) {
+        if (now - timestamp > DEDUPE_TTL_MS) {
+            messageDedupeCache.delete(key);
+        }
+    }
+}
+setInterval(cleanDedupeCache, 60000);
+class EvolutionApiTrigger {
+    constructor() {
+        this.description = {
+            displayName: 'New Evolution API Trigger',
+            name: 'evolutionApiV2Trigger',
+            icon: 'file:evolutionapi.svg',
+            group: ['trigger'],
+            version: 1,
+            subtitle: '={{$parameter["events"].join(", ")}}',
+            description: 'Recebe eventos em tempo real da Evolution API (WhatsApp)',
+            defaults: {
+                name: 'New Evolution API Trigger',
+            },
+            inputs: [],
+            outputs: ["main"],
+            credentials: [
+                {
+                    name: 'evolutionApiV2Api',
+                    required: true,
+                },
+            ],
+            webhooks: [
+                {
+                    name: 'default',
+                    httpMethod: 'POST',
+                    responseMode: 'onReceived',
+                    path: '={{$parameter["path"]}}',
+                    isFullPath: true,
+                },
+            ],
+            properties: [
+                {
+                    displayName: 'Path',
+                    name: 'path',
+                    type: 'string',
+                    default: 'webhook-evolution',
+                    placeholder: 'webhook-evolution',
+                    required: true,
+                    description: 'Caminho do webhook (ex: webhook-evolution). A URL completa será exibida após salvar.',
+                },
+                {
+                    displayName: 'Instance Name or ID',
+                    name: 'instanceName',
+                    type: 'options',
+                    typeOptions: {
+                        loadOptionsMethod: 'getInstances',
+                    },
+                    default: '',
+                    required: true,
+                    description: 'Choose from the list, or specify an ID using an <a href="https://docs.n8n.io/code/expressions/">expression</a>',
+                },
+                {
+                    displayName: 'Events',
+                    name: 'events',
+                    type: 'multiOptions',
+                    default: ['MESSAGES_UPSERT'],
+                    required: true,
+                    description: 'Eventos para escutar',
+                    options: [
+                        {
+                            name: 'Call (Chamada)',
+                            value: 'CALL',
+                            description: 'Chamadas recebidas',
+                        },
+                        {
+                            name: 'Chats Delete',
+                            value: 'CHATS_DELETE',
+                            description: 'Chat deletado',
+                        },
+                        {
+                            name: 'Chats Set',
+                            value: 'CHATS_SET',
+                            description: 'Chats sincronizados',
+                        },
+                        {
+                            name: 'Chats Update',
+                            value: 'CHATS_UPDATE',
+                            description: 'Chat atualizado',
+                        },
+                        {
+                            name: 'Chats Upsert',
+                            value: 'CHATS_UPSERT',
+                            description: 'Chat criado ou atualizado',
+                        },
+                        {
+                            name: 'Connection Update',
+                            value: 'CONNECTION_UPDATE',
+                            description: 'Status da conexão alterado',
+                        },
+                        {
+                            name: 'Contacts Set',
+                            value: 'CONTACTS_SET',
+                            description: 'Contatos sincronizados',
+                        },
+                        {
+                            name: 'Contacts Update',
+                            value: 'CONTACTS_UPDATE',
+                            description: 'Contato atualizado',
+                        },
+                        {
+                            name: 'Contacts Upsert',
+                            value: 'CONTACTS_UPSERT',
+                            description: 'Contato criado ou atualizado',
+                        },
+                        {
+                            name: 'Groups Update',
+                            value: 'GROUPS_UPDATE',
+                            description: 'Grupo atualizado',
+                        },
+                        {
+                            name: 'Groups Upsert',
+                            value: 'GROUPS_UPSERT',
+                            description: 'Grupo criado ou atualizado',
+                        },
+                        {
+                            name: 'Labels Association',
+                            value: 'LABELS_ASSOCIATION',
+                            description: 'Etiqueta associada',
+                        },
+                        {
+                            name: 'Labels Edit',
+                            value: 'LABELS_EDIT',
+                            description: 'Etiqueta editada',
+                        },
+                        {
+                            name: 'Messages Delete',
+                            value: 'MESSAGES_DELETE',
+                            description: 'Mensagem deletada',
+                        },
+                        {
+                            name: 'Messages Set',
+                            value: 'MESSAGES_SET',
+                            description: 'Mensagens sincronizadas',
+                        },
+                        {
+                            name: 'Messages Update',
+                            value: 'MESSAGES_UPDATE',
+                            description: 'Mensagem atualizada (status de leitura, etc)',
+                        },
+                        {
+                            name: 'Messages Upsert',
+                            value: 'MESSAGES_UPSERT',
+                            description: 'Nova mensagem recebida ou enviada',
+                        },
+                        {
+                            name: 'Newsletter Message',
+                            value: 'NEWSLETTER_MESSAGE',
+                            description: 'Mensagem de canal/newsletter recebida (novo!)',
+                        },
+                        {
+                            name: 'Presence Update',
+                            value: 'PRESENCE_UPDATE',
+                            description: 'Status de presença (online, digitando)',
+                        },
+                        {
+                            name: 'QR Code Updated',
+                            value: 'QRCODE_UPDATED',
+                            description: 'QR Code atualizado',
+                        },
+                        {
+                            name: 'Send Message',
+                            value: 'SEND_MESSAGE',
+                            description: 'Mensagem enviada pela API',
+                        },
+                        {
+                            name: 'Typebot Change Status',
+                            value: 'TYPEBOT_CHANGE_STATUS',
+                            description: 'Status do Typebot alterado',
+                        },
+                        {
+                            name: 'Typebot Start',
+                            value: 'TYPEBOT_START',
+                            description: 'Typebot iniciado',
+                        },
+                    ],
+                },
+                {
+                    displayName: 'Options',
+                    name: 'options',
+                    type: 'collection',
+                    placeholder: 'Add Option',
+                    default: {},
+                    options: [
+                        {
+                            displayName: 'Ignore From Me',
+                            name: 'ignoreFromMe',
+                            type: 'boolean',
+                            default: false,
+                            description: 'Whether to ignore messages sent by yourself (fromMe: true). Useful to prevent loops when reposting.',
+                        },
+                        {
+                            displayName: 'Ignore Newsletters I Own',
+                            name: 'ignoreOwnNewsletters',
+                            type: 'boolean',
+                            default: true,
+                            description: 'Whether to ignore messages from newsletters where you are the owner/admin. Prevents loops when reposting.',
+                        },
+                        {
+                            displayName: 'Optimized Payload',
+                            name: 'optimizedPayload',
+                            type: 'boolean',
+                            default: true,
+                            description: 'Whether to remove raw data to reduce payload size (recommended). Keeps only processed fields.',
+                        },
+                        {
+                            displayName: 'Webhook Base64',
+                            name: 'webhookBase64',
+                            type: 'boolean',
+                            default: false,
+                            description: 'Whether to include media as base64 in the webhook payload',
+                        },
+                        {
+                            displayName: 'Webhook by Events',
+                            name: 'webhookByEvents',
+                            type: 'boolean',
+                            default: false,
+                            description: 'Whether to send each event to a separate webhook URL',
+                        },
+                    ],
+                },
+            ],
+        };
+        this.methods = {
+            loadOptions: {
+                getInstances: loadOptions_1.getInstances,
+            },
+        };
+        this.webhookMethods = {
+            default: {
+                async checkExists() {
+                    const webhookUrl = this.getNodeWebhookUrl('default');
+                    const instanceName = this.getNodeParameter('instanceName');
+                    const credentials = await this.getCredentials('evolutionApiV2Api');
+                    try {
+                        const response = await this.helpers.httpRequest({
+                            method: 'GET',
+                            url: `${credentials.serverUrl}/webhook/find/${instanceName}`,
+                            headers: {
+                                apikey: credentials.apiKey,
+                            },
+                            json: true,
+                        });
+                        if (response && response.webhook && response.webhook.url === webhookUrl) {
+                            return true;
+                        }
+                    }
+                    catch (error) {
+                    }
+                    return false;
+                },
+                async create() {
+                    const webhookUrl = this.getNodeWebhookUrl('default');
+                    const instanceName = this.getNodeParameter('instanceName');
+                    const events = this.getNodeParameter('events');
+                    const options = this.getNodeParameter('options');
+                    const credentials = await this.getCredentials('evolutionApiV2Api');
+                    const body = {
+                        webhook: {
+                            enabled: true,
+                            url: webhookUrl,
+                            webhookByEvents: options.webhookByEvents || false,
+                            webhookBase64: options.webhookBase64 || false,
+                            events,
+                        },
+                    };
+                    try {
+                        await this.helpers.httpRequest({
+                            method: 'POST',
+                            url: `${credentials.serverUrl}/webhook/set/${instanceName}`,
+                            headers: {
+                                apikey: credentials.apiKey,
+                                'Content-Type': 'application/json',
+                            },
+                            body,
+                            json: true,
+                        });
+                        return true;
+                    }
+                    catch (error) {
+                        return false;
+                    }
+                },
+                async delete() {
+                    const instanceName = this.getNodeParameter('instanceName');
+                    const credentials = await this.getCredentials('evolutionApiV2Api');
+                    try {
+                        await this.helpers.httpRequest({
+                            method: 'POST',
+                            url: `${credentials.serverUrl}/webhook/set/${instanceName}`,
+                            headers: {
+                                apikey: credentials.apiKey,
+                                'Content-Type': 'application/json',
+                            },
+                            body: {
+                                webhook: {
+                                    enabled: false,
+                                    url: '',
+                                    events: [],
+                                },
+                            },
+                            json: true,
+                        });
+                        return true;
+                    }
+                    catch (error) {
+                        return false;
+                    }
+                },
+            },
+        };
+    }
+    async webhook() {
+        const req = this.getRequestObject();
+        const res = this.getResponseObject();
+        const body = req.body;
+        const options = this.getNodeParameter('options', {});
+        const optimizedPayload = options.optimizedPayload !== false;
+        const ignoreFromMe = options.ignoreFromMe === true;
+        const ignoreOwnNewsletters = options.ignoreOwnNewsletters !== false;
+        const event = body.event;
+        const instance = body.instance;
+        const data = body.data;
+        if (data) {
+            const key = data.key;
+            if (key && key.id) {
+                const dedupeKey = `${instance}_${key.id}`;
+                if (messageDedupeCache.has(dedupeKey)) {
+                    res.status(200).json({ ignored: true, reason: 'duplicate message' });
+                    return { noWebhookResponse: true };
+                }
+                messageDedupeCache.set(dedupeKey, Date.now());
+            }
+        }
+        if (data) {
+            const key = data.key;
+            if (key) {
+                const isFromMe = key.fromMe === true || key.fromMe === 'true' || key.fromMe === 1;
+                const jid = key.remoteJid || '';
+                if (ignoreFromMe && isFromMe) {
+                    res.status(200).json({ ignored: true, reason: 'fromMe filter' });
+                    return { noWebhookResponse: true };
+                }
+                if (ignoreOwnNewsletters && jid.includes('@newsletter') && isFromMe) {
+                    res.status(200).json({ ignored: true, reason: 'ownNewsletter filter' });
+                    return { noWebhookResponse: true };
+                }
+            }
+        }
+        const processedData = processMessageData(data, event);
+        const returnData = {
+            event,
+            instance,
+            ...(optimizedPayload ? {} : { data }),
+            ...processedData,
+            receivedAt: new Date().toISOString(),
+            ...(body.sender && { sender: body.sender }),
+            ...(body.server_url && { serverUrl: body.server_url }),
+            ...(body.date_time && { dateTime: body.date_time }),
+            ...(body.apikey && { apikey: body.apikey }),
+        };
+        return {
+            workflowData: [this.helpers.returnJsonArray([returnData])],
+        };
+    }
+}
+exports.EvolutionApiTrigger = EvolutionApiTrigger;
+function processMessageData(data, event) {
+    const processed = {};
+    if (!data)
+        return processed;
+    const key = data.key;
+    const message = data.message;
+    if (key) {
+        processed.messageId = key.id;
+        processed.remoteJid = key.remoteJid;
+        processed.fromMe = key.fromMe;
+        processed.participant = key.participant;
+        const jid = key.remoteJid;
+        if (jid) {
+            if (jid.includes('@g.us')) {
+                processed.chatType = 'group';
+            }
+            else if (jid.includes('@newsletter')) {
+                processed.chatType = 'newsletter';
+            }
+            else if (jid.includes('@s.whatsapp.net')) {
+                processed.chatType = 'private';
+            }
+            else {
+                processed.chatType = 'unknown';
+            }
+        }
+    }
+    if (data.pushName) {
+        processed.senderName = data.pushName;
+    }
+    if (data.messageTimestamp) {
+        processed.timestamp = data.messageTimestamp;
+        processed.dateTime = new Date(Number(data.messageTimestamp) * 1000).toISOString();
+    }
+    if (data.messageType) {
+        processed.messageType = data.messageType;
+    }
+    if (!message)
+        return processed;
+    if (message.conversation) {
+        processed.text = message.conversation;
+        processed.hasText = true;
+    }
+    if (message.extendedTextMessage) {
+        const extMsg = message.extendedTextMessage;
+        processed.text = extMsg.text;
+        processed.hasText = true;
+        if (extMsg.matchedText || extMsg.canonicalUrl || extMsg.title) {
+            processed.hasLinkPreview = true;
+            processed.linkPreviewUrl = extMsg.matchedText || extMsg.canonicalUrl;
+            processed.linkPreviewTitle = extMsg.title;
+            processed.linkPreviewDescription = extMsg.description;
+            if (extMsg.jpegThumbnail) {
+                processed.linkPreviewThumbnail = convertThumbnailToBase64(extMsg.jpegThumbnail);
+            }
+            if (extMsg.thumbnailDirectPath) {
+                processed.linkPreviewThumbnailDirectPath = extMsg.thumbnailDirectPath;
+            }
+            if (extMsg.mediaKey) {
+                processed.linkPreviewMediaKey = convertThumbnailToBase64(extMsg.mediaKey);
+            }
+            if (extMsg.thumbnailWidth) {
+                processed.linkPreviewThumbnailWidth = extMsg.thumbnailWidth;
+            }
+            if (extMsg.thumbnailHeight) {
+                processed.linkPreviewThumbnailHeight = extMsg.thumbnailHeight;
+            }
+            if (extMsg.thumbnailSha256) {
+                processed.linkPreviewThumbnailSha256 = convertThumbnailToBase64(extMsg.thumbnailSha256);
+            }
+            if (extMsg.thumbnailEncSha256) {
+                processed.linkPreviewThumbnailEncSha256 = convertThumbnailToBase64(extMsg.thumbnailEncSha256);
+            }
+            if (extMsg.mediaKeyTimestamp) {
+                processed.linkPreviewMediaKeyTimestamp = extMsg.mediaKeyTimestamp;
+            }
+        }
+        if (extMsg.contextInfo) {
+            const ctx = extMsg.contextInfo;
+            if (ctx.quotedMessage) {
+                processed.quotedMessage = ctx.quotedMessage;
+                processed.quotedMessageId = ctx.stanzaId;
+                processed.hasQuotedMessage = true;
+            }
+            if (ctx.mentionedJid) {
+                processed.mentionedJids = ctx.mentionedJid;
+                processed.hasMentions = true;
+            }
+            if (!processed.linkPreviewMediaKey && ctx.mediaKey) {
+                processed.linkPreviewMediaKey = convertThumbnailToBase64(ctx.mediaKey);
+            }
+            if (!processed.linkPreviewThumbnailDirectPath && ctx.thumbnailDirectPath) {
+                processed.linkPreviewThumbnailDirectPath = ctx.thumbnailDirectPath;
+            }
+            if (!processed.linkPreviewThumbnailWidth && ctx.thumbnailWidth) {
+                processed.linkPreviewThumbnailWidth = ctx.thumbnailWidth;
+            }
+            if (!processed.linkPreviewThumbnailHeight && ctx.thumbnailHeight) {
+                processed.linkPreviewThumbnailHeight = ctx.thumbnailHeight;
+            }
+            if (!processed.linkPreviewThumbnailSha256 && ctx.thumbnailSha256) {
+                processed.linkPreviewThumbnailSha256 = convertThumbnailToBase64(ctx.thumbnailSha256);
+            }
+            if (!processed.linkPreviewThumbnailEncSha256 && ctx.thumbnailEncSha256) {
+                processed.linkPreviewThumbnailEncSha256 = convertThumbnailToBase64(ctx.thumbnailEncSha256);
+            }
+            if (!processed.linkPreviewMediaKeyTimestamp && ctx.mediaKeyTimestamp) {
+                processed.linkPreviewMediaKeyTimestamp = ctx.mediaKeyTimestamp;
+            }
+        }
+    }
+    if (message.linkPreview) {
+        const linkPreview = message.linkPreview;
+        processed.hasLinkPreview = true;
+        processed.linkPreviewUrl = linkPreview.url;
+        processed.linkPreviewTitle = linkPreview.title;
+        processed.linkPreviewDescription = linkPreview.description;
+        if (linkPreview.thumbnail) {
+            const thumb = linkPreview.thumbnail;
+            processed.linkPreviewThumbnail = thumb.startsWith('data:') ? thumb : `data:image/jpeg;base64,${thumb}`;
+        }
+        if (linkPreview.thumbnailDirectPath) {
+            processed.linkPreviewThumbnailDirectPath = linkPreview.thumbnailDirectPath;
+        }
+        if (linkPreview.mediaKey) {
+            processed.linkPreviewMediaKey = linkPreview.mediaKey;
+        }
+        if (linkPreview.thumbnailWidth) {
+            processed.linkPreviewThumbnailWidth = linkPreview.thumbnailWidth;
+        }
+        if (linkPreview.thumbnailHeight) {
+            processed.linkPreviewThumbnailHeight = linkPreview.thumbnailHeight;
+        }
+        if (linkPreview.thumbnailSha256) {
+            processed.linkPreviewThumbnailSha256 = linkPreview.thumbnailSha256;
+        }
+        if (linkPreview.thumbnailEncSha256) {
+            processed.linkPreviewThumbnailEncSha256 = linkPreview.thumbnailEncSha256;
+        }
+        if (linkPreview.mediaKeyTimestamp) {
+            processed.linkPreviewMediaKeyTimestamp = linkPreview.mediaKeyTimestamp;
+        }
+        if (linkPreview.imageS3Url) {
+            processed.linkPreviewImageS3Url = linkPreview.imageS3Url;
+        }
+        if (linkPreview.imageS3Key) {
+            processed.linkPreviewImageS3Key = linkPreview.imageS3Key;
+        }
+    }
+    if (message.imageMessage) {
+        const img = message.imageMessage;
+        processed.hasMedia = true;
+        processed.mediaType = 'image';
+        processed.caption = img.caption || '';
+        processed.mimetype = img.mimetype;
+        processed.mediaUrl = img.url;
+        processed.mediaWidth = img.width;
+        processed.mediaHeight = img.height;
+        if (img.fileLength) {
+            processed.mediaFileLength = typeof img.fileLength === 'object'
+                ? img.fileLength.low
+                : img.fileLength;
+        }
+        if (img.jpegThumbnail) {
+            processed.thumbnail = convertThumbnailToBase64(img.jpegThumbnail);
+            processed.hasThumbnail = true;
+        }
+    }
+    if (message.videoMessage) {
+        const vid = message.videoMessage;
+        processed.hasMedia = true;
+        processed.mediaType = 'video';
+        processed.caption = vid.caption || '';
+        processed.mimetype = vid.mimetype;
+        processed.mediaUrl = vid.url;
+        processed.mediaWidth = vid.width;
+        processed.mediaHeight = vid.height;
+        processed.mediaDuration = vid.seconds;
+        processed.isGif = vid.gifPlayback || false;
+        if (vid.fileLength) {
+            processed.mediaFileLength = typeof vid.fileLength === 'object'
+                ? vid.fileLength.low
+                : vid.fileLength;
+        }
+        if (vid.jpegThumbnail) {
+            processed.thumbnail = convertThumbnailToBase64(vid.jpegThumbnail);
+            processed.hasThumbnail = true;
+        }
+    }
+    if (message.audioMessage) {
+        const aud = message.audioMessage;
+        processed.hasMedia = true;
+        processed.mediaType = 'audio';
+        processed.mimetype = aud.mimetype;
+        processed.mediaUrl = aud.url;
+        processed.mediaDuration = aud.seconds;
+        processed.isVoiceNote = aud.ptt || false;
+        if (aud.fileLength) {
+            processed.mediaFileLength = typeof aud.fileLength === 'object'
+                ? aud.fileLength.low
+                : aud.fileLength;
+        }
+    }
+    if (message.documentMessage) {
+        const doc = message.documentMessage;
+        processed.hasMedia = true;
+        processed.mediaType = 'document';
+        processed.caption = doc.caption || '';
+        processed.fileName = doc.fileName;
+        processed.mimetype = doc.mimetype;
+        processed.mediaUrl = doc.url;
+        processed.pageCount = doc.pageCount;
+        if (doc.fileLength) {
+            processed.mediaFileLength = typeof doc.fileLength === 'object'
+                ? doc.fileLength.low
+                : doc.fileLength;
+        }
+        if (doc.jpegThumbnail) {
+            processed.thumbnail = convertThumbnailToBase64(doc.jpegThumbnail);
+            processed.hasThumbnail = true;
+        }
+    }
+    if (message.stickerMessage) {
+        const stk = message.stickerMessage;
+        processed.hasMedia = true;
+        processed.mediaType = 'sticker';
+        processed.mimetype = stk.mimetype;
+        processed.mediaUrl = stk.url;
+        processed.mediaWidth = stk.width;
+        processed.mediaHeight = stk.height;
+        processed.isAnimated = stk.isAnimated || false;
+        if (stk.fileLength) {
+            processed.mediaFileLength = typeof stk.fileLength === 'object'
+                ? stk.fileLength.low
+                : stk.fileLength;
+        }
+    }
+    if (message.locationMessage) {
+        const loc = message.locationMessage;
+        processed.hasLocation = true;
+        processed.latitude = loc.degreesLatitude;
+        processed.longitude = loc.degreesLongitude;
+        processed.locationName = loc.name;
+        processed.locationAddress = loc.address;
+        processed.locationUrl = loc.url;
+        if (loc.jpegThumbnail) {
+            processed.thumbnail = convertThumbnailToBase64(loc.jpegThumbnail);
+            processed.hasThumbnail = true;
+        }
+    }
+    if (message.liveLocationMessage) {
+        const loc = message.liveLocationMessage;
+        processed.hasLocation = true;
+        processed.isLiveLocation = true;
+        processed.latitude = loc.degreesLatitude;
+        processed.longitude = loc.degreesLongitude;
+        processed.locationAccuracy = loc.accuracyInMeters;
+        processed.locationSpeed = loc.speedInMps;
+        processed.locationSequenceNumber = loc.sequenceNumber;
+    }
+    if (message.contactMessage) {
+        const contact = message.contactMessage;
+        processed.hasContact = true;
+        processed.contactName = contact.displayName;
+        processed.contactVcard = contact.vcard;
+        const vcard = contact.vcard;
+        if (vcard) {
+            const telMatch = vcard.match(/TEL[^:]*:([^\n]+)/);
+            if (telMatch) {
+                processed.contactPhone = telMatch[1].replace(/\D/g, '');
+            }
+        }
+    }
+    if (message.contactsArrayMessage) {
+        const contacts = message.contactsArrayMessage;
+        processed.hasContacts = true;
+        processed.contactsDisplayName = contacts.displayName;
+        processed.contacts = contacts.contacts;
+    }
+    const pollMsg = message.pollCreationMessage || message.pollCreationMessageV2 || message.pollCreationMessageV3 || message.pollCreationMessageV4 || message.pollCreationMessageV5;
+    if (pollMsg) {
+        const poll = pollMsg;
+        processed.hasPoll = true;
+        processed.pollQuestion = poll.name;
+        processed.pollOptions = poll.options;
+        processed.pollSelectableCount = poll.selectableOptionsCount;
+        if (Array.isArray(poll.options)) {
+            processed.pollOptionsText = poll.options.map(opt => opt.optionName || opt.name || opt.text).filter(Boolean);
+        }
+    }
+    if (message.questionMessage) {
+        const question = message.questionMessage;
+        if (Array.isArray(question.options) && question.options.length > 0) {
+            processed.hasPoll = true;
+            processed.isQuestion = true;
+            processed.pollQuestion = question.question || question.name;
+            processed.pollOptions = question.options;
+            processed.pollSelectableCount = question.selectableOptionsCount || 1;
+            processed.pollOptionsText = question.options.map(opt => opt.optionName || opt.name || opt.text).filter(Boolean);
+        }
+        else if (question.message) {
+            const innerMsg = question.message;
+            const extendedText = innerMsg.extendedTextMessage;
+            if (extendedText) {
+                processed.isQuestion = true;
+                processed.questionText = extendedText.text;
+                if (!processed.text) {
+                    processed.text = extendedText.text;
+                }
+            }
+        }
+    }
+    if (message.pollUpdateMessage) {
+        const pollUpdate = message.pollUpdateMessage;
+        processed.isPollUpdate = true;
+        processed.pollUpdateVote = pollUpdate.vote;
+        processed.pollUpdateMessageKey = pollUpdate.pollCreationMessageKey;
+    }
+    if (message.buttonsMessage) {
+        const btns = message.buttonsMessage;
+        processed.hasButtons = true;
+        processed.buttonsText = btns.contentText;
+        processed.buttonsFooter = btns.footerText;
+        processed.buttons = btns.buttons;
+    }
+    if (message.buttonsResponseMessage) {
+        const resp = message.buttonsResponseMessage;
+        processed.isButtonResponse = true;
+        processed.buttonSelectedId = resp.selectedButtonId;
+        processed.buttonSelectedText = resp.selectedDisplayText;
+    }
+    if (message.listMessage) {
+        const list = message.listMessage;
+        processed.hasList = true;
+        processed.listTitle = list.title;
+        processed.listDescription = list.description;
+        processed.listButtonText = list.buttonText;
+        processed.listFooter = list.footerText;
+        processed.listSections = list.sections;
+    }
+    if (message.listResponseMessage) {
+        const resp = message.listResponseMessage;
+        processed.isListResponse = true;
+        processed.listSelectedTitle = resp.title;
+        processed.listSelectedDescription = resp.description;
+        processed.listSelectedRowId = resp.singleSelectReply
+            ? resp.singleSelectReply.selectedRowId
+            : resp.selectedRowId;
+    }
+    if (message.templateButtonReplyMessage) {
+        const tmpl = message.templateButtonReplyMessage;
+        processed.isTemplateResponse = true;
+        processed.templateSelectedId = tmpl.selectedId;
+        processed.templateSelectedText = tmpl.selectedDisplayText;
+        processed.templateSelectedIndex = tmpl.selectedIndex;
+    }
+    if (message.reactionMessage) {
+        const react = message.reactionMessage;
+        processed.isReaction = true;
+        processed.reactionEmoji = react.text;
+        processed.reactionTargetKey = react.key;
+        processed.reactionTimestamp = react.senderTimestampMs;
+    }
+    if (message.editedMessage || message.protocolMessage) {
+        const proto = message.protocolMessage;
+        if (proto && proto.type === 14) {
+            processed.isEdited = true;
+            processed.editedMessageId = proto.key ? proto.key.id : undefined;
+            if (proto.editedMessage) {
+                const edited = proto.editedMessage;
+                if (edited.conversation) {
+                    processed.text = edited.conversation;
+                    processed.hasText = true;
+                }
+                else if (edited.extendedTextMessage) {
+                    processed.text = edited.extendedTextMessage.text;
+                    processed.hasText = true;
+                }
+            }
+        }
+    }
+    if (message.protocolMessage) {
+        const proto = message.protocolMessage;
+        if (proto.type === 0) {
+            processed.isDeleted = true;
+            processed.deletedMessageId = proto.key ? proto.key.id : undefined;
+        }
+    }
+    if (event === 'newsletter.message' || event === 'NEWSLETTER_MESSAGE') {
+        processed.isNewsletter = true;
+        const jid = key === null || key === void 0 ? void 0 : key.remoteJid;
+        if (jid && jid.includes('@newsletter')) {
+            processed.newsletterId = jid.replace('@newsletter', '');
+        }
+    }
+    if (data.participant) {
+        processed.isGroup = true;
+        processed.participantJid = data.participant;
+    }
+    const messageObj = data.message;
+    if (messageObj === null || messageObj === void 0 ? void 0 : messageObj.mediaS3Url) {
+        processed.mediaS3Url = messageObj.mediaS3Url;
+        processed.mediaS3Key = messageObj.mediaS3Key;
+        processed.hasS3Media = true;
+    }
+    if (!processed.mediaUrl && (messageObj === null || messageObj === void 0 ? void 0 : messageObj.mediaUrl)) {
+        processed.mediaUrl = messageObj.mediaUrl;
+    }
+    if (messageObj === null || messageObj === void 0 ? void 0 : messageObj.base64) {
+        processed.mediaBase64 = messageObj.base64;
+        processed.hasBase64 = true;
+    }
+    else if (data.base64) {
+        processed.mediaBase64 = data.base64;
+        processed.hasBase64 = true;
+    }
+    return processed;
+}
+function convertThumbnailToBase64(thumbnail) {
+    if (!thumbnail)
+        return '';
+    if (typeof thumbnail === 'string') {
+        if (!thumbnail.startsWith('data:')) {
+            return `data:image/jpeg;base64,${thumbnail}`;
+        }
+        return thumbnail;
+    }
+    if (typeof thumbnail === 'object' && thumbnail !== null) {
+        try {
+            const obj = thumbnail;
+            if (obj.type === 'Buffer' && Array.isArray(obj.data)) {
+                const buffer = Buffer.from(obj.data);
+                return `data:image/jpeg;base64,${buffer.toString('base64')}`;
+            }
+            const numericObj = obj;
+            const keys = Object.keys(numericObj).filter((k) => !isNaN(Number(k))).sort((a, b) => Number(a) - Number(b));
+            const bytes = [];
+            for (const key of keys) {
+                const val = numericObj[key];
+                if (typeof val === 'number') {
+                    bytes.push(val);
+                }
+            }
+            if (bytes.length > 0) {
+                const buffer = Buffer.from(bytes);
+                return `data:image/jpeg;base64,${buffer.toString('base64')}`;
+            }
+        }
+        catch {
+        }
+    }
+    return '';
+}
+//# sourceMappingURL=EvolutionApiTrigger.node.js.map