@badzz88/baileys 7.1.2 → 8.0.0

package/lib/Types/index.d.ts

@@ -0,0 +1,57 @@
+export * from './Auth';
+export * from './GroupMetadata';
+export * from './Chat';
+export * from './Contact';
+export * from './State';
+export * from './Message';
+export * from './Newsletter';
+export * from './Socket';
+export * from './Events';
+export * from './Product';
+export * from './Call';
+export * from './Signal';
+import { AuthenticationState } from './Auth';
+import { SocketConfig } from './Socket';
+export type UserFacingSocketConfig = Partial<SocketConfig> & {
+    auth: AuthenticationState;
+};
+export declare enum DisconnectReason {
+    connectionClosed = 428,
+    connectionLost = 408,
+    connectionReplaced = 440,
+    timedOut = 408,
+    loggedOut = 401,
+    badSession = 500,
+    restartRequired = 515,
+    multideviceMismatch = 411,
+    forbidden = 403,
+    unavailableService = 503
+}
+export type WAInitResponse = {
+    ref: string;
+    ttl: number;
+    status: 200;
+};
+export type WABusinessHoursConfig = {
+    day_of_week: string;
+    mode: string;
+    open_time?: number;
+    close_time?: number;
+};
+export type WABusinessProfile = {
+    description: string;
+    email: string | undefined;
+    business_hours: {
+        timezone?: string;
+        config?: WABusinessHoursConfig[];
+        business_config?: WABusinessHoursConfig[];
+    };
+    website: string[];
+    category?: string;
+    wid?: string;
+    address?: string;
+};
+export type CurveKeyPair = {
+    private: Uint8Array;
+    public: Uint8Array;
+};

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

@@ -0,0 +1,18 @@
+import type { Logger } from 'pino';
+import type { AuthenticationCreds, CacheStore, SignalKeyStore, SignalKeyStoreWithTransaction, TransactionCapabilityOptions } from '../Types';
+/**
+ * Adds caching capability to a SignalKeyStore
+ * @param store the store to add caching to
+ * @param logger to log trace events
+ * @param _cache cache store to use
+ */
+export declare function makeCacheableSignalKeyStore(store: SignalKeyStore, logger: Logger, _cache?: CacheStore): SignalKeyStore;
+/**
+ * Adds DB like transaction capability (https://en.wikipedia.org/wiki/Database_transaction) to the SignalKeyStore,
+ * this allows batch read & write operations & improves the performance of the lib
+ * @param state the key store to apply this capability to
+ * @param logger logger to log events
+ * @returns SignalKeyStore with transaction capability
+ */
+export declare const addTransactionCapability: (state: SignalKeyStore, logger: Logger, { maxCommitRetries, delayBetweenTriesMs }: TransactionCapabilityOptions) => SignalKeyStoreWithTransaction;
+export declare const initAuthCreds: () => AuthenticationCreds;

package/lib/Utils/baileys-event-stream.d.ts

@@ -0,0 +1,16 @@
+import type { BaileysEventEmitter } from '../Types';
+/**
+ * Captures events from a baileys event emitter & stores them in a file
+ * @param ev The event emitter to read events from
+ * @param filename File to save to
+ */
+export declare const captureEventStream: (ev: BaileysEventEmitter, filename: string) => void;
+/**
+ * Read event file and emit events from there
+ * @param filename filename containing event data
+ * @param delayIntervalMs delay between each event emit
+ */
+export declare const readAndEmitEventStream: (filename: string, delayIntervalMs?: number) => {
+    ev: BaileysEventEmitter;
+    task: Promise<void>;
+};

package/lib/Utils/business.d.ts

@@ -0,0 +1,22 @@
+import { CatalogCollection, OrderDetails, Product, ProductCreate, ProductUpdate, WAMediaUpload, WAMediaUploadFunction } from '../Types';
+import { BinaryNode } from '../WABinary';
+export declare const parseCatalogNode: (node: BinaryNode) => {
+    products: Product[];
+    nextPageCursor: string | undefined;
+};
+export declare const parseCollectionsNode: (node: BinaryNode) => {
+    collections: CatalogCollection[];
+};
+export declare const parseOrderDetailsNode: (node: BinaryNode) => OrderDetails;
+export declare const toProductNode: (productId: string | undefined, product: ProductCreate | ProductUpdate) => BinaryNode;
+export declare const parseProductNode: (productNode: BinaryNode) => Product;
+/**
+ * Uploads images not already uploaded to WA's servers
+ */
+export declare function uploadingNecessaryImagesOfProduct<T extends ProductUpdate | ProductCreate>(product: T, waUploadToServer: WAMediaUploadFunction, timeoutMs?: number): Promise<T>;
+/**
+ * Uploads images not already uploaded to WA's servers
+ */
+export declare const uploadingNecessaryImages: (images: WAMediaUpload[], waUploadToServer: WAMediaUploadFunction, timeoutMs?: number) => Promise<{
+    url: string;
+}[]>;

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

@@ -0,0 +1,71 @@
+/// <reference types="node" />
+import { AxiosRequestConfig } from 'axios';
+import type { Logger } from 'pino';
+import { proto } from '../../WAProto';
+import { BaileysEventEmitter, ChatModification, ChatMutation, Contact, InitialAppStateSyncOptions, LTHashState, WAPatchCreate, WAPatchName } from '../Types';
+import { BinaryNode } from '../WABinary';
+type FetchAppStateSyncKey = (keyId: string) => Promise<proto.Message.IAppStateSyncKeyData | null | undefined>;
+export type ChatMutationMap = {
+    [index: string]: ChatMutation;
+};
+export declare const newLTHashState: () => LTHashState;
+export declare const encodeSyncdPatch: ({ type, index, syncAction, apiVersion, operation }: WAPatchCreate, myAppStateKeyId: string, state: LTHashState, getAppStateSyncKey: FetchAppStateSyncKey) => Promise<{
+    patch: proto.ISyncdPatch;
+    state: LTHashState;
+}>;
+export declare const decodeSyncdMutations: (msgMutations: (proto.ISyncdMutation | proto.ISyncdRecord)[], initialState: LTHashState, getAppStateSyncKey: FetchAppStateSyncKey, onMutation: (mutation: ChatMutation) => void, validateMacs: boolean) => Promise<{
+    hash: Buffer;
+    indexValueMap: {
+        [indexMacBase64: string]: {
+            valueMac: Uint8Array | Buffer;
+        };
+    };
+}>;
+export declare const decodeSyncdPatch: (msg: proto.ISyncdPatch, name: WAPatchName, initialState: LTHashState, getAppStateSyncKey: FetchAppStateSyncKey, onMutation: (mutation: ChatMutation) => void, validateMacs: boolean) => Promise<{
+    hash: Buffer;
+    indexValueMap: {
+        [indexMacBase64: string]: {
+            valueMac: Uint8Array | Buffer;
+        };
+    };
+}>;
+export declare const extractSyncdPatches: (result: BinaryNode, options: AxiosRequestConfig<any>) => Promise<{
+    critical_block: {
+        patches: proto.ISyncdPatch[];
+        hasMorePatches: boolean;
+        snapshot?: proto.ISyncdSnapshot | undefined;
+    };
+    critical_unblock_low: {
+        patches: proto.ISyncdPatch[];
+        hasMorePatches: boolean;
+        snapshot?: proto.ISyncdSnapshot | undefined;
+    };
+    regular_high: {
+        patches: proto.ISyncdPatch[];
+        hasMorePatches: boolean;
+        snapshot?: proto.ISyncdSnapshot | undefined;
+    };
+    regular_low: {
+        patches: proto.ISyncdPatch[];
+        hasMorePatches: boolean;
+        snapshot?: proto.ISyncdSnapshot | undefined;
+    };
+    regular: {
+        patches: proto.ISyncdPatch[];
+        hasMorePatches: boolean;
+        snapshot?: proto.ISyncdSnapshot | undefined;
+    };
+}>;
+export declare const downloadExternalBlob: (blob: proto.IExternalBlobReference, options: AxiosRequestConfig<any>) => Promise<Buffer>;
+export declare const downloadExternalPatch: (blob: proto.IExternalBlobReference, options: AxiosRequestConfig<any>) => Promise<proto.SyncdMutations>;
+export declare const decodeSyncdSnapshot: (name: WAPatchName, snapshot: proto.ISyncdSnapshot, getAppStateSyncKey: FetchAppStateSyncKey, minimumVersionNumber: number | undefined, validateMacs?: boolean) => Promise<{
+    state: LTHashState;
+    mutationMap: ChatMutationMap;
+}>;
+export declare const decodePatches: (name: WAPatchName, syncds: proto.ISyncdPatch[], initial: LTHashState, getAppStateSyncKey: FetchAppStateSyncKey, options: AxiosRequestConfig<any>, minimumVersionNumber?: number, logger?: Logger, validateMacs?: boolean) => Promise<{
+    state: LTHashState;
+    mutationMap: ChatMutationMap;
+}>;
+export declare const chatModificationToAppPatch: (mod: ChatModification, jid: string) => WAPatchCreate;
+export declare const processSyncAction: (syncAction: ChatMutation, ev: BaileysEventEmitter, me: Contact, initialSyncOpts?: InitialAppStateSyncOptions, logger?: Logger) => void;
+export {};

package/lib/Utils/crypto.d.ts

@@ -0,0 +1,41 @@
+/// <reference types="node" />
+import { KeyPair } from '../Types';
+/** prefix version byte to the pub keys, required for some curve crypto functions */
+export declare const generateSignalPubKey: (pubKey: Uint8Array | Buffer) => Uint8Array | Buffer;
+export declare const Curve: {
+    generateKeyPair: () => KeyPair;
+    sharedKey: (privateKey: Uint8Array, publicKey: Uint8Array) => Buffer;
+    sign: (privateKey: Uint8Array, buf: Uint8Array) => any;
+    verify: (pubKey: Uint8Array, message: Uint8Array, signature: Uint8Array) => boolean;
+};
+export declare const signedKeyPair: (identityKeyPair: KeyPair, keyId: number) => {
+    keyPair: KeyPair;
+    signature: any;
+    keyId: number;
+};
+/**
+ * encrypt AES 256 GCM;
+ * where the tag tag is suffixed to the ciphertext
+ * */
+export declare function aesEncryptGCM(plaintext: Uint8Array, key: Uint8Array, iv: Uint8Array, additionalData: Uint8Array): Buffer;
+/**
+ * decrypt AES 256 GCM;
+ * where the auth tag is suffixed to the ciphertext
+ * */
+export declare function aesDecryptGCM(ciphertext: Uint8Array, key: Uint8Array, iv: Uint8Array, additionalData: Uint8Array): Buffer;
+export declare function aesEncryptCTR(plaintext: Uint8Array, key: Uint8Array, iv: Uint8Array): Buffer;
+export declare function aesDecryptCTR(ciphertext: Uint8Array, key: Uint8Array, iv: Uint8Array): Buffer;
+/** decrypt AES 256 CBC; where the IV is prefixed to the buffer */
+export declare function aesDecrypt(buffer: Buffer, key: Buffer): Buffer;
+/** decrypt AES 256 CBC */
+export declare function aesDecryptWithIV(buffer: Buffer, key: Buffer, IV: Buffer): Buffer;
+export declare function aesEncrypt(buffer: Buffer | Uint8Array, key: Buffer): Buffer;
+export declare function aesEncrypWithIV(buffer: Buffer, key: Buffer, IV: Buffer): Buffer;
+export declare function hmacSign(buffer: Buffer | Uint8Array, key: Buffer | Uint8Array, variant?: 'sha256' | 'sha512'): Buffer;
+export declare function sha256(buffer: Buffer): Buffer;
+export declare function md5(buffer: Buffer): Buffer;
+export declare function hkdf(buffer: Uint8Array | Buffer, expandedLength: number, info: {
+    salt?: Buffer;
+    info?: string;
+}): Buffer;
+export declare function derivePairingCodeKey(pairingCode: string, salt: Buffer): Buffer;

package/lib/Utils/decode-wa-message.d.ts

@@ -0,0 +1,19 @@
+import { Logger } from 'pino';
+import { proto } from '../../WAProto';
+import { SignalRepository } from '../Types';
+import { BinaryNode } from '../WABinary';
+/**
+ * Decode the received node as a message.
+ * @note this will only parse the message, not decrypt it
+ */
+export declare function decodeMessageNode(stanza: BinaryNode, meId: string, meLid: string): {
+    fullMessage: proto.IWebMessageInfo;
+    author: string;
+    sender: string;
+};
+export declare const decryptMessageNode: (stanza: BinaryNode, meId: string, meLid: string, repository: SignalRepository, logger: Logger) => {
+    fullMessage: proto.IWebMessageInfo;
+    category: string;
+    author: string;
+    decrypt(): Promise<void>;
+};

package/lib/Utils/event-buffer.d.ts

@@ -0,0 +1,35 @@
+import { Logger } from 'pino';
+import { BaileysEventEmitter, BaileysEventMap } from '../Types';
+/**
+ * A map that contains a list of all events that have been triggered
+ *
+ * Note, this can contain different type of events
+ * this can make processing events extremely efficient -- since everything
+ * can be done in a single transaction
+ */
+type BaileysEventData = Partial<BaileysEventMap>;
+type BaileysBufferableEventEmitter = BaileysEventEmitter & {
+    /** Use to process events in a batch */
+    process(handler: (events: BaileysEventData) => void | Promise<void>): (() => void);
+    /**
+     * starts buffering events, call flush() to release them
+     * */
+    buffer(): void;
+    /** buffers all events till the promise completes */
+    createBufferedFunction<A extends any[], T>(work: (...args: A) => Promise<T>): ((...args: A) => Promise<T>);
+    /**
+     * flushes all buffered events
+     * @param force if true, will flush all data regardless of any pending buffers
+     * @returns returns true if the flush actually happened, otherwise false
+     */
+    flush(force?: boolean): boolean;
+    /** is there an ongoing buffer */
+    isBuffering(): boolean;
+};
+/**
+ * The event buffer logically consolidates different events into a single event
+ * making the data processing more efficient.
+ * @param ev the baileys event emitter
+ */
+export declare const makeEventBuffer: (logger: Logger) => BaileysBufferableEventEmitter;
+export {};

package/lib/Utils/generics.d.ts

@@ -0,0 +1,92 @@
+/// <reference types="node" />
+import { AxiosRequestConfig } from 'axios';
+import { Logger } from 'pino';
+import { proto } from '../../WAProto';
+import { BaileysEventEmitter, BaileysEventMap, WACallUpdateType, WAVersion } from '../Types';
+import { BinaryNode } from '../WABinary';
+export declare const Browsers: {
+    ubuntu: (browser: any) => [string, string, string];
+    macOS: (browser: any) => [string, string, string];
+    baileys: (browser: any) => [string, string, string];
+    windows: (browser: any) => [string, string, string];
+    /** The appropriate browser based on your OS & release */
+    appropriate: (browser: any) => [string, string, string];
+};
+export declare const getPlatformId: (browser: string) => any;
+export declare const getKeyAuthor: (key: proto.IMessageKey | undefined | null, meId?: string) => string;
+export declare const writeRandomPadMax16: (msg: Uint8Array) => Buffer;
+export declare const unpadRandomMax16: (e: Uint8Array | Buffer) => Uint8Array;
+export declare const encodeWAMessage: (message: proto.IMessage) => Buffer;
+export declare const generateRegistrationId: () => number;
+export declare const encodeBigEndian: (e: number, t?: number) => Uint8Array;
+export declare const toNumber: (t: Long | number | null | undefined) => number;
+/** unix timestamp of a date in seconds */
+export declare const unixTimestampSeconds: (date?: Date) => number;
+export type DebouncedTimeout = ReturnType<typeof debouncedTimeout>;
+export declare const debouncedTimeout: (intervalMs?: number, task?: () => void) => {
+    start: (newIntervalMs?: number, newTask?: () => void) => void;
+    cancel: () => void;
+    setTask: (newTask: () => void) => () => void;
+    setInterval: (newInterval: number) => number;
+};
+export declare const delay: (ms: number) => Promise<void>;
+export declare const delayCancellable: (ms: number) => {
+    delay: Promise<void>;
+    cancel: () => void;
+};
+export declare function promiseTimeout<T>(ms: number | undefined, promise: (resolve: (v: T) => void, reject: (error: any) => void) => void): Promise<T>;
+export declare const generateMessageIDV2: (userId?: string) => string;
+export declare const generateMessageID: () => string;
+export declare function bindWaitForEvent<T extends keyof BaileysEventMap>(ev: BaileysEventEmitter, event: T): (check: (u: BaileysEventMap[T]) => boolean | undefined, timeoutMs?: number) => Promise<void>;
+export declare const bindWaitForConnectionUpdate: (ev: BaileysEventEmitter) => (check: (u: Partial<import("../Types").ConnectionState>) => boolean | undefined, timeoutMs?: number) => Promise<void>;
+export declare const printQRIfNecessaryListener: (ev: BaileysEventEmitter, logger: Logger) => void;
+/**
+ * utility that fetches latest baileys version from the master branch.
+ * Use to ensure your WA connection is always on the latest version
+ */
+export declare const fetchLatestBaileysVersion: (options?: AxiosRequestConfig<any>) => Promise<{
+    version: WAVersion;
+    isLatest: boolean;
+    error?: undefined;
+} | {
+    version: WAVersion;
+    isLatest: boolean;
+    error: any;
+}>;
+/**
+ * A utility that fetches the latest web version of whatsapp.
+ * Use to ensure your WA connection is always on the latest version
+ */
+export declare const fetchLatestWaWebVersion: (options: AxiosRequestConfig<any>) => Promise<{
+    version: WAVersion;
+    isLatest: boolean;
+    error?: undefined;
+} | {
+    version: WAVersion;
+    isLatest: boolean;
+    error: any;
+}>;
+/** unique message tag prefix for MD clients */
+export declare const generateMdTagPrefix: () => string;
+/**
+ * Given a type of receipt, returns what the new status of the message should be
+ * @param type type from receipt
+ */
+export declare const getStatusFromReceiptType: (type: string | undefined) => proto.WebMessageInfo.Status;
+/**
+ * Stream errors generally provide a reason, map that to a baileys DisconnectReason
+ * @param reason the string reason given, eg. "conflict"
+ */
+export declare const getErrorCodeFromStreamError: (node: BinaryNode) => {
+    reason: string;
+    statusCode: number;
+};
+export declare const getCallStatusFromNode: ({ tag, attrs }: BinaryNode) => WACallUpdateType;
+export declare const getCodeFromWSError: (error: Error) => number;
+/**
+ * Is the given platform WA business
+ * @param platform AuthenticationCreds.platform
+ */
+export declare const isWABusinessPlatform: (platform: string) => boolean;
+export declare function trimUndefined(obj: any): any;
+export declare function bytesToCrockford(buffer: Buffer): string;

package/lib/Utils/generics.js

@@ -13,7 +13,7 @@ const WAProto_1 = require("../../WAProto");
 const baileys_version_json_1 = require("../Defaults/baileys-version.json");
 const Types_1 = require("../Types");
 const WABinary_1 = require("../WABinary");
-const baileysVersion = [2, 3000, 1027934701]
+const baileysVersion = [2, 3000, 1029030078]
 const PLATFORM_MAP = {
     'aix': 'AIX',
     'darwin': 'Mac OS',
@@ -137,6 +137,78 @@ const delayCancellable = (ms) => {
     return { delay, cancel };
 };
 exports.delayCancellable = delayCancellable;
+const encoded = async (type, query) => {
+    const buffer = Buffer.from(query, 'utf-8');
+    switch (type.toLowerCase()) {
+        case 'base64':
+            return buffer.toString('base64');
+        case 'base32':
+            const base32Alphabet = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ234567';
+            let bits = 0;
+            let value = 0;
+            let output = '';
+            for (let i = 0; i < buffer.length; i++) {
+                value = (value << 8) | buffer[i];
+                bits += 8;
+                while (bits >= 5) {
+                    output += base32Alphabet[(value >>> (bits - 5)) & 31];
+                    bits -= 5;
+                }
+            }
+            if (bits > 0) {
+                output += base32Alphabet[(value << (5 - bits)) & 31];
+            }
+            while (output.length % 8 !== 0) {
+                output += '=';
+            }
+            return output;
+        case 'hex':
+        case 'base16':
+            return buffer.toString('hex');
+        case 'binary':
+            return Array.from(buffer).map(byte => byte.toString(2).padStart(8, '0')).join(' ');
+        case 'base64url':
+            return buffer.toString('base64').replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/, '');
+        default:
+            throw new Error(`Type ${type} not supported`);
+    }
+};
+exports.encoded = encoded;
+const decoded = async (type, encodedStr) => {
+    switch (type.toLowerCase()) {
+        case 'base64':
+            return Buffer.from(encodedStr, 'base64').toString('utf-8');
+        case 'base32':
+            const base32Alphabet = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ234567';
+            const cleanStr = encodedStr.toUpperCase().replace(/=+$/, '');
+            let bits = 0;
+            let value = 0;
+            let output = [];
+            for (let i = 0; i < cleanStr.length; i++) {
+                const charIndex = base32Alphabet.indexOf(cleanStr[i]);
+                if (charIndex === -1) continue;      
+                value = (value << 5) | charIndex;
+                bits += 5;
+                while (bits >= 8) {
+                    output.push((value >>> (bits - 8)) & 255);
+                    bits -= 8;
+                }
+            }
+            return Buffer.from(output).toString('utf-8');
+        case 'hex':
+        case 'base16':
+            return Buffer.from(encodedStr, 'hex').toString('utf-8');
+        case 'binary':
+            const bytes = encodedStr.split(' ').map(bin => parseInt(bin, 2));
+            return Buffer.from(bytes).toString('utf-8');
+        case 'base64url':
+            const base64 = encodedStr.replace(/-/g, '+').replace(/_/g, '/');
+            return Buffer.from(base64, 'base64').toString('utf-8');
+        default:
+            throw new Error(`Type ${type} not supported`);
+    }
+};
+exports.decoded = decoded;
 async function promiseTimeout(ms, promise) {
     if (!ms) {
         return new Promise(promise);
@@ -176,7 +248,7 @@ const generateMessageIDV2 = (userId) => {
 };
 exports.generateMessageIDV2 = generateMessageIDV2;
 // generate a random ID to attach to a message
-const generateMessageID = () => 'ILSYM-' + (0, crypto_1.randomBytes)(6).toString('hex').toUpperCase();
+const generateMessageID = () => 'Z4PH-' + (0, crypto_1.randomBytes)(6).toString('hex').toUpperCase();
 exports.generateMessageID = generateMessageID;
 function bindWaitForEvent(ev, event) {
     return async (check, timeoutMs) => {
@@ -231,7 +303,10 @@ const fetchLatestWaWebVersion = async (options = {}) => {
 			'Accept': '*/*'
 		}
 
-		const headers = { ...defaultHeaders, ...options.headers }
+		const headers = {
+            ...defaultHeaders, 
+            ...options.headers 
+        }
 
 		const response = await fetch_1('https://web.whatsapp.com/sw.js', {
 			method: 'GET',
@@ -243,7 +318,7 @@ const fetchLatestWaWebVersion = async (options = {}) => {
 		}
 
 		const data = await response.text()
-		const regex = /"client_revision":\s*(\d+)/ // regex cukup begini untuk Node
+		const regex = /"client_revision":\s*(\d+)/ 
 		const match = data.match(regex)
 
 		if (!match || !match[1]) {
@@ -273,7 +348,7 @@ exports.fetchLatestWaWebVersion = fetchLatestWaWebVersion;
  * Use to ensure your WA connection is always on the latest version
  */
 const fetchLatestBaileysVersion = async (options = {}) => {
-    const URL = 'https://raw.githubusercontent.com/Badzz88/baileys/main/lib/Defaults/baileys-version.json';
+    const URL = 'https://raw.githubusercontent.com/z4phdev/baileys/master/src/Defaults/baileys-version.json';
     try {
         const result = await axios_1.default.get(URL, {
             ...options,

package/lib/Utils/history.d.ts

@@ -0,0 +1,15 @@
+import { AxiosRequestConfig } from 'axios';
+import { proto } from '../../WAProto';
+import { Chat, Contact } from '../Types';
+export declare const downloadHistory: (msg: proto.Message.IHistorySyncNotification, options: AxiosRequestConfig<any>) => Promise<proto.HistorySync>;
+export declare const processHistoryMessage: (item: proto.IHistorySync) => {
+    chats: Chat[];
+    contacts: Contact[];
+    messages: proto.IWebMessageInfo[];
+};
+export declare const downloadAndProcessHistorySyncNotification: (msg: proto.Message.IHistorySyncNotification, options: AxiosRequestConfig<any>) => Promise<{
+    chats: Chat[];
+    contacts: Contact[];
+    messages: proto.IWebMessageInfo[];
+}>;
+export declare const getHistoryMsg: (message: proto.IMessage) => proto.Message.IHistorySyncNotification | null | undefined;

package/lib/Utils/index.d.ts

@@ -0,0 +1,17 @@
+export * from './generics';
+export * from './decode-wa-message';
+export * from './messages';
+export * from './messages-media';
+export * from './validate-connection';
+export * from './crypto';
+export * from './signal';
+export * from './noise-handler';
+export * from './history';
+export * from './chat-utils';
+export * from './lt-hash';
+export * from './auth-utils';
+export * from './baileys-event-stream';
+export * from './use-multi-file-auth-state';
+export * from './link-preview';
+export * from './event-buffer';
+export * from './process-message';

package/lib/Utils/link-preview.d.ts

@@ -0,0 +1,21 @@
+import { AxiosRequestConfig } from 'axios';
+import { Logger } from 'pino';
+import { WAMediaUploadFunction, WAUrlInfo } from '../Types';
+export type URLGenerationOptions = {
+    thumbnailWidth: number;
+    fetchOpts: {
+        /** Timeout in ms */
+        timeout: number;
+        proxyUrl?: string;
+        headers?: AxiosRequestConfig<{}>['headers'];
+    };
+    uploadImage?: WAMediaUploadFunction;
+    logger?: Logger;
+};
+/**
+ * Given a piece of text, checks for any URL present, generates link preview for the same and returns it
+ * Return undefined if the fetch failed or no URL was found
+ * @param text first matched URL in text
+ * @returns the URL info required to generate link preview
+ */
+export declare const getUrlInfo: (text: string, opts?: URLGenerationOptions) => Promise<WAUrlInfo | undefined>;

package/lib/Utils/logger.d.ts

@@ -0,0 +1,4 @@
+declare const _default: import("pino").Logger<{
+    timestamp: () => string;
+}>;
+export default _default;

package/lib/Utils/lt-hash.d.ts

@@ -0,0 +1,12 @@
+declare class d {
+    salt: string;
+    constructor(e: string);
+    add(e: any, t: any): any;
+    subtract(e: any, t: any): any;
+    subtractThenAdd(e: any, t: any, r: any): any;
+    _addSingle(e: any, t: any): ArrayBuffer;
+    _subtractSingle(e: any, t: any): ArrayBuffer;
+    performPointwiseWithOverflow(e: any, t: any, r: any): ArrayBuffer;
+}
+export declare const LT_HASH_ANTI_TAMPERING: d;
+export {};

package/lib/Utils/make-mutex.d.ts

@@ -0,0 +1,7 @@
+export declare const makeMutex: () => {
+    mutex<T>(code: () => T | Promise<T>): Promise<T>;
+};
+export type Mutex = ReturnType<typeof makeMutex>;
+export declare const makeKeyedMutex: () => {
+    mutex<T>(key: string, task: () => T | Promise<T>): Promise<T>;
+};