@vanzxy/baileys 2.0.0

package/lib/Utils/use-sqlite-auth-state.js

@@ -0,0 +1,170 @@
+import { mkdir, readFile, stat, unlink, writeFile } from 'fs/promises';
+import { join } from 'path';
+import { proto } from '../../WAProto/index.js';
+import { initAuthCreds } from './auth-utils.js';
+import { BufferJSON } from './generics.js';
+async function loadBetterSqlite3() {
+    try {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const mod = (await import('better-sqlite3'));
+        return mod.default ?? mod;
+    }
+    catch (err) {
+        const helpful = new Error('`better-sqlite3` is required for `useSqliteAuthState`. Install it as a peer dependency: `npm install better-sqlite3` (or `yarn add better-sqlite3`).');
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        helpful.cause = err;
+        throw helpful;
+    }
+}
+const CREDS_ROW_KEY = '__creds__';
+const CREATE_SCHEMA_SQL = `
+CREATE TABLE IF NOT EXISTS creds (
+  key TEXT PRIMARY KEY,
+  value TEXT NOT NULL
+);
+CREATE TABLE IF NOT EXISTS signal_keys (
+  type TEXT NOT NULL,
+  id TEXT NOT NULL,
+  value TEXT NOT NULL,
+  PRIMARY KEY (type, id)
+);
+CREATE INDEX IF NOT EXISTS signal_keys_type_idx ON signal_keys(type);
+`;
+// Vanz@Add 29-08-26 --- Migration tracking, ported in spirit from zapo-js's
+// wa_migrations pattern (packages/store-sqlite/src/migrations.ts). Each entry
+// is `{ id, sql }`; applied migrations are recorded by id in `wa_migrations`
+// so `db.exec(...)` schema changes are only ever run once per database file,
+// letting future releases evolve the schema without a manual ALTER step from
+// the user. Kept as an ordered array (not a folder of files) since the schema
+// here is a single flat file, unlike zapo's per-domain migration modules.
+const MIGRATIONS = [
+    { id: '0001_init', sql: CREATE_SCHEMA_SQL }
+];
+function ensureMigrationsTable(db) {
+    db.exec('CREATE TABLE IF NOT EXISTS wa_migrations (id TEXT PRIMARY KEY, applied_at INTEGER NOT NULL)');
+}
+function runMigrations(db) {
+    ensureMigrationsTable(db);
+    const applied = new Set(db.prepare('SELECT id FROM wa_migrations').all().map((r) => r.id));
+    const insertMigration = db.prepare('INSERT INTO wa_migrations (id, applied_at) VALUES (?, ?)');
+    for (const migration of MIGRATIONS) {
+        if (applied.has(migration.id))
+            continue;
+        const tx = db.transaction(() => {
+            db.exec(migration.sql);
+            insertMigration.run(migration.id, Date.now());
+        });
+        tx();
+    }
+}
+export async function useSqliteAuthState(opts) {
+    let db;
+    if (opts.database) {
+        db = opts.database;
+    }
+    else {
+        const Database = await loadBetterSqlite3();
+        db = new Database(opts.dbPath);
+    }
+    // WAL mode allows concurrent reads alongside a single writer; matches
+    // what SQLite recommends for read-heavy workloads with sporadic writes.
+    db.pragma('journal_mode = WAL');
+    db.pragma('synchronous = NORMAL');
+    runMigrations(db);
+    // Vanz@Fix (bug 8): periodic WAL checkpoint + cleanup old signal keys to prevent DB bloat.
+    // Runs every 30 minutes. WAL checkpoint reclaims WAL file space; key cleanup removes stale session entries.
+    const _walCleanupInterval = setInterval(() => {
+        try {
+            db.pragma('wal_checkpoint(PASSIVE)');
+            // Remove signal keys older than 30 days (pre-keys, session keys that have expired)
+            // Only removes types that are safe to prune (not creds or app-state-sync-key)
+            const pruneTypes = ['pre-key', 'session'];
+            for (const type of pruneTypes) {
+                try {
+                    // Keep last 500 per type to avoid breaking active sessions
+                    db.prepare(`
+                        DELETE FROM signal_keys WHERE type = ? AND id NOT IN (
+                            SELECT id FROM signal_keys WHERE type = ? ORDER BY rowid DESC LIMIT 500
+                        )
+                    `).run(type, type);
+                } catch { /* ignore per-type errors */ }
+            }
+        } catch { /* ignore checkpoint errors — non-fatal */ }
+    }, 30 * 60 * 1000);
+    // Allow Node process to exit even if interval is still running
+    if (_walCleanupInterval.unref) _walCleanupInterval.unref();
+    const stmts = {
+        credsSelect: db.prepare('SELECT value FROM creds WHERE key = ?'),
+        credsUpsert: db.prepare('INSERT INTO creds (key, value) VALUES (?, ?) ON CONFLICT(key) DO UPDATE SET value = excluded.value'),
+        keySelect: db.prepare('SELECT value FROM signal_keys WHERE type = ? AND id = ?'),
+        keyUpsert: db.prepare('INSERT INTO signal_keys (type, id, value) VALUES (?, ?, ?) ON CONFLICT(type, id) DO UPDATE SET value = excluded.value'),
+        keyDelete: db.prepare('DELETE FROM signal_keys WHERE type = ? AND id = ?'),
+        keyListIds: db.prepare('SELECT id FROM signal_keys WHERE type = ?'),
+        keyList: db.prepare('SELECT id, value FROM signal_keys WHERE type = ?'),
+        clearKeys: db.prepare('DELETE FROM signal_keys')
+    };
+    const loadCreds = () => {
+        const row = stmts.credsSelect.get(CREDS_ROW_KEY);
+        if (!row)
+            return initAuthCreds();
+        return JSON.parse(row.value, BufferJSON.reviver);
+    };
+    const persistCreds = (creds) => {
+        stmts.credsUpsert.run(CREDS_ROW_KEY, JSON.stringify(creds, BufferJSON.replacer));
+    };
+    const creds = loadCreds();
+    return {
+        state: {
+            creds,
+            keys: {
+                get: async (type, ids) => {
+                    const data = {};
+                    for (const id of ids) {
+                        const row = stmts.keySelect.get(type, id);
+                        if (row) {
+                            let value = JSON.parse(row.value, BufferJSON.reviver);
+                            if (type === 'app-state-sync-key' && value) {
+                                value = proto.Message.AppStateSyncKeyData.fromObject(value);
+                            }
+                            data[id] = value;
+                        }
+                    }
+                    return data;
+                },
+                set: async (data) => {
+                    const writeTx = db.transaction(() => {
+                        for (const category in data) {
+                            for (const id in data[category]) {
+                                const value = data[category][id];
+                                if (value) {
+                                    const stringified = JSON.stringify(value, BufferJSON.replacer);
+                                    stmts.keyUpsert.run(category, id, stringified);
+                                }
+                                else {
+                                    stmts.keyDelete.run(category, id);
+                                }
+                            }
+                        }
+                    });
+                    writeTx();
+                }
+            }
+        },
+        saveCreds: async () => {
+            persistCreds(creds);
+        },
+        // Vanz@Fix: release the WAL cleanup interval and (if we opened it ourselves)
+        // the underlying db handle. Without this, every useSqliteAuthState() call
+        // (e.g. re-pairing / rotating sessions) leaked a timer + open sqlite fd forever.
+        close: async () => {
+            clearInterval(_walCleanupInterval);
+            if (!opts.database) {
+                try {
+                    db.close();
+                }
+                catch { /* already closed */ }
+            }
+        }
+    };
+}
+//# sourceMappingURL=use-sqlite-auth-state.js.map

package/lib/Utils/validate-connection.d.ts

@@ -0,0 +1,42 @@
+export function generateLoginNode(userJid: any, config: any): any;
+export function generateRegistrationNode({ registrationId, signedPreKey, signedIdentityKey }: {
+    registrationId: any;
+    signedPreKey: any;
+    signedIdentityKey: any;
+}, config: any): any;
+export function configureSuccessfulPairing(stanza: any, { advSecretKey, signedIdentityKey, signalIdentities }: {
+    advSecretKey: any;
+    signedIdentityKey: any;
+    signalIdentities: any;
+}): {
+    creds: {
+        account: any;
+        me: {
+            id: any;
+            name: any;
+            lid: any;
+        };
+        signalIdentities: any[];
+        platform: any;
+    };
+    reply: {
+        tag: string;
+        attrs: {
+            to: string;
+            type: string;
+            id: any;
+        };
+        content: {
+            tag: string;
+            attrs: {};
+            content: {
+                tag: string;
+                attrs: {
+                    'key-index': any;
+                };
+                content: any;
+            }[];
+        }[];
+    };
+};
+export function encodeSignedDeviceIdentity(account: any, includeSignatureKey: any): any;

package/lib/Utils/validate-connection.js

@@ -0,0 +1,199 @@
+import { Boom } from '@hapi/boom';
+import { createHash } from 'crypto';
+import { proto } from '../../WAProto/index.js';
+import { KEY_BUNDLE_TYPE, WA_ADV_ACCOUNT_SIG_PREFIX, WA_ADV_DEVICE_SIG_PREFIX, WA_ADV_HOSTED_ACCOUNT_SIG_PREFIX, COMPANION_DEVICE_VERSION } from '../Defaults/index.js';
+import { getBinaryNodeChild, jidDecode, S_WHATSAPP_NET } from '../WABinary/index.js';
+import { Curve, hmacSign } from './crypto.js';
+import { encodeBigEndian } from './generics.js';
+import { createSignalIdentity } from './signal.js';
+const getUserAgent = (config) => {
+    return {
+        appVersion: {
+            primary: config.version[0],
+            secondary: config.version[1],
+            tertiary: config.version[2]
+        },
+        platform: proto.ClientPayload.UserAgent.Platform.WEB,
+        releaseChannel: proto.ClientPayload.UserAgent.ReleaseChannel.RELEASE,
+        osVersion: '0.1',
+        device: 'Desktop',
+        osBuildNumber: '0.1',
+        localeLanguageIso6391: 'en',
+        mnc: '000',
+        mcc: '000',
+        localeCountryIso31661Alpha2: config.countryCode
+    };
+};
+const PLATFORM_MAP = {
+    'Mac OS': proto.ClientPayload.WebInfo.WebSubPlatform.DARWIN,
+    Windows: proto.ClientPayload.WebInfo.WebSubPlatform.WIN32
+};
+const getWebInfo = (config) => {
+    let webSubPlatform = proto.ClientPayload.WebInfo.WebSubPlatform.WEB_BROWSER;
+    if (config.syncFullHistory &&
+        PLATFORM_MAP[config.browser[0]] &&
+        config.browser[1] === 'Desktop') {
+        webSubPlatform = PLATFORM_MAP[config.browser[0]];
+    }
+    return { webSubPlatform };
+};
+const getClientPayload = (config) => {
+    const payload = {
+        connectType: proto.ClientPayload.ConnectType.WIFI_UNKNOWN,
+        connectReason: proto.ClientPayload.ConnectReason.USER_ACTIVATED,
+        userAgent: getUserAgent(config)
+    };
+    payload.webInfo = getWebInfo(config);
+    if (config.pushName) {
+        payload.pushName = config.pushName;
+    }
+    return payload;
+};
+export const generateLoginNode = (userJid, config) => {
+    const { user, device } = jidDecode(userJid);
+    const payload = {
+        ...getClientPayload(config),
+        passive: true,
+        pull: true,
+        username: +user,
+        device: device,
+        // Vanz@Fix (bug 49): was hardcoded false — now reads from config.lidDbMigrated (default false until investigated)
+        lidDbMigrated: config.lidDbMigrated ?? false
+    };
+    return proto.ClientPayload.fromObject(payload);
+};
+const getPlatformType = (platform) => {
+    const platformType = platform.toUpperCase();
+    return (proto.DeviceProps.PlatformType[platformType] ||
+        proto.DeviceProps.PlatformType.CHROME);
+};
+export const generateRegistrationNode = ({ registrationId, signedPreKey, signedIdentityKey }, config) => {
+    // the app version needs to be md5 hashed
+    // and passed in
+    const appVersionBuf = createHash('md5')
+        .update(config.version.join('.')) // join as string
+        .digest();
+    const companion = {
+        os: config.browser[0],
+        platformType: getPlatformType(config.browser[1]),
+        requireFullSync: config.syncFullHistory,
+        historySyncConfig: {
+            storageQuotaMb: 10240,
+            inlineInitialPayloadInE2EeMsg: true,
+            recentSyncDaysLimit: undefined,
+            supportCallLogHistory: false,
+            supportBotUserAgentChatHistory: true,
+            supportCagReactionsAndPolls: true,
+            supportBizHostedMsg: true,
+            supportRecentSyncChunkMessageCountTuning: true,
+            supportHostedGroupMsg: true,
+            supportFbidBotChatHistory: true,
+            supportAddOnHistorySyncMigration: undefined,
+            supportMessageAssociation: true,
+            supportGroupHistory: false,
+            onDemandReady: undefined,
+            supportGuestChat: undefined
+        },
+        version: COMPANION_DEVICE_VERSION
+    };
+    const companionProto = proto.DeviceProps.encode(companion).finish();
+    const registerPayload = {
+        ...getClientPayload(config),
+        passive: false,
+        pull: false,
+        devicePairingData: {
+            buildHash: appVersionBuf,
+            deviceProps: companionProto,
+            eRegid: encodeBigEndian(registrationId),
+            eKeytype: KEY_BUNDLE_TYPE,
+            eIdent: signedIdentityKey.public,
+            eSkeyId: encodeBigEndian(signedPreKey.keyId, 3),
+            eSkeyVal: signedPreKey.keyPair.public,
+            eSkeySig: signedPreKey.signature
+        }
+    };
+    return proto.ClientPayload.fromObject(registerPayload);
+};
+export const configureSuccessfulPairing = (stanza, { advSecretKey, signedIdentityKey, signalIdentities }) => {
+    const msgId = stanza.attrs.id;
+    const pairSuccessNode = getBinaryNodeChild(stanza, 'pair-success');
+    const deviceIdentityNode = getBinaryNodeChild(pairSuccessNode, 'device-identity');
+    const platformNode = getBinaryNodeChild(pairSuccessNode, 'platform');
+    const deviceNode = getBinaryNodeChild(pairSuccessNode, 'device');
+    const businessNode = getBinaryNodeChild(pairSuccessNode, 'biz');
+    if (!deviceIdentityNode || !deviceNode) {
+        throw new Boom('Missing device-identity or device in pair success node', { data: stanza });
+    }
+    const bizName = businessNode?.attrs.name;
+    const jid = deviceNode.attrs.jid;
+    const lid = deviceNode.attrs.lid;
+    const { details, hmac, accountType } = proto.ADVSignedDeviceIdentityHMAC.decode(deviceIdentityNode.content);
+    let hmacPrefix = Buffer.from([]);
+    if (accountType !== undefined && accountType === proto.ADVEncryptionType.HOSTED) {
+        hmacPrefix = WA_ADV_HOSTED_ACCOUNT_SIG_PREFIX;
+    }
+    const advSign = hmacSign(Buffer.concat([hmacPrefix, details]), Buffer.from(advSecretKey, 'base64'));
+    if (Buffer.compare(hmac, advSign) !== 0) {
+        throw new Boom('Invalid account signature');
+    }
+    const account = proto.ADVSignedDeviceIdentity.decode(details);
+    const { accountSignatureKey, accountSignature, details: deviceDetails } = account;
+    const deviceIdentity = proto.ADVDeviceIdentity.decode(deviceDetails);
+    const accountSignaturePrefix = deviceIdentity.deviceType === proto.ADVEncryptionType.HOSTED
+        ? WA_ADV_HOSTED_ACCOUNT_SIG_PREFIX
+        : WA_ADV_ACCOUNT_SIG_PREFIX;
+    const accountMsg = Buffer.concat([accountSignaturePrefix, deviceDetails, signedIdentityKey.public]);
+    if (!Curve.verify(accountSignatureKey, accountMsg, accountSignature)) {
+        throw new Boom('Failed to verify account signature');
+    }
+    const deviceMsg = Buffer.concat([
+        WA_ADV_DEVICE_SIG_PREFIX,
+        deviceDetails,
+        signedIdentityKey.public,
+        accountSignatureKey
+    ]);
+    account.deviceSignature = Curve.sign(signedIdentityKey.private, deviceMsg);
+    const identity = createSignalIdentity(lid, accountSignatureKey);
+    const accountEnc = encodeSignedDeviceIdentity(account, false);
+    const reply = {
+        tag: 'iq',
+        attrs: {
+            to: S_WHATSAPP_NET,
+            type: 'result',
+            id: msgId
+        },
+        content: [
+            {
+                tag: 'pair-device-sign',
+                attrs: {},
+                content: [
+                    {
+                        tag: 'device-identity',
+                        attrs: { 'key-index': deviceIdentity.keyIndex.toString() },
+                        content: accountEnc
+                    }
+                ]
+            }
+        ]
+    };
+    const authUpdate = {
+        account,
+        me: { id: jid, name: bizName, lid },
+        signalIdentities: [...(signalIdentities || []), identity],
+        platform: platformNode?.attrs.name
+    };
+    return {
+        creds: authUpdate,
+        reply
+    };
+};
+export const encodeSignedDeviceIdentity = (account, includeSignatureKey) => {
+    account = { ...account };
+    // set to null if we are not to include the signature key
+    // or if we are including the signature key but it is empty
+    if (!includeSignatureKey || !account.accountSignatureKey?.length) {
+        account.accountSignatureKey = null;
+    }
+    return proto.ADVSignedDeviceIdentity.encode(account).finish();
+};
+//# sourceMappingURL=validate-connection.js.map

package/lib/Utils/vcard.d.ts

@@ -0,0 +1,58 @@
+export interface ContactPhone {
+    number: string;
+    type?: string;
+    label?: string;
+}
+export interface ContactEmail {
+    email: string;
+    type?: string;
+}
+export interface ContactUrl {
+    url: string;
+    type?: string;
+}
+export interface ContactAddress {
+    street?: string;
+    city?: string;
+    state?: string;
+    postalCode?: string;
+    country?: string;
+    type?: string;
+}
+export interface ContactData {
+    fullName: string;
+    displayName?: string;
+    organization?: string;
+    title?: string;
+    phones?: ContactPhone[];
+    emails?: ContactEmail[];
+    urls?: ContactUrl[];
+    addresses?: ContactAddress[];
+    birthday?: string;
+    note?: string;
+}
+export declare const escapeVCard: (s: string) => string;
+export declare const formatPhone: (p: string) => string;
+export declare const generateVCard: (c: ContactData) => string;
+export declare const generateVCards: (contacts: ContactData[]) => string;
+export declare const parseVCard: (vcard: string) => Partial<ContactData>;
+export declare const createContactCard: (contact: ContactData) => {
+    contacts: {
+        displayName: string;
+        contacts: {
+            vcard: string;
+        }[];
+    };
+};
+export declare const createContactCards: (contacts: ContactData[]) => {
+    contacts: {
+        displayName: string;
+        contacts: {
+            vcard: string;
+        }[];
+    };
+};
+export declare const quickContact: (name: string, phone: string, options?: {
+    organization?: string;
+    email?: string;
+}) => ContactData;

package/lib/Utils/vcard.js

@@ -0,0 +1,105 @@
+// Vanz@Add --- ported from Bail-master addons/vcard.ts (type-only
+// annotations dropped; behavior unchanged).
+export const escapeVCard = (s) => s.replace(/\\/g, '\\\\').replace(/;/g, '\\;').replace(/,/g, '\\,').replace(/\n/g, '\\n');
+// Vanz@Fix 30-08-26 --- the old inline unescape used for FN/ORG/TITLE,
+// `value.replace(/\\([;,n\\])/g, '$1')`, mishandled the `\n` case: it matched
+// the backslash + literal "n" produced by escapeVCard's `\n` escape, then
+// substituted back just the captured "n" character instead of a real newline
+// (`$1` is literally the char "n", not the escape sequence). So a name/org/
+// title containing a real newline round-tripped as "n" inserted in place of
+// the line break instead of the original newline. NOTE already unescaped
+// `\n` correctly on its own, separately. This single helper now reverses
+// every escape escapeVCard() produces (backslash, semicolon, comma, newline)
+// the same correct way, and is reused for all four fields below.
+export const unescapeVCard = (s) => s.replace(/\\(.)/g, (_, ch) => (ch === 'n' ? '\n' : ch));
+export const formatPhone = (p) => p.replace(/[^\d+]/g, '');
+/** Build a VCARD 3.0 string from structured contact data. */
+export const generateVCard = (c) => {
+    const lines = ['BEGIN:VCARD', 'VERSION:3.0', `FN:${escapeVCard(c.fullName)}`];
+    const parts = c.fullName.split(' ');
+    if (parts.length >= 2) {
+        const last = parts[parts.length - 1] || '';
+        const first = parts.slice(0, -1).join(' ');
+        lines.push(`N:${escapeVCard(last)};${escapeVCard(first)};;;`);
+    }
+    else {
+        lines.push(`N:${escapeVCard(c.fullName)};;;;`);
+    }
+    if (c.organization)
+        lines.push(`ORG:${escapeVCard(c.organization)}`);
+    if (c.title)
+        lines.push(`TITLE:${escapeVCard(c.title)}`);
+    for (const p of c.phones ?? []) {
+        const t = p.type || 'CELL';
+        const n = formatPhone(p.number);
+        lines.push(p.label ? `TEL;type=${t};type=VOICE;X-ABLabel=${escapeVCard(p.label)}:${n}` : `TEL;type=${t};type=VOICE:${n}`);
+    }
+    for (const e of c.emails ?? [])
+        lines.push(`EMAIL;type=${e.type || 'OTHER'}:${e.email}`);
+    for (const u of c.urls ?? [])
+        lines.push(`URL;type=${u.type || 'OTHER'}:${u.url}`);
+    for (const a of c.addresses ?? []) {
+        const t = a.type || 'OTHER';
+        const parts = ['', '', a.street || '', a.city || '', a.state || '', a.postalCode || '', a.country || ''].map((v) => escapeVCard(v));
+        lines.push(`ADR;type=${t}:${parts.join(';')}`);
+    }
+    if (c.birthday)
+        lines.push(`BDAY:${c.birthday}`);
+    if (c.note)
+        lines.push(`NOTE:${escapeVCard(c.note)}`);
+    lines.push('END:VCARD');
+    return lines.join('\r\n');
+};
+export const generateVCards = (contacts) => contacts.map(generateVCard).join('\r\n');
+/** Parse a subset of VCARD fields back into structured data. */
+export const parseVCard = (vcard) => {
+    const contact = {};
+    for (const line of vcard.split(/\r?\n/)) {
+        const [key, ...vp] = line.split(':');
+        if (!key)
+            continue;
+        const value = vp.join(':');
+        if (key.startsWith('FN'))
+            contact.fullName = unescapeVCard(value);
+        else if (key.startsWith('ORG'))
+            contact.organization = unescapeVCard(value);
+        else if (key.startsWith('TITLE'))
+            contact.title = unescapeVCard(value);
+        else if (key.startsWith('TEL')) {
+            contact.phones = contact.phones || [];
+            const tm = key.match(/type=(\w+)/i);
+            contact.phones.push({ number: value, type: tm?.[1]?.toUpperCase() || 'CELL' });
+        }
+        else if (key.startsWith('EMAIL')) {
+            contact.emails = contact.emails || [];
+            const tm = key.match(/type=(\w+)/i);
+            contact.emails.push({ email: value, type: tm?.[1]?.toUpperCase() || 'OTHER' });
+        }
+        else if (key.startsWith('BDAY'))
+            contact.birthday = value;
+        else if (key.startsWith('NOTE'))
+            contact.note = unescapeVCard(value);
+    }
+    return contact;
+};
+/** Ready-to-send `contacts` message content for a single contact. */
+export const createContactCard = (contact) => ({
+    contacts: {
+        displayName: contact.displayName || contact.fullName,
+        contacts: [{ vcard: generateVCard(contact) }]
+    }
+});
+/** Ready-to-send `contacts` message content for multiple contacts. */
+export const createContactCards = (contacts) => ({
+    contacts: {
+        displayName: contacts.length === 1 ? contacts[0]?.displayName || contacts[0]?.fullName || '' : `${contacts.length} Contacts`,
+        contacts: contacts.map((c) => ({ vcard: generateVCard(c) }))
+    }
+});
+export const quickContact = (name, phone, options) => ({
+    fullName: name,
+    phones: [{ number: phone, type: 'CELL' }],
+    organization: options?.organization,
+    emails: options?.email ? [{ email: options.email, type: 'WORK' }] : undefined
+});
+//# sourceMappingURL=vcard.js.map

package/lib/VoIP/audio-feeder.d.ts

@@ -0,0 +1,15 @@
+export declare class AudioFeeder {
+    #private;
+    private readonly sampleRate;
+    private readonly channels;
+    private readonly framesPerChunk;
+    private readonly onChunk;
+    private readonly source;
+    droppedChunks: number;
+    underflowChunks: number;
+    bytesProduced: number;
+    chunksEmitted: number;
+    constructor(sampleRate: number, channels: number, framesPerChunk: number, onChunk: (chunk: Float32Array) => void, source?: string);
+    start: () => void;
+    stop: () => void;
+}