@fer2809fl/baileys 1.4.9 → 7.0.0

package/README.md

@@ -1,661 +1,694 @@
 <div align="center">
 
-<img src="https://raw.githubusercontent.com/Fer2809fl/Baileys/refs/heads/main/lib/Baileys.jpeg" alt="Baileys" width="500" style="border-radius: 20px;"/>
+# ⚡ ASTA-BOTS
 
-# @fer2809fl/baileys
-### API de WhatsApp Web para Node.js
+### Librería de WhatsApp Web para bots, en TypeScript
 
-[![npm version](https://img.shields.io/npm/v/@fer2809fl/baileys?color=blueviolet&label=version)](https://www.npmjs.com/package/@fer2809fl/baileys)
-[![License](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE)
-[![Node.js](https://img.shields.io/badge/node-%3E%3D20-brightgreen)](https://nodejs.org)
-[![TypeScript](https://img.shields.io/badge/TypeScript-supported-blue)](https://www.typescriptlang.org)
-
-*Conéctate a WhatsApp Web directamente desde Node.js sin navegadores ni Selenium*
+![Node](https://img.shields.io/badge/node-%3E%3D20.0.0-brightgreen)
+![License](https://img.shields.io/badge/license-MIT-blue)
+![TypeScript](https://img.shields.io/badge/-TypeScript-3178C6?logo=typescript&logoColor=white)
+![ASTA-BOTS](https://img.shields.io/badge/⚡-ASTA--BOTS-00FFFF)
 
 </div>
 
----
+<br/>
+
+> [!NOTE]
+> ASTA-BOTS no requiere Selenium, Puppeteer ni ningún navegador para funcionar. Se conecta directamente a WhatsApp Web mediante un **WebSocket**, lo que la hace mucho más liviana en consumo de RAM y CPU en comparación con soluciones basadas en navegador.
+
+## Índice
+
+- [¿Qué es ASTA-BOTS?](#qué-es-asta-bots)
+- [Características](#características)
+- [Instalación](#instalación)
+- [Inicio rápido](#inicio-rápido)
+  - [Vinculación de la cuenta](#vinculación-de-la-cuenta)
+  - [Guardado de credenciales](#guardado-de-credenciales)
+- [Métodos de mensajería](#métodos-de-mensajería)
+  - [`sendMessage`](#sendmessage-el-método-principal)
+  - [Mensajes de texto](#mensajes-de-texto)
+  - [Mensajes multimedia](#mensajes-multimedia)
+  - [Procesar medios sin enviarlos](#procesar-medios-sin-enviarlos)
+  - [Ubicación y contactos](#ubicación-y-contactos)
+  - [Encuestas, reacciones y respuestas a botones](#encuestas-reacciones-y-respuestas-a-botones)
+  - [Botones, listas, templates y carousel](#botones-listas-templates-y-carousel)
+  - [Mensajes crudos (smgss): pagos, productos, álbumes, eventos y más](#mensajes-crudos-smgss-pagos-productos-álbumes-eventos-y-más)
+  - [Mensajes "raw" (proto armado a mano)](#mensajes-raw-proto-armado-a-mano)
+  - [Editar, eliminar, reenviar y fijar](#editar-eliminar-reenviar-y-fijar)
+  - [Mensajes enriquecidos](#mensajes-enriquecidos)
+  - [Marcar un mensaje como generado por IA](#marcar-un-mensaje-como-generado-por-ia)
+  - [Estados (historias)](#estados-historias)
+  - [Recibos, lectura y presencia](#recibos-lectura-y-presencia)
+- [Grupos, comunidades y canales](#grupos-comunidades-y-canales)
+- [Perfil, privacidad y negocios](#perfil-privacidad-y-negocios)
+- [Store (caché en memoria)](#store-caché-en-memoria)
+- [Utilidades ASTA-BOTS](#utilidades-asta-bots)
+  - [`resolveJid`: resolución automática de JID](#resolvejid-resolución-automática-de-jid)
+  - [Sistema de botones de conveniencia](#sistema-de-botones-de-conveniencia)
+  - [Código de vinculación de marca](#código-de-vinculación-de-marca)
+- [Aviso legal](#aviso-legal)
+- [Créditos](#créditos)
+
+## ¿Qué es ASTA-BOTS?
+
+**ASTA-BOTS** es una librería para conectarse a WhatsApp Web de forma directa, sin depender de un navegador ni de librerías de automatización como Selenium o Puppeteer. Toda la comunicación con WhatsApp ocurre a través de un **WebSocket**, tal como lo hace la propia versión web de WhatsApp, lo que se traduce en una librería rápida y liviana en recursos.
+
+Es un fork de **Baileys**, y conserva casi toda su base: el protocolo, el cifrado, la arquitectura del socket y el manejo de credenciales. Además, incorpora algunos métodos para enviar mensajes con contenido enriquecido (tablas, listas, código y LaTeX), botones/listas/carousel nativos de WhatsApp, un dispatcher para contenido avanzado (pagos, productos, álbumes, eventos), y utilidades propias de **ASTA-BOTS** para resolución automática de JID y botones de conveniencia — más detalle en las secciones correspondientes.
+
+Este README está enfocado principalmente en explicar **cómo enviar cada tipo de mensaje**, ya que es lo que más se necesita a la hora de integrar la librería en un proyecto real.
+
+## Características
+
+- 🔌 Conexión directa por WebSocket, sin navegador de por medio.
+- 💬 Envío de todo tipo de mensajes: texto, imágenes, video, audio, notas de voz, documentos, stickers, ubicación, contactos, encuestas y más.
+- 🔘 Botones, listas de selección, templates y carousel (interactive/native_flow), con el nodo `biz` necesario para que WhatsApp los acepte y renderice.
+- ⚡ **Resolución automática de JID** (`resolveJid`): detecta el destinatario de un comando por citado, mención o argumento, sin pasar el número a mano.
+- ⚡ **Helpers de botones listos para usar** (`sendQuickReplyButtons`, `sendUrlButton`, `sendListMenu`, etc.) y un detector de respuestas de botón (`setupButtonHandler`) para enrutarlas directo a tus comandos.
+- 💳 Contenido avanzado vía `smgss`: pedidos de pago, cards de producto, álbumes, eventos, resultados de encuesta e historias por grupo.
+- 🖼️ Procesamiento de medios (`resize`, `convert`, `toSticker`, `compress`, `metadata`) sobre cualquier `Buffer`, sin necesidad de enviarlo.
+- 🛠️ Salida de emergencia `raw: true` para mandar un mensaje armado a mano cuando ningún builder alcanza.
+- 🧩 Métodos para enviar mensajes enriquecidos: tablas, listas, código y LaTeX.
+- 🤖 Marca de "generado por IA" en mensajes de chats individuales.
+- 📸 Publicación de estados (historias) con notificación por menciones, tanto a contactos individuales como a grupos.
+- 👥 Administración completa de grupos, comunidades y canales de difusión.
+- 🔐 2 métodos de vinculación: código QR o código de emparejamiento (con código de marca **`ASTABOTS`** por defecto).
+- 🗂️ 3 formas de guardar credenciales: por archivos múltiples, un solo archivo o SQLite.
+
+## Instalación
+
+Instalación directa desde GitHub:
 
-## 🆕 Novedades — v1.8.9
+```bash
+npm install github:TU-USUARIO/asta-bots
+```
 
-### ✅ Nuevas funciones añadidas
-- **Botones interactivos** — Se agregaron funciones nativas para enviar botones de WhatsApp:
-  - `sendCopyButton` — Botón que copia texto al portapapeles
-  - `sendUrlButton` — Botón que abre un enlace en el navegador
-  - `sendQuickReplyButtons` — Botones de respuesta rápida
-  - `sendCallButton` — Botón para iniciar una llamada telefónica
-  - `sendListMenu` — Menú desplegable con secciones y filas
-  - `sendInteractiveMessage` — Combinación de botones mixtos (URL + Copiar + Rápido)
+> Cambia `TU-USUARIO/asta-bots` por la ruta de tu propio repositorio de ASTA-BOTS en GitHub.
+>
+> **Requisito:** Node.js **20** o superior.
 
-### 🐛 Correcciones
-- **Error en macOS** — Se reparó un bug crítico que impedía iniciar sesión correctamente en dispositivos Mac. El proceso de pairing/QR ahora funciona de forma estable en macOS.
+Una vez instalada, importala en tu proyecto:
 
----
+```ts
+import makeWASocket from 'baileys'
+```
 
-## ⚠️ Nota Importante
+## Inicio rápido
 
-ꕤ Esta librería está basada en Baileys. No está afiliada ni aprobada oficialmente por WhatsApp.
+Para conectar una cuenta de WhatsApp a ASTA-BOTS hacen falta dos cosas: **cómo se guardan las credenciales de la sesión** y **cómo se vincula el dispositivo** (que puede ser con código QR o con código de emparejamiento).
 
-> **@fer2809fl/baileys** y su desarrollador no se hacen responsables por el mal uso de esta librería.
-> Úsala de forma responsable — nada de spam ni actividades maliciosas.
+### Vinculación de la cuenta
 
----
+ASTA-BOTS soporta los **2 métodos de vinculación** que ofrece WhatsApp:
 
-## 📦 Instalación
+#### 1. Con código QR
 
-Puedes instalarla de varias formas, todas funcionan igual:
+```ts
+import makeWASocket, { useMultiFileAuthState } from 'baileys'
 
-**Opción 1 — Desde npm (recomendado)**
-```bash
-npm install @fer2809fl/baileys
-yarn add @fer2809fl/baileys
-```
+async function iniciar() {
+  const { state, saveCreds } = await useMultiFileAuthState('sesion')
 
-**Opción 2 — Desde GitHub directamente**
-```bash
-npm install github:Fer2809fl/Baileys
-yarn add github:Fer2809fl/Baileys
-```
+  const sock = makeWASocket({
+    auth: state,
+    printQRInTerminal: true
+  })
 
-**Opción 3 — También funciona con el paquete original**
-```bash
-npm install @whiskeysockets/baileys
-yarn add @whiskeysockets/baileys
-```
+  sock.ev.on('creds.update', saveCreds)
 
-**Opción — En tu package.json** (elige una de estas formas):
-```json
-{
-  "dependencies": {
-    "@fer2809fl/baileys": "^1.8.9"
-  }
+  sock.ev.on('connection.update', (update) => {
+    console.log(update)
+  })
 }
+
+iniciar()
 ```
-```json
-{
-  "dependencies": {
-    "@whiskeysockets/baileys": "github:Fer2809fl/Baileys"
-  }
+
+Al iniciar, se imprime un código QR en la terminal que hay que escanear desde WhatsApp (Dispositivos vinculados → Vincular un dispositivo).
+
+#### 2. Con código de emparejamiento
+
+```ts
+const sock = makeWASocket({
+  auth: state,
+  printQRInTerminal: false
+})
+
+if (!sock.authState?.creds?.registered) {
+  const codigo = await sock.requestPairingCode('5215512345678') // número con código de país, sin +
+  console.log('Tu código de emparejamiento es:', codigo)
 }
 ```
 
----
+En este caso, en vez de escanear un QR, WhatsApp te muestra en el celular un código de 8 caracteres que hay que ingresar desde la opción "Vincular con número de teléfono".
 
-## ⚡ Inicio Rápido
+### Guardado de credenciales
 
-### JavaScript
-```javascript
-const { makeWASocket, useMultiFileAuthState } = require('@fer2809fl/baileys')
+Una vez vinculada la cuenta, ASTA-BOTS necesita persistir las credenciales para no tener que volver a escanear el QR o pedir el código cada vez. Hay **3 formas** de hacerlo, todas exportadas por la librería:
 
-async function startBot() {
-    const { state, saveCreds } = await useMultiFileAuthState('session-mymelody')
-    
-    const melody = makeWASocket({
-        auth: state,
-        printQRInTerminal: true
-    })
+| Método | Cómo guarda los datos | Cuándo conviene |
+|---|---|---|
+| `useMultiFileAuthState('carpeta')` | Un archivo por cada clave, dentro de una carpeta | Uso por defecto, ideal para desarrollo y bots simples |
+| `useSingleFileAuthState('archivo.json')` | Todo en un único archivo JSON | Cuando querés portar la sesión fácilmente como un solo archivo |
+| `useSqliteAuthState({ dbPath: 'sesion.db' })` | En una base de datos SQLite (requiere `better-sqlite3`) | Bots con mucho volumen de claves o que necesitan acceso concurrente |
 
-    melody.ev.on('connection.update', ({ connection }) => {
-        if (connection === 'open') console.log('✅ ¡Conectado con éxito!')
-        if (connection === 'close') console.log('❌ Conexión cerrada, reconectando...')
-    })
+Ejemplo con SQLite:
 
-    melody.ev.on('messages.upsert', async ({ messages }) => {
-        const m = messages[0]
-        if (!m.message) return
+```ts
+import makeWASocket, { useSqliteAuthState } from 'baileys'
 
-        await melody.sendMessage(m.key.remoteJid, { 
-            text: '¡Hola! Soy un bot de Delta!' 
-        })
-    })
+const { state, saveCreds } = await useSqliteAuthState({ dbPath: 'sesion.db' })
 
-    melody.ev.on('creds.update', saveCreds)
-}
+const sock = makeWASocket({ auth: state })
+sock.ev.on('creds.update', saveCreds)
+```
+
+## Métodos de mensajería
+
+Todos los métodos de envío viven dentro del objeto `sock` que devuelve `makeWASocket()`. La firma general es siempre parecida: reciben el **JID** (identificador del chat) y el contenido del mensaje.
+
+Formatos de JID más comunes:
+
+| Tipo de chat | Formato de JID |
+|---|---|
+| Contacto individual | `5215512345678@s.whatsapp.net` |
+| Grupo | `1234567890@g.us` |
+| Canal de difusión (newsletter) | `1234567890@newsletter` |
+| Estado (historia) | `status@broadcast` |
+| Identificador LID | `123456789@lid` |
+
+> **¿Qué es un LID?** Es un identificador que WhatsApp usa como capa de privacidad: en ciertos contextos (por ejemplo, dentro de comunidades) un contacto no se identifica con su número de teléfono (`@s.whatsapp.net`) sino con un `@lid`, un ID que no revela el número real. ASTA-BOTS mantiene internamente una tabla de equivalencias entre el LID y el número de teléfono real (`LIDMappingStore`) para poder cifrar y enviar los mensajes correctamente sin que tengas que hacer nada manualmente. Si necesitás revisarlo, `isLidUser(jid)` te dice si un JID es de tipo LID.
 
-startBot()
+### `sendMessage` — el método principal
+
+```ts
+await sock.sendMessage(jid, contenido, opciones)
 ```
 
-### TypeScript
-```typescript
-import makeWASocket, { useMultiFileAuthState, DisconnectReason } from '@fer2809fl/baileys'
-import { Boom } from '@hapi/boom'
+- **`jid`** *(string)*: destinatario del mensaje (contacto, grupo, canal o `status@broadcast` para estados).
+- **`contenido`** *(`AnyMessageContent`)*: define qué tipo de mensaje se envía (texto, imagen, video, encuesta, botones, etc. — ver detalle abajo).
+- **`opciones`** *(`MiscMessageGenerationOptions`, opcional)*: permite, entre otras cosas:
+  - `quoted`: el mensaje al que se responde (citar).
+  - `messageId`: forzar un ID de mensaje propio.
+  - `ephemeralExpiration`: duración de los mensajes efímeros.
+  - `mediaUploadTimeoutMs`: tiempo máximo para subir archivos.
 
-async function startBot(): Promise<void> {
-    const { state, saveCreds } = await useMultiFileAuthState('session-mymelody')
-    
-    const melody = makeWASocket({
-        auth: state,
-        printQRInTerminal: true
-    })
+Todos los métodos de envío devuelven una promesa que se resuelve con el mensaje ya construido y enviado (`WAMessage`), el cual podés guardar para citarlo, editarlo o eliminarlo más adelante.
 
-    melody.ev.on('connection.update', ({ connection, lastDisconnect }) => {
-        if (connection === 'close') {
-            const shouldReconnect = (lastDisconnect?.error as Boom)?.output?.statusCode !== DisconnectReason.loggedOut
-            if (shouldReconnect) startBot()
-        }
-        if (connection === 'open') console.log('✅ ¡Conectado!')
-    })
+El resto de los métodos de esta sección (`sendTable`, `sendList`, `sendCodeBlock`, etc.) son en realidad **atajos**: por debajo construyen el `contenido` correcto y llaman a `relayMessage` por vos, para que no tengas que armar la estructura del mensaje a mano.
 
-    melody.ev.on('messages.upsert', async ({ messages }) => {
-        const m = messages[0]
-        if (!m.message) return
+> Si el `contenido` incluye botones, lista, template o carousel, `sendMessage` agrega automáticamente el nodo `biz` que WhatsApp exige para aceptarlos y renderizarlos — no hace falta que hagas nada extra para eso.
 
-        await melody.sendMessage(m.key.remoteJid!, { 
-            text: '¡Hola! Soy un bot de Delta!' 
-        })
-    })
+### Mensajes de texto
 
-    melody.ev.on('creds.update', saveCreds)
-}
+```ts
+await sock.sendMessage(jid, { text: 'Hola, esto es ASTA-BOTS 👋' })
+```
 
-startBot()
+Con vista previa de enlace desactivada:
+
+```ts
+await sock.sendMessage(jid, { text: 'Mirá esto: https://ejemplo.com', linkPreview: null })
 ```
 
----
+Citando un mensaje:
 
-## ✨ Características
-
-### General
-- 🚀 Optimizado para mayor velocidad y estabilidad
-- 📸 Mensajes multimedia (imágenes, video, audio, documentos)
-- 🤖 Comandos personalizados fáciles de implementar
-- 👥 Soporte para grupos y chats privados
-- 🔘 **Mensajes interactivos con botones, listas y más** *(nuevo en v1.8.9)*
-
-### Técnicas
-- ⚡ Sin Selenium — Conexión directa vía WebSocket
-- 💾 Super eficiente — Bajo consumo de RAM
-- 📱 Soporte multi-dispositivo — Compatible con WhatsApp Web
-- 🔷 Totalmente tipado — TypeScript y JavaScript
-- 🔄 Reconexión automática ante desconexiones
-- 🔐 Sesiones persistentes guardadas localmente
-- 🌐 API completa de WhatsApp Web
-- 🍎 **Compatible con macOS** — Error de pairing reparado *(fix en v1.8.9)*
+```ts
+await sock.sendMessage(jid, { text: 'Respondiendo a tu mensaje' }, { quoted: mensajeOriginal })
+```
 
----
+### Mensajes multimedia
+
+| Tipo | Campo | Ejemplo |
+|---|---|---|
+| Imagen | `image` | `{ image: { url: './foto.jpg' }, caption: 'Mirá esto' }` |
+| Video | `video` | `{ video: { url: './video.mp4' }, caption: 'Un video', gifPlayback: false }` |
+| Nota de voz | `audio` + `ptt: true` | `{ audio: { url: './audio.mp3' }, ptt: true }` |
+| Audio normal | `audio` | `{ audio: { url: './cancion.mp3' }, mimetype: 'audio/mp4' }` |
+| Video nota (círculo) | `video` + `ptv: true` | `{ video: { url: './nota.mp4' }, ptv: true }` |
+| Sticker | `sticker` | `{ sticker: { url: './sticker.webp' } }` |
+| Documento | `document` | `{ document: { url: './archivo.pdf' }, mimetype: 'application/pdf', fileName: 'informe.pdf' }` |
+| Paquete de stickers | `stickerPack` | `{ stickerPack: { name: 'Mi pack', cover: {...}, stickers: [...] } }` |
+| Álbum (varias fotos/videos) | `album` | `{ album: { images: [...], videos: [...] } }` |
+
+Ejemplo completo:
+
+```ts
+await sock.sendMessage(jid, {
+  image: { url: './foto.jpg' },
+  caption: 'Foto enviada desde ASTA-BOTS'
+})
+```
 
-## 🔘 Botones Interactivos *(nuevo en v1.8.9)*
+> `WAMediaUpload` acepta una URL (`{ url: '...' }`), un `Buffer` o un `Stream`, tanto para archivos locales como remotos.
 
-Desde la versión **1.8.9** puedes importar y usar funciones nativas para enviar botones interactivos de WhatsApp.
+### Procesar medios sin enviarlos
 
-### Importar las funciones
+Además de enviar, el socket expone helpers para procesar imágenes y video directamente sobre un `Buffer`, sin que eso implique mandar ningún mensaje:
 
-```javascript
-// JavaScript (CommonJS)
-const {
-    sendCopyButton,
-    sendUrlButton,
-    sendQuickReplyButtons,
-    sendCallButton,
-    sendListMenu,
-    sendInteractiveMessage
-} = require('@fer2809fl/baileys')
+```ts
+const redimensionada = await sock.resize(buffer, 512, 512, { quality: 80 })
+const convertida = await sock.convert(buffer, { to: 'webp' })
+const sticker = await sock.toSticker(buffer, { quality: 80 })
+const comprimida = await sock.compress(buffer, { quality: 50 })
+const info = await sock.metadata(buffer) // { size, mimetype, width, height, duration, ... }
 ```
 
-```typescript
-// TypeScript / ESM
-import {
-    sendCopyButton,
-    sendUrlButton,
-    sendQuickReplyButtons,
-    sendCallButton,
-    sendListMenu,
-    sendInteractiveMessage
-} from '@fer2809fl/baileys'
+Usan `sharp` (si está instalado) y caen a `ffmpeg`/`ffprobe` para lo que `sharp` no soporta (video). No afectan la velocidad de la conexión ni del envío de mensajes — son solo utilidades de conveniencia para procesar archivos.
+
+### Ubicación y contactos
+
+```ts
+// Ubicación
+await sock.sendMessage(jid, {
+  location: { degreesLatitude: 19.4326, degreesLongitude: -99.1332, name: 'CDMX' }
+})
+
+// Contacto (vCard)
+await sock.sendMessage(jid, {
+  contacts: {
+    displayName: 'Soporte',
+    contacts: [{ vcard: 'BEGIN:VCARD\nVERSION:3.0\nFN:Soporte\nTEL:+521234567890\nEND:VCARD' }]
+  }
+})
 ```
 
----
+### Encuestas, reacciones y respuestas a botones
 
-### 📋 `sendCopyButton` — Botón Copiar
-Muestra un botón que al tocarlo copia un texto al portapapeles del usuario.
+```ts
+// Encuesta
+await sock.sendMessage(jid, {
+  poll: { name: '¿Cuál prefieres?', values: ['Opción A', 'Opción B'], selectableCount: 1 }
+})
 
-```javascript
-await sendCopyButton(
-    conn,
-    jid,
-    '📋 *CÓDIGO DE INSTALACIÓN*\n\nEjecuta este comando en tu terminal:',
-    'npm install asta-bot',   // texto que se copiará
-    '📋 Copiar Comando'       // etiqueta del botón
-)
+// Reacción a un mensaje
+await sock.sendMessage(jid, { react: { text: '🔥', key: mensaje.key } })
+
+// Respuesta a un botón / lista (uso interno al procesar interacciones)
+await sock.sendMessage(jid, { buttonReply: { displayText: 'Sí', id: 'btn_si', index: 0 }, type: 'plain' })
 ```
 
----
+### Botones, listas, templates y carousel
 
-### 🔗 `sendUrlButton` — Botón URL
-Abre un enlace en el navegador al tocar el botón.
+ASTA-BOTS puede armar botones nativos (`native_flow`), listas de selección, templates legados y carousel directamente desde `sock.sendMessage`, sin tener que construir el protobuf a mano. En todos los casos se agrega automáticamente el nodo `biz` necesario para que WhatsApp los acepte.
 
-```javascript
-await sendUrlButton(
-    conn,
-    jid,
-    '🔗 *ENLACES IMPORTANTES*\n\nVisita nuestro repositorio oficial:',
-    'https://github.com/Fer2809fl/Asta_bot',  // URL de destino
-    '🌐 Ver GitHub'                            // etiqueta del botón
-)
+**Botones** — soporta respuesta rápida (`id`), enlace (`url`), llamada (`call`), copiar texto (`copy`), una mini-lista embebida (`sections`), un flow crudo (`name` + `paramsJson`), o un botón ya armado con `nativeFlowInfo` (por ejemplo, reenviado de otro lado) — en ese caso se respeta tal cual viene:
+
+```ts
+await sock.sendMessage(jid, {
+  text: 'Elegí una opción',
+  footer: 'Powered by ASTA-BOTS',
+  buttons: [
+    { text: 'Visitar sitio', url: 'https://ejemplo.com' },
+    { text: 'Llamar', call: '+50488888888' },
+    { text: 'Copiar código', copy: 'ABC123' },
+    { text: 'Responder', id: 'opt_1' }
+  ]
+})
 ```
 
----
+> `buttons`/`sections`/`templateButtons`/`nativeFlow`/`cards` se evalúan **antes** que `text` en el armado interno del mensaje, así que combinar `text` (el cuerpo) junto con cualquiera de estos tipos funciona sin que el texto se coma al resto del contenido.
+
+**Lista de selección única:**
+
+```ts
+await sock.sendMessage(jid, {
+  description: 'Elegí un producto del catálogo',
+  title: 'Catálogo',
+  buttonText: 'Ver opciones',
+  footer: 'ASTA-BOTS',
+  sections: [
+    {
+      title: 'Sección 1',
+      rows: [
+        { title: 'Producto A', rowId: 'a' },
+        { title: 'Producto B', rowId: 'b' }
+      ]
+    }
+  ]
+})
+```
 
-### ⚡ `sendQuickReplyButtons` — Botones de Respuesta Rápida
-Muestra varios botones de respuesta rápida debajo del mensaje.
-
-```javascript
-await sendQuickReplyButtons(
-    conn,
-    jid,
-    '🎮 *MENÚ DE OPCIONES*\n\n¿Qué deseas hacer?',
-    [
-        { id: 'menu',  text: '📋 Ver Menú'    },
-        { id: 'info',  text: 'ℹ️ Información' },
-        { id: 'owner', text: '👑 Owner'       }
-    ]
-)
+**Template buttons** (formato legado — solo se renderiza en WhatsApp Web, Desktop e iOS):
+
+```ts
+await sock.sendMessage(jid, {
+  text: 'Confirmá tu pedido',
+  templateButtons: [
+    { text: 'Sí', id: 'yes' },
+    { text: 'Visitar', url: 'https://ejemplo.com' },
+    { text: 'Llamar', call: '+50488888888' }
+  ]
+})
 ```
 
----
+**Interactive message genérico** (`nativeFlow`), con header de imagen/video/documento:
+
+```ts
+await sock.sendMessage(jid, {
+  image: { url: 'https://ejemplo.com/foto.jpg' },
+  caption: 'Mirá esto',
+  title: 'Título',
+  subtitle: 'Subtítulo',
+  footer: 'ASTA-BOTS',
+  nativeFlow: [
+    { text: 'Ver más', url: 'https://ejemplo.com' }
+  ]
+})
+```
 
-### 📞 `sendCallButton` — Botón de Llamada
-Inicia una llamada al número indicado al tocar el botón.
+**Carousel** (varias cards, cada una con su propio header y botones):
 
-```javascript
-await sendCallButton(
-    conn,
-    jid,
-    '📞 *SOPORTE TÉCNICO*\n\n¿Necesitas ayuda? Llámanos:',
-    '+5214183357841',  // número de teléfono
-    '📞 Llamar Ahora'  // etiqueta del botón
-)
+```ts
+await sock.sendMessage(jid, {
+  cards: [
+    { image: { url: 'https://ejemplo.com/1.jpg' }, caption: 'Carta 1', nativeFlow: [{ text: 'Comprar', id: 'buy_1' }] },
+    { image: { url: 'https://ejemplo.com/2.jpg' }, caption: 'Carta 2', nativeFlow: [{ text: 'Comprar', id: 'buy_2' }] }
+  ]
+})
 ```
 
----
+### Mensajes crudos (smgss): pagos, productos, álbumes, eventos y más
+
+Para contenido que no tiene un atajo declarativo simple, ASTA-BOTS incluye un dispatcher (`smgss`) que reconoce el contenido a partir de su forma y lo arma internamente. Se usa igual que cualquier otro contenido, pasándolo directo a `sock.sendMessage(jid, contenido)`:
+
+| Contenido | Qué hace |
+|---|---|
+| `{ requestPaymentMessage: {...} }` | Pedido de pago, con nota de texto o sticker adjunto opcional. |
+| `{ productMessage: {...} }` | Card de un producto individual (imagen, precio, descripción). |
+| `{ interactiveButtons: [...] }` | Botones declarativos con header de imagen/video/documento/ubicación/producto. |
+| `{ interactiveMessage: {...} }` | Interactive message armado a mano (media header + botones nativos propios). |
+| `{ interactiveMessage: { carouselMessage: {...} } }` | Carousel armado a mano, con cards en formato de proto crudo. |
+| `{ albumMessage: [...] }` o `{ album: [...] }` | Álbum: manda el contenedor y después cada foto/video asociado. |
+| `{ eventMessage: {...} }` | Evento de WhatsApp (nombre, descripción, fecha, ubicación, link para unirse). |
+| `{ pollResultMessage: {...} }` | Snapshot de resultados de una encuesta. |
+| `{ groupStatusMessage: {...} }` | Historia visible solo para un grupo puntual (distinto al estado normal). |
+
+Ejemplo de pedido de pago:
+
+```ts
+await sock.sendMessage(jid, {
+  requestPaymentMessage: {
+    amount: 50000, // en la unidad mínima de la moneda (ej. centavos)
+    currency: 'USD',
+    from: '0@s.whatsapp.net',
+    note: 'Pago por el servicio de este mes'
+  }
+})
+```
 
-### 📋 `sendListMenu` — Menú Desplegable (Lista)
-Muestra un menú con secciones y opciones seleccionables.
-
-```javascript
-await sendListMenu(
-    conn,
-    jid,
-    '📋 *SELECCIONA UNA OPCIÓN*',
-    'Menú Principal',  // título del botón que abre la lista
-    [
-        {
-            title: '📱 COMANDOS BÁSICOS',
-            rows: [
-                { id: '#menu',  title: '📋 Menú',  description: 'Ver todos los comandos' },
-                { id: '#ping',  title: '🏓 Ping',  description: 'Ver latencia del bot'   },
-                { id: '#owner', title: '👑 Owner', description: 'Info del creador'       }
-            ]
-        },
-        {
-            title: '🎮 COMANDOS DE GRUPO',
-            rows: [
-                { id: '#add',     title: '➕ Agregar', description: 'Agregar usuario al grupo'  },
-                { id: '#kick',    title: '👢 Expulsar', description: 'Expulsar usuario del grupo' },
-                { id: '#promote', title: '⭐ Promover', description: 'Dar admin a un usuario'   }
-            ]
-        },
-        {
-            title: '🔧 CONFIGURACIÓN',
-            rows: [
-                { id: '#sinprefix', title: '⚙️ Sin Prefijo', description: 'Activar/desactivar prefijo' },
-                { id: '#antilink', title: '🔗 Anti Link',    description: 'Bloquear enlaces'           }
-            ]
-        }
-    ]
-)
+Ejemplo de álbum:
+
+```ts
+await sock.sendMessage(jid, {
+  album: [
+    { image: { url: './foto1.jpg' } },
+    { image: { url: './foto2.jpg' } },
+    { video: { url: './video1.mp4' } }
+  ]
+})
 ```
 
----
+### Mensajes "raw" (proto armado a mano)
 
-### 🎯 `sendInteractiveMessage` — Múltiples Botones Mixtos
-Combina distintos tipos de botones en un solo mensaje.
-
-```javascript
-await sendInteractiveMessage(
-    conn,
-    jid,
-    '🎯 *PANEL DE CONTROL*\n\nSelecciona una acción rápida:',
-    [
-        { type: 'url',   text: '🌐 GitHub',        value: 'https://github.com/Fer2809fl/Asta_bot' },
-        { type: 'copy',  text: '📋 Comando Inicio', value: 'npm start'                             },
-        { type: 'quick', text: '📋 Ver Menú',       value: 'menu'                                  }
-    ]
-)
+Para casos que ningún builder cubre todavía, se puede pasar el contenido del mensaje ya armado como protobuf, agregando `raw: true`. ASTA-BOTS no lo interpreta ni lo transforma — lo manda tal cual:
+
+```ts
+await sock.sendMessage(jid, {
+  raw: true,
+  extendedTextMessage: { text: 'Mensaje armado a mano' }
+})
 ```
 
----
+Es una salida de emergencia para power users; para el 99% de los casos alcanza con los métodos normales de `sendMessage`.
 
-### Plugin de ejemplo completo
-
-Aquí un plugin listo para usar en tu bot con todos los tipos de botones:
-
-```javascript
-// plugins/botones.js
-import { 
-    sendCopyButton,
-    sendUrlButton,
-    sendQuickReplyButtons,
-    sendCallButton,
-    sendListMenu,
-    sendInteractiveMessage
-} from '@fer2809fl/baileys'
-
-let handler = async (m, { conn, usedPrefix }) => {
-
-    // #boton1 — Botón Copiar
-    if (m.text === `${usedPrefix}boton1`) {
-        await sendCopyButton(conn, m.chat,
-            '📋 *CÓDIGO DE INSTALACIÓN*\n\nEjecuta este comando en tu terminal:',
-            'npm install asta-bot',
-            '📋 Copiar Comando'
-        )
-    }
+### Editar, eliminar, reenviar y fijar
 
-    // #boton2 — Botón URL
-    else if (m.text === `${usedPrefix}boton2`) {
-        await sendUrlButton(conn, m.chat,
-            '🔗 *ENLACES IMPORTANTES*\n\nVisita nuestro repositorio oficial:',
-            'https://github.com/Fer2809fl/Asta_bot',
-            '🌐 Ver GitHub'
-        )
-    }
+```ts
+// Editar un mensaje ya enviado
+await sock.sendMessage(jid, { text: 'Texto corregido', edit: mensajeAnterior.key })
 
-    // #boton3 — Botones de Respuesta Rápida
-    else if (m.text === `${usedPrefix}boton3`) {
-        await sendQuickReplyButtons(conn, m.chat,
-            '🎮 *MENÚ DE OPCIONES*\n\n¿Qué deseas hacer?',
-            [
-                { id: 'menu',  text: '📋 Ver Menú'    },
-                { id: 'info',  text: 'ℹ️ Información' },
-                { id: 'owner', text: '👑 Owner'       }
-            ]
-        )
-    }
+// Eliminar (para todos)
+await sock.sendMessage(jid, { delete: mensaje.key })
 
-    // #boton4 — Botón de Llamada
-    else if (m.text === `${usedPrefix}boton4`) {
-        await sendCallButton(conn, m.chat,
-            '📞 *SOPORTE TÉCNICO*\n\n¿Necesitas ayuda? Llámanos:',
-            '+5214183357841',
-            '📞 Llamar Ahora'
-        )
-    }
+// Reenviar un mensaje
+await sock.sendMessage(jid, { forward: mensajeOriginal })
 
-    // #boton5 — Lista Desplegable
-    else if (m.text === `${usedPrefix}boton5`) {
-        await sendListMenu(conn, m.chat,
-            '📋 *SELECCIONA UNA OPCIÓN*',
-            'Menú Principal',
-            [
-                {
-                    title: '📱 COMANDOS BÁSICOS',
-                    rows: [
-                        { id: '#menu',  title: '📋 Menú',  description: 'Ver todos los comandos' },
-                        { id: '#ping',  title: '🏓 Ping',  description: 'Ver latencia del bot'   },
-                        { id: '#owner', title: '👑 Owner', description: 'Info del creador'       }
-                    ]
-                },
-                {
-                    title: '🎮 COMANDOS DE GRUPO',
-                    rows: [
-                        { id: '#add',     title: '➕ Agregar', description: 'Agregar usuario al grupo'    },
-                        { id: '#kick',    title: '👢 Expulsar', description: 'Expulsar usuario del grupo' },
-                        { id: '#promote', title: '⭐ Promover', description: 'Dar admin a un usuario'    }
-                    ]
-                },
-                {
-                    title: '🔧 CONFIGURACIÓN',
-                    rows: [
-                        { id: '#sinprefix', title: '⚙️ Sin Prefijo', description: 'Activar/desactivar prefijo' },
-                        { id: '#antilink',  title: '🔗 Anti Link',   description: 'Bloquear enlaces'           }
-                    ]
-                }
-            ]
-        )
-    }
+// Fijar un mensaje en el chat (24h, 7 días o 30 días)
+await sock.sendMessage(jid, { pin: mensaje.key, type: 1, time: 86400 })
+```
 
-    // #boton6 — Botones Mixtos
-    else if (m.text === `${usedPrefix}boton6`) {
-        await sendInteractiveMessage(conn, m.chat,
-            '🎯 *PANEL DE CONTROL*\n\nSelecciona una acción rápida:',
-            [
-                { type: 'url',   text: '🌐 GitHub',        value: 'https://github.com/Fer2809fl/Asta_bot' },
-                { type: 'copy',  text: '📋 Comando Inicio', value: 'npm start'                             },
-                { type: 'quick', text: '📋 Ver Menú',       value: 'menu'                                  }
-            ]
-        )
-    }
+### Mensajes enriquecidos
 
-    // #botones — Ayuda
-    else if (m.text === `${usedPrefix}botones`) {
-        await conn.reply(m.chat,
-            `🧪 *COMANDOS DE PRUEBA - BOTONES INTERACTIVOS*\n\n` +
-            `┌✦ *BOTÓN COPIAR*\n` +
-            `│ ${usedPrefix}boton1 - Botón que copia texto\n│\n` +
-            `├✦ *BOTÓN URL*\n` +
-            `│ ${usedPrefix}boton2 - Botón que abre enlace\n│\n` +
-            `├✦ *BOTONES RÁPIDOS*\n` +
-            `│ ${usedPrefix}boton3 - Botones de respuesta\n│\n` +
-            `├✦ *BOTÓN LLAMADA*\n` +
-            `│ ${usedPrefix}boton4 - Botón para llamar\n│\n` +
-            `├✦ *LISTA DESPLEGABLE*\n` +
-            `│ ${usedPrefix}boton5 - Menú con opciones\n│\n` +
-            `└✦ *MÚLTIPLES BOTONES*\n` +
-            `  ${usedPrefix}boton6 - Combinación de botones\n\n` +
-            `✨ *Prueba cada uno y mira cómo funcionan!*`, m)
-    }
-}
+Estos métodos permiten enviar contenido "enriquecido" reutilizando el mismo formato interno que WhatsApp usa para las respuestas de Meta AI (tablas, código con resaltado de sintaxis, LaTeX, etc.), sin tener que armar el protobuf a mano.
 
-handler.command = ['boton1', 'boton2', 'boton3', 'boton4', 'boton5', 'boton6', 'botones']
-handler.help    = ['boton1', 'boton2', 'boton3', 'boton4', 'boton5', 'boton6', 'botones']
-handler.tags    = ['test']
+**`sendTable`** — envía una tabla con encabezados y filas:
 
-export default handler
+```ts
+await sock.sendTable(
+  jid,
+  'Precios',
+  ['Producto', 'Precio'],
+  [['Café', '$50'], ['Té', '$40']],
+  undefined,
+  { footer: 'Precios sujetos a cambio' }
+)
 ```
 
----
+**`sendList`** — envía una lista simple de elementos:
 
-## 📖 Uso Básico
+```ts
+await sock.sendList(jid, 'Tareas pendientes', ['Comprar pan', 'Enviar reporte', 'Llamar al cliente'])
+```
 
-### Inicializar el bot
+> No confundir con la lista de selección de WhatsApp (`sections`) explicada en [Botones, listas, templates y carousel](#botones-listas-templates-y-carousel) — `sendList` arma un mensaje enriquecido de solo lectura, no una lista interactiva con opciones seleccionables.
 
-```javascript
-// JavaScript
-const { makeWASocket, useMultiFileAuthState } = require('@fer2809fl/baileys')
+**`sendCodeBlock`** — envía código con resaltado de sintaxis (soporta `javascript`, `typescript`, `python`, entre otros):
 
-const { state, saveCreds } = await useMultiFileAuthState('session-mymelody')
-const melody = makeWASocket({ auth: state, printQRInTerminal: true })
-melody.ev.on('creds.update', saveCreds)
+```ts
+await sock.sendCodeBlock(jid, 'console.log("Hola mundo")', undefined, { language: 'javascript', title: 'Ejemplo' })
 ```
 
-```typescript
-// TypeScript
-import makeWASocket, { useMultiFileAuthState } from '@fer2809fl/baileys'
+**`sendLatex`** — envía una o más expresiones matemáticas en formato LaTeX:
 
-const { state, saveCreds } = await useMultiFileAuthState('session-mymelody')
-const melody = makeWASocket({ auth: state, printQRInTerminal: true })
-melody.ev.on('creds.update', saveCreds)
+```ts
+await sock.sendLatex(jid, undefined, {
+  text: 'La fórmula cuadrática es:',
+  expressions: [{ latexExpression: 'x = \\frac{-b \\pm \\sqrt{b^2-4ac}}{2a}' }]
+})
 ```
 
-### Enviar mensajes
+**`sendRichMessage`** — envía una combinación libre de sub-mensajes (texto, tabla, código, LaTeX, imágenes) en un solo mensaje:
 
-```javascript
-// Texto simple
-await melody.sendMessage(jid, { text: '¡Hola mundo!' })
+```ts
+await sock.sendRichMessage(jid, [
+  { messageType: RichSubMessageType.TEXT, messageText: 'Resultado del análisis:' },
+  { messageType: RichSubMessageType.TABLE, tableMetadata: { title: 'Datos', rows: [...] } }
+])
+```
 
-// Imagen con caption
-await melody.sendMessage(jid, {
-    image: { url: './images/mymelody.jpg' },
-    caption: '¡Mira mi nueva foto!'
-})
+**`captureUnifiedResponse`** / **`sendUnifiedResponse`** — permiten capturar la respuesta enriquecida de un mensaje recibido y reenviarla o reutilizarla tal cual:
 
-// Video con caption
-await melody.sendMessage(jid, {
-    video: { url: './videos/clip.mp4' },
-    caption: '¡Nuevo video!'
-})
+```ts
+const capturado = sock.captureUnifiedResponse(mensajeRecibido.message)
+if (capturado) {
+  await sock.sendUnifiedResponse(otroJid, undefined, capturado)
+}
+```
 
-// Audio (PTT = nota de voz)
-await melody.sendMessage(jid, {
-    audio: { url: './audio/nota.mp3' },
-    mimetype: 'audio/mp4',
-    ptt: true
-})
+**`updateMediaMessage`** — re-sube un archivo multimedia cuyo enlace venció, para poder reenviarlo:
 
-// Sticker
-await melody.sendMessage(jid, {
-    sticker: { url: './stickers/melody.webp' }
-})
+```ts
+await sock.updateMediaMessage(mensajeConMediaVencido)
+```
 
-// Documento
-await melody.sendMessage(jid, {
-    document: { url: './archivo.pdf' },
-    mimetype: 'application/pdf',
-    fileName: 'archivo.pdf'
-})
+### Marcar un mensaje como generado por IA
 
-// Reaccionar a un mensaje
-await melody.sendMessage(jid, {
-    react: { text: '💖', key: m.key }
-})
+Cualquier mensaje regular (texto, imagen, video, etc.) puede llevar la etiqueta/icono de "generado por IA" que WhatsApp muestra junto al mensaje, agregando la propiedad `ai: true` al contenido:
+
+```ts
+await sock.sendMessage(jid, { text: 'Esta respuesta la generó un modelo de IA', ai: true })
 ```
 
----
+> ⚠️ Esta marca **solo funciona en chats individuales** (no en grupos). Si se intenta usar `ai: true` en un grupo, ASTA-BOTS lanza un error indicando que el icono de IA solo está permitido en chats privados.
 
-## 🤖 Comandos Personalizados
-
-### JavaScript
-```javascript
-melody.ev.on('messages.upsert', async ({ messages }) => {
-    const m = messages[0]
-    const body = m.message?.conversation
-        || m.message?.extendedTextMessage?.text
-        || ''
-
-    const prefix = '!'
-    if (!body.startsWith(prefix)) return
-
-    const [cmd, ...args] = body.slice(prefix.length).trim().split(' ')
-
-    switch (cmd.toLowerCase()) {
-        case 'hola':
-            await melody.sendMessage(m.key.remoteJid, {
-                text: '¡Hola! Soy Delta, ¿en qué puedo ayudarte?'
-            })
-            break
-        case 'ping':
-            await melody.sendMessage(m.key.remoteJid, { text: '🏓 Pong!' })
-            break
-        default:
-            await melody.sendMessage(m.key.remoteJid, {
-                text: `Comando desconocido: ${cmd}`
-            })
-    }
-})
+### Estados (historias)
+
+`sendStatusWhatsApp` publica un estado (historia) en tu cuenta. A diferencia de `sendMessage`, este método está pensado para trabajar junto con **menciones**: el segundo parámetro es un arreglo de JIDs (contactos o grupos) a los que se les notifica que fueron mencionados en el estado.
+
+```ts
+await sock.sendStatusWhatsApp(
+  { text: 'Nuevo estado 🚀', backgroundColor: '#25D366' },
+  [contactoJid, grupoJid] // se les notifica el estado como mención
+)
 ```
 
----
+- Si se pasa un JID de **contacto individual**, recibe la notificación de mención de estado como corresponde a un chat privado.
+- Si se pasa un JID de **grupo**, el grupo entero recibe una única notificación de mención de estado a nivel de grupo (no se le manda una notificación repetida a cada miembro por separado).
+- Si no se pasa ningún JID, el estado no se publica ya que requiere pasar las menciones necesarias.
+- Para contenido multimedia (imagen, video, audio) en el estado, se pueden combinar los mismos campos que en `sendMessage` (`image`, `video`, `audio`), y ASTA-BOTS ajusta automáticamente el color de fondo y la fuente cuando corresponde.
 
-## ⚙️ Configuración Avanzada
+### Recibos, lectura y presencia
 
-```javascript
-const melody = makeWASocket({
-    auth: state,
-    printQRInTerminal: true,
-    markOnlineOnConnect: false,
-    browser: ["Delta", "Chrome", "1.0.0"],
-    logger: require('pino')({ level: 'silent' }),
-    syncFullHistory: false,
-    generateHighQualityLinkPreview: true
-})
+
+```ts
+// Marcar mensajes como leídos (doble check azul)
+await sock.readMessages([mensaje.key])
+
+// Enviar un recibo manualmente
+await sock.sendReceipt(jid, participante, [id], 'read')
+
+// Actualizar presencia (escribiendo, grabando audio, en línea)
+await sock.sendPresenceUpdate('composing', jid) // 'available' | 'unavailable' | 'composing' | 'recording' | 'paused'
+
+// Suscribirse a la presencia de un contacto
+await sock.presenceSubscribe(jid)
 ```
 
----
+## Grupos, comunidades y canales
 
-## 🛠️ Funciones Útiles
+ASTA-BOTS conserva toda la funcionalidad estándar de Baileys para administrar grupos, comunidades (grupos con subgrupos) y canales de difusión (newsletters):
 
-### Broadcast a múltiples chats
-```javascript
-async function broadcastMessage(jids, message) {
-    for (const jid of jids) {
-        await melody.sendMessage(jid, { text: message })
-        await new Promise(r => setTimeout(r, 1000)) // delay para evitar ban
-    }
-}
+```ts
+await sock.groupCreate('Mi grupo', [jid1, jid2])
+await sock.groupParticipantsUpdate(jid, [participante], 'add') // 'add' | 'remove' | 'promote' | 'demote'
+await sock.groupInviteCode(jid)
+
+await sock.communityCreate('Mi comunidad', 'Descripción')
+
+await sock.newsletterCreate('Mi canal', 'Descripción del canal')
 ```
 
-### Descargar medios recibidos
-```javascript
-const { downloadMediaMessage } = require('@fer2809fl/baileys')
+## Perfil, privacidad y negocios
 
-melody.ev.on('messages.upsert', async ({ messages }) => {
-    const m = messages[0]
-    if (!m.message?.imageMessage) return
+```ts
+await sock.updateProfileName('Mi Bot')
+await sock.updateProfileStatus('Disponible 24/7')
+await sock.updateProfilePicture(jid, { url: './avatar.jpg' })
 
-    const buffer = await downloadMediaMessage(m, 'buffer', {})
-    require('fs').writeFileSync('./imagen_recibida.jpg', buffer)
-    console.log('✅ Imagen guardada')
-})
+await sock.updateBlockStatus(jid, 'block') // o 'unblock'
+
+// API de negocios (catálogo, pedidos)
+await sock.getCatalog({ jid })
+await sock.productCreate({ ... })
 ```
 
-### Obtener info de un grupo
-```javascript
-const metadata = await melody.groupMetadata(jid)
-console.log('Nombre:', metadata.subject)
-console.log('Participantes:', metadata.participants.length)
+## Store (caché en memoria)
+
+El **Store** es un caché en memoria de chats, contactos, mensajes y metadata de grupos, que se va llenando solo a medida que van llegando eventos (`sock.ev`). El Baileys oficial más reciente **eliminó este módulo** de la librería; en ASTA-BOTS se mantiene disponible porque resuelve un problema muy común al hacer un bot: no depender de volver a pedirle todo a WhatsApp (mensaje anterior, foto de perfil, metadata de un grupo) cada vez que se necesita.
+
+### ¿Cuándo conviene usarlo?
+
+- Si tu bot necesita **buscar mensajes anteriores** (por ejemplo, para citar o reenviar algo que no tenés a mano).
+- Si querés **listar los chats o contactos** sin tener que reconstruirlos manualmente desde los eventos.
+- Si hacés muchas consultas de `groupMetadata` o `profilePictureUrl` y no querés golpear la API de WhatsApp cada vez.
+
+Si tu bot es simple y solo responde a mensajes entrantes sin necesitar historial, podés omitirlo sin problema; el store consume RAM porque guarda todo en memoria.
+
+### Uso
+
+```ts
+import makeWASocket, { makeInMemoryStore, useMultiFileAuthState } from 'baileys'
+
+const store = makeInMemoryStore({})
+store.readFromFile('./store.json') // opcional: cargar datos guardados de una corrida anterior
+
+const { state, saveCreds } = await useMultiFileAuthState('sesion')
+const sock = makeWASocket({ auth: state })
+
+store.bind(sock.ev) // conecta el store a todos los eventos del socket
+
+sock.ev.on('creds.update', saveCreds)
+
+// Guardar el store a disco cada cierto tiempo
+setInterval(() => {
+  store.writeToFile('./store.json')
+}, 10_000)
+
+// Ejemplos de consulta
+const chats = store.chats.all()
+const contacto = store.contacts['5215512345678@s.whatsapp.net']
+const mensaje = await store.loadMessage(jid, mensajeId)
 ```
 
-### Mencionar usuarios en un grupo
-```javascript
-await melody.sendMessage(jid, {
-    text: '@1234567890 ¡Hola!',
-    mentions: ['1234567890@s.whatsapp.net']
-})
+## Utilidades ASTA-BOTS
+
+Estas utilidades son propias de **ASTA-BOTS** y no existen en el Baileys original: nacieron para resolver lo más repetitivo al armar un bot de comandos.
+
+### `resolveJid`: resolución automática de JID
+
+Detecta el JID objetivo de un comando sin que tengas que pasarlo a mano, siguiendo esta prioridad: **mensaje citado → primera mención → argumento numérico → remitente**.
+
+```ts
+import { resolveJid } from 'baileys'
+
+// .ban (respondiendo a alguien) → toma el citado
+// .ban @usuario                  → toma la mención
+// .ban 5216141234567             → toma el argumento
+// .ban                           → cae al remitente
+const targetJid = resolveJid(m, args[0])
 ```
 
----
+### Sistema de botones de conveniencia
 
-## 📁 Estructura Recomendada del Proyecto
+Además del soporte nativo de `sock.sendMessage` (ver [Botones, listas, templates y carousel](#botones-listas-templates-y-carousel)), ASTA-BOTS trae funciones listas para usar cuando querés algo rápido sin armar el objeto del mensaje:
 
+```ts
+import { sendQuickReplyButtons, setupButtonHandler } from 'baileys'
+
+// Engancha el detector de respuestas de botón una sola vez, al iniciar
+setupButtonHandler(sock, plugins, db)
+
+await sendQuickReplyButtons(sock, jid, '¿Qué querés hacer?', [
+  { text: '📋 Menú', id: 'menu' },
+  { text: '⚙️ Ajustes', id: 'settings' }
+])
 ```
-mi-bot/
-├── index.js          # Entrada principal
-├── config.js         # Configuración general
-├── commands/
-│   ├── hola.js
-│   ├── ping.js
-│   ├── stickers.js
-│   └── botones.js    
-├── events/
-│   ├── messages.js
-│   └── connection.js
-├── utils/
-│   └── helpers.js
-└── session-mymelody/ # Sesión guardada automáticamente
+
+| Función | Qué hace |
+|---|---|
+| `sendCopyButton` | Botón que copia texto al portapapeles |
+| `sendUrlButton` | Botón de enlace |
+| `sendQuickReplyButtons` | Botones de respuesta rápida |
+| `sendCallButton` | Botón de llamada |
+| `sendListMenu` | Lista desplegable con secciones |
+| `sendInteractiveMessage` | Combinación de varios tipos de botón |
+| `handleButtonResponse` | Detecta y ejecuta el comando de un botón presionado |
+| `setupButtonHandler` | Engancha el detector de botones al socket sin pisar tu handler de mensajes |
+
+Todas caen a texto plano automáticamente si WhatsApp rechaza el mensaje interactivo.
+
+### Código de vinculación de marca
+
+Al pedir un código de emparejamiento sin especificar uno propio, ASTA-BOTS usa por defecto el código de marca **`ASTABOTS`** (8 caracteres, cumple el requisito de WhatsApp):
+
+```ts
+const code = await sock.requestPairingCode('5216141234567')
+// code === 'ASTABOTS'
+
+// o con tu propio código de 8 caracteres:
+const code2 = await sock.requestPairingCode('5216141234567', 'MIPROPIO')
 ```
 
----
+## Aviso legal
 
-## 📝 Historial de Versiones
+Este proyecto no está afiliado, asociado, autorizado ni respaldado de ninguna forma por WhatsApp Inc. ni por Meta. "WhatsApp" y las marcas relacionadas son propiedad de sus respectivos dueños.
 
-| Versión | Cambios |
-|---------|---------|
-| **1.8.9** | ✅ Botones interactivos (`sendCopyButton`, `sendUrlButton`, `sendQuickReplyButtons`, `sendCallButton`, `sendListMenu`, `sendInteractiveMessage`) — 🐛 Fix error de pairing en macOS |
-| 1.4.5 | Versión estable anterior |
+El uso de esta librería es responsabilidad exclusiva de quien la implementa. Se recomienda no usarla para spam, mensajería masiva no solicitada ni cualquier práctica que viole los Términos de Servicio de WhatsApp.
 
----
+## Créditos
 
-## 🔗 Links
+**ASTA-BOTS** es un fork de **[Baileys](https://github.com/WhiskeySockets/Baileys)**, la librería original mantenida por la comunidad de **WhiskeySockets**. Gran parte de la base de este proyecto —el manejo del protocolo de WhatsApp Web, el cifrado, la arquitectura del socket y la mayoría del código— proviene de ese trabajo original.
 
-- 📦 npm: [npmjs.com/package/@fer2809fl/baileys](https://www.npmjs.com/package/@fer2809fl/baileys)
-- 💻 Repositorio: [github.com/Fer2809fl/Baileys](https://github.com/Fer2809fl/Baileys)
-- 🐛 Issues: [github.com/Fer2809fl/Baileys/issues](https://github.com/Fer2809fl/Baileys/issues)
+- Repositorio oficial: https://github.com/WhiskeySockets/Baileys
+- Licencia: MIT
+
+Si esta librería te resulta útil, considerá también dar reconocimiento y apoyo al proyecto original que es de this-xys/bails. 🙌
 
 ---
 
-<div align="center">
+<div align="center">Hecho con 💙 por <b>ASTA-BOTS</b></div>
 
-Desarrollado con 🤍 por [Fer2809fl](https://github.com/Fer2809fl)
+## créditos
+
+this-xys/bails
 
-</div>