@arcaelas/whatsapp 4.5.0 → 6.0.0

package/build/esm/lib/message/index.js

@@ -1,28 +1,26 @@
 /**
  * @file message/index.ts
- * @description Entidad Message — una sola clase base que recibe `{wa, doc}` en el constructor.
- * Subclases especializadas (Text, Image, Video, Audio, Gps, Poll) override `content()` según su tipo.
+ * @description Entidad Message — clase base con getters puros y subclases por tipo
+ * (Text, Image, Video, Audio, Sticker, Document, Location, Poll, VCard, Event);
+ * `message(wa, raw)` evalúa el tipo y retorna la instancia correcta.
+ * Message entity — pure-getter base class with per-type subclasses;
+ * `message(wa, raw)` evaluates the type and returns the right instance.
  */
 import { aesEncryptGCM, downloadMediaMessage, generateForwardMessageContent, generateMessageID, generateWAMessageFromContent, getAggregateVotesInPollMessage, getContentType, getKeyAuthor, hmacSign, jidNormalizedUser, proto, sha256, updateMessageWithPollUpdate, } from 'baileys';
 import { randomBytes } from 'node:crypto';
 import { Readable } from 'node:stream';
+import { internals } from '../../lib/internal.js';
 import { Chat } from '../../lib/chat/index.js';
 import { deserialize, serialize } from '../../lib/store/index.js';
-export var MessageStatus;
-(function (MessageStatus) {
-    MessageStatus[MessageStatus["ERROR"] = 0] = "ERROR";
-    MessageStatus[MessageStatus["PENDING"] = 1] = "PENDING";
-    MessageStatus[MessageStatus["SERVER_ACK"] = 2] = "SERVER_ACK";
-    MessageStatus[MessageStatus["DELIVERED"] = 3] = "DELIVERED";
-    MessageStatus[MessageStatus["READ"] = 4] = "READ";
-    MessageStatus[MessageStatus["PLAYED"] = 5] = "PLAYED";
-})(MessageStatus || (MessageStatus = {}));
+/** Estados legibles indexados por el status numérico de baileys. / Readable states indexed by the baileys numeric status. */
+const STATUS = ['error', 'pending', 'sent', 'delivered', 'read', 'played'];
 const MESSAGE_TYPE_MAP = {
     conversation: 'text',
     extendedTextMessage: 'text',
     imageMessage: 'image',
     videoMessage: 'video',
     audioMessage: 'audio',
+    stickerMessage: 'sticker',
     locationMessage: 'location',
     liveLocationMessage: 'location',
     pollCreationMessage: 'poll',
@@ -35,292 +33,441 @@ const MESSAGE_TYPE_MAP = {
     eventMessage: 'event',
 };
 /**
- * Construye el documento IMessage desde el raw de baileys.
+ * Desenvuelve los wrappers de contenido (view-once, documento con caption).
+ * Unwraps content wrappers (view-once, captioned document).
  */
-export function build_message_doc(raw, self_id, edited = false) {
-    const key = raw.key ?? {};
-    const msg = raw.message ?? {};
-    const unwrapped = msg.viewOnceMessage?.message ??
+function unwrap(msg) {
+    return (msg.viewOnceMessage?.message ??
         msg.viewOnceMessageV2?.message ??
         msg.viewOnceMessageV2Extension?.message ??
         msg.documentWithCaptionMessage?.message ??
-        msg;
-    const content_type = getContentType(unwrapped);
-    const msg_type = MESSAGE_TYPE_MAP[content_type ?? ''] ?? 'text';
-    const msg_content = unwrapped[content_type];
-    const context_info = msg_content
-        ?.contextInfo;
-    const ephemeral_duration = raw.ephemeralDuration ?? context_info?.expiration;
-    const deleted_at = raw.ephemeralStartTimestamp != null && ephemeral_duration != null
-        ? (Number(raw.ephemeralStartTimestamp) + ephemeral_duration) * 1000
-        : null;
-    let mime = 'text/plain';
-    if (msg_type === 'location' || msg_type === 'poll' || msg_type === 'event') {
-        mime = 'application/json';
-    }
-    else if (msg_type === 'vcard') {
-        mime = 'text/vcard';
-    }
-    else if (msg_type !== 'text' && typeof msg_content === 'object') {
-        mime = msg_content?.mimetype ?? 'application/octet-stream';
-    }
-    let caption = '';
-    if (typeof msg_content === 'string') {
-        caption = msg_content;
-    }
-    else if (msg_type === 'event') {
-        caption = msg_content?.description ?? '';
-    }
-    else if (msg_content) {
-        caption =
-            msg_content.caption ??
-                msg_content.text ??
-                msg_content.name ??
-                msg_content.displayName ??
-                '';
-    }
-    const author = key.fromMe && self_id
-        ? jidNormalizedUser(self_id)
-        : key.participant || key.remoteJidAlt || key.remoteJid || '';
-    return {
-        id: key.id ?? '',
-        cid: key.remoteJidAlt ?? key.remoteJid ?? '',
-        mid: context_info?.stanzaId ?? null,
-        me: key.fromMe ?? false,
-        type: msg_type,
-        author,
-        status: raw.status ?? MessageStatus.PENDING,
-        starred: raw.starred ?? false,
-        forwarded: context_info?.isForwarded ?? false,
-        created_at: (Number(raw.messageTimestamp) || Math.floor(Date.now() / 1000)) * 1000,
-        deleted_at,
-        mime,
-        caption,
-        edited,
-        raw,
-    };
+        msg);
+}
+/**
+ * Convierte un número o Long del proto a number plano.
+ * Converts a proto number or Long into a plain number.
+ */
+function to_number(value) {
+    return Number(value?.toString() ?? 0);
+}
+/**
+ * Convierte los bytes del proto (Uint8Array runtime o base64 post-engine) a Buffer.
+ * Converts proto bytes (runtime Uint8Array or post-engine base64) into a Buffer.
+ */
+function to_buffer(value) {
+    if (value instanceof Uint8Array && value.length > 0)
+        return Buffer.from(value);
+    if (typeof value === 'string' && value.length > 0)
+        return Buffer.from(value, 'base64');
+    return null;
+}
+/**
+ * Envío base: resuelve el destino, cita si hay `mid`, marca view-once, persiste el doc
+ * (con su binario cuando aplica) y retorna la instancia del mensaje enviado.
+ * Base send: resolves the target, quotes when `mid` is given, flags view-once, persists
+ * the doc (with its binary when it applies) and returns the sent message instance.
+ */
+async function send(wa, cid, content, binary, extra = {}, doc_overrides) {
+    let result = null;
+    const jid = await internals(wa).resolve_jid(cid);
+    const socket = internals(wa).socket;
+    if (jid && socket) {
+        const quoted = extra.mid
+            ? (deserialize(await wa.engine.get(`/chat/${jid}/message/${extra.mid}`))?.raw ?? undefined)
+            : undefined;
+        const raw = await socket.sendMessage(jid, {
+            ...content,
+            ...(extra.once && { viewOnce: true }),
+            ...(quoted && { quoted }),
+        });
+        const sent_id = raw?.key?.id;
+        if (raw && sent_id) {
+            const instance = message(wa, raw);
+            if (doc_overrides) {
+                Object.assign(instance._raw, doc_overrides);
+            }
+            await wa.engine.set(`/chat/${jid}/message/${sent_id}`, serialize(instance._raw), instance._raw.created_at);
+            if (binary) {
+                await write_content(wa, `/chat/${jid}/message/${sent_id}/content`, binary);
+            }
+            result = instance;
+        }
+    }
+    return result;
+}
+/**
+ * Binario persistido de un documento: primero el crudo del engine y, si el driver no soporta
+ * binarios o el dato viene de una sesión anterior, el documento JSON con base64.
+ * A document's persisted binary: the engine's raw one first and, when the driver lacks binary
+ * support or the data comes from an older session, the base64 JSON document.
+ *
+ * @param wa - Cliente dueño / Owner client
+ * @param path - Ruta del contenido / Content path
+ * @returns Binario o null / Binary or null
+ */
+async function read_content(wa, path) {
+    const raw = await wa.engine.get_buffer?.(path);
+    if (raw?.length) {
+        return raw;
+    }
+    const legacy = deserialize(await wa.engine.get(path));
+    return legacy?.data ? Buffer.from(legacy.data, 'base64') : null;
+}
+/**
+ * Persiste el binario de un documento: crudo cuando el driver lo soporta, JSON con base64
+ * en caso contrario.
+ * Persists a document's binary: raw when the driver supports it, base64 JSON otherwise.
+ *
+ * @param wa - Cliente dueño / Owner client
+ * @param path - Ruta del contenido / Content path
+ * @param data - Binario a guardar / Binary to store
+ */
+async function write_content(wa, path, data) {
+    if (wa.engine.set_buffer) {
+        await wa.engine.set_buffer(path, data);
+    }
+    else {
+        await wa.engine.set(path, serialize({ data: data.toString('base64') }));
+    }
 }
 /**
- * Clase base del mensaje. Una sola clase — toda la API de instancia vive aquí.
- * Base message class. Single class — all instance API lives here.
+ * Stream del binario del mensaje: cache del engine o descarga de baileys.
+ * Message binary stream: engine cache or baileys download.
+ */
+async function media_stream(wa, doc) {
+    const cached = await read_content(wa, `/chat/${doc.cid}/message/${doc.id}/content`);
+    if (cached) {
+        return Readable.from(cached);
+    }
+    const socket = internals(wa).socket;
+    if (socket) {
+        try {
+            return (await downloadMediaMessage(doc.raw, 'stream', {}));
+        }
+        catch {
+            /* media may be expired */
+        }
+    }
+    return Readable.from(Buffer.alloc(0));
+}
+/**
+ * Acumula un Readable en Buffer.
+ * Drains a Readable into a Buffer.
+ */
+async function drain(readable) {
+    const chunks = [];
+    for await (const chunk of readable) {
+        chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+    }
+    return Buffer.concat(chunks);
+}
+/**
+ * Clase base del mensaje: recibe el cliente y el raw, deriva el estado con getters y
+ * opera contra WhatsApp con sus métodos. Los estáticos reciben el cliente como primer
+ * argumento (`Message.text(wa, cid, …)`).
+ * Base message class: receives the client and the raw, derives state via getters and
+ * operates against WhatsApp with its methods. Statics take the client as their first
+ * argument (`Message.text(wa, cid, …)`).
  */
 export class Message {
-    constructor(options) {
-        /** @internal Cache de la promesa de `author()` para evitar engine round-trips repetidos. */
-        this._author_cache = null;
-        /** @internal Cache de la promesa de `chat()` para evitar engine round-trips repetidos. */
-        this._chat_cache = null;
-        this._wa = options.wa;
-        this._doc = options.doc;
+    /**
+     * @internal Cliente dueño y documento persistido. `status`, `created_at` y
+     * `deleted_at` guardan los valores numéricos del protocolo; los getters los
+     * presentan legibles. `viewed` existe únicamente en los status broadcast (Feed).
+     * Owner client and persisted document. `status`, `created_at` and `deleted_at`
+     * keep the protocol numeric values; getters expose them readable. `viewed` only
+     * exists on status broadcasts (Feed).
+     */
+    constructor(_wa, _raw) {
+        this._wa = _wa;
+        this._raw = _raw;
     }
+    /** Identificador del mensaje. / Message identifier. */
     get id() {
-        return this._doc.id;
+        return this._raw.id;
     }
+    /** Identificador del chat del mensaje. / Message chat identifier. */
     get cid() {
-        return this._doc.cid;
+        return this._raw.cid;
     }
-    get type() {
-        return this._doc.type;
+    /** Identificador del mensaje citado, o null. / Quoted message identifier, or null. */
+    get mid() {
+        return this._raw.mid;
     }
-    /** JID del autor del mensaje. Para acceso síncrono sin hidratar el Contact. */
+    /** JID del autor, para acceso síncrono. / Author JID, for sync access. */
     get from() {
-        return this._doc.author;
-    }
-    /** MIME type del contenido. `text/plain` para texto, `application/json` para location/poll, mimetype real para media. */
-    get mime() {
-        return this._doc.mime;
-    }
-    get mid() {
-        return this._doc.mid;
+        return this._raw.author;
     }
+    /** true si soy el autor. / true when I am the author. */
     get me() {
-        return this._doc.me;
+        return this._raw.me;
     }
+    /** Tipo del mensaje. / Message type. */
+    get type() {
+        return this._raw.type;
+    }
+    /** MIME: text/plain en texto, text/json en poll/location/vcard/event, real en media. / MIME: text/plain for text, text/json for poll/location/vcard/event, actual for media. */
+    get mime() {
+        const { type } = this._raw;
+        if (type === 'text')
+            return 'text/plain';
+        if (type === 'poll' || type === 'location' || type === 'vcard' || type === 'event')
+            return 'text/json';
+        return this._raw.mime;
+    }
+    /** Texto del mensaje o caption del media. / Message text or media caption. */
     get caption() {
-        return this._doc.caption;
+        return this._raw.caption;
     }
+    /** Estado legible del mensaje. / Readable message state. */
+    get status() {
+        return STATUS[this._raw.status] ?? 'pending';
+    }
+    /** true si el mensaje fue visto. / true when the message was seen. */
+    get read() {
+        return this._raw.status >= 4;
+    }
+    /** true si está destacado. / true when starred. */
     get starred() {
-        return this._doc.starred;
+        return this._raw.starred;
     }
+    /** true si fue reenviado. / true when forwarded. */
     get forwarded() {
-        return this._doc.forwarded;
+        return this._raw.forwarded;
     }
+    /** true si fue editado. / true when edited. */
+    get edited() {
+        return this._raw.edited;
+    }
+    /** true si es de una sola lectura (view-once). / true when view-once. */
     get once() {
-        return this._doc.deleted_at !== null;
+        const msg = this._raw.raw.message;
+        return Boolean(msg?.viewOnceMessage ?? msg?.viewOnceMessageV2 ?? msg?.viewOnceMessageV2Extension);
     }
+    /** Fecha de creación en ISO UTC. / Creation date as ISO UTC. */
     get created_at() {
-        return this._doc.created_at;
+        return new Date(this._raw.created_at).toISOString();
     }
-    get deleted_at() {
-        return this._doc.deleted_at;
-    }
-    get status() {
-        return this._doc.status;
-    }
-    get edited() {
-        return this._doc.edited;
+    /** Vencimiento del mensaje temporal en ISO UTC, o null. / Ephemeral expiration as ISO UTC, or null. */
+    get expires_at() {
+        return this._raw.deleted_at != null ? new Date(this._raw.deleted_at).toISOString() : null;
     }
     /**
-     * Contacto del autor (resuelve vía `wa.Contact.get`; fallback a instancia mínima).
-     * Memoizado por instancia: la primera llamada va al engine; las siguientes
-     * reutilizan la misma promesa sin nuevos round-trips.
-     * Author contact (resolves via `wa.Contact.get`; falls back to a minimal instance).
-     * Instance-memoized: first call hits the engine; subsequent calls reuse the
-     * same promise without further round-trips.
+     * Contacto autor del mensaje, desde el engine (ficha mínima si no está persistido).
+     * Message author contact, from the engine (minimal card when not persisted).
+     *
+     * @returns Contacto / Contact
      */
     async author() {
-        return (this._author_cache ??= (async () => {
-            const { _wa, _doc } = this;
-            const fetched = _doc.author ? await _wa.Contact.get(_doc.author) : null;
-            return (fetched ??
-                new _wa.Contact({
-                    id: _doc.author,
-                    lid: null,
-                    name: null,
-                    notify: null,
-                    verified_name: null,
-                    img_url: null,
-                    status: null,
-                }, new _wa.Chat({ id: _doc.author, name: _doc.author.split('@')[0] })));
-        })());
+        const cached = deserialize(await this._wa.engine.get(`/contact/${this._raw.author}`));
+        return new this._wa.Contact(cached ?? { id: this._raw.author });
     }
     /**
-     * Chat al que pertenece el mensaje. Memoizado por instancia: la primera llamada
-     * va al engine; las siguientes reutilizan la misma promesa.
-     * Chat the message belongs to. Instance-memoized: first call hits the engine;
-     * subsequent calls reuse the same promise.
+     * Chat al que pertenece el mensaje.
+     * Chat the message belongs to.
+     *
+     * @returns Chat / Chat
      */
     async chat() {
-        return (this._chat_cache ??= (async () => {
-            const cached = deserialize(await this._wa.engine.get(`/chat/${this._doc.cid}`));
-            return new this._wa.Chat(cached ?? { id: this._doc.cid, name: this._doc.cid.split('@')[0] });
-        })());
+        const cached = deserialize(await this._wa.engine.get(`/chat/${this._raw.cid}`));
+        return new this._wa.Chat(cached ?? { id: this._raw.cid });
+    }
+    /**
+     * Mensaje citado cuando hay `mid`, o null.
+     * Quoted message when `mid` exists, or null.
+     *
+     * @returns Mensaje citado o null / Quoted message or null
+     */
+    async message() {
+        return this._raw.mid ? Message.get(this._wa, this._raw.cid, this._raw.mid) : null;
     }
-    /** Contenido sin parsear, directo del engine. Las subclases override según su tipo. */
+    /**
+     * Contenido del mensaje: texto como su caption, media como binario, y
+     * poll/location/vcard/event como JSON.
+     * Message content: text as its caption, media as binary, and
+     * poll/location/vcard/event as JSON.
+     *
+     * @returns Buffer del contenido / Content buffer
+     */
     async content() {
-        const cached = deserialize(await this._wa.engine.get(`/chat/${this._doc.cid}/message/${this._doc.id}/content`));
-        return cached?.data ? Buffer.from(cached.data, 'base64') : Buffer.alloc(0);
+        return (await read_content(this._wa, `/chat/${this._raw.cid}/message/${this._raw.id}/content`)) ?? Buffer.alloc(0);
     }
     /**
-     * Devuelve un `Readable` con los bytes del mensaje. Para media (image/video/audio)
-     * lee desde el cache del engine o, si falta, descarga desde baileys. Para text/location/poll
-     * retorna el mismo binario que `content()` envuelto en un Readable.
-     * Returns a `Readable` of the message bytes. For media (image/video/audio) it reads
-     * from the engine cache or, if missing, downloads from baileys. For text/location/poll
-     * it wraps the `content()` buffer in a Readable.
+     * Stream del contenido; para media descarga de baileys si el cache falta.
+     * Content stream; media falls back to a baileys download when the cache is missing.
+     *
+     * @returns Readable del contenido / Content readable
      */
     async stream() {
-        return _media_stream(this);
+        return media_stream(this._wa, this._raw);
     }
-    /** Reacciona al mensaje (emoji vacío para retirar). */
+    /**
+     * Reacciones del mensaje agrupadas por emoji con su conteo.
+     * Message reactions grouped by emoji with their count.
+     *
+     * @returns Conteo por emoji / Per-emoji count
+     */
+    async reactions() {
+        const counts = new Map();
+        for (const { emoji } of this._raw.reactions ?? []) {
+            counts.set(emoji, (counts.get(emoji) ?? 0) + 1);
+        }
+        return [...counts.entries()].map(([emoji, count]) => ({ emoji, count }));
+    }
+    /**
+     * Reacciona al mensaje; el emoji vacío retira la reacción.
+     * Reacts to the message; an empty emoji removes the reaction.
+     *
+     * @param emoji - Emoji o '' / Emoji or ''
+     * @returns true si se envió / true when sent
+     */
     async react(emoji) {
-        const { _wa, _doc } = this;
         let ok = false;
-        if (_wa._socket) {
-            await _wa._socket.sendMessage(_doc.cid, {
-                react: { text: emoji, key: { remoteJid: _doc.cid, id: _doc.id, fromMe: _doc.me } },
+        const socket = internals(this._wa).socket;
+        if (socket) {
+            const { cid, id, me, author } = this._raw;
+            await socket.sendMessage(cid, {
+                react: {
+                    text: emoji,
+                    key: { remoteJid: cid, id, fromMe: me, ...(cid.endsWith('@g.us') && !me && { participant: author }) },
+                },
             });
             ok = true;
         }
         return ok;
     }
-    /** Reenvía el mensaje a un destino (CID, Chat o Contact). */
-    async forward(target) {
-        const { _wa, _doc } = this;
-        const to_cid = typeof target === 'string'
-            ? target
-            : target instanceof Chat
-                ? target.id
-                : (await target.chat()).id;
+    /**
+     * Destaca o quita el destacado del mensaje.
+     * Stars or unstars the message.
+     *
+     * @param value - true destaca / true stars
+     * @returns true si se envió / true when sent
+     */
+    async star(value) {
         let ok = false;
-        if (_wa._socket) {
-            const jid = await _wa._resolve_jid(to_cid);
-            if (jid) {
-                if (_doc.raw.message) {
-                    try {
-                        const wa_msg = generateWAMessageFromContent(jid, generateForwardMessageContent(_doc.raw, false), { userJid: _wa._socket.user?.id ?? '' });
-                        if (wa_msg.message && wa_msg.key?.id) {
-                            await _wa._socket.relayMessage(jid, wa_msg.message, { messageId: wa_msg.key.id });
-                            ok = true;
-                        }
-                    }
-                    catch {
-                        /* fallback below */
-                    }
-                }
-                if (!ok) {
-                    const buf = await this.content();
-                    if (buf.length > 0) {
-                        if (_doc.type === 'text') {
-                            ok = (await _wa.Message.text(jid, buf.toString())) !== null;
-                        }
-                        else if (_doc.type === 'image') {
-                            ok =
-                                (await _wa.Message.image(jid, buf, { caption: _doc.caption || undefined })) !==
-                                    null;
-                        }
-                        else if (_doc.type === 'video') {
-                            ok =
-                                (await _wa.Message.video(jid, buf, { caption: _doc.caption || undefined })) !==
-                                    null;
-                        }
-                        else if (_doc.type === 'audio') {
-                            ok = (await _wa.Message.audio(jid, buf)) !== null;
-                        }
-                        else if (_doc.type === 'location') {
-                            try {
-                                ok =
-                                    (await _wa.Message.location(jid, JSON.parse(buf.toString()))) !== null;
-                            }
-                            catch {
-                                /* invalid payload */
-                            }
-                        }
-                    }
-                }
-            }
+        const socket = internals(this._wa).socket;
+        if (socket) {
+            const doc = this._raw;
+            await socket.chatModify({ star: { messages: [{ id: doc.id, fromMe: doc.me }], star: value } }, doc.cid);
+            doc.starred = value;
+            await this._wa.engine.set(`/chat/${doc.cid}/message/${doc.id}`, serialize(doc), doc.created_at);
+            ok = true;
         }
         return ok;
     }
-    /** Marca el mensaje como leído. */
+    /**
+     * Marca el mensaje como leído.
+     * Marks the message as read.
+     *
+     * @returns true si se envió / true when sent
+     */
     async seen() {
-        const { _wa, _doc } = this;
         let ok = false;
-        if (_wa._socket) {
-            const is_group = _doc.cid.endsWith('@g.us');
-            await _wa._socket.readMessages([
-                { remoteJid: _doc.cid, id: _doc.id, participant: is_group ? _doc.author : undefined },
+        const socket = internals(this._wa).socket;
+        if (socket) {
+            const { cid, id, author } = this._raw;
+            await socket.readMessages([
+                { remoteJid: cid, id, participant: cid.endsWith('@g.us') ? author : undefined },
             ]);
             ok = true;
         }
         return ok;
     }
-    /** Destaca/retira destacado del mensaje. */
-    async star(value) {
-        const { _wa: wa, _doc: doc } = this;
+    /**
+     * Edita el caption del mensaje propio (texto, imagen o video).
+     * Edits the own message caption (text, image or video).
+     *
+     * @param caption - Texto nuevo / New text
+     * @returns true si se editó / true when edited
+     */
+    async edit(caption) {
+        const doc = this._raw;
         let ok = false;
-        if (wa._socket) {
-            await wa._socket.chatModify({
-                star: { messages: [{ id: doc.id, fromMe: doc.me }], star: value },
-            }, doc.cid);
-            doc.starred = value;
-            await wa.engine.set(`/chat/${doc.cid}/message/${doc.id}`, serialize(doc));
-            ok = true;
+        const socket = internals(this._wa).socket;
+        if (socket && doc.me) {
+            if (doc.type === 'text') {
+                await socket.sendMessage(doc.cid, {
+                    text: caption,
+                    edit: { remoteJid: doc.cid, id: doc.id, fromMe: true },
+                });
+                const content_type = getContentType(doc.raw.message ?? {});
+                doc.raw.message =
+                    content_type === 'conversation' ? { conversation: caption } : { extendedTextMessage: { text: caption } };
+                ok = true;
+            }
+            else if (doc.type === 'image' || doc.type === 'video') {
+                const media_key = doc.type === 'image' ? 'imageMessage' : 'videoMessage';
+                const media = doc.raw.message?.[media_key];
+                if (media) {
+                    const edited = { [media_key]: { ...media, caption } };
+                    await socket.relayMessage(doc.cid, {
+                        protocolMessage: {
+                            key: { remoteJid: doc.cid, id: doc.id, fromMe: true },
+                            type: proto.Message.ProtocolMessage.Type.MESSAGE_EDIT,
+                            editedMessage: edited,
+                            timestampMs: Date.now(),
+                        },
+                    }, { messageId: generateMessageID() });
+                    doc.raw.message = { ...doc.raw.message, ...edited };
+                    ok = true;
+                }
+            }
+            if (ok) {
+                doc.caption = caption;
+                doc.edited = true;
+                await this._wa.engine.set(`/chat/${doc.cid}/message/${doc.id}`, serialize(doc), doc.created_at);
+            }
         }
         return ok;
     }
-    /** Elimina el mensaje. `all=true` (default) borra para todos; `all=false` borra sólo en mi dispositivo. */
-    async delete(all = true) {
-        const { _wa: wa, _doc: doc } = this;
+    /**
+     * Reenvía el mensaje a otro chat.
+     * Forwards the message to another chat.
+     *
+     * @param target - CID, Chat o Contact destino / Target CID, Chat or Contact
+     * @returns true si se reenvió / true when forwarded
+     */
+    async forward(target) {
+        const doc = this._raw;
+        const to_cid = typeof target === 'string' ? target : target instanceof Chat ? target._raw.id : (target.jid ?? target.lid ?? '');
         let ok = false;
-        if (wa._socket) {
+        const socket = internals(this._wa).socket;
+        if (socket && to_cid) {
+            const jid = await internals(this._wa).resolve_jid(to_cid);
+            if (jid && doc.raw.message) {
+                try {
+                    const wa_msg = generateWAMessageFromContent(jid, generateForwardMessageContent(doc.raw, false), {
+                        userJid: socket.user?.id ?? '',
+                    });
+                    if (wa_msg.message && wa_msg.key?.id) {
+                        await socket.relayMessage(jid, wa_msg.message, { messageId: wa_msg.key.id });
+                        ok = true;
+                    }
+                }
+                catch {
+                    /* forward content may be unsupported */
+                }
+            }
+        }
+        return ok;
+    }
+    /**
+     * Elimina el mensaje: solo en mi dispositivo por defecto, para todos con `true`.
+     * Deletes the message: this device only by default, for everyone with `true`.
+     *
+     * @param all - true elimina para todos / true deletes for everyone
+     * @returns true si se eliminó / true when deleted
+     */
+    async delete(all = false) {
+        const doc = this._raw;
+        let ok = false;
+        const socket = internals(this._wa).socket;
+        if (socket) {
             if (all) {
-                await wa._socket.sendMessage(doc.cid, {
-                    delete: { remoteJid: doc.cid, id: doc.id, fromMe: doc.me },
-                });
+                await socket.sendMessage(doc.cid, { delete: { remoteJid: doc.cid, id: doc.id, fromMe: doc.me } });
             }
             else {
-                await wa._socket.chatModify({
+                await socket.chatModify({
                     deleteForMe: {
                         deleteMedia: false,
                         key: { remoteJid: doc.cid, id: doc.id, fromMe: doc.me },
@@ -328,161 +475,372 @@ export class Message {
                     },
                 }, doc.cid);
             }
-            await wa.engine.unset(`/chat/${doc.cid}/message/${doc.id}`);
+            await this._wa.engine.unset(`/chat/${doc.cid}/message/${doc.id}`);
             ok = true;
         }
         return ok;
     }
-    /** Edita el texto/caption del mensaje (solo propios editables). */
-    async edit(text) {
-        const { _wa: wa, _doc: doc } = this;
-        let ok = false;
-        if (wa._socket && doc.me) {
-            try {
-                await wa._socket.sendMessage(doc.cid, {
-                    text,
-                    edit: { remoteJid: doc.cid, id: doc.id, fromMe: true },
-                });
-                const content_type = getContentType(doc.raw.message ?? {});
-                if (content_type === 'conversation') {
-                    doc.raw.message = { conversation: text };
-                }
-                else if (content_type === 'extendedTextMessage') {
-                    doc.raw.message = { extendedTextMessage: { text } };
-                }
-                doc.caption = text;
-                doc.edited = true;
-                await wa.engine.set(`/chat/${doc.cid}/message/${doc.id}`, serialize(doc));
-                ok = true;
-            }
-            catch {
-                ok = false;
-            }
-        }
-        return ok;
+    /** Responde con texto. / Replies with text. */
+    async text(caption, extra = {}) {
+        return Message.text(this._wa, this._raw.cid, caption, { ...extra, mid: this._raw.id });
     }
-    /** Observa cambios sobre este mensaje. Retorna unsubscribe. / Watches this message. Returns unsubscribe. */
-    watch(handler) {
-        const cid = this.cid;
-        const id = this.id;
-        return this._wa.on('message:updated', (updated) => {
-            if (updated.cid === cid && updated.id === id) {
-                handler(updated);
-            }
-        });
+    /** Responde con imagen. / Replies with an image. */
+    async image(buf, extra = {}) {
+        return Message.image(this._wa, this._raw.cid, buf, { ...extra, mid: this._raw.id });
     }
-    /** Responde con texto. */
-    async text(caption, opts = {}) {
-        return this._wa.Message.text(this.cid, caption, { ...opts, mid: this.id });
+    /** Responde con video. / Replies with a video. */
+    async video(buf, extra = {}) {
+        return Message.video(this._wa, this._raw.cid, buf, { ...extra, mid: this._raw.id });
     }
-    /** Responde con imagen. */
-    async image(buf, opts = {}) {
-        return this._wa.Message.image(this.cid, buf, { ...opts, mid: this.id });
+    /** Responde con audio. / Replies with audio. */
+    async audio(buf, extra = {}) {
+        return Message.audio(this._wa, this._raw.cid, buf, { ...extra, mid: this._raw.id });
     }
-    /** Responde con video. */
-    async video(buf, opts = {}) {
-        return this._wa.Message.video(this.cid, buf, { ...opts, mid: this.id });
+    /** Responde con ubicación. / Replies with a location. */
+    async location(loc, extra = {}) {
+        return Message.location(this._wa, this._raw.cid, loc, { ...extra, mid: this._raw.id });
     }
-    /** Responde con audio. */
-    async audio(buf, opts = {}) {
-        return this._wa.Message.audio(this.cid, buf, { ...opts, mid: this.id });
+    /** Responde con encuesta. / Replies with a poll. */
+    async poll(input, extra = {}) {
+        return Message.poll(this._wa, this._raw.cid, input, { ...extra, mid: this._raw.id });
     }
-    /** Responde con ubicación. */
-    async location(loc, opts = {}) {
-        return this._wa.Message.location(this.cid, loc, { ...opts, mid: this.id });
+    /** Responde con documento. / Replies with a document. */
+    async document(buf, extra) {
+        return Message.document(this._wa, this._raw.cid, buf, { ...extra, mid: this._raw.id });
     }
-    /** Responde con encuesta. */
-    async poll(poll, opts = {}) {
-        return this._wa.Message.poll(this.cid, poll, { ...opts, mid: this.id });
+    /** Responde con tarjeta(s) de contacto. / Replies with contact card(s). */
+    async vcard(contacts, extra = {}) {
+        return Message.vcard(this._wa, this._raw.cid, contacts, { ...extra, mid: this._raw.id });
     }
-    /** Responde con documento. */
-    async document(buf, opts) {
-        return this._wa.Message.document(this.cid, buf, { ...opts, mid: this.id });
+    /** Responde con evento. / Replies with an event. */
+    async event(data, extra = {}) {
+        return Message.event(this._wa, this._raw.cid, data, { ...extra, mid: this._raw.id });
+    }
+    /**
+     * Obtiene un mensaje por chat y id.
+     * Retrieves a message by chat and id.
+     *
+     * @param wa - Cliente dueño / Owner client
+     * @param cid - Identificador del chat / Chat identifier
+     * @param mid - Identificador del mensaje / Message identifier
+     * @returns Mensaje o null / Message or null
+     */
+    static async get(wa, cid, mid) {
+        const jid = await internals(wa).resolve_jid(cid);
+        if (jid) {
+            const doc = deserialize(await wa.engine.get(`/chat/${jid}/message/${mid}`));
+            if (doc)
+                return message(wa, doc);
+        }
+        return null;
     }
-    /** Responde con tarjeta(s) de contacto. */
-    async vcard(contacts, opts = {}) {
-        return this._wa.Message.vcard(this.cid, contacts, { ...opts, mid: this.id });
+    /**
+     * Pagina los mensajes de un chat desde el más reciente.
+     * Paginates chat messages from the most recent one.
+     *
+     * @param wa - Cliente dueño / Owner client
+     * @param cid - Identificador del chat / Chat identifier
+     * @param offset - Desplazamiento / Offset
+     * @param limit - Tamaño de página / Page size
+     * @returns Página de mensajes / Message page
+     */
+    static async list(wa, cid, offset = 0, limit = 50) {
+        const jid = await internals(wa).resolve_jid(cid);
+        if (jid) {
+            return (await wa.engine.list(`/chat/${jid}/message`, offset, limit))
+                .map((raw) => deserialize(raw))
+                .filter((doc) => doc !== null)
+                .map((doc) => message(wa, doc));
+        }
+        return [];
+    }
+    /** Envía texto. / Sends text. */
+    static async text(wa, cid, caption, extra = {}) {
+        return send(wa, cid, { text: caption }, undefined, extra);
+    }
+    /** Envía imagen. / Sends an image. */
+    static async image(wa, cid, buf, extra = {}) {
+        return send(wa, cid, { image: buf, caption: extra.caption }, buf, extra);
+    }
+    /** Envía video. / Sends a video. */
+    static async video(wa, cid, buf, extra = {}) {
+        return send(wa, cid, { video: buf, caption: extra.caption }, buf, extra);
+    }
+    /** Envía audio. / Sends audio. */
+    static async audio(wa, cid, buf, extra = {}) {
+        return send(wa, cid, { audio: buf, ptt: extra.ptt ?? true }, buf, extra);
+    }
+    /** Envía ubicación. / Sends a location. */
+    static async location(wa, cid, loc, extra = {}) {
+        return send(wa, cid, { location: { degreesLatitude: loc.lat, degreesLongitude: loc.lng } }, undefined, extra);
+    }
+    /** Envía encuesta. / Sends a poll. */
+    static async poll(wa, cid, input, extra = {}) {
+        const multiple = extra.multiple ?? false;
+        return send(wa, cid, {
+            poll: {
+                name: input.content,
+                values: input.options.map((option) => option.content),
+                selectableCount: multiple ? 0 : 1,
+            },
+        }, undefined, extra, { multiple });
+    }
+    /** Envía documento. / Sends a document. */
+    static async document(wa, cid, buf, extra) {
+        return send(wa, cid, { document: buf, fileName: extra.file_name, mimetype: extra.mimetype ?? 'application/octet-stream', caption: extra.caption }, buf, extra);
+    }
+    /** Envía tarjeta(s) de contacto. / Sends contact card(s). */
+    static async vcard(wa, cid, contacts, extra = {}) {
+        const built = contacts.map((entry) => ({
+            displayName: entry.name,
+            vcard: [
+                'BEGIN:VCARD',
+                'VERSION:3.0',
+                `FN:${entry.name}`,
+                `TEL;type=CELL;waid=${entry.phone.replace(/\D+/g, '')}:${entry.phone}`,
+                'END:VCARD',
+            ].join('\n'),
+        }));
+        return send(wa, cid, { contacts: { contacts: built } }, Buffer.from(built.map((entry) => entry.vcard).join('\n'), 'utf-8'), extra);
     }
-    /** Responde con evento. */
-    async event(data, opts = {}) {
-        return this._wa.Message.event(this.cid, data, { ...opts, mid: this.id });
+    /** Envía evento. / Sends an event. */
+    static async event(wa, cid, data, extra = {}) {
+        const binary = Buffer.from(JSON.stringify({ name: data.name, caption: data.caption, start: data.start.getTime(), end: data.end?.getTime() ?? null }), 'utf-8');
+        return send(wa, cid, {
+            event: {
+                name: data.name,
+                description: data.caption,
+                startDate: data.start,
+                endDate: data.end,
+                location: data.place ? { degreesLatitude: data.place.lat, degreesLongitude: data.place.lng } : undefined,
+            },
+        }, binary, extra);
+    }
+    /** Reacciona a un mensaje por id. / Reacts to a message by id. */
+    static async react(wa, cid, mid, emoji) {
+        const msg = await Message.get(wa, cid, mid);
+        return msg ? msg.react(emoji) : false;
+    }
+    /** Destaca un mensaje por id. / Stars a message by id. */
+    static async star(wa, cid, mid, value) {
+        const msg = await Message.get(wa, cid, mid);
+        return msg ? msg.star(value) : false;
+    }
+    /** Marca un mensaje como leído por id. / Marks a message as read by id. */
+    static async seen(wa, cid, mid) {
+        const msg = await Message.get(wa, cid, mid);
+        return msg ? msg.seen() : false;
+    }
+    /** Edita un mensaje por id. / Edits a message by id. */
+    static async edit(wa, cid, mid, caption) {
+        const msg = await Message.get(wa, cid, mid);
+        return msg ? msg.edit(caption) : false;
+    }
+    /** Reenvía un mensaje por id. / Forwards a message by id. */
+    static async forward(wa, cid, mid, target) {
+        const msg = await Message.get(wa, cid, mid);
+        return msg ? msg.forward(target) : false;
+    }
+    /** Elimina un mensaje por id. / Deletes a message by id. */
+    static async delete(wa, cid, mid, all = false) {
+        const msg = await Message.get(wa, cid, mid);
+        return msg ? msg.delete(all) : false;
+    }
+    /** Reacciones de un mensaje por id. / Reactions of a message by id. */
+    static async reactions(wa, cid, mid) {
+        const msg = await Message.get(wa, cid, mid);
+        return msg ? msg.reactions() : [];
     }
 }
 /**
- * Mensaje de texto. Override `content()` para retornar el caption como Buffer sin pasar por engine.
- * Text message. Overrides `content()` returning caption as Buffer directly.
+ * Mensaje de texto; `preview()` expone la tarjeta del enlace embebido.
+ * Text message; `preview()` exposes the embedded link card.
  */
 export class Text extends Message {
-    async content() {
-        return Buffer.from(this.caption, 'utf-8');
-    }
-}
-/** @internal Helper compartido por media classes: stream del binario (cache → download). */
-async function _media_stream(msg) {
-    const wa = msg._wa;
-    const doc = msg._doc;
-    const cached = deserialize(await wa.engine.get(`/chat/${doc.cid}/message/${doc.id}/content`));
-    if (cached?.data) {
-        return Readable.from(Buffer.from(cached.data, 'base64'));
-    }
-    if (wa._socket) {
-        try {
-            return (await downloadMediaMessage(doc.raw, 'stream', {}));
-        }
-        catch {
-            /* fallback empty */
+    /**
+     * Preview del enlace del texto, o null cuando no trae metadata.
+     * Text link preview, or null when it carries no metadata.
+     *
+     * @returns { link, name, content, thumb } o null / { link, name, content, thumb } or null
+     */
+    async preview() {
+        const ext = this._raw.raw.message?.extendedTextMessage;
+        if (ext?.matchedText && (ext.title || ext.description)) {
+            return {
+                link: ext.matchedText,
+                name: ext.title ?? null,
+                content: ext.description ?? null,
+                thumb: to_buffer(ext.jpegThumbnail),
+            };
         }
+        return null;
     }
-    return Readable.from(Buffer.alloc(0));
-}
-/** @internal Acumula un Readable en Buffer. */
-async function _drain(readable) {
-    const chunks = [];
-    for await (const chunk of readable) {
-        chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
-    }
-    return Buffer.concat(chunks);
 }
 /**
- * Mensaje de imagen. Hereda `stream()` de la clase base; `content()` drena el stream.
- * Image message. Inherits `stream()` from the base class; `content()` drains the stream.
+ * Mensaje de imagen: dimensiones, peso y miniatura.
+ * Image message: dimensions, size and thumbnail.
  */
 export class Image extends Message {
+    /** @internal */
+    get _media() {
+        return unwrap(this._raw.raw.message ?? {}).imageMessage;
+    }
+    /** Ancho en píxeles. / Width in pixels. */
+    get width() {
+        return this._media?.width ?? 0;
+    }
+    /** Alto en píxeles. / Height in pixels. */
+    get height() {
+        return this._media?.height ?? 0;
+    }
+    /** Peso en bytes. / Size in bytes. */
+    get size() {
+        return to_number(this._media?.fileLength);
+    }
+    /**
+     * Miniatura JPEG embebida, o null.
+     * Embedded JPEG thumbnail, or null.
+     *
+     * @returns Buffer de la miniatura o null / Thumbnail buffer or null
+     */
+    async thumb() {
+        return to_buffer(this._media?.jpegThumbnail);
+    }
     async content() {
-        return _drain(await this.stream());
+        return drain(await this.stream());
     }
 }
 /**
- * Mensaje de video. Hereda `stream()` de la clase base; `content()` drena el stream.
- * Video message. Inherits `stream()` from the base class; `content()` drains the stream.
+ * Mensaje de video: dimensiones, duración, peso y miniatura.
+ * Video message: dimensions, duration, size and thumbnail.
  */
 export class Video extends Message {
+    /** @internal */
+    get _media() {
+        return unwrap(this._raw.raw.message ?? {}).videoMessage;
+    }
+    /** Ancho en píxeles. / Width in pixels. */
+    get width() {
+        return this._media?.width ?? 0;
+    }
+    /** Alto en píxeles. / Height in pixels. */
+    get height() {
+        return this._media?.height ?? 0;
+    }
+    /** Duración en segundos. / Duration in seconds. */
+    get duration() {
+        return this._media?.seconds ?? 0;
+    }
+    /** Peso en bytes. / Size in bytes. */
+    get size() {
+        return to_number(this._media?.fileLength);
+    }
+    /**
+     * Miniatura JPEG embebida, o null.
+     * Embedded JPEG thumbnail, or null.
+     *
+     * @returns Buffer de la miniatura o null / Thumbnail buffer or null
+     */
+    async thumb() {
+        return to_buffer(this._media?.jpegThumbnail);
+    }
     async content() {
-        return _drain(await this.stream());
+        return drain(await this.stream());
     }
 }
 /**
- * Mensaje de audio. Hereda `stream()` de la clase base; `content()` drena el stream.
- * `ptt` indica si es nota de voz (push-to-talk).
- * Audio message. Inherits `stream()` from the base class; `content()` drains the stream.
- * `ptt` flags voice notes.
+ * Mensaje de audio: nota de voz o archivo, con forma de onda del protocolo.
+ * Audio message: voice note or file, with the protocol waveform.
  */
 export class Audio extends Message {
-    /** true si es nota de voz (push-to-talk). / true if push-to-talk voice note. */
+    /** @internal */
+    get _media() {
+        return unwrap(this._raw.raw.message ?? {}).audioMessage;
+    }
+    /** true si es nota de voz. / true when push-to-talk. */
     get ptt() {
-        return this._doc.raw.message?.audioMessage?.ptt === true;
+        return this._media?.ptt === true;
+    }
+    /** Duración en segundos. / Duration in seconds. */
+    get duration() {
+        return this._media?.seconds ?? 0;
+    }
+    /** Peso en bytes. / Size in bytes. */
+    get size() {
+        return to_number(this._media?.fileLength);
+    }
+    /** Forma de onda 0-100 lista para pintar. / Paint-ready 0-100 waveform. */
+    get waveform() {
+        const wave = this._media?.waveform;
+        const bytes = wave instanceof Uint8Array ? wave : typeof wave === 'string' ? Buffer.from(wave, 'base64') : Buffer.alloc(0);
+        return Array.from(bytes);
     }
     async content() {
-        return _drain(await this.stream());
+        return drain(await this.stream());
     }
 }
 /**
- * Mensaje de ubicación. Agrega getters sync `lat`, `lng`, `link` derivados del raw.
- * Location message. Adds sync getters `lat`, `lng`, `link` derived from raw.
+ * Mensaje de sticker: dimensiones, peso y animación.
+ * Sticker message: dimensions, size and animation.
  */
-export class Gps extends Message {
+export class Sticker extends Message {
+    /** @internal */
+    get _media() {
+        return unwrap(this._raw.raw.message ?? {}).stickerMessage;
+    }
+    /** Ancho en píxeles. / Width in pixels. */
+    get width() {
+        return this._media?.width ?? 0;
+    }
+    /** Alto en píxeles. / Height in pixels. */
+    get height() {
+        return this._media?.height ?? 0;
+    }
+    /** true si el sticker es animado. / true when animated. */
+    get animated() {
+        return this._media?.isAnimated === true;
+    }
+    /** Peso en bytes. / Size in bytes. */
+    get size() {
+        return to_number(this._media?.fileLength);
+    }
+    async content() {
+        return drain(await this.stream());
+    }
+}
+/**
+ * Mensaje de documento; el MIME real vive en `mime` de la base.
+ * Document message; the actual MIME lives in the base `mime`.
+ */
+export class Document extends Message {
+    /** @internal */
+    get _media() {
+        return unwrap(this._raw.raw.message ?? {}).documentMessage;
+    }
+    /** Nombre del archivo. / File name. */
+    get name() {
+        return this._media?.fileName ?? '';
+    }
+    /** Número de páginas (PDF); 0 cuando no aplica. / Page count (PDF); 0 when not applicable. */
+    get pages() {
+        return this._media?.pageCount ?? 0;
+    }
+    /** Peso en bytes. / Size in bytes. */
+    get size() {
+        return to_number(this._media?.fileLength);
+    }
+    async content() {
+        return drain(await this.stream());
+    }
+}
+/**
+ * Mensaje de ubicación, fija o en vivo.
+ * Location message, static or live.
+ */
+export class Location extends Message {
+    /** @internal */
     get _loc() {
-        return this._doc.raw.message?.locationMessage ?? this._doc.raw.message?.liveLocationMessage;
+        return this._raw.raw.message?.locationMessage ?? this._raw.raw.message?.liveLocationMessage;
     }
     /** Latitud en grados. / Latitude in degrees. */
     get lat() {
@@ -492,283 +850,184 @@ export class Gps extends Message {
     get lng() {
         return this._loc?.degreesLongitude ?? 0;
     }
-    /** URL de Google Maps apuntando a la coordenada. / Google Maps URL for the coordinate. */
-    get link() {
-        return `https://www.google.com/maps/@${this.lat},${this.lng},15z`;
-    }
     /** true si es ubicación en tiempo real. / true when live location. */
     get live() {
-        return Boolean(this._doc.raw.message?.liveLocationMessage);
+        return Boolean(this._raw.raw.message?.liveLocationMessage);
+    }
+    /** URL de Google Maps de la coordenada. / Google Maps URL for the coordinate. */
+    get link() {
+        return `https://www.google.com/maps/@${this.lat},${this.lng},15z`;
     }
 }
 /**
- * Mensaje de encuesta. `caption` es la pregunta (heredada); agrega `options[]` con conteo y `multiple`.
- * Poll message. `caption` is the question (inherited); adds `options[]` with counts and `multiple`.
+ * Mensaje de encuesta: opciones con conteo, votos por contacto y voto propio.
+ * Poll message: options with counts, per-contact votes and self-voting.
  */
 export class Poll extends Message {
+    /** @internal */
     get _poll() {
-        const m = this._doc.raw.message;
-        return m?.pollCreationMessage ?? m?.pollCreationMessageV2 ?? m?.pollCreationMessageV3;
+        const msg = this._raw.raw.message;
+        return msg?.pollCreationMessage ?? msg?.pollCreationMessageV2 ?? msg?.pollCreationMessageV3;
+    }
+    /** @internal Updates de voto con los bytes normalizados post-engine. / Vote updates with post-engine normalized bytes. */
+    get _updates() {
+        return (this._raw.raw.pollUpdates ?? []).map((update) => ({
+            ...update,
+            vote: update.vote
+                ? {
+                    ...update.vote,
+                    selectedOptions: (update.vote.selectedOptions ?? []).map((option) => typeof option === 'string' ? Buffer.from(option, 'base64') : option),
+                }
+                : update.vote,
+        }));
     }
-    /**
-     * true si admite múltiples respuestas. Lee primero el flag explícito persistido
-     * al enviar (caso propio, donde WhatsApp pierde el discriminador en el echo);
-     * fallback al `selectableOptionsCount` del proto (polls foráneos o de UI móvil).
-     * true if the poll accepts multiple answers. Prefers the persisted send-time
-     * flag (own polls, since WhatsApp drops the discriminator on echo); falls back
-     * to the proto `selectableOptionsCount` (foreign or mobile-UI polls).
-     */
+    /** true si admite varias respuestas. / true when multi-select. */
     get multiple() {
-        if (typeof this._doc.multiple === 'boolean') {
-            return this._doc.multiple;
+        if (typeof this._raw.multiple === 'boolean') {
+            return this._raw.multiple;
         }
         return (this._poll?.selectableOptionsCount ?? 1) !== 1;
     }
-    /** Opciones con conteo de votos actualizado. / Options with up-to-date vote counts. */
+    /** Opciones con su conteo de votos. / Options with their vote counts. */
     get options() {
-        const opts = this._poll?.options ?? [];
-        const raw_updates = this._doc.raw.pollUpdates ?? [];
-        // Normaliza selectedOptions de base64-string a Buffer (BufferJSON no reconstruye el tipo aquí)
-        const updates = raw_updates.map((u) => ({
-            ...u,
-            vote: u.vote
-                ? {
-                    ...u.vote,
-                    selectedOptions: (u.vote.selectedOptions ?? []).map((s) => typeof s === 'string' ? Buffer.from(s, 'base64') : s),
-                }
-                : u.vote,
-        }));
-        const aggregated = getAggregateVotesInPollMessage({ message: this._doc.raw.message ?? undefined, pollUpdates: updates }, this._wa._socket?.user?.id);
-        const counts = new Map(aggregated.map((a) => [a.name, a.voters.length]));
-        return opts.map((o) => ({
-            content: o.optionName ?? '',
-            count: counts.get(o.optionName ?? '') ?? 0,
+        const aggregated = getAggregateVotesInPollMessage({ message: this._raw.raw.message ?? undefined, pollUpdates: this._updates }, internals(this._wa).socket?.user?.id);
+        const counts = new Map(aggregated.map((entry) => [entry.name, entry.voters.length]));
+        return (this._poll?.options ?? []).map((option) => ({
+            name: option.optionName ?? '',
+            count: counts.get(option.optionName ?? '') ?? 0,
         }));
     }
     /**
-     * Vota en la encuesta. Acepta un índice o lista de índices (para `multiple`).
-     * Cifra el voto (HMAC+AES-GCM, igual que baileys.decryptPollVote) y lo enruta al chat
-     * @lid del contacto con la identidad LID propia, replicando byte a byte un voto entrante
-     * que sí descifra. El voto ENTRANTE (contacto → este cliente) funciona; el voto propio
-     * de este cliente aplicado a una encuesta NO se refleja en el teléfono del destinatario
-     * cuando este cliente es un dispositivo vinculado (companion): estructura, identidades y
-     * addressing coinciden con un voto válido, pero WhatsApp no lo propaga. Best-effort.
+     * Votos individuales: opción elegida y teléfono del votante.
+     * Individual votes: chosen option and voter phone.
      *
-     * Votes in the poll. Encrypts the vote (HMAC+AES-GCM, same as baileys.decryptPollVote)
-     * and routes it to the contact's @lid chat with our own LID identity, mirroring a working
-     * incoming vote byte-for-byte. INCOMING votes work; a self-vote from this client does NOT
-     * show on the recipient's phone when this client is a linked (companion) device — the
-     * structure, identities and addressing match a valid vote but WhatsApp won't propagate it.
-     * Best-effort.
+     * @returns Lista de votos / Vote list
+     */
+    async votes() {
+        const aggregated = getAggregateVotesInPollMessage({ message: this._raw.raw.message ?? undefined, pollUpdates: this._updates }, internals(this._wa).socket?.user?.id);
+        const result = [];
+        for (const entry of aggregated) {
+            for (const voter of entry.voters) {
+                const jid = await internals(this._wa).resolve_jid(voter);
+                result.push({ name: entry.name, contact: (jid ?? voter).split('@')[0].split(':')[0] });
+            }
+        }
+        return result;
+    }
+    /**
+     * Vota en la encuesta con uno o varios índices. Cifra el voto (HMAC+AES-GCM) y lo
+     * enruta al chat @lid con la identidad LID propia. Best-effort: el voto entrante
+     * descifra correcto, pero WhatsApp no propaga el voto emitido desde un dispositivo
+     * vinculado (companion).
+     * Votes in the poll with one or more indexes. Encrypts the vote (HMAC+AES-GCM) and
+     * routes it to the @lid chat with the own LID identity. Best-effort: incoming votes
+     * decrypt fine, but WhatsApp does not propagate votes emitted from a linked
+     * (companion) device.
+     *
+     * @param index - Índice o índices de la opción / Option index or indexes
+     * @returns true si el voto se emitió / true when the vote was relayed
      */
     async select(index) {
-        const { _wa, _doc } = this;
-        const indices = Array.isArray(index) ? index : [index];
+        const doc = this._raw;
         const opts = this._poll?.options ?? [];
-        const selected_options = indices
+        const selected_options = (Array.isArray(index) ? index : [index])
             .filter((i) => i >= 0 && i < opts.length)
             .map((i) => sha256(Buffer.from(opts[i].optionName ?? '')));
-        // messageSecret puede llegar como Buffer (raw runtime) o string base64 (post-deserialize
-        // del engine). Normaliza a Buffer antes de derivar el HMAC.
-        // messageSecret may arrive as Buffer (runtime raw) or base64 string (post engine
-        // deserialize). Normalize to Buffer before deriving the HMAC.
-        const secret_raw = _doc.raw.message?.messageContextInfo?.messageSecret;
+        const secret_raw = doc.raw.message?.messageContextInfo?.messageSecret;
         const poll_enc_key = typeof secret_raw === 'string' ? Buffer.from(secret_raw, 'base64') : secret_raw;
-        if (!poll_enc_key || !_wa._socket || selected_options.length === 0) {
+        const socket = internals(this._wa).socket;
+        if (!poll_enc_key || !socket || selected_options.length === 0) {
             return false;
         }
-        const poll_key = _doc.raw.key ?? {};
-        const self_id = _wa._socket.user?.id ?? '';
-        const self_lid = _wa._socket.user?.lid ?? '';
-        // El voto se enruta al chat @lid del contacto: los clientes migrados corren el chat
-        // en @lid y derivan la clave del JID visible del stanza; enviarlo por PN lo deja
-        // indescifrable en el teléfono. El @lid destino sale del propio poll (si ya es @lid),
-        // del store de contactos, o del lidMapping de baileys.
-        // The vote is routed to the contact's @lid chat: migrated clients run the chat on
-        // @lid and derive the key from the stanza's visible JID; sending via PN leaves it
-        // undecryptable on the phone. The @lid dest comes from the poll (if already @lid),
-        // the contact store, or baileys' lidMapping.
-        let dest = _doc.cid;
+        const poll_key = doc.raw.key ?? {};
+        const self_id = socket.user?.id ?? '';
+        const self_lid = socket.user?.lid ?? '';
+        let dest = doc.cid;
         if (poll_key.remoteJid?.endsWith('@lid')) {
             dest = poll_key.remoteJid;
         }
-        else if (!_doc.cid.endsWith('@lid')) {
-            const contact_raw = deserialize(await _wa.engine.get(`/contact/${_doc.cid}`));
-            const mapped = await _wa._socket.signalRepository?.lidMapping?.getLIDForPN(_doc.cid).catch(() => null);
-            dest = contact_raw?.lid ?? mapped ?? _doc.cid;
+        else if (!doc.cid.endsWith('@lid')) {
+            const contact_raw = deserialize(await this._wa.engine.get(`/contact/${doc.cid}`));
+            const mapped = await socket.signalRepository?.lidMapping?.getLIDForPN(doc.cid).catch(() => null);
+            dest = contact_raw?.lid ?? mapped ?? doc.cid;
         }
-        // Identidad del HMAC atada al destino real: baileys firma con meLid cuando el envío
-        // va por @lid, así que voter y (en polls propios) creator usan el LID propio para que
-        // el receptor derive la misma clave. PN sólo si no se conoce ningún LID.
-        // HMAC identity tied to the actual destination: baileys signs with meLid for @lid
-        // sends, so voter and (on own polls) creator use our LID so the receiver derives the
-        // same key. PN only when no LID is known.
         const self_for_send = dest.endsWith('@lid') && self_lid ? self_lid : self_id;
         const voter_jid = jidNormalizedUser(self_for_send);
-        let poll_creator_raw;
-        if (poll_key.fromMe) {
-            poll_creator_raw = self_for_send;
-        }
-        else if (poll_key.remoteJid?.endsWith('@lid')) {
-            poll_creator_raw = poll_key.remoteJid;
-        }
-        else {
-            poll_creator_raw = getKeyAuthor(poll_key, self_id);
-        }
-        const poll_creator_jid = jidNormalizedUser(poll_creator_raw);
-        const poll_msg_id = this.id;
-        // Derivar clave y encriptar el voto (mismo algoritmo que baileys.decryptPollVote)
+        const poll_creator_jid = jidNormalizedUser(poll_key.fromMe
+            ? self_for_send
+            : poll_key.remoteJid?.endsWith('@lid')
+                ? poll_key.remoteJid
+                : getKeyAuthor(poll_key, self_id));
         const sign = Buffer.concat([
-            Buffer.from(poll_msg_id),
+            Buffer.from(doc.id),
             Buffer.from(poll_creator_jid),
             Buffer.from(voter_jid),
             Buffer.from('Poll Vote'),
             new Uint8Array([1]),
         ]);
-        const key0 = hmacSign(poll_enc_key, new Uint8Array(32), 'sha256');
-        const enc_key = hmacSign(sign, key0, 'sha256');
-        const payload = proto.Message.PollVoteMessage.encode({
-            selectedOptions: selected_options,
-        }).finish();
-        const aad = Buffer.from(`${poll_msg_id}\x00${voter_jid}`);
+        const enc_key = hmacSign(sign, hmacSign(poll_enc_key, new Uint8Array(32), 'sha256'), 'sha256');
         const enc_iv = randomBytes(12);
-        const enc_payload = aesEncryptGCM(payload, enc_key, enc_iv, aad);
+        const enc_payload = aesEncryptGCM(proto.Message.PollVoteMessage.encode({ selectedOptions: selected_options }).finish(), enc_key, enc_iv, Buffer.from(`${doc.id}\x00${voter_jid}`));
         const msg_id = generateMessageID();
-        // La pollCreationMessageKey debe referenciar el poll con el mismo addressing que el
-        // stanza (dest): un voto entrante que sí funciona trae la key con remoteJid = @lid del
-        // creador, coincidiendo con el chat @lid del stanza. Enviarla con remoteJid PN mientras
-        // el stanza va por @lid deja al receptor sin poder casar el voto con el poll.
-        // The pollCreationMessageKey must reference the poll with the same addressing as the
-        // stanza (dest): a working incoming vote carries the key with the creator's @lid
-        // remoteJid, matching the @lid stanza chat. A PN remoteJid on an @lid stanza leaves the
-        // receiver unable to match the vote to the poll.
-        const creation_key = dest === _doc.cid ? _doc.raw.key : { ..._doc.raw.key, remoteJid: dest };
-        await _wa._socket.relayMessage(dest, {
+        await socket.relayMessage(dest, {
             pollUpdateMessage: {
-                pollCreationMessageKey: creation_key,
+                pollCreationMessageKey: dest === doc.cid ? doc.raw.key : { ...doc.raw.key, remoteJid: dest },
                 vote: { encPayload: enc_payload, encIv: enc_iv },
                 senderTimestampMs: Date.now(),
             },
         }, { messageId: msg_id });
-        // baileys.relayMessage no echa upsert local al companion que envió el voto.
-        // Mergemos el voto propio en el doc para que `options[].count` y el evento
-        // `message:updated` reflejen el cambio sin esperar (nunca) un echo del servidor.
-        // baileys.relayMessage doesn't emit a local upsert on the originating companion.
-        // We merge the own vote into the doc so `options[].count` and the `message:updated`
-        // event reflect the change without waiting for a server echo that never comes.
-        const own_update_key = {
-            remoteJid: _doc.raw.key?.remoteJid ?? _doc.cid,
-            fromMe: true,
-            id: msg_id,
-        };
-        updateMessageWithPollUpdate(_doc.raw, {
-            pollUpdateMessageKey: own_update_key,
+        updateMessageWithPollUpdate(doc.raw, {
+            pollUpdateMessageKey: { remoteJid: doc.raw.key?.remoteJid ?? doc.cid, fromMe: true, id: msg_id },
             vote: { selectedOptions: selected_options },
             senderTimestampMs: Date.now(),
         });
-        await _wa.engine.set(`/chat/${_doc.cid}/message/${_doc.id}`, serialize(_doc));
-        _wa._event.emit('message:updated', this, await this.chat(), _wa);
+        await this._wa.engine.set(`/chat/${doc.cid}/message/${doc.id}`, serialize(doc), doc.created_at);
+        this._wa.emit('message:updated', this, await this.chat(), this._wa);
         return true;
     }
 }
 /**
- * Mensaje de documento. WhatsApp permite enviar cualquier archivo (PDF, imagen,
- * audio, video, etc.) como documento; lo que lo distingue de image/video/audio es
- * el tipo de mensaje (`documentMessage`), no el mimetype. Hereda `stream()` de la
- * clase base; `content()` drena el stream (cache → download).
- * Document message. WhatsApp lets you send any file (PDF, image, audio, video…)
- * as a document; what sets it apart from image/video/audio is the message type
- * (`documentMessage`), not the mimetype. Inherits `stream()` from the base class;
- * `content()` drains the stream (cache → download).
- */
-export class Document extends Message {
-    get _doc_msg() {
-        const m = this._doc.raw.message;
-        return m?.documentMessage ?? m?.documentWithCaptionMessage?.message?.documentMessage;
-    }
-    /** Nombre del archivo. / File name. */
-    get file_name() {
-        return this._doc_msg?.fileName ?? '';
-    }
-    /** Tamaño en bytes (0 si se desconoce). / Size in bytes (0 if unknown). */
-    get size() {
-        return Number(this._doc_msg?.fileLength?.toString() ?? '0');
-    }
-    /** Número de páginas (PDF); 0 si no aplica. / Page count (PDF); 0 when not applicable. */
-    get pages() {
-        return this._doc_msg?.pageCount ?? 0;
-    }
-    /** Título del documento. / Document title. */
-    get title() {
-        return this._doc_msg?.title ?? '';
-    }
-    async content() {
-        return _drain(await this.stream());
-    }
-}
-/**
- * Construye un vCard 3.0 mínimo con el teléfono enlazado como contacto de WhatsApp.
- * Builds a minimal vCard 3.0 with the phone linked as a WhatsApp contact.
- *
- * @param name - Nombre mostrado / Display name
- * @param phone - Teléfono en formato internacional / Phone in international format
- * @returns String vCard (VCF) / vCard (VCF) string
- */
-function build_vcard(name, phone) {
-    const waid = phone.replace(/\D+/g, '');
-    return [
-        'BEGIN:VCARD',
-        'VERSION:3.0',
-        `FN:${name}`,
-        `TEL;type=CELL;waid=${waid}:${phone}`,
-        'END:VCARD',
-    ].join('\n');
-}
-/**
- * Mensaje de tarjeta(s) de contacto (vCard). Unifica `contactMessage` (uno) y
- * `contactsArrayMessage` (varios) bajo una sola lista `contacts`.
- * Contact card message (vCard). Unifies `contactMessage` (single) and
- * `contactsArrayMessage` (multiple) under a single `contacts` list.
+ * Mensaje de tarjeta(s) de contacto.
+ * Contact card(s) message.
  */
 export class VCard extends Message {
-    /** Contactos de la tarjeta con nombre y teléfono. / Card contacts with name and phone. */
+    /** Contactos de la tarjeta. / Card contacts. */
     get contacts() {
-        const m = this._doc.raw.message;
-        const raw = m?.contactsArrayMessage?.contacts ?? (m?.contactMessage ? [m.contactMessage] : []);
-        return raw.map((c) => {
-            const tel = (c.vcard ?? '').match(/TEL[^:]*:(.+)/);
-            return { name: c.displayName ?? '', phone: tel ? tel[1].trim() : '' };
+        const msg = this._raw.raw.message;
+        const raw = msg?.contactsArrayMessage?.contacts ?? (msg?.contactMessage ? [msg.contactMessage] : []);
+        return raw.map((card) => {
+            const tel = (card.vcard ?? '').match(/TEL[^:]*:(.+)/);
+            return { name: card.displayName ?? '', phone: tel ? tel[1].trim() : '' };
         });
     }
 }
 /**
- * Mensaje de evento de calendario (`eventMessage`): nombre, descripción, rango de
- * fechas, estado de cancelación, link de unión y ubicación.
- * Calendar event message (`eventMessage`): name, description, date range,
- * cancellation state, join link and location.
+ * Mensaje de evento de calendario.
+ * Calendar event message.
  */
 export class Event extends Message {
+    /** @internal */
     get _event() {
-        return this._doc.raw.message?.eventMessage;
+        return this._raw.raw.message?.eventMessage;
     }
     /** Nombre del evento. / Event name. */
     get name() {
         return this._event?.name ?? '';
     }
-    /** Epoch ms de inicio. / Start epoch ms. */
+    /** Inicio en ISO UTC. / Start as ISO UTC. */
     get start() {
-        return Number(this._event?.startTime?.toString() ?? '0') * 1000;
+        return new Date(to_number(this._event?.startTime) * 1000).toISOString();
     }
-    /** Epoch ms de fin, o null. / End epoch ms, or null. */
+    /** Fin en ISO UTC, o null. / End as ISO UTC, or null. */
     get end() {
         const end = this._event?.endTime;
-        return end == null ? null : Number(end.toString()) * 1000;
+        return end == null ? null : new Date(to_number(end) * 1000).toISOString();
     }
-    /** true si el evento fue cancelado. / true if the event was canceled. */
+    /** true si fue cancelado. / true when canceled. */
     get canceled() {
         return this._event?.isCanceled ?? false;
     }
-    /** Link de unión (audio/video), si aplica. / Join link (audio/video), if any. */
+    /** Link de unión, si aplica. / Join link, if any. */
     get link() {
         return this._event?.joinLink ?? '';
     }
@@ -779,205 +1038,74 @@ export class Event extends Message {
     }
 }
 /**
- * Factoría que enlaza los statics a `wa` y expone las subclases.
- * Factory binding statics to `wa` and exposing subclasses.
+ * Factoría de Message: evalúa el tipo y retorna la instancia de la subclase correcta.
+ * Acepta el documento persistido o el mensaje crudo de baileys — en ese caso el
+ * documento se deriva aquí mismo (id, tipo, autor, caption, mime, fechas).
+ * Message factory: evaluates the type and returns the right subclass instance. Accepts
+ * the persisted document or the raw baileys message — in that case the document is
+ * derived right here (id, type, author, caption, mime, dates).
+ *
+ * @param wa - Instancia principal / Main WhatsApp instance
+ * @param raw - Documento persistido o WAMessage crudo / Persisted document or raw WAMessage
+ * @returns Instancia del tipo correcto / Right-type instance
  */
-export function message(wa) {
-    async function build_instance(doc) {
-        const opts = { wa, doc };
-        if (doc.type === 'text') {
-            return new Text(opts);
-        }
-        if (doc.type === 'image') {
-            return new Image(opts);
-        }
-        if (doc.type === 'video') {
-            return new Video(opts);
-        }
-        if (doc.type === 'audio') {
-            return new Audio(opts);
-        }
-        if (doc.type === 'location') {
-            return new Gps(opts);
-        }
-        if (doc.type === 'poll') {
-            return new Poll(opts);
-        }
-        if (doc.type === 'document') {
-            return new Document(opts);
-        }
-        if (doc.type === 'vcard') {
-            return new VCard(opts);
-        }
-        if (doc.type === 'event') {
-            return new Event(opts);
-        }
-        return new Message(opts);
-    }
-    async function send(cid, content, binary, reply_to, doc_overrides) {
-        let result = null;
-        const jid = await wa._resolve_jid(cid);
-        if (jid && wa._socket) {
-            let quoted;
-            if (reply_to) {
-                const ref_doc = deserialize(await wa.engine.get(`/chat/${jid}/message/${reply_to}`));
-                if (ref_doc) {
-                    quoted = ref_doc.raw;
-                }
-            }
-            const raw = await wa._socket.sendMessage(jid, {
-                ...content,
-                ...(quoted ? { quoted } : {}),
-            });
-            const sent_id = raw?.key?.id;
-            if (raw && sent_id) {
-                const doc = build_message_doc(raw, wa._socket?.user?.id);
-                if (doc_overrides) {
-                    Object.assign(doc, doc_overrides);
-                }
-                await wa.engine.set(`/chat/${jid}/message/${sent_id}`, serialize(doc));
-                if (binary) {
-                    await wa.engine.set(`/chat/${jid}/message/${sent_id}/content`, serialize({ data: binary.toString('base64') }));
-                }
-                result = await build_instance(doc);
-            }
-        }
-        return result;
+export function message(wa, raw) {
+    let doc;
+    if ('key' in raw) {
+        const key = raw.key ?? {};
+        const unwrapped = unwrap(raw.message ?? {});
+        const content_type = getContentType(unwrapped);
+        const msg_type = MESSAGE_TYPE_MAP[content_type] ?? 'text';
+        const msg_content = unwrapped[content_type];
+        const context_info = msg_content?.contextInfo;
+        const ephemeral_duration = raw.ephemeralDuration ?? context_info?.expiration;
+        const self_id = internals(wa).socket?.user?.id;
+        doc = {
+            id: key.id ?? '',
+            cid: key.remoteJidAlt ?? key.remoteJid ?? '',
+            mid: context_info?.stanzaId ?? null,
+            me: key.fromMe ?? false,
+            type: msg_type,
+            author: key.fromMe && self_id
+                ? jidNormalizedUser(self_id)
+                : key.participant || key.remoteJidAlt || key.remoteJid || '',
+            status: raw.status ?? 1,
+            starred: raw.starred ?? false,
+            forwarded: context_info?.isForwarded ?? false,
+            created_at: (Number(raw.messageTimestamp) || Math.floor(Date.now() / 1000)) * 1000,
+            deleted_at: raw.ephemeralStartTimestamp != null && ephemeral_duration != null
+                ? (Number(raw.ephemeralStartTimestamp) + ephemeral_duration) * 1000
+                : null,
+            mime: typeof msg_content === 'object' && msg_type !== 'text'
+                ? (msg_content?.mimetype ?? 'application/octet-stream')
+                : 'text/plain',
+            caption: typeof msg_content === 'string'
+                ? msg_content
+                : msg_type === 'event'
+                    ? (msg_content?.description ?? '')
+                    : (msg_content?.caption ??
+                        msg_content?.text ??
+                        msg_content?.name ??
+                        msg_content?.displayName ??
+                        ''),
+            edited: false,
+            raw,
+        };
     }
-    const api = {
-        // Clases expuestas para instanceof
-        Text,
-        Image,
-        Video,
-        Audio,
-        Gps,
-        Poll,
-        Document,
-        VCard,
-        Event,
-        // Helpers internos (usados por orquestador WhatsApp)
-        build_message_doc,
-        build_instance,
-        /** Obtiene un mensaje por CID/MID. */
-        async get(cid, mid) {
-            const jid = await wa._resolve_jid(cid);
-            if (!jid) {
-                return null;
-            }
-            const doc = deserialize(await wa.engine.get(`/chat/${jid}/message/${mid}`));
-            return doc ? build_instance(doc) : null;
-        },
-        /** Pagina mensajes de un chat. */
-        async list(cid, offset = 0, limit = 50) {
-            const jid = await wa._resolve_jid(cid);
-            const result = [];
-            if (jid) {
-                for (const raw of await wa.engine.list(`/chat/${jid}/message`, offset, limit)) {
-                    const doc = deserialize(raw);
-                    if (doc) {
-                        result.push(await build_instance(doc));
-                    }
-                }
-            }
-            return result;
-        },
-        /** Cuenta mensajes de un chat. */
-        async count(cid) {
-            const jid = await wa._resolve_jid(cid);
-            return jid ? wa.engine.count(`/chat/${jid}/message`) : 0;
-        },
-        async text(cid, caption, opts = {}) {
-            return send(cid, { text: caption }, undefined, opts.mid);
-        },
-        async image(cid, buf, opts = {}) {
-            return send(cid, { image: buf, caption: opts.caption }, buf, opts.mid);
-        },
-        async video(cid, buf, opts = {}) {
-            return send(cid, { video: buf, caption: opts.caption }, buf, opts.mid);
-        },
-        async audio(cid, buf, opts = {}) {
-            return send(cid, { audio: buf, ptt: opts.ptt ?? true }, buf, opts.mid);
-        },
-        async location(cid, loc, opts = {}) {
-            return send(cid, { location: { degreesLatitude: loc.lat, degreesLongitude: loc.lng } }, undefined, opts.mid);
-        },
-        async poll(cid, p, opts = {}) {
-            const multiple = opts.multiple ?? false;
-            return send(cid, {
-                poll: {
-                    name: p.content,
-                    values: p.options.map((o) => o.content),
-                    selectableCount: multiple ? 0 : 1,
-                },
-            }, undefined, opts.mid, { multiple });
-        },
-        async document(cid, buf, opts) {
-            return send(cid, {
-                document: buf,
-                fileName: opts.file_name,
-                mimetype: opts.mimetype ?? 'application/octet-stream',
-                caption: opts.caption,
-            }, buf, opts.mid);
-        },
-        async vcard(cid, contacts, opts = {}) {
-            const built = contacts.map((c) => ({
-                displayName: c.name,
-                vcard: build_vcard(c.name, c.phone),
-            }));
-            const binary = Buffer.from(built.map((c) => c.vcard).join('\n'), 'utf-8');
-            return send(cid, { contacts: { contacts: built } }, binary, opts.mid);
-        },
-        async event(cid, data, opts = {}) {
-            const binary = Buffer.from(JSON.stringify({
-                name: data.name,
-                caption: data.caption,
-                start: data.start.getTime(),
-                end: data.end?.getTime() ?? null,
-            }), 'utf-8');
-            return send(cid, {
-                event: {
-                    name: data.name,
-                    description: data.caption,
-                    startDate: data.start,
-                    endDate: data.end,
-                    location: data.place
-                        ? { degreesLatitude: data.place.lat, degreesLongitude: data.place.lng }
-                        : undefined,
-                },
-            }, binary, opts.mid);
-        },
-        async edit(cid, mid, text) {
-            const m = await api.get(cid, mid);
-            return m ? m.edit(text) : false;
-        },
-        async delete(cid, mid, all = true) {
-            const m = await api.get(cid, mid);
-            return m ? m.delete(all) : false;
-        },
-        async react(cid, mid, emoji) {
-            const m = await api.get(cid, mid);
-            return m ? m.react(emoji) : false;
-        },
-        async forward(cid, mid, target) {
-            const m = await api.get(cid, mid);
-            return m ? m.forward(target) : false;
-        },
-        async seen(cid, mid) {
-            const m = await api.get(cid, mid);
-            return m ? m.seen() : false;
-        },
-        async star(cid, mid, value) {
-            const m = await api.get(cid, mid);
-            return m ? m.star(value) : false;
-        },
-        watch(cid, mid, handler) {
-            return wa.on('message:updated', (updated) => {
-                if (updated.cid === cid && updated.id === mid) {
-                    handler(updated);
-                }
-            });
-        },
+    else {
+        doc = raw;
+    }
+    const types = {
+        text: Text,
+        image: Image,
+        video: Video,
+        audio: Audio,
+        sticker: Sticker,
+        document: Document,
+        location: Location,
+        poll: Poll,
+        vcard: VCard,
+        event: Event,
     };
-    return api;
+    return new (types[doc.type] ?? Message)(wa, doc);
 }
-//# sourceMappingURL=index.js.map