@neelegirl/wa-api 1.6.2 → 1.6.4

package/dist/Messaging/index.d.ts

@@ -1,49 +1,28 @@
-
+/**
+ * Send a message to a chat JID or phone number.
+ */
+export declare function sendMessage(
+  sessionId: string,
+  jid: string,
+  content: import("@neelegirl/baileys/lib").AnyMessageContent,
+  options?: import("@neelegirl/baileys/lib").MiscMessageGenerationOptions
+): Promise<import("@neelegirl/baileys/lib").proto.WebMessageInfo>;
 
 /**
- * Send a message to target
- *
- * @param sessionId - Session ID
- * @param jid - Target
- * @param content - Message content
- * @param options - Message options
+ * Send status mentions using the current session socket.
  */
-export declare function sendMessage(
-    sessionId: string,
-    jid: string,
-    content: import("@neelegirl/baileys").AnyMessageContent,
-    options?: import("@neelegirl/baileys").MiscMessageGenerationOptions
-  ): Promise<import("@neelegirl/baileys").proto.WebMessageInfo>;
 export declare function sendStatusMentions(
-    sessionId: string,
-    content: import("@neelegirl/baileys").AnyMessageContent,
-    options?: import("@neelegirl/baileys").MiscMessageGenerationOptions
-): Promise<import("@neelegirl/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)
- */
+  sessionId: string,
+  content: any,
+  options?: import("@neelegirl/baileys/lib").MiscMessageGenerationOptions
+): Promise<any>;
+
 /**
- * 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`)
+ * Low-level relayMessage wrapper.
  */
 export declare function relayMessage(
   sessionId: string,
   jid: string,
   content: any,
-  options?: import('@neelegirl/baileys').MiscMessageGenerationOptions
-): Promise<string>;
+  options?: import("@neelegirl/baileys/lib").MiscMessageGenerationOptions
+): Promise<string>;

package/dist/Messaging/index.js

@@ -1,119 +1,61 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __rest = (this && this.__rest) || function (s, e) {
-    var t = {};
-    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
-        t[p] = s[p];
-    if (s != null && typeof Object.getOwnPropertySymbols === "function")
-        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
-            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
-                t[p[i]] = s[p[i]];
-        }
-    return t;
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
+"use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.relayMessage = exports.sendMessage = void 0;
+exports.relayMessage = exports.sendStatusMentions = exports.sendMessage = void 0;
+
 const Defaults_1 = require("../Defaults");
 const Socket_1 = require("../Socket");
 const Utils_1 = require("../Utils");
-const create_delay_1 = require("../Utils/create-delay");
-const is_exist_1 = require("../Utils/is-exist");
 const Error_1 = require("../Error");
 
 const sessionCache = new Map();
 
 function getCachedSession(sessionId) {
-  let session = sessionCache.get(sessionId);
-  if (!session) {
-    session = Socket_1.getSession(sessionId);
-    if (!session) throw new Error_1.WhatsappError(Defaults_1.Messages.sessionNotFound(sessionId));
-    sessionCache.set(sessionId, session);
-  }
-  return session;
+    let session = sessionCache.get(sessionId);
+    if (!session) {
+        session = (0, Socket_1.getSession)(sessionId);
+        if (!session) {
+            throw new Error_1.WhatsappError(Defaults_1.Messages.sessionNotFound(sessionId));
+        }
+        sessionCache.set(sessionId, session);
+    }
+    return session;
 }
 
-/**
- * Universal sendMessage wrapper for all Baileys message types in JavaScript.
- *
- * @param {string} sessionId   Your multi-session identifier
- * @param {string} jid         Destination JID (user or group) or phone number
- * @param {object} content     AnyMessageContent payload
- * @param {object} [options]   MiscMessageGenerationOptions (quoted, mentions, etc.)
- * @returns {Promise<any>}
- */
-async function sendMessage(sessionId, jid, content, options) {
-  const session = getCachedSession(sessionId);
-
-  // Convert phone number to JID if needed
-  const destJid = jid.includes("@") ? jid : (0, Utils_1.phoneToJid)({ to: jid });
-
-  try {
-    return await session.sendMessage(destJid, content, options || {});
-  } catch (err) {
-    // Wrap Baileys errors into WhatsappError for consistency
-    throw new Error_1.WhatsappError(
-      `Failed to send message to ${destJid}: ${err.message}`,
-      { cause: err }
-    );
-  }
+function resolveJid(jid) {
+    return jid.includes("@") ? jid : (0, Utils_1.phoneToJid)({ to: jid });
 }
 
+async function sendMessage(sessionId, jid, content, options) {
+    const session = getCachedSession(sessionId);
+    const destJid = resolveJid(jid);
+    try {
+        return await session.sendMessage(destJid, content, options || {});
+    }
+    catch (err) {
+        throw new Error_1.WhatsappError(`Failed to send message to ${destJid}: ${err.message}`, { cause: err });
+    }
+}
 exports.sendMessage = sendMessage;
-/**
- * Universal sendMessage wrapper for all Baileys message types in JavaScript.
- *
- * @param {string} sessionId   Your multi-session identifier
- * @param {string} jid         Destination JID (user or group) or phone number
- * @param {object} content     AnyMessageContent payload
- * @param {object} [options]   MiscMessageGenerationOptions (quoted, mentions, etc.)
- * @returns {Promise<any>}
- */
-async function sendStatusMentions(sessionId, content, options) {
-  const session = getCachedSession(sessionId);
 
-  try {
-    return await session.sendStatusMentions( content, options || {});
-  } catch (err) {
-    // Wrap Baileys errors into WhatsappError for consistency
-    throw new Error_1.WhatsappError(
-      `Failed to send message: ${err.message}`,
-      { cause: err }
-    );
-  }
+async function sendStatusMentions(sessionId, content, options) {
+    const session = getCachedSession(sessionId);
+    try {
+        return await session.sendStatusMentions(content, options || {});
+    }
+    catch (err) {
+        throw new Error_1.WhatsappError(`Failed to send status mention: ${err.message}`, { cause: err });
+    }
 }
-
 exports.sendStatusMentions = sendStatusMentions;
-/**
- * Low-level relayMessage-Wrapper für Baileys.
- *
- * @param {string} sessionId - Deine Session-ID
- * @param {string} jid       - Ziel-JID oder Telefonnummer
- * @param {object} content   - das rohe Message-Node-Objekt
- * @param {object} options   - zusätzliche Relay-Optionen wie messageId, participant, additionalNodes, etc.
- *
- * @returns {Promise<string>} die gesendete Nachricht-ID
- */
-async function relayMessage(sessionId, jid, content, options = {}) {
-  const session = getCachedSession(sessionId);
-  if (!session) throw new Error_1.WhatsappError(`Session ${sessionId} nicht gefunden`);
 
-  const destJid = jid.includes("@") ? jid : (0, Utils_1.phoneToJid)({ to: jid });
-  try {
-    // Baileys-intern sendet hier direkt das XML-Stanza
-    return await session.relayMessage(destJid, content, options);
-  } catch (err) {
-    throw new Error_1.WhatsappError(`Relay an ${destJid} fehlgeschlagen: ${err.message}`, { cause: err });
-  }
+async function relayMessage(sessionId, jid, content, options = {}) {
+    const session = getCachedSession(sessionId);
+    const destJid = resolveJid(jid);
+    try {
+        return await session.relayMessage(destJid, content, options);
+    }
+    catch (err) {
+        throw new Error_1.WhatsappError(`Relay to ${destJid} failed: ${err.message}`, { cause: err });
+    }
 }
-exports.relayMessage = relayMessage;
+exports.relayMessage = relayMessage;

package/dist/Socket/index.d.ts

@@ -1,24 +1,45 @@
-import { WASocket } from "@neelegirl/baileys";
+import { WASocket } from "@neelegirl/baileys/lib";
 import type { MessageReceived, MessageUpdated, StartSessionParams } from "../Types";
+
 export declare const startSession: (sessionId?: string, options?: StartSessionParams) => Promise<WASocket>;
+
+export declare const onimaii: (sessionId: string, connect: (config: any) => WASocket) => Promise<WASocket>;
+
+export declare const startSessionWithPairingCode: (
+  sessionId?: string,
+  options?: {
+    phoneNumber: string;
+  },
+  pairingCode?: string
+) => Promise<WASocket>;
+
 /**
- * @deprecated Use startSession method instead
+ * @deprecated Use startSession method instead.
  */
 export declare const startWhatsapp: (sessionId?: string, options?: StartSessionParams) => Promise<WASocket>;
-export declare const startSessionWithPairingCode: (sessionId?: string, options?: {
-    phoneNumber: string;
-}, key?: string) => Promise<WASocket>;
+
 export declare const deleteSession: (sessionId: string) => Promise<void>;
+
 export declare const getAllSession: () => string[];
+
 export declare const getSession: (key: string) => WASocket | undefined;
+
+export declare const getAllSessionData: () => Record<string, WASocket | undefined>;
+
 export declare const loadSessionsFromStorage: () => Promise<string[]>;
+
+export declare const sock: (conn: any) => any;
+
 export declare const onMessageReceived: (listener: (msg: MessageReceived) => any) => void;
-export declare const onQRUpdated: (listener: ({ sessionId, qr }: {
-    sessionId: string;
-    qr: string;
-}) => any) => void;
+
+export declare const onQRUpdated: (listener: ({ sessionId, qr }: { sessionId: string; qr: string }) => any) => void;
+
 export declare const onConnected: (listener: (sessionId: string) => any) => void;
+
 export declare const onDisconnected: (listener: (sessionId: string) => any) => void;
+
 export declare const onConnecting: (listener: (sessionId: string) => any) => void;
-export declare const onMessageUpdate: (listener: (data: MessageUpdated) => any) => void;
-export declare const onPairingCode: (listener: (sessionId: string, code: string) => any) => void;
+
+export declare const onMessageUpdate: (listener: (sessionId: string, data: MessageUpdated) => any) => void;
+
+export declare const onPairingCode: (listener: (sessionId: string, code: string) => any) => void;