@arcaelas/whatsapp 6.1.3 → 7.0.0

package/build/cjs/lib/status/index.d.ts

@@ -1,26 +1,30 @@
 /**
  * @file status/index.ts
- * @description Entidad Feed — publicación del status broadcast (`status@broadcast`) como
- * subclase de Message: hereda author/chat/content/stream y anula lo que un status no soporta.
- * Feed entity — status broadcast post as a Message subclass: inherits
- * author/chat/content/stream and voids what a status does not support.
+ * @description Entidad Feed — publicación del status broadcast como subclase de Message:
+ * hereda author/stream y anula lo que un status no soporta.
+ * Feed entity — status broadcast post as a Message subclass: inherits author/stream and
+ * voids what a status does not support.
  */
-import type { WAMessage } from 'baileys';
-import { Message } from '../../lib/message';
-import type { WhatsApp } from '../../lib/whatsapp';
+import type { WAMessage, WASocket } from 'baileys';
+import Message from '../../lib/message';
+import { type Engine } from '../../lib/store';
+import type WhatsApp from '../../lib/whatsapp';
 /** Vida útil del status: 24 horas en ms. / Status lifetime: 24h in ms. */
 export declare const TTL_MS: number;
 /**
- * Publicación del status broadcast. El documento del status se adapta al shape de
- * Message en el constructor (`cid` fijo a `status@broadcast`, `author` desde
- * `author_jid`, `deleted_at` desde `expires_at`), así los getters heredados aplican
- * tal cual.
- * Status broadcast post. The status document is adapted to the Message shape in the
- * constructor (`cid` pinned to `status@broadcast`, `author` from `author_jid`,
- * `deleted_at` from `expires_at`), so inherited getters apply as-is.
+ * Publicación del status broadcast. El documento se adapta al shape de Message en el
+ * constructor (`cid` fijo a `status@broadcast`, `author` desde `author_jid`, `deleted_at`
+ * desde `expires_at`), así los getters heredados aplican tal cual.
+ * Status broadcast post. The document is adapted to the Message shape in the constructor
+ * (`cid` pinned to `status@broadcast`, `author` from `author_jid`, `deleted_at` from
+ * `expires_at`), so inherited getters apply as-is.
  */
 export declare class Feed extends Message {
-    constructor(wa: WhatsApp, doc: {
+    constructor(init: {
+        wa: WhatsApp;
+        engine: Engine;
+        socket: WASocket;
+    }, doc: {
         id: string;
         author_jid: string;
         type: 'text' | 'image' | 'video' | 'audio';
@@ -33,43 +37,28 @@ export declare class Feed extends Message {
     });
     /** true si ya enviamos read receipt sobre este status. / true once a read receipt was sent. */
     get viewed(): boolean;
+    /** Binario del status: vive bajo `/status`, no bajo `/chat`. / Status binary: it lives under `/status`, not `/chat`. */
+    content(): Promise<Buffer>;
     /**
      * Marca el status como visto enviando read receipt y persiste `viewed`.
-     * Marks the status as seen sending a read receipt and persists `viewed`.
-     *
-     * @returns true si se envió / true when sent
+     * Marks the status as seen sending a read receipt and persisting `viewed`.
      */
     view(): Promise<boolean>;
     /** Un status marca visto con `view()`. / A status marks seen via `view()`. */
     seen(): Promise<boolean>;
-    /** No soportado en un status. / Unsupported on a status. */
     message(): Promise<never>;
-    /** No soportado en un status. / Unsupported on a status. */
     react(): Promise<never>;
-    /** No soportado en un status. / Unsupported on a status. */
     star(): Promise<never>;
-    /** No soportado en un status. / Unsupported on a status. */
     edit(): Promise<never>;
-    /** No soportado en un status. / Unsupported on a status. */
     forward(): Promise<never>;
-    /** No soportado en un status. / Unsupported on a status. */
     delete(): Promise<never>;
-    /** No soportado en un status. / Unsupported on a status. */
     text(): Promise<never>;
-    /** No soportado en un status. / Unsupported on a status. */
     image(): Promise<never>;
-    /** No soportado en un status. / Unsupported on a status. */
     video(): Promise<never>;
-    /** No soportado en un status. / Unsupported on a status. */
     audio(): Promise<never>;
-    /** No soportado en un status. / Unsupported on a status. */
     location(): Promise<never>;
-    /** No soportado en un status. / Unsupported on a status. */
     poll(): Promise<never>;
-    /** No soportado en un status. / Unsupported on a status. */
     document(): Promise<never>;
-    /** No soportado en un status. / Unsupported on a status. */
     vcard(): Promise<never>;
-    /** No soportado en un status. / Unsupported on a status. */
     event(): Promise<never>;
 }

package/build/cjs/lib/status/index.js

@@ -1,30 +1,31 @@
 "use strict";
 /**
  * @file status/index.ts
- * @description Entidad Feed — publicación del status broadcast (`status@broadcast`) como
- * subclase de Message: hereda author/chat/content/stream y anula lo que un status no soporta.
- * Feed entity — status broadcast post as a Message subclass: inherits
- * author/chat/content/stream and voids what a status does not support.
+ * @description Entidad Feed — publicación del status broadcast como subclase de Message:
+ * hereda author/stream y anula lo que un status no soporta.
+ * Feed entity — status broadcast post as a Message subclass: inherits author/stream and
+ * voids what a status does not support.
  */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Feed = exports.TTL_MS = void 0;
-const internal_1 = require("../../lib/internal");
-const message_1 = require("../../lib/message");
+const message_1 = __importDefault(require("../../lib/message"));
 const store_1 = require("../../lib/store");
 /** Vida útil del status: 24 horas en ms. / Status lifetime: 24h in ms. */
-exports.TTL_MS = 24 * 60 * 60 * 1000;
+exports.TTL_MS = 24 * 60 * 60 * 1_000;
 /**
- * Publicación del status broadcast. El documento del status se adapta al shape de
- * Message en el constructor (`cid` fijo a `status@broadcast`, `author` desde
- * `author_jid`, `deleted_at` desde `expires_at`), así los getters heredados aplican
- * tal cual.
- * Status broadcast post. The status document is adapted to the Message shape in the
- * constructor (`cid` pinned to `status@broadcast`, `author` from `author_jid`,
- * `deleted_at` from `expires_at`), so inherited getters apply as-is.
+ * Publicación del status broadcast. El documento se adapta al shape de Message en el
+ * constructor (`cid` fijo a `status@broadcast`, `author` desde `author_jid`, `deleted_at`
+ * desde `expires_at`), así los getters heredados aplican tal cual.
+ * Status broadcast post. The document is adapted to the Message shape in the constructor
+ * (`cid` pinned to `status@broadcast`, `author` from `author_jid`, `deleted_at` from
+ * `expires_at`), so inherited getters apply as-is.
  */
-class Feed extends message_1.Message {
-    constructor(wa, doc) {
-        super(wa, {
+class Feed extends message_1.default {
+    constructor(init, doc) {
+        super(init, {
             ...doc,
             cid: 'status@broadcast',
             mid: null,
@@ -41,91 +42,49 @@ class Feed extends message_1.Message {
     get viewed() {
         return this._raw.viewed ?? false;
     }
+    /** Binario del status: vive bajo `/status`, no bajo `/chat`. / Status binary: it lives under `/status`, not `/chat`. */
+    async content() {
+        const path = `/status/${this._raw.id}/content`;
+        const cached = await this._init.engine.get_buffer?.(path);
+        if (cached?.length)
+            return cached;
+        const legacy = (0, store_1.deserialize)(await this._init.engine.get(path));
+        return legacy?.data ? Buffer.from(legacy.data, 'base64') : Buffer.alloc(0);
+    }
     /**
      * Marca el status como visto enviando read receipt y persiste `viewed`.
-     * Marks the status as seen sending a read receipt and persists `viewed`.
-     *
-     * @returns true si se envió / true when sent
+     * Marks the status as seen sending a read receipt and persisting `viewed`.
      */
     async view() {
-        let ok = false;
-        const socket = (0, internal_1.internals)(this._wa).socket;
-        if (socket) {
-            if (!this.viewed) {
-                await socket.readMessages([
-                    { remoteJid: 'status@broadcast', id: this._raw.id, participant: this._raw.author },
-                ]);
-                this._raw.viewed = true;
-                await this._wa.engine.set(`/status/${this._raw.id}`, (0, store_1.serialize)(this._raw));
-            }
-            this._wa.emit('feed:updated', this, this._wa);
-            ok = true;
+        if (!this.viewed) {
+            await this._init.socket.readMessages([
+                { remoteJid: 'status@broadcast', id: this._raw.id, participant: this._raw.author },
+            ]);
+            this._raw.viewed = true;
+            await this._init.engine.set(`/status/${this._raw.id}`, (0, store_1.serialize)(this._raw));
         }
-        return ok;
+        this._init.wa.emit('feed:updated', this, this._init.wa);
+        return true;
     }
     /** Un status marca visto con `view()`. / A status marks seen via `view()`. */
     async seen() {
         return this.view();
     }
-    /** No soportado en un status. / Unsupported on a status. */
-    async message() {
-        throw new Error('ERR_FEED_UNSUPPORTED');
-    }
-    /** No soportado en un status. / Unsupported on a status. */
-    async react() {
-        throw new Error('ERR_FEED_UNSUPPORTED');
-    }
-    /** No soportado en un status. / Unsupported on a status. */
-    async star() {
-        throw new Error('ERR_FEED_UNSUPPORTED');
-    }
-    /** No soportado en un status. / Unsupported on a status. */
-    async edit() {
-        throw new Error('ERR_FEED_UNSUPPORTED');
-    }
-    /** No soportado en un status. / Unsupported on a status. */
-    async forward() {
-        throw new Error('ERR_FEED_UNSUPPORTED');
-    }
-    /** No soportado en un status. / Unsupported on a status. */
-    async delete() {
-        throw new Error('ERR_FEED_UNSUPPORTED');
-    }
-    /** No soportado en un status. / Unsupported on a status. */
-    async text() {
-        throw new Error('ERR_FEED_UNSUPPORTED');
-    }
-    /** No soportado en un status. / Unsupported on a status. */
-    async image() {
-        throw new Error('ERR_FEED_UNSUPPORTED');
-    }
-    /** No soportado en un status. / Unsupported on a status. */
-    async video() {
-        throw new Error('ERR_FEED_UNSUPPORTED');
-    }
-    /** No soportado en un status. / Unsupported on a status. */
-    async audio() {
-        throw new Error('ERR_FEED_UNSUPPORTED');
-    }
-    /** No soportado en un status. / Unsupported on a status. */
-    async location() {
-        throw new Error('ERR_FEED_UNSUPPORTED');
-    }
-    /** No soportado en un status. / Unsupported on a status. */
-    async poll() {
-        throw new Error('ERR_FEED_UNSUPPORTED');
-    }
-    /** No soportado en un status. / Unsupported on a status. */
-    async document() {
-        throw new Error('ERR_FEED_UNSUPPORTED');
-    }
-    /** No soportado en un status. / Unsupported on a status. */
-    async vcard() {
-        throw new Error('ERR_FEED_UNSUPPORTED');
-    }
-    /** No soportado en un status. / Unsupported on a status. */
-    async event() {
-        throw new Error('ERR_FEED_UNSUPPORTED');
-    }
+    /* Un status no soporta el resto de operaciones de Message. / A status supports none of the remaining Message operations. */
+    async message() { throw new Error('ERR_FEED_UNSUPPORTED'); }
+    async react() { throw new Error('ERR_FEED_UNSUPPORTED'); }
+    async star() { throw new Error('ERR_FEED_UNSUPPORTED'); }
+    async edit() { throw new Error('ERR_FEED_UNSUPPORTED'); }
+    async forward() { throw new Error('ERR_FEED_UNSUPPORTED'); }
+    async delete() { throw new Error('ERR_FEED_UNSUPPORTED'); }
+    async text() { throw new Error('ERR_FEED_UNSUPPORTED'); }
+    async image() { throw new Error('ERR_FEED_UNSUPPORTED'); }
+    async video() { throw new Error('ERR_FEED_UNSUPPORTED'); }
+    async audio() { throw new Error('ERR_FEED_UNSUPPORTED'); }
+    async location() { throw new Error('ERR_FEED_UNSUPPORTED'); }
+    async poll() { throw new Error('ERR_FEED_UNSUPPORTED'); }
+    async document() { throw new Error('ERR_FEED_UNSUPPORTED'); }
+    async vcard() { throw new Error('ERR_FEED_UNSUPPORTED'); }
+    async event() { throw new Error('ERR_FEED_UNSUPPORTED'); }
 }
 exports.Feed = Feed;

package/build/cjs/lib/store/index.d.ts

@@ -3,6 +3,8 @@
  * @description Barrel del módulo store — reexporta Engine + drivers y expone helpers de serialización.
  * Store module barrel — re-exports Engine + drivers and provides serialization helpers.
  */
+import { type WASocket } from 'baileys';
+import type { Engine } from '../../lib/store/engine';
 export { FileSystemEngine, RedisEngine, S3Engine, SQLiteEngine, type Engine, type RedisClient, type SQLiteDatabase } from '../../lib/store/engine';
 /**
  * Serializa un documento a string preservando Buffers con BufferJSON de baileys.
@@ -24,3 +26,17 @@ export declare function serialize<T>(doc: T): string;
  * @returns Documento parseado o null / Parsed document or null
  */
 export declare function deserialize<T>(raw: string | null): T | null;
+/**
+ * JID canónico de un teléfono, JID o LID: los grupos y JIDs pasan tal cual, el LID se mapea
+ * contra los índices `/lid` del engine (o contra baileys cuando hay socket) y el resto se
+ * trata como teléfono.
+ * Canonical JID for a phone, JID or LID: groups and JIDs pass through, the LID is mapped
+ * against the engine `/lid` indexes (or against baileys when a socket is given) and the rest
+ * is treated as a phone.
+ *
+ * @param engine - Motor con los índices `/lid` / Engine holding the `/lid` indexes
+ * @param uid - Identificador crudo / Raw identifier
+ * @param socket - Socket vivo para el mapping de baileys, si hay / Live socket for the baileys mapping, if any
+ * @returns JID canónico, o null si es irresoluble / Canonical JID, or null when unresolvable
+ */
+export declare const jid_of: (engine: Engine, uid: string, socket?: WASocket) => Promise<string | null>;

package/build/cjs/lib/store/index.js

@@ -5,10 +5,11 @@
  * Store module barrel — re-exports Engine + drivers and provides serialization helpers.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SQLiteEngine = exports.S3Engine = exports.RedisEngine = exports.FileSystemEngine = void 0;
+exports.jid_of = exports.SQLiteEngine = exports.S3Engine = exports.RedisEngine = exports.FileSystemEngine = void 0;
 exports.serialize = serialize;
 exports.deserialize = deserialize;
 const baileys_1 = require("baileys");
+const baileys_2 = require("baileys");
 var engine_1 = require("../../lib/store/engine");
 Object.defineProperty(exports, "FileSystemEngine", { enumerable: true, get: function () { return engine_1.FileSystemEngine; } });
 Object.defineProperty(exports, "RedisEngine", { enumerable: true, get: function () { return engine_1.RedisEngine; } });
@@ -22,7 +23,7 @@ Object.defineProperty(exports, "SQLiteEngine", { enumerable: true, get: function
  * @returns String JSON / JSON string
  */
 function serialize(doc) {
-    return JSON.stringify(doc, baileys_1.BufferJSON.replacer);
+    return JSON.stringify(doc, baileys_2.BufferJSON.replacer);
 }
 /**
  * Deserializa un string JSON a documento aplicando BufferJSON. Retorna null si la entrada es
@@ -40,9 +41,34 @@ function deserialize(raw) {
         return null;
     }
     try {
-        return JSON.parse(raw, baileys_1.BufferJSON.reviver);
+        return JSON.parse(raw, baileys_2.BufferJSON.reviver);
     }
     catch {
         return null;
     }
 }
+/**
+ * JID canónico de un teléfono, JID o LID: los grupos y JIDs pasan tal cual, el LID se mapea
+ * contra los índices `/lid` del engine (o contra baileys cuando hay socket) y el resto se
+ * trata como teléfono.
+ * Canonical JID for a phone, JID or LID: groups and JIDs pass through, the LID is mapped
+ * against the engine `/lid` indexes (or against baileys when a socket is given) and the rest
+ * is treated as a phone.
+ *
+ * @param engine - Motor con los índices `/lid` / Engine holding the `/lid` indexes
+ * @param uid - Identificador crudo / Raw identifier
+ * @param socket - Socket vivo para el mapping de baileys, si hay / Live socket for the baileys mapping, if any
+ * @returns JID canónico, o null si es irresoluble / Canonical JID, or null when unresolvable
+ */
+const jid_of = async (engine, uid, socket) => {
+    if (uid.endsWith('@g.us') || uid.endsWith('@s.whatsapp.net'))
+        return uid;
+    const lid = uid.endsWith('@lid') ? (0, baileys_1.jidNormalizedUser)(uid) : '';
+    const mapped = lid
+        ? deserialize(await engine.get(`/lid/${lid}`))
+            ?? deserialize(await engine.get(`/lid/${lid.split('@')[0]}_reverse`))
+            ?? await socket?.signalRepository?.lidMapping?.getPNForLID(lid).catch(() => null)
+        : uid.replace(/\D/g, '');
+    return mapped ? (String(mapped).includes('@') ? (0, baileys_1.jidNormalizedUser)(String(mapped)) : `${mapped}@s.whatsapp.net`) : null;
+};
+exports.jid_of = jid_of;

package/build/cjs/lib/whatsapp/index.d.ts

@@ -1,87 +1,28 @@
-/**
- * @file whatsapp/index.ts
- * @description Orquestador principal del cliente WhatsApp v3.
- * Main orchestrator of the WhatsApp v3 client.
- */
-import { chat, Chat } from '../../lib/chat';
-import { contact, Contact } from '../../lib/contact';
-import { Audio, Document, Event, Image, Location, Message, Poll, Sticker, Text, VCard, Video } from '../../lib/message';
+import { chat } from '../../lib/chat';
+import { Account, contact } from '../../lib/contact';
+import Message, { message } from '../../lib/message';
 import { Feed } from '../../lib/status';
 import { type Engine } from '../../lib/store';
-/**
- * Opciones del cliente WhatsApp.
- * WhatsApp client options.
- */
-/**
- * Configuración de reconexión automática tras cierres no-loggedOut.
- * - `true` (default): reintenta indefinidamente con 60s de intervalo.
- * - `false`: no reconecta.
- * - `number`: máximo N reintentos con 60s de intervalo.
- * - `{ max, interval }`: control explícito (interval en segundos).
- *
- * Automatic reconnection config for non-loggedOut closes.
- */
-export type ReconnectOption = boolean | number | {
-    max?: number;
-    interval?: number;
-};
-export interface IWhatsApp {
+type ChatInstance = InstanceType<ReturnType<typeof chat>>;
+type ContactInstance = InstanceType<ReturnType<typeof contact>>;
+interface Options {
     /** Motor de almacenamiento. / Storage engine. */
     engine: Engine;
-    /**
-     * Teléfono de la cuenta. Su presencia habilita el emparejamiento por PIN; sin él la
-     * vinculación es siempre por QR.
-     * Account phone. Its presence enables PIN pairing; without it linking is always by QR.
-     */
+    /** Teléfono de la cuenta: su presencia habilita el PIN; sin él la vinculación es por QR. / Account phone: its presence enables the PIN; without it linking is by QR. */
     phone?: number | string;
-    /**
-     * Elige el canal de vinculación **cuando hay `phone`**: `otp` (default) o `qr`. Sin
-     * `phone` la opción se ignora, porque el PIN no puede pedirse sin número.
-     * Picks the linking channel **when `phone` is set**: `otp` (default) or `qr`. Without
-     * `phone` it is ignored, since a PIN cannot be requested without a number.
-     */
+    /** Canal de vinculación cuando hay `phone`; sin `phone` se ignora. / Linking channel when `phone` is set; ignored without it. */
     method?: 'qr' | 'otp';
-    /**
-     * Si al recibir `loggedOut` debe limpiar todo el engine (default: `true`).
-     * Si es `false`, solo elimina `/session/creds` y preserva historial.
-     *
-     * Whether to clear the entire engine on `loggedOut` (default: `true`).
-     */
+    /** Vaciar el engine al recibir `loggedOut`; con `false` sólo borra las credenciales. / Clear the engine on `loggedOut`; with `false` it only drops the credentials. */
     autoclean?: boolean;
-    /** Reconexión automática tras cierres no-loggedOut. Default: `true`. / Auto-reconnect on non-loggedOut closes. */
-    reconnect?: ReconnectOption;
-    /**
-     * Descarga del historial de mensajes al vincular (default: `true`). Sólo afecta los
-     * mensajes: contactos, credenciales, LID mappings y tctokens se sincronizan siempre
-     * (rc13 los exige para enviar). `false` omite únicamente el historial de mensajes.
-     *
-     * Message-history download on link (default: `true`). Messages only: contacts,
-     * credentials, LID mappings and tctokens always sync (rc13 requires them to send).
-     */
+    /** Reintentos tras cierres no-loggedOut: `true` infinitos, un número como máximo, o el control explícito (`interval` en segundos). / Retries after non-loggedOut closes: `true` for endless, a number as the cap, or explicit control (`interval` in seconds). */
+    reconnect?: boolean | number | {
+        max?: number;
+        interval?: number;
+    };
+    /** Descargar el historial de mensajes al vincular; contactos, credenciales, LID mappings y tctokens se sincronizan siempre. / Download the message history on link; contacts, credentials, LID mappings and tctokens always sync. */
     sync?: boolean;
 }
-/**
- * Opciones de desconexión.
- * Disconnect options.
- */
-export interface DisconnectOptions {
-    /** No emitir el evento `disconnected` de este cierre. / Suppress this close's `disconnected` event. */
-    silent?: boolean;
-    /** Vaciar el engine tras cerrar. / Clear the engine after closing. */
-    destroy?: boolean;
-}
-/** Argumentos de un estático de envío sin el cliente ni el cid. / Send-static arguments without client and cid. */
-type Tail<P extends unknown[]> = P extends [unknown, unknown, ...infer R] ? R : never;
-type MessageInstance = Message;
-type ChatInstance = InstanceType<ReturnType<typeof chat>>;
-type ContactInstance = InstanceType<ReturnType<typeof contact>>;
-/**
- * Mapa de eventos emitidos por el cliente. Cada listener recibe el artefacto principal seguido
- * de la instancia del cliente como último argumento.
- * Map of events emitted by the client. Each listener receives the primary payload followed by
- * the client instance as the last argument.
- */
-interface WhatsAppEventMap {
+interface EventMap {
     connected: [WhatsApp];
     disconnected: [WhatsApp];
     'contact:created': [ContactInstance, ChatInstance, WhatsApp];
@@ -94,151 +35,42 @@ interface WhatsAppEventMap {
     'chat:unarchived': [ChatInstance, WhatsApp];
     'chat:muted': [ChatInstance, WhatsApp];
     'chat:unmuted': [ChatInstance, WhatsApp];
-    'message:created': [MessageInstance, ChatInstance, WhatsApp];
-    'message:updated': [MessageInstance, ChatInstance, WhatsApp];
-    'message:deleted': [MessageInstance, ChatInstance, WhatsApp];
-    'message:reacted': [MessageInstance, ChatInstance, string, WhatsApp];
-    'message:starred': [MessageInstance, ChatInstance, WhatsApp];
-    'message:unstarred': [MessageInstance, ChatInstance, WhatsApp];
-    'message:forwarded': [MessageInstance, ChatInstance, WhatsApp];
-    'message:seen': [MessageInstance, ChatInstance, WhatsApp];
+    'message:created': [Message, ChatInstance, WhatsApp];
+    'message:updated': [Message, ChatInstance, WhatsApp];
+    'message:deleted': [Message, ChatInstance, WhatsApp];
+    'message:reacted': [Message, ChatInstance, string, WhatsApp];
+    'message:starred': [Message, ChatInstance, WhatsApp];
+    'message:unstarred': [Message, ChatInstance, WhatsApp];
+    'message:forwarded': [Message, ChatInstance, WhatsApp];
+    'message:seen': [Message, ChatInstance, WhatsApp];
     'feed:created': [Feed, WhatsApp];
     'feed:updated': [Feed, WhatsApp];
     'feed:deleted': [Feed, WhatsApp];
 }
-/**
- * Cliente principal de WhatsApp. No inicia la conexión al instanciar.
- * Main WhatsApp client. Does not connect on instantiation.
- *
- * @example
- * const wa = new WhatsApp({ engine: new FileSystemEngine(__dirname), phone: 5491112345678 });
- * wa.on('message:created', (msg) => console.log(msg.caption));
- * await wa.connect((code) => console.log(code));
- */
-export declare class WhatsApp {
+export default class WhatsApp {
     #private;
-    /** Motor de almacenamiento de la sesión. / Session storage engine. */
     readonly engine: Engine;
-    /** Entidad `Contact` ligada a este cliente. / `Contact` entity bound to this client. */
-    readonly Contact: ReturnType<typeof contact>;
-    /** Entidad `Chat` ligada a este cliente. / `Chat` entity bound to this client. */
-    readonly Chat: ReturnType<typeof chat>;
-    /**
-     * Entidad `Message` ligada a este cliente: los mismos estáticos de `Message` sin repetir
-     * la instancia, más las subclases para `instanceof`.
-     * `Message` entity bound to this client: the same `Message` statics without repeating the
-     * instance, plus the subclasses for `instanceof`.
-     */
-    readonly Message: {
-        get: (cid: string, mid: string) => ReturnType<typeof Message.get>;
-        list: (cid: string, offset?: number, limit?: number) => ReturnType<typeof Message.list>;
-        text: (cid: string, ...rest: Tail<Parameters<typeof Message.text>>) => ReturnType<typeof Message.text>;
-        image: (cid: string, ...rest: Tail<Parameters<typeof Message.image>>) => ReturnType<typeof Message.image>;
-        video: (cid: string, ...rest: Tail<Parameters<typeof Message.video>>) => ReturnType<typeof Message.video>;
-        audio: (cid: string, ...rest: Tail<Parameters<typeof Message.audio>>) => ReturnType<typeof Message.audio>;
-        location: (cid: string, ...rest: Tail<Parameters<typeof Message.location>>) => ReturnType<typeof Message.location>;
-        poll: (cid: string, ...rest: Tail<Parameters<typeof Message.poll>>) => ReturnType<typeof Message.poll>;
-        document: (cid: string, ...rest: Tail<Parameters<typeof Message.document>>) => ReturnType<typeof Message.document>;
-        vcard: (cid: string, ...rest: Tail<Parameters<typeof Message.vcard>>) => ReturnType<typeof Message.vcard>;
-        event: (cid: string, ...rest: Tail<Parameters<typeof Message.event>>) => ReturnType<typeof Message.event>;
-        react: (cid: string, mid: string, emoji: string) => Promise<boolean>;
-        star: (cid: string, mid: string, value: boolean) => Promise<boolean>;
-        seen: (cid: string, mid: string) => Promise<boolean>;
-        edit: (cid: string, mid: string, caption: string) => Promise<boolean>;
-        forward: (cid: string, mid: string, target: string | Chat | Contact) => Promise<boolean>;
-        delete: (cid: string, mid: string, all?: boolean) => Promise<boolean>;
-        reactions: (cid: string, mid: string) => Promise<{
-            emoji: string;
-            count: number;
-        }[]>;
-        Text: typeof Text;
-        Image: typeof Image;
-        Video: typeof Video;
-        Audio: typeof Audio;
-        Sticker: typeof Sticker;
-        Document: typeof Document;
-        Location: typeof Location;
-        Poll: typeof Poll;
-        VCard: typeof VCard;
-        Event: typeof Event;
-    };
-    constructor(options: IWhatsApp);
-    /**
-     * Contacto de la cuenta autenticada, o null mientras no hay sesión abierta.
-     * Authenticated account's contact, or null while there is no open session.
-     */
-    get contact(): InstanceType<ReturnType<typeof contact>> | null;
-    /**
-     * Emite un evento del cliente. Lo usan las entidades de la librería para propagar los
-     * cambios que provocan; el consumidor puede emitir los suyos para pruebas.
-     * Emits a client event. Library entities use it to propagate the changes they cause;
-     * consumers may emit their own for testing.
-     *
-     * @param event - Nombre del evento / Event name
-     * @param args - Argumentos del evento / Event arguments
-     * @returns true si había listeners / true when listeners were present
-     */
-    emit<E extends keyof WhatsAppEventMap>(event: E, ...args: WhatsAppEventMap[E]): boolean;
-    /**
-     * Registra un listener de evento. Retorna función para desuscribirse.
-     * Registers an event listener. Returns an unsubscribe function.
-     */
-    on<E extends keyof WhatsAppEventMap>(event: E, handler: (...args: WhatsAppEventMap[E]) => void): () => void;
-    /**
-     * Quita un listener previamente registrado.
-     * Removes a previously registered listener.
-     */
-    off<E extends keyof WhatsAppEventMap>(event: E, handler: (...args: WhatsAppEventMap[E]) => void): this;
-    /**
-     * Registra un listener one-shot. Retorna función para desuscribirse antes de que dispare.
-     * Registers a one-shot listener. Returns an unsubscribe function.
-     */
-    once<E extends keyof WhatsAppEventMap>(event: E, handler: (...args: WhatsAppEventMap[E]) => void): () => void;
-    /**
-     * Inicia la conexión. El callback recibe el PIN (string) si se configuró `phone`, o el QR (Buffer PNG) si no.
-     * Resuelve cuando la sesión sincroniza; reintenta automáticamente en cierres no-loggedOut.
-     *
-     * Starts the connection. Callback receives the PIN (string) when `phone` is configured, or the QR (PNG Buffer) otherwise.
-     * Resolves once the session is synced; retries on non-loggedOut disconnects.
-     */
+    Contact: ReturnType<typeof contact>;
+    Chat: ReturnType<typeof chat>;
+    /** Entidad `Message`, publicada al conectar. / `Message` entity, published on connect. */
+    Message: ReturnType<typeof message>;
+    /** Cuenta autenticada, publicada al conectar; null mientras no hay usuario. / Authenticated account, published on connect; null while there is no user. */
+    account: () => Promise<Account | null>;
+    constructor(options: Options);
+    emit<E extends keyof EventMap>(event: E, ...args: EventMap[E]): boolean;
+    on<E extends keyof EventMap>(event: E, handler: (...args: EventMap[E]) => void): () => void;
+    once<E extends keyof EventMap>(event: E, handler: (...args: EventMap[E]) => void): () => void;
+    off<E extends keyof EventMap>(event: E, handler: (...args: EventMap[E]) => void): this;
     connect(callback: (auth: string | Buffer) => void | Promise<void>): Promise<void>;
     /**
-     * Actualiza el perfil de la cuenta en WhatsApp: nombre público, bio y/o foto. Sólo se
-     * envía lo que llega en el parche; `photo: null` elimina la foto actual.
-     * Updates the account profile on WhatsApp: public name, bio and/or picture. Only the
-     * given fields are sent; `photo: null` removes the current picture.
+     * Cierra la sesión: cancela el reintento pendiente y termina el socket.
+     * Closes the session: cancels the pending retry and ends the socket.
      *
-     * @param patch - Campos a actualizar / Fields to update
-     * @returns true si todo lo pedido se envió / true when everything requested was sent
-     * @throws ERR_PROFILE_PICTURE_LIB si falta `sharp` o `jimp` para procesar la foto / when `sharp` or `jimp` is missing to process the picture
-     */
-    profile(patch: {
-        name?: string;
-        content?: string;
-        photo?: string | Buffer | null;
-    }): Promise<boolean>;
-    /**
-     * Publica un estado (status broadcast). Con sólo `caption` publica texto; con `content`
-     * publica imagen o video (el tipo se deduce del binario) usando `caption` como pie.
-     * `contacts` es la audiencia: WhatsApp no reparte el estado a quien no esté en la lista.
-     * Publishes a status broadcast. With only `caption` it posts text; with `content` it
-     * posts an image or video (type inferred from the binary) using `caption` as its footer.
-     * `contacts` is the audience: WhatsApp does not deliver the status to anyone outside it.
-     *
-     * @param post - Contenido, pie y audiencia / Content, caption and audience
-     * @returns Publicación creada, o null si no hay sesión / Created post, or null without a session
-     * @throws ERR_FEED_EMPTY sin `content` ni `caption` / when neither `content` nor `caption` is given
-     * @throws ERR_FEED_MEDIA si el binario no es imagen ni video / when the binary is neither image nor video
-     */
-    feed(post: {
-        content?: Buffer;
-        caption?: string;
-        contacts: (string | number)[];
-    }): Promise<Feed | null>;
-    /**
-     * Cierra la conexión. Con `destroy: true` vacía el engine completo.
-     * Closes the connection. With `destroy: true` clears the engine entirely.
+     * @param options - `silent` calla el evento `disconnected`; `destroy` vacía el engine / `silent` mutes the `disconnected` event; `destroy` clears the engine
      */
-    disconnect(options?: DisconnectOptions): Promise<void>;
+    disconnect(options?: {
+        silent?: boolean;
+        destroy?: boolean;
+    }): Promise<void>;
 }
-export default WhatsApp;
+export {};