@mrlegendbot/baileys 1.2.5 → 1.2.6

package/lib/Signal/lid-mapping.d.ts

@@ -0,0 +1,23 @@
+import type { LIDMapping, SignalKeyStoreWithTransaction } from '../Types/index.js';
+import type { ILogger } from '../Utils/logger.js';
+export declare class LIDMappingStore {
+    private readonly mappingCache;
+    private readonly keys;
+    private readonly logger;
+    private pnToLIDFunc?;
+    private readonly inflightLIDLookups;
+    private readonly inflightPNLookups;
+    constructor(keys: SignalKeyStoreWithTransaction, logger: ILogger, pnToLIDFunc?: (jids: string[]) => Promise<LIDMapping[] | undefined>);
+    storeLIDPNMappings(pairs: LIDMapping[]): Promise<void>;
+    getLIDForPN(pn: string): Promise<string | null>;
+    getLIDsForPNs(pns: string[]): Promise<LIDMapping[] | null>;
+    private _getLIDsForPNsImpl;
+    getPNForLID(lid: string): Promise<string | null>;
+    getPNsForLIDs(lids: string[]): Promise<LIDMapping[] | null>;
+    private _getPNsForLIDsImpl;
+    /**
+     * Close the cache and release resources
+     */
+    close(): void;
+}
+//# sourceMappingURL=lid-mapping.d.ts.map

package/lib/Signal/lid-mapping.js

@@ -1,295 +1,277 @@
 import { LRUCache } from 'lru-cache';
 import { isHostedPnUser, isLidUser, isPnUser, jidDecode, jidNormalizedUser, WAJIDDomains } from '../WABinary/index.js';
 export class LIDMappingStore {
-  constructor(keys, logger, pnToLIDFunc) {
-    this.mappingCache = new LRUCache({
-      ttl: 3 * 24 * 60 * 60 * 1000,
-      ttlAutopurge: true,
-      updateAgeOnGet: true
-    });
-    this.inflightLIDLookups = new Map();
-    this.inflightPNLookups = new Map();
-    this.keys = keys;
-    this.pnToLIDFunc = pnToLIDFunc;
-    this.logger = logger;
-  }
-  async storeLIDPNMappings(pairs) {
-    if (pairs.length === 0) return;
-    const validatedPairs = [];
-    for (const {
-      lid,
-      pn
-    } of pairs) {
-      if (!(isLidUser(lid) && isPnUser(pn) || isPnUser(lid) && isLidUser(pn))) {
-        this.logger.warn(`Invalid LID-PN mapping: ${lid}, ${pn}`);
-        continue;
-      }
-      const lidDecoded = jidDecode(lid);
-      const pnDecoded = jidDecode(pn);
-      if (!lidDecoded || !pnDecoded) continue;
-      validatedPairs.push({
-        pnUser: pnDecoded.user,
-        lidUser: lidDecoded.user
-      });
+    constructor(keys, logger, pnToLIDFunc) {
+        this.mappingCache = new LRUCache({
+            ttl: 3 * 24 * 60 * 60 * 1000, // 7 days
+            ttlAutopurge: true,
+            updateAgeOnGet: true
+        });
+        this.inflightLIDLookups = new Map();
+        this.inflightPNLookups = new Map();
+        this.keys = keys;
+        this.pnToLIDFunc = pnToLIDFunc;
+        this.logger = logger;
     }
-    if (validatedPairs.length === 0) return;
-    const cacheMissSet = new Set();
-    const existingMappings = new Map();
-    for (const {
-      pnUser
-    } of validatedPairs) {
-      const cached = this.mappingCache.get(`pn:${pnUser}`);
-      if (cached) {
-        existingMappings.set(pnUser, cached);
-      } else {
-        cacheMissSet.add(pnUser);
-      }
-    }
-    if (cacheMissSet.size > 0) {
-      const cacheMisses = [...cacheMissSet];
-      this.logger.trace(`Batch fetching ${cacheMisses.length} LID mappings from database`);
-      const stored = await this.keys.get('lid-mapping', cacheMisses);
-      for (const pnUser of cacheMisses) {
-        const existingLidUser = stored[pnUser];
-        if (existingLidUser) {
-          existingMappings.set(pnUser, existingLidUser);
-          this.mappingCache.set(`pn:${pnUser}`, existingLidUser);
-          this.mappingCache.set(`lid:${existingLidUser}`, pnUser);
+    async storeLIDPNMappings(pairs) {
+        if (pairs.length === 0)
+            return;
+        const validatedPairs = [];
+        for (const { lid, pn } of pairs) {
+            if (!((isLidUser(lid) && isPnUser(pn)) || (isPnUser(lid) && isLidUser(pn)))) {
+                this.logger.warn(`Invalid LID-PN mapping: ${lid}, ${pn}`);
+                continue;
+            }
+            const lidDecoded = jidDecode(lid);
+            const pnDecoded = jidDecode(pn);
+            if (!lidDecoded || !pnDecoded)
+                continue;
+            validatedPairs.push({ pnUser: pnDecoded.user, lidUser: lidDecoded.user });
+        }
+        if (validatedPairs.length === 0)
+            return;
+        const cacheMissSet = new Set();
+        const existingMappings = new Map();
+        for (const { pnUser } of validatedPairs) {
+            const cached = this.mappingCache.get(`pn:${pnUser}`);
+            if (cached) {
+                existingMappings.set(pnUser, cached);
+            }
+            else {
+                cacheMissSet.add(pnUser);
+            }
+        }
+        if (cacheMissSet.size > 0) {
+            const cacheMisses = [...cacheMissSet];
+            this.logger.trace(`Batch fetching ${cacheMisses.length} LID mappings from database`);
+            const stored = await this.keys.get('lid-mapping', cacheMisses);
+            for (const pnUser of cacheMisses) {
+                const existingLidUser = stored[pnUser];
+                if (existingLidUser) {
+                    existingMappings.set(pnUser, existingLidUser);
+                    this.mappingCache.set(`pn:${pnUser}`, existingLidUser);
+                    this.mappingCache.set(`lid:${existingLidUser}`, pnUser);
+                }
+            }
+        }
+        const pairMap = {};
+        for (const { pnUser, lidUser } of validatedPairs) {
+            const existingLidUser = existingMappings.get(pnUser);
+            if (existingLidUser === lidUser) {
+                this.logger.debug({ pnUser, lidUser }, 'LID mapping already exists, skipping');
+                continue;
+            }
+            pairMap[pnUser] = lidUser;
+        }
+        if (Object.keys(pairMap).length === 0)
+            return;
+        this.logger.trace({ pairMap }, `Storing ${Object.keys(pairMap).length} pn mappings`);
+        const batchData = {};
+        for (const [pnUser, lidUser] of Object.entries(pairMap)) {
+            batchData[pnUser] = lidUser;
+            batchData[`${lidUser}_reverse`] = pnUser;
+        }
+        await this.keys.transaction(async () => {
+            await this.keys.set({ 'lid-mapping': batchData });
+        }, 'lid-mapping');
+        // Update cache after successful DB write
+        for (const [pnUser, lidUser] of Object.entries(pairMap)) {
+            this.mappingCache.set(`pn:${pnUser}`, lidUser);
+            this.mappingCache.set(`lid:${lidUser}`, pnUser);
         }
-      }
-    }
-    const pairMap = {};
-    for (const {
-      pnUser,
-      lidUser
-    } of validatedPairs) {
-      const existingLidUser = existingMappings.get(pnUser);
-      if (existingLidUser === lidUser) {
-        this.logger.debug({
-          pnUser,
-          lidUser
-        }, 'LID mapping already exists, skipping');
-        continue;
-      }
-      pairMap[pnUser] = lidUser;
-    }
-    if (Object.keys(pairMap).length === 0) return;
-    this.logger.trace({
-      pairMap
-    }, `Storing ${Object.keys(pairMap).length} pn mappings`);
-    const batchData = {};
-    for (const [pnUser, lidUser] of Object.entries(pairMap)) {
-      batchData[pnUser] = lidUser;
-      batchData[`${lidUser}_reverse`] = pnUser;
-    }
-    await this.keys.transaction(async () => {
-      await this.keys.set({
-        'lid-mapping': batchData
-      });
-    }, 'lid-mapping');
-    for (const [pnUser, lidUser] of Object.entries(pairMap)) {
-      this.mappingCache.set(`pn:${pnUser}`, lidUser);
-      this.mappingCache.set(`lid:${lidUser}`, pnUser);
-    }
-  }
-  async getLIDForPN(pn) {
-    return (await this.getLIDsForPNs([pn]))?.[0]?.lid || null;
-  }
-  async getLIDsForPNs(pns) {
-    if (pns.length === 0) return null;
-    const sortedPns = [...new Set(pns)].sort();
-    const cacheKey = sortedPns.join(',');
-    const inflight = this.inflightLIDLookups.get(cacheKey);
-    if (inflight) {
-      this.logger.trace(`Coalescing getLIDsForPNs request for ${sortedPns.length} PNs`);
-      return inflight;
     }
-    const promise = this._getLIDsForPNsImpl(pns);
-    this.inflightLIDLookups.set(cacheKey, promise);
-    try {
-      return await promise;
-    } finally {
-      this.inflightLIDLookups.delete(cacheKey);
+    async getLIDForPN(pn) {
+        return (await this.getLIDsForPNs([pn]))?.[0]?.lid || null;
     }
-  }
-  async _getLIDsForPNsImpl(pns) {
-    const usyncFetch = {};
-    const successfulPairs = {};
-    const pending = [];
-    const addResolvedPair = (pn, decoded, lidUser) => {
-      const normalizedLidUser = lidUser.toString();
-      if (!normalizedLidUser) {
-        this.logger.warn(`Invalid or empty LID user for PN ${pn}: lidUser = "${lidUser}"`);
-        return false;
-      }
-      const pnDevice = decoded.device !== undefined ? decoded.device : 0;
-      const deviceSpecificLid = `${normalizedLidUser}${!!pnDevice ? `:${pnDevice}` : ``}@${decoded.server === 'hosted' ? 'hosted.lid' : 'lid'}`;
-      this.logger.trace(`getLIDForPN: ${pn} → ${deviceSpecificLid} (user mapping with device ${pnDevice})`);
-      successfulPairs[pn] = {
-        lid: deviceSpecificLid,
-        pn
-      };
-      return true;
-    };
-    for (const pn of pns) {
-      if (!isPnUser(pn) && !isHostedPnUser(pn)) continue;
-      const decoded = jidDecode(pn);
-      if (!decoded) continue;
-      const pnUser = decoded.user;
-      const cached = this.mappingCache.get(`pn:${pnUser}`);
-      if (cached && typeof cached === 'string') {
-        if (!addResolvedPair(pn, decoded, cached)) {
-          this.logger.warn(`Invalid entry for ${pn} (pair not resolved)`);
-          continue;
+    async getLIDsForPNs(pns) {
+        if (pns.length === 0)
+            return null;
+        const sortedPns = [...new Set(pns)].sort();
+        const cacheKey = sortedPns.join(',');
+        const inflight = this.inflightLIDLookups.get(cacheKey);
+        if (inflight) {
+            this.logger.trace(`Coalescing getLIDsForPNs request for ${sortedPns.length} PNs`);
+            return inflight;
         }
-        continue;
-      }
-      pending.push({
-        pn,
-        pnUser,
-        decoded
-      });
-    }
-    if (pending.length) {
-      const pnUsers = [...new Set(pending.map(item => item.pnUser))];
-      const stored = await this.keys.get('lid-mapping', pnUsers);
-      for (const pnUser of pnUsers) {
-        const lidUser = stored[pnUser];
-        if (lidUser && typeof lidUser === 'string') {
-          this.mappingCache.set(`pn:${pnUser}`, lidUser);
-          this.mappingCache.set(`lid:${lidUser}`, pnUser);
+        const promise = this._getLIDsForPNsImpl(pns);
+        this.inflightLIDLookups.set(cacheKey, promise);
+        try {
+            return await promise;
         }
-      }
-      for (const {
-        pn,
-        pnUser,
-        decoded
-      } of pending) {
-        const cached = this.mappingCache.get(`pn:${pnUser}`);
-        if (cached && typeof cached === 'string') {
-          if (!addResolvedPair(pn, decoded, cached)) {
-            this.logger.warn(`Invalid entry for ${pn} (pair not resolved)`);
-            continue;
-          }
-        } else {
-          this.logger.trace(`No LID mapping found for PN user ${pnUser}; batch getting from USync`);
-          const device = decoded.device || 0;
-          let normalizedPn = jidNormalizedUser(pn);
-          if (isHostedPnUser(normalizedPn)) {
-            normalizedPn = `${pnUser}@s.whatsapp.net`;
-          }
-          if (!usyncFetch[normalizedPn]) {
-            usyncFetch[normalizedPn] = [device];
-          } else {
-            usyncFetch[normalizedPn]?.push(device);
-          }
+        finally {
+            this.inflightLIDLookups.delete(cacheKey);
         }
-      }
     }
-    if (Object.keys(usyncFetch).length > 0) {
-      const result = await this.pnToLIDFunc?.(Object.keys(usyncFetch));
-      if (result && result.length > 0) {
-        await this.storeLIDPNMappings(result);
-        for (const pair of result) {
-          const pnDecoded = jidDecode(pair.pn);
-          const pnUser = pnDecoded?.user;
-          if (!pnUser) continue;
-          const lidUser = jidDecode(pair.lid)?.user;
-          if (!lidUser) continue;
-          for (const device of usyncFetch[pair.pn]) {
-            const deviceSpecificLid = `${lidUser}${!!device ? `:${device}` : ``}@${device === 99 ? 'hosted.lid' : 'lid'}`;
-            this.logger.trace(`getLIDForPN: USYNC success for ${pair.pn} → ${deviceSpecificLid} (user mapping with device ${device})`);
-            const deviceSpecificPn = `${pnUser}${!!device ? `:${device}` : ``}@${device === 99 ? 'hosted' : 's.whatsapp.net'}`;
-            successfulPairs[deviceSpecificPn] = {
-              lid: deviceSpecificLid,
-              pn: deviceSpecificPn
-            };
-          }
+    async _getLIDsForPNsImpl(pns) {
+        const usyncFetch = {};
+        const successfulPairs = {};
+        const pending = [];
+        const addResolvedPair = (pn, decoded, lidUser) => {
+            const normalizedLidUser = lidUser.toString();
+            if (!normalizedLidUser) {
+                this.logger.warn(`Invalid or empty LID user for PN ${pn}: lidUser = "${lidUser}"`);
+                return false;
+            }
+            // Push the PN device ID to the LID to maintain device separation
+            const pnDevice = decoded.device !== undefined ? decoded.device : 0;
+            const deviceSpecificLid = `${normalizedLidUser}${!!pnDevice ? `:${pnDevice}` : ``}@${decoded.server === 'hosted' ? 'hosted.lid' : 'lid'}`;
+            this.logger.trace(`getLIDForPN: ${pn} → ${deviceSpecificLid} (user mapping with device ${pnDevice})`);
+            successfulPairs[pn] = { lid: deviceSpecificLid, pn };
+            return true;
+        };
+        for (const pn of pns) {
+            if (!isPnUser(pn) && !isHostedPnUser(pn))
+                continue;
+            const decoded = jidDecode(pn);
+            if (!decoded)
+                continue;
+            const pnUser = decoded.user;
+            const cached = this.mappingCache.get(`pn:${pnUser}`);
+            if (cached && typeof cached === 'string') {
+                if (!addResolvedPair(pn, decoded, cached)) {
+                    this.logger.warn(`Invalid entry for ${pn} (pair not resolved)`);
+                    continue;
+                }
+                continue;
+            }
+            pending.push({ pn, pnUser, decoded });
         }
-      } else {
-        this.logger.warn('USync fetch yielded no results for pending PNs');
-      }
-    }
-    return Object.values(successfulPairs).length > 0 ? Object.values(successfulPairs) : null;
-  }
-  async getPNForLID(lid) {
-    return (await this.getPNsForLIDs([lid]))?.[0]?.pn || null;
-  }
-  async getPNsForLIDs(lids) {
-    if (lids.length === 0) return null;
-    const sortedLids = [...new Set(lids)].sort();
-    const cacheKey = sortedLids.join(',');
-    const inflight = this.inflightPNLookups.get(cacheKey);
-    if (inflight) {
-      this.logger.trace(`Coalescing getPNsForLIDs request for ${sortedLids.length} LIDs`);
-      return inflight;
+        if (pending.length) {
+            const pnUsers = [...new Set(pending.map(item => item.pnUser))];
+            const stored = await this.keys.get('lid-mapping', pnUsers);
+            for (const pnUser of pnUsers) {
+                const lidUser = stored[pnUser];
+                if (lidUser && typeof lidUser === 'string') {
+                    this.mappingCache.set(`pn:${pnUser}`, lidUser);
+                    this.mappingCache.set(`lid:${lidUser}`, pnUser);
+                }
+            }
+            for (const { pn, pnUser, decoded } of pending) {
+                const cached = this.mappingCache.get(`pn:${pnUser}`);
+                if (cached && typeof cached === 'string') {
+                    if (!addResolvedPair(pn, decoded, cached)) {
+                        this.logger.warn(`Invalid entry for ${pn} (pair not resolved)`);
+                        continue;
+                    }
+                }
+                else {
+                    this.logger.trace(`No LID mapping found for PN user ${pnUser}; batch getting from USync`);
+                    const device = decoded.device || 0;
+                    let normalizedPn = jidNormalizedUser(pn);
+                    if (isHostedPnUser(normalizedPn)) {
+                        normalizedPn = `${pnUser}@s.whatsapp.net`;
+                    }
+                    if (!usyncFetch[normalizedPn]) {
+                        usyncFetch[normalizedPn] = [device];
+                    }
+                    else {
+                        usyncFetch[normalizedPn]?.push(device);
+                    }
+                }
+            }
+        }
+        if (Object.keys(usyncFetch).length > 0) {
+            const result = await this.pnToLIDFunc?.(Object.keys(usyncFetch)); // this function already adds LIDs to mapping
+            if (result && result.length > 0) {
+                await this.storeLIDPNMappings(result);
+                for (const pair of result) {
+                    const pnDecoded = jidDecode(pair.pn);
+                    const pnUser = pnDecoded?.user;
+                    if (!pnUser)
+                        continue;
+                    const lidUser = jidDecode(pair.lid)?.user;
+                    if (!lidUser)
+                        continue;
+                    for (const device of usyncFetch[pair.pn]) {
+                        const deviceSpecificLid = `${lidUser}${!!device ? `:${device}` : ``}@${device === 99 ? 'hosted.lid' : 'lid'}`;
+                        this.logger.trace(`getLIDForPN: USYNC success for ${pair.pn} → ${deviceSpecificLid} (user mapping with device ${device})`);
+                        const deviceSpecificPn = `${pnUser}${!!device ? `:${device}` : ``}@${device === 99 ? 'hosted' : 's.whatsapp.net'}`;
+                        successfulPairs[deviceSpecificPn] = { lid: deviceSpecificLid, pn: deviceSpecificPn };
+                    }
+                }
+            }
+            else {
+                this.logger.warn('USync fetch yielded no results for pending PNs');
+            }
+        }
+        return Object.values(successfulPairs).length > 0 ? Object.values(successfulPairs) : null;
     }
-    const promise = this._getPNsForLIDsImpl(lids);
-    this.inflightPNLookups.set(cacheKey, promise);
-    try {
-      return await promise;
-    } finally {
-      this.inflightPNLookups.delete(cacheKey);
+    async getPNForLID(lid) {
+        return (await this.getPNsForLIDs([lid]))?.[0]?.pn || null;
     }
-  }
-  async _getPNsForLIDsImpl(lids) {
-    const successfulPairs = {};
-    const pending = [];
-    const addResolvedPair = (lid, decoded, pnUser) => {
-      if (!pnUser || typeof pnUser !== 'string') {
-        return false;
-      }
-      const lidDevice = decoded.device !== undefined ? decoded.device : 0;
-      const pnJid = `${pnUser}:${lidDevice}@${decoded.domainType === WAJIDDomains.HOSTED_LID ? 'hosted' : 's.whatsapp.net'}`;
-      this.logger.trace(`Found reverse mapping: ${lid} → ${pnJid}`);
-      successfulPairs[lid] = {
-        lid,
-        pn: pnJid
-      };
-      return true;
-    };
-    for (const lid of lids) {
-      if (!isLidUser(lid)) continue;
-      const decoded = jidDecode(lid);
-      if (!decoded) continue;
-      const lidUser = decoded.user;
-      const cached = this.mappingCache.get(`lid:${lidUser}`);
-      if (cached && typeof cached === 'string') {
-        addResolvedPair(lid, decoded, cached);
-        continue;
-      }
-      pending.push({
-        lid,
-        lidUser,
-        decoded
-      });
+    async getPNsForLIDs(lids) {
+        if (lids.length === 0)
+            return null;
+        const sortedLids = [...new Set(lids)].sort();
+        const cacheKey = sortedLids.join(',');
+        const inflight = this.inflightPNLookups.get(cacheKey);
+        if (inflight) {
+            this.logger.trace(`Coalescing getPNsForLIDs request for ${sortedLids.length} LIDs`);
+            return inflight;
+        }
+        const promise = this._getPNsForLIDsImpl(lids);
+        this.inflightPNLookups.set(cacheKey, promise);
+        try {
+            return await promise;
+        }
+        finally {
+            this.inflightPNLookups.delete(cacheKey);
+        }
     }
-    if (pending.length) {
-      const reverseKeys = [...new Set(pending.map(item => `${item.lidUser}_reverse`))];
-      const stored = await this.keys.get('lid-mapping', reverseKeys);
-      for (const {
-        lid,
-        lidUser,
-        decoded
-      } of pending) {
-        let pnUser = this.mappingCache.get(`lid:${lidUser}`);
-        if (!pnUser || typeof pnUser !== 'string') {
-          pnUser = stored[`${lidUser}_reverse`];
-          if (pnUser && typeof pnUser === 'string') {
-            this.mappingCache.set(`lid:${lidUser}`, pnUser);
-            this.mappingCache.set(`pn:${pnUser}`, lidUser);
-          }
+    async _getPNsForLIDsImpl(lids) {
+        const successfulPairs = {};
+        const pending = [];
+        const addResolvedPair = (lid, decoded, pnUser) => {
+            if (!pnUser || typeof pnUser !== 'string') {
+                return false;
+            }
+            const lidDevice = decoded.device !== undefined ? decoded.device : 0;
+            const pnJid = `${pnUser}:${lidDevice}@${decoded.domainType === WAJIDDomains.HOSTED_LID ? 'hosted' : 's.whatsapp.net'}`;
+            this.logger.trace(`Found reverse mapping: ${lid} → ${pnJid}`);
+            successfulPairs[lid] = { lid, pn: pnJid };
+            return true;
+        };
+        for (const lid of lids) {
+            if (!isLidUser(lid))
+                continue;
+            const decoded = jidDecode(lid);
+            if (!decoded)
+                continue;
+            const lidUser = decoded.user;
+            const cached = this.mappingCache.get(`lid:${lidUser}`);
+            if (cached && typeof cached === 'string') {
+                addResolvedPair(lid, decoded, cached);
+                continue;
+            }
+            pending.push({ lid, lidUser, decoded });
         }
-        if (pnUser && typeof pnUser === 'string') {
-          addResolvedPair(lid, decoded, pnUser);
-        } else {
-          this.logger.trace(`No reverse mapping found for LID user: ${lidUser}`);
+        if (pending.length) {
+            const reverseKeys = [...new Set(pending.map(item => `${item.lidUser}_reverse`))];
+            const stored = await this.keys.get('lid-mapping', reverseKeys);
+            for (const { lid, lidUser, decoded } of pending) {
+                let pnUser = this.mappingCache.get(`lid:${lidUser}`);
+                if (!pnUser || typeof pnUser !== 'string') {
+                    pnUser = stored[`${lidUser}_reverse`];
+                    if (pnUser && typeof pnUser === 'string') {
+                        this.mappingCache.set(`lid:${lidUser}`, pnUser);
+                        this.mappingCache.set(`pn:${pnUser}`, lidUser);
+                    }
+                }
+                if (pnUser && typeof pnUser === 'string') {
+                    addResolvedPair(lid, decoded, pnUser);
+                }
+                else {
+                    this.logger.trace(`No reverse mapping found for LID user: ${lidUser}`);
+                }
+            }
         }
-      }
+        return Object.values(successfulPairs).length ? Object.values(successfulPairs) : null;
+    }
+    /**
+     * Close the cache and release resources
+     */
+    close() {
+        this.mappingCache.clear();
     }
-    return Object.values(successfulPairs).length ? Object.values(successfulPairs) : null;
-  }
-  close() {
-    this.mappingCache.clear();
-  }
 }
+//# sourceMappingURL=lid-mapping.js.map

package/lib/Socket/Client/index.d.ts

@@ -0,0 +1,3 @@
+export * from './types.js';
+export * from './websocket.js';
+//# sourceMappingURL=index.d.ts.map

package/lib/Socket/Client/index.js

@@ -1,2 +1,3 @@
 export * from './types.js';
 export * from './websocket.js';
+//# sourceMappingURL=index.js.map

package/lib/Socket/Client/types.d.ts

@@ -0,0 +1,16 @@
+import { EventEmitter } from 'events';
+import { URL } from 'url';
+import type { SocketConfig } from '../../Types/index.js';
+export declare abstract class AbstractSocketClient extends EventEmitter {
+    url: URL;
+    config: SocketConfig;
+    abstract get isOpen(): boolean;
+    abstract get isClosed(): boolean;
+    abstract get isClosing(): boolean;
+    abstract get isConnecting(): boolean;
+    constructor(url: URL, config: SocketConfig);
+    abstract connect(): void;
+    abstract close(): void;
+    abstract send(str: Uint8Array | string, cb?: (err?: Error) => void): boolean;
+}
+//# sourceMappingURL=types.d.ts.map

package/lib/Socket/Client/types.js

@@ -1,10 +1,11 @@
 import { EventEmitter } from 'events';
 import { URL } from 'url';
 export class AbstractSocketClient extends EventEmitter {
-  constructor(url, config) {
-    super();
-    this.url = url;
-    this.config = config;
-    this.setMaxListeners(0);
-  }
+    constructor(url, config) {
+        super();
+        this.url = url;
+        this.config = config;
+        this.setMaxListeners(0);
+    }
 }
+//# sourceMappingURL=types.js.map

package/lib/Socket/Client/websocket.d.ts

@@ -0,0 +1,13 @@
+import WebSocket from 'ws';
+import { AbstractSocketClient } from './types.js';
+export declare class WebSocketClient extends AbstractSocketClient {
+    protected socket: WebSocket | null;
+    get isOpen(): boolean;
+    get isClosed(): boolean;
+    get isClosing(): boolean;
+    get isConnecting(): boolean;
+    connect(): void;
+    close(): Promise<void>;
+    send(str: string | Uint8Array, cb?: (err?: Error) => void): boolean;
+}
+//# sourceMappingURL=websocket.d.ts.map