@ezychat/wa 0.0.0-stage → 0.1.39

package/dist/baileys/auth-store.d.ts

@@ -0,0 +1,14 @@
+import { type AuthenticationState } from 'baileys';
+export interface AuthStore {
+    readonly dir: string;
+    /** Load (or create) the multi-file auth state. */
+    load(): Promise<{
+        state: AuthenticationState;
+        saveCreds: () => Promise<void>;
+    }>;
+    /** Remove all auth/session files. */
+    wipe(): Promise<void>;
+    /** Copy the auth dir to `${dir}.bak-<ts>`; returns the backup path. */
+    backup(): Promise<string>;
+}
+export declare function createAuthStore(dir: string): AuthStore;

package/dist/baileys/auth-store.js

@@ -0,0 +1,22 @@
+import { cp, mkdir, rm } from 'node:fs/promises';
+import { useMultiFileAuthState } from 'baileys';
+export function createAuthStore(dir) {
+    return {
+        dir,
+        async load() {
+            await mkdir(dir, { recursive: true });
+            return useMultiFileAuthState(dir);
+        },
+        async wipe() {
+            await rm(dir, { recursive: true, force: true });
+        },
+        async backup() {
+            const target = `${dir}.bak-${Date.now()}`;
+            await cp(dir, target, { recursive: true, force: true }).catch((err) => {
+                if (err.code !== 'ENOENT')
+                    throw err;
+            });
+            return target;
+        },
+    };
+}

package/dist/baileys/contact-aliases.d.ts

@@ -0,0 +1,5 @@
+import type { WaContactAlias } from '../types.js';
+/** Accept only numeric direct identities; normalize device IDs and legacy PN domains. */
+export declare function normalizeContactJid(jid: unknown): string | null;
+/** Canonical orientation is PN -> LID, regardless of the event field orientation. */
+export declare function contactAliasPair(first: unknown, second: unknown): WaContactAlias | null;

package/dist/baileys/contact-aliases.js

@@ -0,0 +1,15 @@
+/** Accept only numeric direct identities; normalize device IDs and legacy PN domains. */
+export function normalizeContactJid(jid) {
+    if (typeof jid !== 'string')
+        return null;
+    const match = /^(\d+)(?::\d+)?@(s\.whatsapp\.net|c\.us|lid)$/.exec(jid);
+    return match ? `${match[1]}@${match[2] === 'lid' ? 'lid' : 's.whatsapp.net'}` : null;
+}
+/** Canonical orientation is PN -> LID, regardless of the event field orientation. */
+export function contactAliasPair(first, second) {
+    const a = normalizeContactJid(first);
+    const b = normalizeContactJid(second);
+    if (!a || !b || a.endsWith('@lid') === b.endsWith('@lid'))
+        return null;
+    return a.endsWith('@lid') ? { jid: b, alias: a } : { jid: a, alias: b };
+}

package/dist/baileys/disconnect.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Classification of Baileys disconnect status codes (spec §8).
+ * Numeric values mirror Baileys' `DisconnectReason` enum; kept as literals so
+ * this module stays pure and cheap to test.
+ */
+export type DisconnectAction = 'reconnect' | 'logged_out' | 'replaced' | 'bad_session' | 'blocked';
+export declare const DisconnectCode: {
+    readonly loggedOut: 401;
+    readonly forbidden: 403;
+    readonly timedOut: 408;
+    readonly multideviceMismatch: 411;
+    readonly connectionClosed: 428;
+    readonly connectionReplaced: 440;
+    readonly badSession: 500;
+    readonly unavailableService: 503;
+    readonly restartRequired: 515;
+};
+export declare function classifyDisconnect(statusCode: number | undefined): DisconnectAction;
+/** Exponential backoff 2s -> 60s with +/-20% jitter. */
+export declare function backoffMs(attempt: number, rand?: () => number): number;

package/dist/baileys/disconnect.js

@@ -0,0 +1,32 @@
+export const DisconnectCode = {
+    loggedOut: 401,
+    forbidden: 403,
+    timedOut: 408, // also connectionLost
+    multideviceMismatch: 411,
+    connectionClosed: 428,
+    connectionReplaced: 440,
+    badSession: 500,
+    unavailableService: 503,
+    restartRequired: 515,
+};
+export function classifyDisconnect(statusCode) {
+    switch (statusCode) {
+        case DisconnectCode.loggedOut:
+            return 'logged_out';
+        case DisconnectCode.connectionReplaced:
+            return 'replaced';
+        case DisconnectCode.badSession:
+            return 'bad_session';
+        case DisconnectCode.forbidden:
+        case DisconnectCode.multideviceMismatch:
+            return 'blocked';
+        // restartRequired, timedOut/connectionLost, connectionClosed, unavailableService, unknown
+        default:
+            return 'reconnect';
+    }
+}
+/** Exponential backoff 2s -> 60s with +/-20% jitter. */
+export function backoffMs(attempt, rand = Math.random) {
+    const base = Math.min(60_000, 2000 * 2 ** Math.max(0, attempt));
+    return Math.round(base * (0.8 + 0.4 * rand()));
+}

package/dist/baileys/groups.d.ts

@@ -0,0 +1,6 @@
+import type { GroupMetadata } from 'baileys';
+import type { WaGroupInfo } from '../types.js';
+/** Map Baileys group metadata to our shape. Members carry no names; only what WhatsApp sent. */
+export declare function mapGroupMetadata(meta: GroupMetadata): WaGroupInfo;
+/** The About text from a Baileys `fetchStatus` result; null when hidden or unset. */
+export declare function aboutFromStatusResult(list: unknown): string | null;

package/dist/baileys/groups.js

@@ -0,0 +1,45 @@
+import { normalizeContactJid } from './contact-aliases.js';
+const ROLE = {
+    superadmin: 'superadmin',
+    admin: 'admin',
+};
+/** Map Baileys group metadata to our shape. Members carry no names; only what WhatsApp sent. */
+export function mapGroupMetadata(meta) {
+    const participants = [];
+    const seen = new Set();
+    for (const p of meta.participants ?? []) {
+        const id = normalizeContactJid(p.id);
+        if (!id || seen.has(id))
+            continue;
+        seen.add(id);
+        const isLid = id.endsWith('@lid');
+        const phoneJid = isLid ? normalizeContactJid(p.phoneNumber) : id;
+        const lidJid = isLid ? id : normalizeContactJid(p.lid);
+        participants.push({
+            jid: id,
+            phoneJid: phoneJid && !phoneJid.endsWith('@lid') ? phoneJid : null,
+            lidJid: lidJid && lidJid.endsWith('@lid') ? lidJid : null,
+            username: typeof p.username === 'string' && p.username ? p.username : null,
+            role: ROLE[String(p.admin ?? '')] ?? 'member',
+        });
+    }
+    const created = Number(meta.creation);
+    return {
+        jid: meta.id,
+        name: meta.subject || null,
+        description: meta.desc || null,
+        createdAt: Number.isFinite(created) && created > 0 ? created * 1000 : null,
+        // The WhatsApp ID first: the creator's number may later belong to someone else.
+        ownerJid: normalizeContactJid(meta.owner) ?? normalizeContactJid(meta.ownerPn),
+        size: Math.max(Number(meta.size) || 0, participants.length),
+        participants,
+    };
+}
+/** The About text from a Baileys `fetchStatus` result; null when hidden or unset. */
+export function aboutFromStatusResult(list) {
+    // A timed-out query resolves to undefined instead of throwing: a failure, never "no About".
+    if (!Array.isArray(list))
+        throw new Error('About query returned no result');
+    const status = list[0]?.status?.status;
+    return typeof status === 'string' && status.trim() ? status : null;
+}

package/dist/baileys/index.d.ts

@@ -0,0 +1,6 @@
+import type { WaAdapter, WaAdapterOptions } from '../types.js';
+export declare function createBaileysAdapter(opts: WaAdapterOptions): WaAdapter;
+export { BaileysAdapter } from './adapter.js';
+export { classifyDisconnect, backoffMs, type DisconnectAction } from './disconnect.js';
+export { mapWAMessage, jidType } from './mapping.js';
+export { createAuthStore, type AuthStore } from './auth-store.js';

package/dist/baileys/index.js

@@ -0,0 +1,8 @@
+import { BaileysAdapter } from './adapter.js';
+export function createBaileysAdapter(opts) {
+    return new BaileysAdapter(opts);
+}
+export { BaileysAdapter } from './adapter.js';
+export { classifyDisconnect, backoffMs } from './disconnect.js';
+export { mapWAMessage, jidType } from './mapping.js';
+export { createAuthStore } from './auth-store.js';

package/dist/baileys/lru.d.ts

@@ -0,0 +1,9 @@
+/** Minimal insertion-ordered LRU cache. */
+export declare class Lru<K, V> {
+    private readonly max;
+    private readonly map;
+    constructor(max: number);
+    get(key: K): V | undefined;
+    set(key: K, value: V): void;
+    get size(): number;
+}

package/dist/baileys/lru.js

@@ -0,0 +1,30 @@
+/** Minimal insertion-ordered LRU cache. */
+export class Lru {
+    max;
+    map = new Map();
+    constructor(max) {
+        this.max = max;
+    }
+    get(key) {
+        const v = this.map.get(key);
+        if (v !== undefined) {
+            this.map.delete(key);
+            this.map.set(key, v);
+        }
+        return v;
+    }
+    set(key, value) {
+        if (this.map.has(key))
+            this.map.delete(key);
+        this.map.set(key, value);
+        while (this.map.size > this.max) {
+            const oldest = this.map.keys().next();
+            if (oldest.done)
+                break;
+            this.map.delete(oldest.value);
+        }
+    }
+    get size() {
+        return this.map.size;
+    }
+}

package/dist/baileys/mapping.d.ts

@@ -0,0 +1,21 @@
+import { type proto, type WAMessage } from 'baileys';
+import type { WaIncomingMessage } from '../types.js';
+export type JidKind = 'dm' | 'group' | 'other';
+export declare function jidType(jid: string): JidKind;
+type LongLike = {
+    toNumber(): number;
+} | {
+    low: number;
+    high: number;
+};
+/** Convert a protobuf timestamp (number | Long | null) in seconds to epoch ms. */
+export declare function toMs(ts: number | LongLike | null | undefined, fallback?: number): number;
+/** Optional hook for media downloads that need a live socket (reupload of expired media). */
+export type MediaDownloader = (msg: WAMessage) => Promise<Buffer>;
+/**
+ * Map a raw Baileys message to our adapter shape. Returns null for messages
+ * that should not appear in the inbox (reactions, protocol, key distribution,
+ * status/newsletter/broadcast, empty).
+ */
+export declare function mapWAMessage(msg: proto.IWebMessageInfo, download?: MediaDownloader): WaIncomingMessage | null;
+export {};

package/dist/baileys/mapping.js

@@ -0,0 +1,128 @@
+import { downloadMediaMessage, normalizeMessageContent } from 'baileys';
+import { normalizeContactJid } from './contact-aliases.js';
+export function jidType(jid) {
+    if (jid.endsWith('@g.us'))
+        return 'group';
+    if (jid.endsWith('@s.whatsapp.net') || jid.endsWith('@lid'))
+        return 'dm';
+    // status@broadcast, @broadcast lists, @newsletter channels, anything unknown
+    return 'other';
+}
+/** Convert a protobuf timestamp (number | Long | null) in seconds to epoch ms. */
+export function toMs(ts, fallback = Date.now()) {
+    if (ts == null)
+        return fallback;
+    if (typeof ts === 'number')
+        return ts * 1000;
+    if ('toNumber' in ts && typeof ts.toNumber === 'function')
+        return ts.toNumber() * 1000;
+    if ('low' in ts)
+        return ((ts.high >>> 0) * 2 ** 32 + (ts.low >>> 0)) * 1000;
+    return fallback;
+}
+const defaultDownloader = async (msg) => (await downloadMediaMessage(msg, 'buffer', {}));
+/**
+ * Map a raw Baileys message to our adapter shape. Returns null for messages
+ * that should not appear in the inbox (reactions, protocol, key distribution,
+ * status/newsletter/broadcast, empty).
+ */
+export function mapWAMessage(msg, download = defaultDownloader) {
+    const key = msg.key;
+    const chatJid = key?.remoteJid;
+    const id = key?.id;
+    if (!key || !chatJid || !id)
+        return null;
+    if (jidType(chatJid) === 'other')
+        return null;
+    const content = normalizeMessageContent(msg.message);
+    if (!content)
+        return null;
+    const fromMe = !!key.fromMe;
+    const isGroup = jidType(chatJid) === 'group';
+    const senderJid = fromMe ? null : isGroup ? normalizeContactJid(key.participant) : chatJid;
+    const senderJidAlt = !fromMe && isGroup ? normalizeContactJid(key.participantAlt) : null;
+    const senderName = fromMe ? null : (msg.pushName ?? null);
+    const timestamp = toMs(msg.messageTimestamp);
+    let type;
+    let body = null;
+    let ctx;
+    let media = null;
+    if (content.conversation != null) {
+        type = 'text';
+        body = content.conversation;
+    }
+    else if (content.extendedTextMessage) {
+        type = 'text';
+        body = content.extendedTextMessage.text ?? '';
+        ctx = content.extendedTextMessage;
+    }
+    else if (content.imageMessage) {
+        const m = content.imageMessage;
+        type = 'image';
+        body = m.caption ?? null;
+        ctx = m;
+        media = { mime: m.mimetype ?? 'image/jpeg', fileName: null };
+    }
+    else if (content.videoMessage) {
+        const m = content.videoMessage;
+        type = 'video';
+        body = m.caption ?? null;
+        ctx = m;
+        media = { mime: m.mimetype ?? 'video/mp4', fileName: null };
+    }
+    else if (content.audioMessage) {
+        const m = content.audioMessage;
+        type = 'audio';
+        ctx = m;
+        media = {
+            mime: m.mimetype ?? (m.ptt ? 'audio/ogg; codecs=opus' : 'audio/mpeg'),
+            fileName: null,
+        };
+    }
+    else if (content.documentMessage) {
+        const m = content.documentMessage;
+        type = 'document';
+        body = m.caption ?? null;
+        ctx = m;
+        media = {
+            mime: m.mimetype ?? 'application/octet-stream',
+            fileName: m.fileName ?? m.title ?? null,
+        };
+    }
+    else if (content.stickerMessage) {
+        const m = content.stickerMessage;
+        type = 'sticker';
+        ctx = m;
+        media = { mime: m.mimetype ?? 'image/webp', fileName: null };
+    }
+    else {
+        // reactionMessage, protocolMessage, senderKeyDistributionMessage, polls, calls, etc.
+        return null;
+    }
+    const quotedId = ctx?.contextInfo?.stanzaId ?? null;
+    const raw = msg;
+    // The same person's other address (PN for a LID chat or the reverse); only for direct chats.
+    // remoteJidAlt is on Baileys' WAMessageKey, not on proto.IMessageKey.
+    const alt = isGroup ? null : normalizeContactJid(key.remoteJidAlt);
+    const chatJidAlt = alt && alt.endsWith('@lid') !== chatJid.endsWith('@lid') ? alt : null;
+    return {
+        id,
+        chatJid,
+        chatJidAlt,
+        senderJid,
+        senderJidAlt,
+        senderName,
+        fromMe,
+        type,
+        body,
+        mentionedJids: [
+            ...new Set((ctx?.contextInfo?.mentionedJid ?? []).flatMap((jid) => {
+                const normalized = normalizeContactJid(jid);
+                return normalized ? [normalized] : [];
+            })),
+        ],
+        quotedId,
+        timestamp,
+        media: media ? { ...media, download: () => download(raw) } : null,
+    };
+}

package/dist/baileys/photos.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Turns a Baileys `profilePictureUrl` call into an answer: a URL, `null` for a real "no photo"
+ * (WhatsApp error 404) or "private" (401), or a thrown error for a failed lookup, so it is never
+ * remembered as "no photo". Baileys resolves a timed-out query to `undefined`: that is a failure too.
+ */
+export declare function profilePhoto(lookup: () => Promise<string | undefined>): Promise<string | null>;

package/dist/baileys/photos.js

@@ -0,0 +1,20 @@
+/**
+ * Turns a Baileys `profilePictureUrl` call into an answer: a URL, `null` for a real "no photo"
+ * (WhatsApp error 404) or "private" (401), or a thrown error for a failed lookup, so it is never
+ * remembered as "no photo". Baileys resolves a timed-out query to `undefined`: that is a failure too.
+ */
+export async function profilePhoto(lookup) {
+    let url;
+    try {
+        url = await lookup();
+    }
+    catch (err) {
+        const code = err.data;
+        if (code === 404 || code === 401)
+            return null;
+        throw err;
+    }
+    if (!url)
+        throw new Error('Profile picture query returned no result');
+    return url;
+}

package/dist/baileys/quoted.d.ts

@@ -0,0 +1,15 @@
+import type { WAMessage } from 'baileys';
+import type { WaQuotedRef } from '../types.js';
+/**
+ * A cached message re-pointed at the chat the reply goes to. One person can be reached by a phone
+ * number and a WhatsApp ID (LID); a message cached under the old address would otherwise make
+ * Baileys mark the quote as coming from another chat (`contextInfo.remoteJid`).
+ */
+export declare function quotedForChat(cached: WAMessage, chatJid: string): WAMessage;
+/**
+ * A minimal WAMessage for Baileys' `quoted` option, rebuilt from the saved message when the live one
+ * is no longer cached. Baileys reads `key.id` (stanzaId), `key.fromMe`, `key.remoteJid` (must be the
+ * chat the reply goes to, or it adds a foreign remoteJid), `key.participant` (group sender) and the
+ * message content (the preview recipients see).
+ */
+export declare function quotedFromRef(ref: WaQuotedRef, chatJid: string): WAMessage;

package/dist/baileys/quoted.js

@@ -0,0 +1,36 @@
+/** Shown in the quote when the quoted media had no caption (WhatsApp still links it by id). */
+const MEDIA_LABEL = {
+    image: '📷 Photo',
+    video: '🎥 Video',
+    audio: '🎤 Voice message',
+    document: '📄 Document',
+    sticker: 'Sticker',
+};
+/**
+ * A cached message re-pointed at the chat the reply goes to. One person can be reached by a phone
+ * number and a WhatsApp ID (LID); a message cached under the old address would otherwise make
+ * Baileys mark the quote as coming from another chat (`contextInfo.remoteJid`).
+ */
+export function quotedForChat(cached, chatJid) {
+    if (cached.key.remoteJid === chatJid)
+        return cached;
+    return { ...cached, key: { ...cached.key, remoteJid: chatJid } };
+}
+/**
+ * A minimal WAMessage for Baileys' `quoted` option, rebuilt from the saved message when the live one
+ * is no longer cached. Baileys reads `key.id` (stanzaId), `key.fromMe`, `key.remoteJid` (must be the
+ * chat the reply goes to, or it adds a foreign remoteJid), `key.participant` (group sender) and the
+ * message content (the preview recipients see).
+ */
+export function quotedFromRef(ref, chatJid) {
+    const isGroup = chatJid.endsWith('@g.us');
+    return {
+        key: {
+            remoteJid: chatJid,
+            id: ref.id,
+            fromMe: ref.fromMe,
+            ...(isGroup && !ref.fromMe && ref.senderJid ? { participant: ref.senderJid } : {}),
+        },
+        message: { conversation: ref.text?.trim() ? ref.text : (MEDIA_LABEL[ref.type] ?? '') },
+    };
+}

package/dist/baileys/stored-lid-mappings.d.ts

@@ -0,0 +1,8 @@
+import type { WaContactAlias } from '../types.js';
+/**
+ * PN-LID pairs WhatsApp already gave this account, read offline from the multi-file auth store
+ * (no socket, no `baileys` import) so the server can merge chats at startup. A number's forward file
+ * is its current WhatsApp ID; a reverse file only fills numbers without one (an old ID's reverse file
+ * can outlive a number that moved). Missing dir returns []; any other directory error throws.
+ */
+export declare function readStoredLidMappings(authDir: string): WaContactAlias[];

package/dist/baileys/stored-lid-mappings.js

@@ -0,0 +1,96 @@
+import { readdirSync, readFileSync, statSync } from 'node:fs';
+import { join } from 'node:path';
+import { contactAliasPair, normalizeContactJid } from './contact-aliases.js';
+// Baileys' useMultiFileAuthState stores key `<id>` of type `lid-mapping` as `lid-mapping-<id>.json`.
+// LIDMappingStore writes `<pnUser>` -> "<lidUser>" and `<lidUser>_reverse` -> "<pnUser>".
+const FORWARD = /^lid-mapping-(\d+)\.json$/;
+const REVERSE = /^lid-mapping-(\d+)_reverse\.json$/;
+// A mapping file holds one short JSON string; anything bigger is not one.
+const MAX_FILE_BYTES = 1024;
+function readUser(file) {
+    try {
+        const stat = statSync(file);
+        if (!stat.isFile() || stat.size > MAX_FILE_BYTES)
+            return null;
+        const value = JSON.parse(readFileSync(file, 'utf8'));
+        return typeof value === 'string' && /^\d+$/.test(value) ? value : null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * The linked account's own PN and LID (never aliased). Fails closed: without a readable creds.json
+ * carrying `me.id` the account's own identities cannot be excluded, so refuse to guess.
+ */
+function ownJids(authDir) {
+    let me;
+    try {
+        me = JSON.parse(readFileSync(join(authDir, 'creds.json'), 'utf8')).me;
+    }
+    catch {
+        me = undefined;
+    }
+    const own = normalizeContactJid(me?.id);
+    if (!own)
+        throw new Error('wa-auth creds.json missing or has no account id');
+    const set = new Set([own]);
+    const lid = normalizeContactJid(me?.lid);
+    if (lid)
+        set.add(lid);
+    return set;
+}
+/**
+ * PN-LID pairs WhatsApp already gave this account, read offline from the multi-file auth store
+ * (no socket, no `baileys` import) so the server can merge chats at startup. A number's forward file
+ * is its current WhatsApp ID; a reverse file only fills numbers without one (an old ID's reverse file
+ * can outlive a number that moved). Missing dir returns []; any other directory error throws.
+ */
+export function readStoredLidMappings(authDir) {
+    let names;
+    try {
+        names = readdirSync(authDir);
+    }
+    catch (err) {
+        if (err.code === 'ENOENT')
+            return [];
+        throw err;
+    }
+    const lidOf = new Map();
+    const reverse = new Map();
+    for (const name of names) {
+        const forward = FORWARD.exec(name);
+        if (forward) {
+            const lid = readUser(join(authDir, name));
+            if (lid)
+                lidOf.set(forward[1], lid);
+            continue;
+        }
+        const back = REVERSE.exec(name);
+        if (back) {
+            const pn = readUser(join(authDir, name));
+            if (pn)
+                reverse.set(pn, (reverse.get(pn) ?? new Set()).add(back[1]));
+        }
+    }
+    for (const [pn, lids] of reverse) {
+        if (!lidOf.has(pn) && lids.size === 1)
+            lidOf.set(pn, [...lids][0]);
+    }
+    if (lidOf.size === 0)
+        return [];
+    const own = ownJids(authDir);
+    // A LID claimed by more than one number is ambiguous: emitting it would join two people's chats.
+    const claims = new Map();
+    for (const lid of lidOf.values())
+        claims.set(lid, (claims.get(lid) ?? 0) + 1);
+    const out = [];
+    for (const [pn, lid] of [...lidOf].sort(([a], [b]) => a.localeCompare(b))) {
+        if (claims.get(lid) !== 1)
+            continue;
+        const pair = contactAliasPair(`${pn}@s.whatsapp.net`, `${lid}@lid`);
+        if (pair && !own.has(pair.jid) && !own.has(pair.alias))
+            out.push({ ...pair, source: 'keystore' });
+    }
+    return out;
+}

package/dist/fake/fake-adapter.d.ts

@@ -0,0 +1,84 @@
+import { EventEmitter } from 'node:events';
+import type { WaStatus } from '@ezychat/shared';
+import { type SendResult, type WaAdapter, type WaAdapterEvents, type WaContactAlias, type WaGroupInfo, type WaIncomingMessage, type WaSendFile, type WaSendOptions } from '../types.js';
+export interface FakeSentRecord {
+    chatJid: string;
+    text?: string;
+    file?: WaSendFile;
+    id: string;
+    /** Reply options as the real adapter would receive them. */
+    reply?: WaSendOptions;
+}
+/**
+ * In-memory WaAdapter for tests and `--fake-wa` dev mode. Never touches the network.
+ */
+/** Per-process id prefix, so a restarted dev server never reuses message ids stored in app.db. */
+export declare const FAKE_RUN: string;
+export declare class FakeWaAdapter extends EventEmitter implements WaAdapter {
+    private _status;
+    private readonly autoOpen;
+    private inCounter;
+    private outCounter;
+    private nextSendError;
+    private readonly media;
+    private readonly groups;
+    private readonly abouts;
+    /** Every getGroupInfo / getAbout call, for tests that check caching. */
+    readonly groupInfoCalls: string[];
+    readonly aboutCalls: string[];
+    readonly sent: FakeSentRecord[];
+    readonly reads: Array<{
+        chatJid: string;
+        messageIds: string[];
+    }>;
+    readonly presences: Array<{
+        chatJid: string;
+        presence: 'composing' | 'paused';
+    }>;
+    constructor(opts?: {
+        autoOpen?: boolean;
+    });
+    get status(): WaStatus;
+    on<K extends keyof WaAdapterEvents>(ev: K, fn: (...a: WaAdapterEvents[K]) => void): this;
+    off<K extends keyof WaAdapterEvents>(ev: K, fn: (...a: WaAdapterEvents[K]) => void): this;
+    private emitTyped;
+    private setStatus;
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    logout(): Promise<void>;
+    takeover(): Promise<void>;
+    /** test helper: last phone number a pairing code was requested for */
+    pairingRequests: string[];
+    requestPairingCode(phone: string): Promise<string>;
+    private beforeSend;
+    private afterSend;
+    sendText(chatJid: string, text: string, opts?: WaSendOptions): Promise<SendResult>;
+    sendMedia(chatJid: string, file: WaSendFile, opts?: WaSendOptions): Promise<SendResult>;
+    markRead(chatJid: string, messageIds: string[]): Promise<void>;
+    sendPresence(chatJid: string, presence: 'composing' | 'paused'): Promise<void>;
+    downloadMedia(messageId: string): Promise<Buffer | null>;
+    getProfilePicture(_jid: string): Promise<string | null>;
+    getContactAliases(_jids: string[]): Promise<WaContactAlias[]>;
+    getGroupInfo(groupJid: string): Promise<WaGroupInfo>;
+    getAbout(jid: string): Promise<string | null>;
+    /** Make the next getAbout calls fail, as a WhatsApp request error would. */
+    aboutFails: boolean;
+    /** What getGroupInfo returns for this group (members as WhatsApp lists them, no names). */
+    setGroupInfo(info: WaGroupInfo): void;
+    /** What getAbout returns for this person. */
+    setAbout(jid: string, about: string): void;
+    /** Emit `groupChanged`, as WhatsApp does when members are added, removed, promoted or demoted. */
+    simulateGroupChanged(groupJid: string): void;
+    /** makes downloadMedia(messageId) return `buffer` */
+    setMedia(messageId: string, buffer: Buffer): void;
+    /** Emit explicit PN/LID pairs as the adapter does when WhatsApp reveals them. */
+    simulateContactAliases(pairs: WaContactAlias[]): void;
+    /** Emit an incoming live message. Generates id `FAKE-<run>-<n>` unless given. */
+    simulateIncoming(p: Partial<WaIncomingMessage> & {
+        chatJid: string;
+        body: string;
+    }): WaIncomingMessage;
+    simulateStatus(s: Partial<WaStatus>): void;
+    failNextSend(err?: Error): void;
+    setConnected(connected: boolean): void;
+}