@deathnaitsa/wa-api 1.0.45 → 2.0.1

package/package.json

@@ -1,41 +1,18 @@
-{
+{
   "name": "@deathnaitsa/wa-api",
-  "version": "1.0.45",
-  "description": "Multi Session Whatsapp Library",
+  "version": "2.0.0001",
+  "type": "module",
   "main": "dist/index.js",
-  "types": "dist/index.d.ts",
-"licenses": "LiCINSE",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/DeathNaitsa/wa-api.git"
-  },
-  "homepage": "https://github.com/DeathNaitsa/wa-api#readme",
-  "bugs": {
-    "url": "https://github.com/DeathNaitsa/wa-api/issues"
-  },
-  "files": [
-    "dist/**/*"
-  ],
   "scripts": {
-    "build": "tsc",
-    "publish": "npm publish --access public",
-     
-    "start": "tsc && node ./dist/index.js",
-    "test": "jest",
-    "run-script": "node ./dist/index.js"
+    "build": "node build.js",
+    "prepublishOnly": "npm run build"
   },
-  "author": "DeathNaitsa",
-  "license": "ISC",
   "dependencies": {
-    "jest": "^29.0.0",
-    "@adiwajshing/keyed-db": "^0.2.4",
-    "@hapi/boom": "^10.0.1",
-    "@deathnaitsa/baileys": "^1.0.19",
-    "mime": "^3.0.0",
-    "pino": "^8.11.0",
-    "qrcode-terminal": "^0.12.0"
+    "baileys": "latest",
+    "pino": "latest",
+    "qrcode-terminal": "latest"
   },
   "devDependencies": {
-    "@types/mime": "^3.0.1"
+    "javascript-obfuscator": "^4.1.0"
   }
 }

package/socket.js

@@ -0,0 +1,424 @@
+import { startSession, onMessage, sendText, client, getAllSessionsInfo, getGlobalStats, countReceivedMessage } from './nishi-wa-api-new/src/index.js';
+
+// Start sessions
+await startSession('bot');
+await startSession('bot2');
+
+// Command lock to prevent duplicate execution
+const commandLocks = new Map();
+
+async function acquireLock(key, timeoutMs = 5000) {
+    const now = Date.now();
+    const existing = commandLocks.get(key);
+    
+    // Check if already locked
+    if (existing && now - existing < timeoutMs) {
+        return false; // Lock already held
+    }
+    
+    // Acquire lock
+    commandLocks.set(key, now);
+    return true;
+}
+
+function releaseLock(key) {
+    commandLocks.delete(key);
+}
+
+// Chat assignment system (only in this bot implementation)
+const chatAssignments = new Map(); // chatId -> sessionId
+
+function assignChat(chatId, sessionId) {
+    const sessions = client.getAllSessions();
+    if (!sessions.includes(sessionId)) {
+        throw new Error(`Session '${sessionId}' not found`);
+    }
+    chatAssignments.set(chatId, sessionId);
+    console.log(`📞 Chat ${chatId} assigned to ${sessionId}`);
+}
+
+function getChatAssignment(chatId) {
+    return chatAssignments.get(chatId);
+}
+
+function autoAssignChat(chatId, preferredSessionId) {
+    const assignedSession = chatAssignments.get(chatId);
+    const sessions = client.getAllSessions();
+    
+    // Auto-assign if not assigned or assigned session is offline
+    if (!assignedSession || !sessions.includes(assignedSession)) {
+        // Prefer the session that received the message
+        const newSession = sessions.includes(preferredSessionId) ? preferredSessionId : sessions[0];
+        if (newSession) {
+            chatAssignments.set(chatId, newSession);
+            console.log(`📞 Chat ${chatId} auto-assigned to ${newSession}`);
+            return newSession;
+        }
+    }
+    
+    return assignedSession;
+}
+
+function isAssignedToSession(chatId, sessionId) {
+    const assignedSession = autoAssignChat(chatId, sessionId);
+    return assignedSession === sessionId;
+}
+
+console.log('\n📱 WhatsApp Bot läuft!');
+console.log('WhatsApp Befehle:');
+console.log('  !ping              - Bot testen (nur diese Session)');
+console.log('  !ping all          - Alle Sessions testen');
+console.log('  !info              - Nachrichteninfo anzeigen');
+console.log('  !liste             - Alle Sessions auflisten');
+console.log('  !stats             - Detaillierte Session-Statistiken');
+console.log('  !gesamtstats       - Gesamtstatistik aller Sessions');
+console.log('  !neustart <id>     - Session neu starten');
+console.log('  !pause <id>        - Session pausieren');
+console.log('  !fortsetzen <id>   - Session fortsetzen');
+console.log('  !stopp <id>        - Session stoppen');
+console.log('  !löschen <id>      - Session-Daten löschen');
+console.log('  !start <id>        - Neue Session starten');
+console.log('  !zuweisen <id>     - Diesen Chat einer Session zuweisen');
+console.log('  !zuweisungen       - Alle Chat-Zuweisungen anzeigen\n');
+
+// WhatsApp message handler
+onMessage(async (msg) => {
+    // Ignore own messages
+    if (msg.fromMe) return;
+
+    // Check if this message is assigned to this session
+    if (!isAssignedToSession(msg.from, msg.sessionId)) {
+        const assignedTo = getChatAssignment(msg.from);
+        console.log(`⏭️  Skipping message for ${msg.from} (assigned to ${assignedTo})`);
+        return;
+    }
+
+    // Count this message (only for assigned session to avoid duplicates)
+    countReceivedMessage(msg.sessionId);
+
+    // Mark when we received and started processing this message
+    const messageProcessingStart = Date.now();
+
+    const [cmd, ...args] = msg.message.trim().split(' ');
+    const targetSession = args[0];
+    
+    // Helper to safely send messages
+    const safeSend = async (text) => {
+        try {
+            const sessions = client.getAllSessions();
+            if (sessions.includes(msg.sessionId)) {
+                await sendText(msg.sessionId, msg.from, text);
+            }
+        } catch (e) {
+            console.error('Could not send message:', e.message);
+        }
+    };
+
+    try {
+        switch (cmd) {
+            case '!ping':
+                if (targetSession === 'all') {
+                    // Test all sessions
+                    const allSessions = client.getAllSessions();
+                    let pingMessage = '🏓 *Ping Test - Alle Sessions*\n\n';
+                    
+                    for (const sid of allSessions) {
+                        const sessionSendStart = Date.now();
+                        try {
+                            // Send test message and measure time
+                            await sendText(sid, msg.from, '🏓 Ping...');
+                            const sendTime = Date.now() - sessionSendStart;
+                            pingMessage += `🟢 *${sid}*: ${sendTime}ms\n`;
+                        } catch (e) {
+                            pingMessage += `🔴 *${sid}*: Fehler\n`;
+                        }
+                    }
+                    
+                    // Final summary message
+                    const totalLatency = Date.now() - messageProcessingStart;
+                    pingMessage += `\n⏱️ Gesamt: ${totalLatency}ms`;
+                    await sendText(msg.sessionId, msg.from, pingMessage);
+                } else {
+                    // Only test current session - measure send time
+                    const sendStart = Date.now();
+                    await sendText(msg.sessionId, msg.from, `🏓 Pong!`);
+                    const sendTime = Date.now() - sendStart;
+                    const totalLatency = Date.now() - messageProcessingStart;
+                    
+                    // Send detailed timing
+                    const timingInfo = `⏱️ Verarbeitung: ${totalLatency}ms\n📤 Sendezeit: ${sendTime}ms`;
+                    await sendText(msg.sessionId, msg.from, timingInfo);
+                }
+                break;
+            
+            case '!info':
+                const info = `📱 *Session Info*\n\nSession: ${msg.sessionId}\nVon: ${msg.from}\nName: ${msg.name}\nGruppe: ${msg.isGroup ? 'Ja' : 'Nein'}\nTyp: ${msg.type}\nZeitstempel: ${new Date(msg.timestamp * 1000).toLocaleString('de-DE')}`;
+                await sendText(msg.sessionId, msg.from, info);
+                break;
+
+            case '!liste':
+                const sessions = client.getAllSessions();
+                const response = sessions.length 
+                    ? `📋 *Aktive Sessions:*\n\n${sessions.map(s => `• ${s}`).join('\n')}` 
+                    : '❌ Keine aktiven Sessions';
+                await sendText(msg.sessionId, msg.from, response);
+                break;
+
+            case '!stats':
+                const allStats = getAllSessionsInfo();
+                
+                if (allStats.length === 0) {
+                    await safeSend('❌ Keine Sessions vorhanden');
+                    break;
+                }
+
+                let statsMessage = '📊 *Session Statistiken*\n\n';
+                
+                for (const stat of allStats) {
+                    const statusEmoji = stat.isActive ? '🟢' : 
+                                       stat.status === 'stopped' ? '🔴' : 
+                                       stat.status === 'paused' ? '⏸️' : '⚪';
+                    
+                    const statusText = stat.isActive ? 'Aktiv' :
+                                      stat.status === 'stopped' ? 'Gestoppt' :
+                                      stat.status === 'paused' ? 'Pausiert' :
+                                      stat.status === 'connecting' ? 'Verbindet...' :
+                                      stat.status === 'disconnected' ? 'Getrennt' :
+                                      stat.status;
+
+                    const totalMsgs = (stat.messagesReceived || 0) + (stat.messagesSent || 0);
+                    
+                    statsMessage += `${statusEmoji} *${stat.sessionId}*\n`;
+                    statsMessage += `├─ Status: ${statusText}\n`;
+                    statsMessage += `├─ Uptime: ${stat.uptimeFormatted}\n`;
+                    statsMessage += `├─ Neustarts: ${stat.restartCount}\n`;
+                    statsMessage += `└─ Nachrichten: ${totalMsgs} (↓${stat.messagesReceived || 0} / ↑${stat.messagesSent || 0})\n\n`;
+                }
+
+                statsMessage += `_Gesamt: ${allStats.length} Session(s)_`;
+                await safeSend(statsMessage);
+                break;
+
+            case '!gesamtstats':
+                const globalStats = getGlobalStats();
+                
+                const formatDate = (timestamp) => {
+                    const date = new Date(timestamp);
+                    return date.toLocaleString('de-DE', { 
+                        day: '2-digit', 
+                        month: '2-digit', 
+                        year: 'numeric',
+                        hour: '2-digit',
+                        minute: '2-digit'
+                    });
+                };
+                
+                const formatUptime = (ms) => {
+                    const seconds = Math.floor(ms / 1000);
+                    const minutes = Math.floor(seconds / 60);
+                    const hours = Math.floor(minutes / 60);
+                    const days = Math.floor(hours / 24);
+                    
+                    if (days > 0) return `${days}d ${hours % 24}h ${minutes % 60}m`;
+                    if (hours > 0) return `${hours}h ${minutes % 60}m`;
+                    if (minutes > 0) return `${minutes}m`;
+                    return `${seconds}s`;
+                };
+                
+                const totalMessages = (globalStats.totalMessagesReceived || 0) + (globalStats.totalMessagesSent || 0);
+                const received = (globalStats.totalMessagesReceived || 0).toLocaleString('de-DE');
+                const sent = (globalStats.totalMessagesSent || 0).toLocaleString('de-DE');
+                
+                let globalMessage = '📊 *Gesamtstatistik*\n\n';
+                globalMessage += `📨 Nachrichten: ${totalMessages.toLocaleString('de-DE')} (↓${received} / ↑${sent})\n`;
+                globalMessage += `🔢 Sessions: ${globalStats.totalSessions}\n`;
+                globalMessage += `🔄 Neustarts: ${globalStats.totalRestarts}\n`;
+                globalMessage += `⏱️ Gesamtlaufzeit: ${formatUptime(globalStats.totalUptime)}\n`;
+                globalMessage += `🗓️ Seit: ${formatDate(globalStats.firstStarted)}\n`;
+                globalMessage += `🕐 Aktualisiert: ${formatDate(globalStats.lastUpdated)}`;
+                
+                await safeSend(globalMessage);
+                break;
+
+            case '!neustart':
+                if (!targetSession) {
+                    await safeSend('❌ Verwendung: !neustart <sessionId>');
+                    break;
+                }
+                
+                // Check lock to prevent duplicate restart
+                const restartKey = `restart:${targetSession}`;
+                if (!await acquireLock(restartKey)) {
+                    await safeSend(`⏳ Session *${targetSession}* wird bereits neu gestartet...`);
+                    break;
+                }
+                
+                try {
+                    // Send response first if restarting own session
+                    if (targetSession === msg.sessionId) {
+                        await safeSend(`🔄 Starte Session *${targetSession}* neu...`);
+                        await new Promise(resolve => setTimeout(resolve, 1500));
+                        await client.restartSession(targetSession);
+                    } else {
+                        await client.restartSession(targetSession);
+                        await safeSend(`✅ Session *${targetSession}* wurde neu gestartet`);
+                    }
+                } finally {
+                    releaseLock(restartKey);
+                }
+                break;
+
+            case '!pause':
+                if (!targetSession) {
+                    await safeSend('❌ Verwendung: !pause <sessionId>');
+                    break;
+                }
+                
+                // Check lock to prevent duplicate pause
+                const pauseKey = `pause:${targetSession}`;
+                if (!await acquireLock(pauseKey)) {
+                    await safeSend(`⏳ Session *${targetSession}* wird bereits pausiert...`);
+                    break;
+                }
+                
+                try {
+                    // Send response first if pausing own session
+                    if (targetSession === msg.sessionId) {
+                        await safeSend(`⏸️ Pausiere Session *${targetSession}*...`);
+                        await new Promise(resolve => setTimeout(resolve, 1500));
+                        await client.pauseSession(targetSession);
+                    } else {
+                        await client.pauseSession(targetSession);
+                        await safeSend(`⏸️ Session *${targetSession}* wurde pausiert`);
+                    }
+                } finally {
+                    releaseLock(pauseKey);
+                }
+                break;
+
+            case '!fortsetzen':
+                if (!targetSession) {
+                    await safeSend('❌ Verwendung: !fortsetzen <sessionId>');
+                    break;
+                }
+                await client.resumeSession(targetSession);
+                await safeSend(`▶️ Session *${targetSession}* wurde fortgesetzt`);
+                break;
+
+            case '!stopp':
+                if (!targetSession) {
+                    await safeSend('❌ Verwendung: !stopp <sessionId>');
+                    break;
+                }
+                
+                // Check lock to prevent duplicate stop
+                const stopKey = `stop:${targetSession}`;
+                if (!await acquireLock(stopKey)) {
+                    await safeSend(`⏳ Session *${targetSession}* wird bereits gestoppt...`);
+                    break;
+                }
+                
+                try {
+                    // Send response first, then stop
+                    if (targetSession === msg.sessionId) {
+                        // Stopping own session - send message first
+                        await safeSend(`⏹️ Stoppe Session *${targetSession}*...`);
+                        await new Promise(resolve => setTimeout(resolve, 1500));
+                        await client.stopSession(targetSession);
+                    } else {
+                        // Stopping different session
+                        await client.stopSession(targetSession);
+                        await safeSend(`⏹️ Session *${targetSession}* wurde gestoppt`);
+                    }
+                } finally {
+                    releaseLock(stopKey);
+                }
+                break;
+
+            case '!löschen':
+                if (!targetSession) {
+                    await safeSend('❌ Verwendung: !löschen <sessionId>');
+                    break;
+                }
+                
+                // Check lock to prevent duplicate delete
+                const deleteKey = `delete:${targetSession}`;
+                if (!await acquireLock(deleteKey)) {
+                    await safeSend(`⏳ Session *${targetSession}* wird bereits gelöscht...`);
+                    break;
+                }
+                
+                try {
+                    // Send response first if deleting own session
+                    if (targetSession === msg.sessionId) {
+                        await safeSend(`🗑️ Lösche Session *${targetSession}*...`);
+                        await new Promise(resolve => setTimeout(resolve, 1500));
+                        await client.deleteSessionData(targetSession);
+                    } else {
+                        await client.deleteSessionData(targetSession);
+                        await safeSend(`🗑️ Session *${targetSession}* wurde gelöscht`);
+                    }
+                } finally {
+                    releaseLock(deleteKey);
+                }
+                break;
+
+            case '!start':
+                if (!targetSession) {
+                    await safeSend('❌ Verwendung: !start <sessionId>');
+                    break;
+                }
+                
+                // Check lock to prevent duplicate start
+                const startKey = `start:${targetSession}`;
+                if (!await acquireLock(startKey)) {
+                    await safeSend(`⏳ Session *${targetSession}* wird bereits gestartet...`);
+                    break;
+                }
+                
+                try {
+                    await startSession(targetSession);
+                    await safeSend(`✅ Session *${targetSession}* wurde gestartet`);
+                } finally {
+                    releaseLock(startKey);
+                }
+                break;
+
+            case '!zuweisen':
+                if (!targetSession) {
+                    await safeSend('❌ Verwendung: !zuweisen <sessionId>');
+                    break;
+                }
+                
+                try {
+                    assignChat(msg.from, targetSession);
+                    await safeSend(`📞 Dieser Chat ist jetzt *${targetSession}* zugewiesen`);
+                } catch (e) {
+                    await safeSend(`❌ ${e.message}`);
+                }
+                break;
+
+            case '!zuweisungen':
+                const assignmentList = Array.from(chatAssignments.entries())
+                    .map(([chat, session]) => `• ${chat.split('@')[0]}: *${session}*`)
+                    .join('\n');
+                
+                await safeSend(assignmentList 
+                    ? `📋 *Chat-Zuweisungen:*\n\n${assignmentList}` 
+                    : '📋 Noch keine Chat-Zuweisungen');
+                break;
+        }
+    } catch (error) {
+        console.error('❌ Error:', error.message);
+        // Only send error if session still exists
+        try {
+            const sessions = client.getAllSessions();
+            if (sessions.includes(msg.sessionId)) {
+                await sendText(msg.sessionId, msg.from, `❌ Error: ${error.message}`);
+            }
+        } catch (e) {
+            // Ignore if can't send error message
+            console.error('Could not send error message:', e.message);
+        }
+    }
+});

package/LICENSE

@@ -1,2 +0,0 @@
-Copyright (c) 2023 Deathnaitsa
-Kopiergeschützt. Alle Rechte vorbehalten.

package/dist/Defaults/index.d.ts

@@ -1,18 +0,0 @@
-export declare abstract class CREDENTIALS {
-    static DIR_NAME: string;
-    static SUFFIX: string;
-}
-export declare enum CALLBACK_KEY {
-    ON_MESSAGE_RECEIVED = "on-message-received",
-    ON_QR = "on-qr",
-    ON_CONNECTED = "on-connected",
-    ON_DISCONNECTED = "on-disconnected",
-    ON_CONNECTING = "on-connecting",
-    ON_MESSAGE_UPDATED = "on-message-updated"
-}
-export declare abstract class Messages {
-    static sessionAlreadyExist: (sessionId: string) => string;
-    static sessionNotFound: (sessionId: string) => string;
-    static paremetersRequired: (props: string[] | string) => string;
-}
-//# sourceMappingURL=index.d.ts.map

package/dist/Defaults/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/Defaults/index.ts"],"names":[],"mappings":"AAAA,8BAAsB,WAAW;IAC/B,MAAM,CAAC,QAAQ,EAAE,MAAM,CAAoB;IAC3C,MAAM,CAAC,MAAM,EAAE,MAAM,CAAkB;CACxC;AAED,oBAAY,YAAY;IACtB,mBAAmB,wBAAwB;IAC3C,KAAK,UAAU;IACf,YAAY,iBAAiB;IAC7B,eAAe,oBAAoB;IACnC,aAAa,kBAAkB;IAC/B,kBAAkB,uBAAuB;CAC1C;AAED,8BAAsB,QAAQ;IAC5B,MAAM,CAAC,mBAAmB,cAAe,MAAM,KAAG,MAAM,CACe;IAEvE,MAAM,CAAC,eAAe,cAAe,MAAM,KAAG,MAAM,CACP;IAE7C,MAAM,CAAC,kBAAkB,UAAW,MAAM,EAAE,GAAG,MAAM,YAOpC;CAClB"}

package/dist/Defaults/index.js

@@ -1,28 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Messages = exports.CALLBACK_KEY = exports.CREDENTIALS = void 0;
-class CREDENTIALS {
-}
-exports.CREDENTIALS = CREDENTIALS;
-CREDENTIALS.DIR_NAME = "wa_credentials";
-CREDENTIALS.SUFFIX = "_credentials";
-var CALLBACK_KEY;
-(function (CALLBACK_KEY) {
-    CALLBACK_KEY["ON_MESSAGE_RECEIVED"] = "on-message-received";
-    CALLBACK_KEY["ON_QR"] = "on-qr";
-    CALLBACK_KEY["ON_CONNECTED"] = "on-connected";
-    CALLBACK_KEY["ON_DISCONNECTED"] = "on-disconnected";
-    CALLBACK_KEY["ON_CONNECTING"] = "on-connecting";
-    CALLBACK_KEY["ON_MESSAGE_UPDATED"] = "on-message-updated";
-    CALLBACK_KEY["ON_PAIRING_CODE"] = "on-pairing-code";
-})(CALLBACK_KEY || (exports.CALLBACK_KEY = CALLBACK_KEY = {}));
-class Messages {
-}
-exports.Messages = Messages;
-Messages.sessionAlreadyExist = (sessionId) => `Session ID :${sessionId} is already exist, Try another Session ID.`;
-Messages.sessionNotFound = (sessionId) => `Session with ID: ${sessionId} Not Exist!`;
-Messages.paremetersRequired = (props) => `Parameter ${typeof props == "string"
-    ? props
-    : props instanceof Array
-        ? props.join(", ")
-        : ""} is required`;

package/dist/Error/index.d.ts

@@ -1,5 +0,0 @@
-export declare class WhatsappError extends Error {
-    constructor(message: string);
-    static isWhatsappError(error: any): error is WhatsappError;
-}
-//# sourceMappingURL=index.d.ts.map

package/dist/Error/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/Error/index.ts"],"names":[],"mappings":"AAAA,qBAAa,aAAc,SAAQ,KAAK;gBAC1B,OAAO,EAAE,MAAM;IAM3B,MAAM,CAAC,eAAe,CAAC,KAAK,EAAE,GAAG,GAAG,KAAK,IAAI,aAAa;CAG3D"}

package/dist/Error/index.js

@@ -1,14 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.WhatsappError = void 0;
-class WhatsappError extends Error {
-    constructor(message) {
-        super(message);
-        this.name = "WhatsappError";
-        Object.setPrototypeOf(this, WhatsappError.prototype);
-    }
-    static isWhatsappError(error) {
-        return error instanceof WhatsappError || error instanceof Error;
-    }
-}
-exports.WhatsappError = WhatsappError;

package/dist/Messaging/index.d.ts

@@ -1,44 +0,0 @@
-
-
-/**
- * Send a message to target
- *
- * @param sessionId - Session ID
- * @param jid - Target
- * @param content - Message content
- * @param options - Message options
- */
-export declare function sendMessage(
-    sessionId: string,
-    jid: string,
-    content: import("@deathnaitsa/baileys").AnyMessageContent,
-    options?: import("@deathnaitsa/baileys").MiscMessageGenerationOptions
-  ): Promise<import("@deathnaitsa/baileys").proto.WebMessageInfo>;
-    /**
- * Sendet einen rohen WAMessage-Stanza an WhatsApp.
- *
- * @param sessionId  Deine Session-ID
- * @param jid        Ziel-JID oder Telefonnummer (z. B. '491234567890@s.whatsapp.net' oder 'status@broadcast')
- * @param content    Raw-Message-Node (z. B. protocolMessage, videoMessage, etc.)
- * @param options    Optional: Relay-Parameter wie messageId, participant, additionalNodes, statusJidList
- * @returns          Promise mit der gesendeten Nachricht-ID (msgId)
- */
-/**
- * Low-level relayMessage-Wrapper für direkten Baileys-Stanza Dispatch.
- *
- * Sendet ein rohes WAMessage-Stanza (z.B. protocolMessage, disappearingMessagesInChat,
- * videoMessage, etc.) direkt an WhatsApp über die interne `relayMessage`-Methode.
- *
- * @param sessionId  Deine Multi-Session-ID
- * @param jid        Ziel-JID oder Telefonnummer (z.B. '491234567890@s.whatsapp.net' oder 'status@broadcast')
- * @param content    Raw-Message-Node (proto.WebMessageInfo oder AnyMessageContent-ähnlich)
- * @param options    Optional: Relay-Parameter wie `messageId`, `participant`, `additionalNodes`,
- *                   `statusJidList`, `useCachedGroupMetadata`, usw.
- * @returns          Promise mit der gesendeten Nachricht-ID (`msgId`)
- */
-export declare function relayMessage(
-  sessionId: string,
-  jid: string,
-  content: any,
-  options?: import('@deathnaitsa/baileys').MiscMessageGenerationOptions
-): Promise<string>;

package/dist/Messaging/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/Messaging/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,yBAAyB,CAAC;AAGhD,OAAO,EACL,cAAc,EACd,gBAAgB,EAChB,aAAa,EACb,eAAe,EAChB,MAAM,UAAU,CAAC;AAOlB,eAAO,MAAM,eAAe,+CAMzB,gBAAgB,KAAG,QAAQ,MAAM,cAAc,GAAG,SAAS,CAsB7D,CAAC;AACF,eAAO,MAAM,SAAS,sDAOnB,cAAc,KAAG,QAAQ,MAAM,cAAc,GAAG,SAAS,CA8B3D,CAAC;AACF,eAAO,MAAM,SAAS,sDAOnB,cAAc,KAAG,QAAQ,MAAM,cAAc,GAAG,SAAS,CA8B3D,CAAC;AACF,eAAO,MAAM,YAAY;cASb,MAAM;MACd,QAAQ,MAAM,cAAc,GAAG,SAAS,CAuC3C,CAAC;AAEF,eAAO,MAAM,aAAa,gDAMvB,KAAK,cAAc,EAAE,MAAM,CAAC,KAAG,QAAQ,MAAM,cAAc,GAAG,SAAS,CAgCzE,CAAC;AAEF,eAAO,MAAM,WAAW,gDAMrB,cAAc,KAAG,QAAQ,MAAM,cAAc,GAAG,SAAS,CA+B3D,CAAC;AAEF;;;;;;;;;GASG;AACH,eAAO,MAAM,UAAU,0CAKpB,eAAe,kBAgBjB,CAAC;AAEF;;;;;;;;;GASG;AACH,eAAO,MAAM,WAAW,uBAA8B,aAAa,kBAKlE,CAAC"}