@vanzxysenpai/baileys 0.0.0-stage → 0.0.2

package/lib/Utils/payment-guard.js

@@ -0,0 +1,143 @@
+// Vanz@Port --- ported from @lpzeravk/baileys 1.0.0 (payment-guard.js). Creator credits untouched. See NOTICE.md.
+// lib/Utils/payment-guard.js
+//
+// Encanamento genérico para detecção de mensagens de pagamento "stealth"
+// (ocultas/editadas). A LIB não decide o que é payment — isso é lógica do
+// seu bot. Aqui só garantimos que NENHUM caminho de entrada fica sem cobrir:
+//
+//   1) Mensagem direta normal      -> 'messages.upsert'
+//   2) Mensagem EDITADA depois     -> 'messages.update' (protocolMessage MESSAGE_EDIT)
+//   3) Mensagem que falhou decrypt -> 'messages.decrypt-failed' (emitido pela lib)
+//
+// Limite real (sem prometer o impossível): uma mensagem que falha no decrypt
+// (PreKey/CIPHERTEXT) nunca foi lida pelo bot — não existe forma de "ver" que
+// é payment. O que dá pra garantir é que isso nunca passe em silêncio: o
+// evento é sempre emitido, e cabe ao seu detector decidir o que fazer com a
+// falta de conteúdo (ex: tratar como suspeito, igual ao 'unreadable' que você
+// já usa no seu messageEnvelopeRegistry).
+//
+// Você injeta sua própria lógica (paymentMessage.js, messageEnvelopeRegistry.js
+// etc. do seu bot) via callbacks — a lib não importa nada do seu projeto.
+
+/**
+ * @typedef {Object} PaymentGuardHooks
+ * @property {(webMessage: any) => boolean} isPaymentMessage
+ *   Função que decide se um webMessage (ou webMessage sintético de edição)
+ *   é uma mensagem de pagamento. Normalmente seu `hasPaymentMessage`.
+ * @property {(webMessage: any, isPayment: boolean) => void} [recordEnvelope]
+ *   Chamado para TODA mensagem de grupo vista (payment ou não), inclusive
+ *   falhas de decrypt (com `webMessage.message === null`). Normalmente seu
+ *   `recordMessageEnvelope`.
+ * @property {(detection: PaymentDetection) => void} onDetect
+ *   Chamado sempre que uma detecção (direta, editada ou indecifrável
+ *   suspeita) acontece.
+ * @property {boolean} [treatDecryptFailureAsSuspicious=true]
+ */
+
+/**
+ * @typedef {Object} PaymentDetection
+ * @property {'direct'|'edited'|'undecryptable'} type
+ * @property {string} remoteJid
+ * @property {string|undefined} participant
+ * @property {string|undefined} messageId
+ * @property {boolean} [isPreKeyError]
+ * @property {string} [errorMessage]
+ */
+
+const extractEditedContent = (updateEntry) => updateEntry?.update?.message?.editedMessage?.message || null;
+
+/**
+ * Liga o guard completo num socket Baileys. Chame uma vez, logo após criar o sock.
+ *
+ * @param {import('../Socket/index.js').WASocket} sock
+ * @param {PaymentGuardHooks} hooks
+ * @returns {() => void} função de cleanup que remove todos os listeners
+ */
+export const bindPaymentGuard = (sock, hooks) => {
+    const {
+        isPaymentMessage,
+        recordEnvelope = () => {},
+        onDetect = () => {},
+        treatDecryptFailureAsSuspicious = true,
+    } = hooks || {};
+
+    if (typeof isPaymentMessage !== 'function') {
+        throw new Error('bindPaymentGuard: hooks.isPaymentMessage é obrigatório');
+    }
+
+    // ── 1) Mensagens diretas ────────────────────────────────────────────────
+    const onUpsert = ({ messages }) => {
+        for (const webMessage of messages || []) {
+            const remoteJid = webMessage?.key?.remoteJid;
+            if (!remoteJid?.endsWith('@g.us')) continue;
+
+            const isPayment = isPaymentMessage(webMessage);
+            recordEnvelope(webMessage, isPayment);
+
+            if (isPayment) {
+                onDetect({
+                    type: 'direct',
+                    remoteJid,
+                    participant: webMessage.key?.participant,
+                    messageId: webMessage.key?.id,
+                });
+            }
+        }
+    };
+
+    // ── 2) Mensagens editadas (golpe de edição pós-envio) ───────────────────
+    const onUpdate = (updates) => {
+        for (const u of updates || []) {
+            const editedContent = extractEditedContent(u);
+            if (!editedContent) continue;
+
+            const remoteJid = u.key?.remoteJid;
+            if (!remoteJid?.endsWith('@g.us')) continue;
+
+            const syntheticWebMessage = { message: editedContent, key: u.key };
+            const isPayment = isPaymentMessage(syntheticWebMessage);
+            recordEnvelope(syntheticWebMessage, isPayment);
+
+            if (isPayment) {
+                onDetect({
+                    type: 'edited',
+                    remoteJid,
+                    participant: u.key?.participant,
+                    messageId: u.key?.id,
+                });
+            }
+        }
+    };
+
+    // ── 3) Falha de decrypt (PreKey / CIPHERTEXT) ───────────────────────────
+    const onDecryptFailed = (failInfo) => {
+        const remoteJid = failInfo?.remoteJid;
+        if (!remoteJid?.endsWith('@g.us')) return;
+
+        recordEnvelope(
+            { key: { remoteJid, id: failInfo.messageId, participant: failInfo.participant }, message: null },
+            false
+        );
+
+        if (treatDecryptFailureAsSuspicious) {
+            onDetect({
+                type: 'undecryptable',
+                remoteJid,
+                participant: failInfo.participant,
+                messageId: failInfo.messageId,
+                isPreKeyError: failInfo.isPreKeyError,
+                errorMessage: failInfo.errorMessage,
+            });
+        }
+    };
+
+    sock.ev.on('messages.upsert', onUpsert);
+    sock.ev.on('messages.update', onUpdate);
+    sock.ev.on('messages.decrypt-failed', onDecryptFailed);
+
+    return function unbindPaymentGuard() {
+        sock.ev.off('messages.upsert', onUpsert);
+        sock.ev.off('messages.update', onUpdate);
+        sock.ev.off('messages.decrypt-failed', onDecryptFailed);
+    };
+};

package/lib/Utils/payment-messages.d.ts

@@ -0,0 +1,42 @@
+export const SplitPaymentStatus: Readonly<{
+    PENDING: 0;
+    PAID: 1;
+}>;
+export const ReminderFrequency: Readonly<{
+    REMINDER_FREQUENCY_UNKNOWN: 0;
+    WEEKLY: 1;
+    BI_WEEKLY: 2;
+    MONTHLY: 3;
+    QUARTERLY: 4;
+}>;
+export const ReminderStatus: Readonly<{
+    REMINDER_STATUS_UNKNOWN: 0;
+    ACTIVE: 1;
+    CANCELLED_BY_CREATOR: 2;
+    STOPPED_BY_RECEIVER: 3;
+    EXPIRED: 4;
+    PAID: 5;
+}>;
+export const MONEY_OFFSET: 1000;
+export function money(amount: any, currencyCode: any, offset?: number): {
+    value: number;
+    offset: number;
+    currencyCode: string;
+};
+export function readMoney(value: any): {
+    amount: number;
+    currencyCode: any;
+};
+export function buildSplitPayment(opts1?: { [key: string]: any; 
+    participants?: any[];
+}): any;
+export function buildSplitPaymentUpdate(opts2?: { [key: string]: any; }): {
+    splitId: string;
+    participantJid: any;
+};
+export function buildPaymentReminder(opts3?: { [key: string]: any; 
+    frequency?: 3;
+    status?: 1;
+}): any;
+export function readSplitPayment(msg: any): any;
+export function readPaymentReminder(msg: any): any;

package/lib/Utils/payment-messages.js

@@ -0,0 +1,161 @@
+// Vanz@Port --- ported from @rexxhayanasi/elaina-baileys 1.3.10 (payment-messages.js). Creator credits untouched. See NOTICE.md.
+
+export const SplitPaymentStatus = Object.freeze({ PENDING: 0, PAID: 1 })
+
+export const ReminderFrequency = Object.freeze({
+    REMINDER_FREQUENCY_UNKNOWN: 0,
+    WEEKLY: 1,
+    BI_WEEKLY: 2,
+    MONTHLY: 3,
+    QUARTERLY: 4
+})
+
+export const ReminderStatus = Object.freeze({
+    REMINDER_STATUS_UNKNOWN: 0,
+    ACTIVE: 1,
+    CANCELLED_BY_CREATOR: 2,
+    STOPPED_BY_RECEIVER: 3,
+    EXPIRED: 4,
+    PAID: 5
+})
+
+export const MONEY_OFFSET = 1000
+
+const drop = (object) => {
+    for (const key of Object.keys(object)) {
+        if (object[key] === undefined || object[key] === null) {
+            delete object[key]
+        }
+    }
+    return object
+}
+
+/**
+ * Money travels as an integer scaled by offset, so 50000 rupiah at the usual
+ * offset of 1000 goes on the wire as 50000000. Passing the scaled value by
+ * mistake overcharges by three orders of magnitude, so the amount here is
+ * always the human one.
+ */
+export const money = (amount, currencyCode, offset = MONEY_OFFSET) => {
+    const value = Number(amount)
+    if (!Number.isFinite(value) || value < 0) {
+        throw new TypeError('money needs a non-negative amount')
+    }
+    if (typeof currencyCode !== 'string' || currencyCode.length !== 3) {
+        throw new TypeError('money needs a three letter currency code, like IDR or USD')
+    }
+    if (!Number.isInteger(offset) || offset <= 0) {
+        throw new TypeError('money offset must be a positive integer')
+    }
+    return { value: Math.round(value * offset), offset, currencyCode: currencyCode.toUpperCase() }
+}
+
+export const readMoney = (value) => {
+    if (!value?.offset) {
+        return undefined
+    }
+    return {
+        amount: Number(value.value) / Number(value.offset),
+        currencyCode: value.currencyCode
+    }
+}
+
+export const buildSplitPayment = ({ splitId, total, currency, description, requesterJid, participants = [], createdAt } = {}) => {
+    if (!splitId) {
+        throw new TypeError('buildSplitPayment needs a splitId, the update message is keyed on it')
+    }
+    if (!participants.length) {
+        throw new TypeError('buildSplitPayment needs at least one participant')
+    }
+    return drop({
+        splitId: String(splitId),
+        totalAmount: total === undefined ? undefined : money(total, currency),
+        description,
+        requesterJid,
+        participants: participants.map((participant, index) => {
+            if (!participant?.jid) {
+                throw new TypeError(`participant ${index} needs a jid`)
+            }
+            return drop({
+                jid: participant.jid,
+                amount: participant.amount === undefined ? undefined : money(participant.amount, participant.currency ?? currency),
+                status: participant.status ?? SplitPaymentStatus.PENDING
+            })
+        }),
+        createdAtMs: createdAt === undefined ? Date.now() : Number(createdAt)
+    })
+}
+
+export const buildSplitPaymentUpdate = ({ splitId, participantJid } = {}) => {
+    if (!splitId || !participantJid) {
+        throw new TypeError('buildSplitPaymentUpdate needs both splitId and participantJid')
+    }
+    return { splitId: String(splitId), participantJid }
+}
+
+export const buildPaymentReminder = ({
+    reminderId,
+    instanceId,
+    description,
+    frequency = ReminderFrequency.MONTHLY,
+    status = ReminderStatus.ACTIVE,
+    amount,
+    currency,
+    payeeVpa,
+    payeeJid,
+    payerJid
+} = {}) => {
+    if (!reminderId) {
+        throw new TypeError('buildPaymentReminder needs a reminderId')
+    }
+    return drop({
+        reminderId: String(reminderId),
+        instanceId: instanceId === undefined ? undefined : String(instanceId),
+        description,
+        frequency,
+        status,
+        amount: amount === undefined ? undefined : money(amount, currency),
+        payeeVpa,
+        payeeJid,
+        payerJid
+    })
+}
+
+export const readSplitPayment = (msg) => {
+    const message = msg?.message ?? msg
+    const split = message?.splitPaymentMessage
+    if (!split) {
+        return null
+    }
+    return drop({
+        splitId: split.splitId,
+        total: readMoney(split.totalAmount),
+        description: split.description,
+        requesterJid: split.requesterJid,
+        createdAtMs: split.createdAtMs === undefined ? undefined : Number(split.createdAtMs),
+        participants: (split.participants ?? []).map(participant => drop({
+            jid: participant.jid,
+            amount: readMoney(participant.amount),
+            status: participant.status
+        }))
+    })
+}
+
+export const readPaymentReminder = (msg) => {
+    const message = msg?.message ?? msg
+    const reminder = message?.paymentReminderMessage
+    if (!reminder) {
+        return null
+    }
+    return drop({
+        reminderId: reminder.reminderId,
+        instanceId: reminder.instanceId,
+        description: reminder.description,
+        frequency: reminder.frequency,
+        status: reminder.status,
+        amount: readMoney(reminder.amount),
+        payeeVpa: reminder.payeeVpa,
+        payeeJid: reminder.payeeJid,
+        payerJid: reminder.payerJid
+    })
+}

package/lib/Utils/payment-utils.d.ts

@@ -0,0 +1,75 @@
+/**
+ * Build one `payment_account` entry for `payment_settings` (shown as a payout option on a
+ * PENDING/request card). `institution` must exactly match WhatsApp's registry name for that
+ * bank/e-wallet, or its logo won't render.
+ * @param {'bank_account'|'digital_wallet'} accountType
+ * @param {'id_account_number'|'phone_number'} identifierType
+ * @param {string} identifier Account number or phone number.
+ * @param {string} institution Exact registry name, e.g. "Bank Central Asia", "GoPay".
+ * @param {string} beneficiaryName Payee name shown on every listed account.
+ */
+export function buildPaymentAccount(accountType: "bank_account" | "digital_wallet", identifierType: "id_account_number" | "phone_number", identifier: string, institution: string, beneficiaryName: string): {
+    type: string;
+    payment_account: {
+        account_type: "bank_account" | "digital_wallet";
+        identifier_type: "id_account_number" | "phone_number";
+        identifier_value: string;
+        institution_name: string;
+        beneficiary_name: string;
+    };
+};
+/**
+ * Build the `review_and_pay` native-flow button's `buttonParamsJson` payload.
+ * @param {object} spec
+ * @param {number} spec.amount Nominal amount, in rupiah (whole units, not cents).
+ * @param {string} spec.item Item/product name shown on the card.
+ * @param {string} [spec.note] Additional note/description.
+ * @param {boolean} [spec.done] `false` (default) = PENDING request card with a "Lihat opsi
+ *   pembayaran" button listing `spec.accounts`. `true` = COMPLETED card (already paid).
+ * @param {object[]} [spec.accounts] Payout options for the PENDING card — array of
+ *   `buildPaymentAccount(...)` results. Required (and only used) when `done` is falsy.
+ * @returns {string} The JSON-stringified payload, ready for `Button#addButton('review_and_pay', ...)`.
+ */
+export function buildPaymentParams(opts3?: { [key: string]: any; 
+    amount: number;
+    item: string;
+    note?: string;
+    done?: boolean;
+    accounts?: object[];
+}): string;
+/**
+ * Build and send a `review_and_pay` order/payment card via the existing `Button` builder.
+ * Thin convenience wrapper around `buildPaymentParams()` + `Button` — for anything beyond a
+ * single header image/title/body/footer/button (e.g. extra buttons alongside the payment
+ * one), build the `Button` yourself and call `.addButton('review_and_pay', buildPaymentParams(spec))`.
+ * @param {import('../../WAProto/index.js').WASocket} client Active Baileys socket.
+ * @param {string} jid Destination chat/group jid.
+ * @param {object} spec Same shape as `buildPaymentParams()`'s `spec`.
+ * @param {object} [opts]
+ * @param {string} [opts.title] Header title. @param {string} [opts.body] Body text.
+ * @param {string} [opts.footer] Footer text. @param {string} [opts.image] Header image URL.
+ */
+export function sendPayment(client: any, jid: string, spec: object, opts1?: { [key: string]: any; 
+    title?: string;
+    body?: string;
+    footer?: string;
+    image?: string;
+}): Promise<any>;
+/**
+ * Build and send a `review_and_pay` order/payment card via the existing `Button` builder.
+ * Thin convenience wrapper around `buildPaymentParams()` + `Button` — for anything beyond a
+ * single header image/title/body/footer/button (e.g. extra buttons alongside the payment
+ * one), build the `Button` yourself and call `.addButton('review_and_pay', buildPaymentParams(spec))`.
+ * @param {import('../../WAProto/index.js').WASocket} client Active Baileys socket.
+ * @param {string} jid Destination chat/group jid.
+ * @param {object} spec Same shape as `buildPaymentParams()`'s `spec`.
+ * @param {object} [opts]
+ * @param {string} [opts.title] Header title. @param {string} [opts.body] Body text.
+ * @param {string} [opts.footer] Footer text. @param {string} [opts.image] Header image URL.
+ */
+export function Pay(client: any, jid: string, spec: object, opts2?: { [key: string]: any; 
+    title?: string;
+    body?: string;
+    footer?: string;
+    image?: string;
+}): Promise<any>;

package/lib/Utils/payment-utils.js

@@ -0,0 +1,145 @@
+
+// Button is imported lazily inside sendPayment(): Button.js imports buildPaymentParams() from this file (Button#addPay), so a static import here would be circular.
+
+/**
+ * Build one `payment_account` entry for `payment_settings` (shown as a payout option on a
+ * PENDING/request card). `institution` must exactly match WhatsApp's registry name for that
+ * bank/e-wallet, or its logo won't render.
+ * @param {'bank_account'|'digital_wallet'} accountType
+ * @param {'id_account_number'|'phone_number'} identifierType
+ * @param {string} identifier Account number or phone number.
+ * @param {string} institution Exact registry name, e.g. "Bank Central Asia", "GoPay".
+ * @param {string} beneficiaryName Payee name shown on every listed account.
+ */
+export function buildPaymentAccount(accountType, identifierType, identifier, institution, beneficiaryName) {
+	return {
+		type: 'payment_account',
+		payment_account: {
+			account_type: accountType,
+			identifier_type: identifierType,
+			identifier_value: identifier,
+			institution_name: institution,
+			beneficiary_name: beneficiaryName,
+		},
+	};
+}
+
+/**
+ * Build the `review_and_pay` native-flow button's `buttonParamsJson` payload.
+ * @param {object} spec
+ * @param {number} spec.amount Nominal amount, in rupiah (whole units, not cents).
+ * @param {string} spec.item Item/product name shown on the card.
+ * @param {string} [spec.note] Additional note/description.
+ * @param {boolean} [spec.done] `false` (default) = PENDING request card with a "Lihat opsi
+ *   pembayaran" button listing `spec.accounts`. `true` = COMPLETED card (already paid).
+ * @param {object[]} [spec.accounts] Payout options for the PENDING card — array of
+ *   `buildPaymentAccount(...)` results. Required (and only used) when `done` is falsy.
+ * @returns {string} The JSON-stringified payload, ready for `Button#addButton('review_and_pay', ...)`.
+ */
+export function buildPaymentParams({ amount, item, note = '', done = false, accounts = [] } = {}) {
+	if (typeof amount !== 'number' || !Number.isFinite(amount)) {
+		throw new TypeError('buildPaymentParams: spec.amount must be a finite number');
+	}
+	if (typeof item !== 'string' || !item) {
+		throw new TypeError('buildPaymentParams: spec.item must be a non-empty string');
+	}
+
+	const value = amount * 100; // offset 100 -> value = rupiah * 100
+	const money = { value, offset: 100 };
+
+	if (done) {
+		const refId = `CPAY-${Date.now()}`;
+		const item_ = {
+			retailer_id: `item-${Date.now()}${Math.floor(Math.random() * 1e6)}`,
+			name: item,
+			amount: money,
+			quantity: 1,
+		};
+
+		return JSON.stringify({
+			currency: 'IDR',
+			total_amount: money,
+			reference_id: refId,
+			type: 'physical-goods',
+			additional_note: note,
+			native_payment_methods: [],
+			share_payment_status: true,
+			payment_type: '',
+			payment_method: 'confirm',
+			payment_status: 'captured',
+			payment_timestamp: Date.now(),
+			payment_configuration: '',
+			order: {
+				status: 'completed',
+				order_type: 'PAYMENT_REQUEST',
+				subtotal: money,
+				items: [item_],
+			},
+		});
+	}
+
+	if (!accounts.length) {
+		throw new TypeError('buildPaymentParams: spec.accounts is required (and non-empty) when spec.done is not true');
+	}
+
+	const refId = `PAY-${Date.now()}`;
+	const item_ = {
+		name: item,
+		amount: money,
+		quantity: 1,
+		description: note,
+	};
+
+	return JSON.stringify({
+		currency: 'IDR',
+		total_amount: money,
+		reference_id: refId,
+		type: 'physical-goods',
+		additional_note: note,
+		native_payment_methods: [],
+		share_payment_status: false,
+		payment_configuration: '',
+		payment_type: 'upr',
+		payment_settings: accounts,
+		order: {
+			status: 'pending',
+			description: note,
+			order_type: 'PAYMENT_REQUEST',
+			items: [item_],
+			subtotal: money,
+			tax: { value: 0, offset: 100 },
+			shipping: { value: 0, offset: 100 },
+			discount: { value: 0, offset: 100 },
+		},
+	});
+}
+
+/**
+ * Build and send a `review_and_pay` order/payment card via the existing `Button` builder.
+ * Thin convenience wrapper around `buildPaymentParams()` + `Button` — for anything beyond a
+ * single header image/title/body/footer/button (e.g. extra buttons alongside the payment
+ * one), build the `Button` yourself and call `.addButton('review_and_pay', buildPaymentParams(spec))`.
+ * @param {import('../../WAProto/index.js').WASocket} client Active Baileys socket.
+ * @param {string} jid Destination chat/group jid.
+ * @param {object} spec Same shape as `buildPaymentParams()`'s `spec`.
+ * @param {object} [opts]
+ * @param {string} [opts.title] Header title. @param {string} [opts.body] Body text.
+ * @param {string} [opts.footer] Footer text. @param {string} [opts.image] Header image URL.
+ */
+export async function sendPayment(client, jid, spec, { title = '', body = '', footer = '', image } = {}) {
+	const { Button } = await import('../Builders/index.js');
+	const params = buildPaymentParams(spec);
+	const btn = new Button(client);
+
+	if (title) btn.setTitle(title);
+	if (body) btn.setBody(body);
+	if (footer) btn.setFooter(footer);
+	if (image) btn.setImage(image);
+
+	btn.addButton('review_and_pay', params);
+
+	return btn.send(jid);
+}
+
+/** Go-name alias of `sendPayment()` (Go `MessageBuilder.Pay` + `Send`). */
+export const Pay = sendPayment;

package/lib/Utils/phone-utils.d.ts

@@ -0,0 +1,3 @@
+export function validateE164(raw: any): string;
+export function jidToPhone(jid: any): string;
+export function phoneToJid(phone: any, isGroup?: boolean): string;

package/lib/Utils/phone-utils.js

@@ -0,0 +1,29 @@
+// Vanz@Port (2.0.3) --- from kangwifi72/baileys 1.4.9 (validateE164, jidToPhone, phoneToJid), with fixes.
+// NOT ported: donor normalizePhoneNumber (strips a leading 0 whenever length > 10 -- wrong for most locales, e.g. 08xx -> 62xx needs a country code).
+/** Validate an E.164 number (optionally with '+'), returning it as '+<digits>'. Throws on invalid input. */
+export const validateE164 = (raw) => {
+    if (typeof raw !== 'string') {
+        throw new TypeError(`Invalid E.164 number: ${String(raw)}`);
+    }
+    let num = raw.trim();
+    if (num.startsWith('+')) {
+        num = num.slice(1);
+    }
+    if (!/^[1-9][0-9]{6,14}$/.test(num)) {
+        throw new Error(`Invalid E.164 number: ${raw}`);
+    }
+    return `+${num}`;
+};
+/** '628123@s.whatsapp.net' -> '628123'; '' for anything that is not a plain phone-number JID (LID, group, bot...). */
+export const jidToPhone = (jid) => {
+    const match = typeof jid === 'string' ? jid.match(/^(\d+)(?::\d+)?@(?:s\.whatsapp\.net|c\.us)$/) : null;
+    return match ? match[1] : '';
+};
+/** Digits of `phone` -> '<digits>@s.whatsapp.net' (or '@g.us' when isGroup). Throws when no digits are present. */
+export const phoneToJid = (phone, isGroup = false) => {
+    const digits = String(phone ?? '').replace(/[^0-9]/g, '');
+    if (!digits) {
+        throw new Error(`Cannot build a JID from "${phone}"`);
+    }
+    return `${digits}@${isGroup ? 'g.us' : 's.whatsapp.net'}`;
+};

package/lib/Utils/pre-key-manager.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Manages pre-key operations with proper concurrency control
+ */
+export class PreKeyManager {
+    constructor(store: any, logger: any);
+    store: any;
+    logger: any;
+    queues: Map<any, any>;
+    /**
+     * Get or create a queue for a specific key type
+     */
+    getQueue(keyType: any): any;
+    /**
+     * Process pre-key operations (updates and deletions)
+     */
+    processOperations(data: any, keyType: any, transactionCache: any, mutations: any, isInTransaction: any): Promise<any>;
+    /**
+     * Process deletions with validation
+     */
+    processDeletions(keyType: any, ids: any, transactionCache: any, mutations: any, isInTransaction: any): Promise<void>;
+    /**
+     * Validate and process pre-key deletions outside transactions
+     */
+    validateDeletions(data: any, keyType: any): Promise<any>;
+}