@alannxd/baileys 6.0.5 → 6.0.9

package/lib/Utils/generics.d.ts

@@ -1,91 +0,0 @@
-import { proto } from '../../WAProto/index.js';
-import type { BaileysEventEmitter, BaileysEventMap, ConnectionState, WACallUpdateType, WAMessageKey, WAVersion } from '../Types/index.js';
-import { type BinaryNode } from '../WABinary/index.js';
-export declare const BufferJSON: {
-    replacer: (k: any, value: any) => any;
-    reviver: (_: any, value: any) => any;
-};
-export declare const getKeyAuthor: (key: WAMessageKey | undefined | null, meId?: string) => string;
-export declare const isStringNullOrEmpty: (value: string | null | undefined) => value is null | undefined | "";
-export declare const writeRandomPadMax16: (msg: Uint8Array) => Buffer<ArrayBuffer>;
-export declare const unpadRandomMax16: (e: Uint8Array | Buffer) => Uint8Array<ArrayBuffer>;
-export declare const generateParticipantHashV2: (participants: string[]) => string;
-export declare const encodeWAMessage: (message: proto.IMessage) => Buffer<ArrayBuffer>;
-export declare const generateRegistrationId: () => number;
-export declare const encodeBigEndian: (e: number, t?: number) => Uint8Array<ArrayBuffer>;
-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]) => Promise<boolean | undefined>, timeoutMs?: number) => Promise<void>;
-export declare const bindWaitForConnectionUpdate: (ev: BaileysEventEmitter) => (check: (u: Partial<ConnectionState>) => Promise<boolean | undefined>, timeoutMs?: number) => Promise<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?: RequestInit) => Promise<{
-    version: WAVersion;
-    isLatest: boolean;
-    error?: undefined;
-} | {
-    version: WAVersion;
-    isLatest: boolean;
-    error: unknown;
-}>;
-/**
- * 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?: RequestInit) => Promise<{
-    version: WAVersion;
-    isLatest: boolean;
-    error?: undefined;
-} | {
-    version: WAVersion;
-    isLatest: boolean;
-    error: unknown;
-}>;
-/** 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 | undefined;
-/**
- * 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) => platform is "smba" | "smbi";
-export declare function trimUndefined(obj: {
-    [_: string]: any;
-}): {
-    [_: string]: any;
-};
-export declare function bytesToCrockford(buffer: Buffer): string;
-export declare function encodeNewsletterMessage(message: proto.IMessage): Uint8Array;
-//# sourceMappingURL=generics.d.ts.map

package/lib/Utils/history.d.ts

@@ -1,24 +0,0 @@
-import { proto } from '../../WAProto/index.js';
-import type { Chat, Contact, LIDMapping, WAMessage } from '../Types/index.js';
-import type { ILogger } from './logger.js';
-export declare const downloadHistory: (msg: proto.Message.IHistorySyncNotification, options: RequestInit) => Promise<proto.HistorySync>;
-export declare const processHistoryMessage: (item: proto.IHistorySync, logger?: ILogger) => {
-    chats: Chat[];
-    contacts: Contact[];
-    messages: WAMessage[];
-    lidPnMappings: LIDMapping[];
-    pastParticipants: proto.IPastParticipants[] | null | undefined;
-    syncType: proto.HistorySync.HistorySyncType | null | undefined;
-    progress: number | null | undefined;
-};
-export declare const downloadAndProcessHistorySyncNotification: (msg: proto.Message.IHistorySyncNotification, options: RequestInit, logger?: ILogger) => Promise<{
-    chats: Chat[];
-    contacts: Contact[];
-    messages: WAMessage[];
-    lidPnMappings: LIDMapping[];
-    pastParticipants: proto.IPastParticipants[] | null | undefined;
-    syncType: proto.HistorySync.HistorySyncType | null | undefined;
-    progress: number | null | undefined;
-}>;
-export declare const getHistoryMsg: (message: proto.IMessage) => proto.Message.IHistorySyncNotification;
-//# sourceMappingURL=history.d.ts.map

package/lib/Utils/identity-change-handler.d.ts

@@ -1,44 +0,0 @@
-import NodeCache from '@cacheable/node-cache';
-import { type BinaryNode } from '../WABinary/index.js';
-import type { ILogger } from './logger.js';
-export type IdentityChangeResult = {
-    action: 'no_identity_node';
-} | {
-    action: 'invalid_notification';
-} | {
-    action: 'skipped_companion_device';
-    device: number;
-} | {
-    action: 'skipped_self_primary';
-} | {
-    action: 'debounced';
-} | {
-    action: 'skipped_offline';
-} | {
-    action: 'skipped_no_session';
-} | {
-    action: 'session_refreshed';
-} | {
-    action: 'session_refresh_failed';
-    error: unknown;
-};
-export type IdentityChangeContext = {
-    meId: string | undefined;
-    meLid: string | undefined;
-    validateSession: (jid: string) => Promise<{
-        exists: boolean;
-        reason?: string;
-    }>;
-    assertSessions: (jids: string[], force?: boolean) => Promise<boolean>;
-    debounceCache: NodeCache<boolean>;
-    logger: ILogger;
-    /**
-     * Invoked right before `assertSessions` is called for an existing-session identity change.
-     * Used to kick off fire-and-forget side effects (e.g. tctoken re-issuance) in the same
-     * order WA Web does — i.e. before the E2E session is re-established.
-     * Must not throw; implementations are responsible for their own error handling.
-     */
-    onBeforeSessionRefresh?: (jid: string) => void;
-};
-export declare function handleIdentityChange(node: BinaryNode, ctx: IdentityChangeContext): Promise<IdentityChangeResult>;
-//# sourceMappingURL=identity-change-handler.d.ts.map

package/lib/Utils/index.d.ts

@@ -1,22 +0,0 @@
-export * from './generics.js';
-export * from './decode-wa-message.js';
-export * from './messages.js';
-export * from './messages-media.js';
-export * from './validate-connection.js';
-export * from './crypto.js';
-export * from './signal.js';
-export * from './noise-handler.js';
-export * from './history.js';
-export * from './chat-utils.js';
-export * from './lt-hash.js';
-export * from './auth-utils.js';
-export * from './use-multi-file-auth-state.js';
-export * from './link-preview.js';
-export * from './event-buffer.js';
-export * from './process-message.js';
-export * from './message-retry-manager.js';
-export * from './browser-utils.js';
-export * from './companion-reg-client-utils.js';
-export * from './identity-change-handler.js';
-export * from './stanza-ack.js';
-//# sourceMappingURL=index.d.ts.map

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

@@ -1,21 +0,0 @@
-import type { WAMediaUploadFunction, WAUrlInfo } from '../Types/index.js';
-import type { ILogger } from './logger.js';
-export type URLGenerationOptions = {
-    thumbnailWidth: number;
-    fetchOpts: {
-        /** Timeout in ms */
-        timeout: number;
-        proxyUrl?: string;
-        headers?: HeadersInit;
-    };
-    uploadImage?: WAMediaUploadFunction;
-    logger?: ILogger;
-};
-/**
- * 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>;
-//# sourceMappingURL=link-preview.d.ts.map

package/lib/Utils/logger.d.ts

@@ -1,12 +0,0 @@
-export interface ILogger {
-    level: string;
-    child(obj: Record<string, unknown>): ILogger;
-    trace(obj: unknown, msg?: string): void;
-    debug(obj: unknown, msg?: string): void;
-    info(obj: unknown, msg?: string): void;
-    warn(obj: unknown, msg?: string): void;
-    error(obj: unknown, msg?: string): void;
-}
-declare const _default: import("pino").Logger<never, boolean>;
-export default _default;
-//# sourceMappingURL=logger.d.ts.map

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

@@ -1,8 +0,0 @@
-import { LTHashAntiTampering } from 'whatsapp-rust-bridge';
-/**
- * LT Hash is a summation based hash algorithm that maintains the integrity of a piece of data
- * over a series of mutations. You can add/remove mutations and it'll return a hash equal to
- * if the same series of mutations was made sequentially.
- */
-export declare const LT_HASH_ANTI_TAMPERING: LTHashAntiTampering;
-//# sourceMappingURL=lt-hash.d.ts.map

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

@@ -1,9 +0,0 @@
-export declare const makeMutex: () => {
-    mutex<T>(code: () => Promise<T> | T): Promise<T>;
-};
-export type Mutex = ReturnType<typeof makeMutex>;
-export declare const makeKeyedMutex: () => {
-    mutex<T>(key: string, task: () => Promise<T> | T): Promise<T>;
-};
-export type KeyedMutex = ReturnType<typeof makeKeyedMutex>;
-//# sourceMappingURL=make-mutex.d.ts.map

package/lib/Utils/message-retry-manager.d.ts

@@ -1,115 +0,0 @@
-import type { proto } from '../../WAProto/index.js';
-import type { ILogger } from './logger.js';
-export interface RecentMessageKey {
-    to: string;
-    id: string;
-}
-export interface RecentMessage {
-    message: proto.IMessage;
-    timestamp: number;
-}
-export interface SessionRecreateHistory {
-    [jid: string]: number;
-}
-export interface RetryCounter {
-    [messageId: string]: number;
-}
-export type PendingPhoneRequest = Record<string, ReturnType<typeof setTimeout>>;
-export interface RetryStatistics {
-    totalRetries: number;
-    successfulRetries: number;
-    failedRetries: number;
-    mediaRetries: number;
-    sessionRecreations: number;
-    phoneRequests: number;
-}
-export declare enum RetryReason {
-    UnknownError = 0,
-    SignalErrorNoSession = 1,
-    SignalErrorInvalidKey = 2,
-    SignalErrorInvalidKeyId = 3,
-    /** MAC verification failed - most common cause of decryption failures */
-    SignalErrorInvalidMessage = 4,
-    SignalErrorInvalidSignature = 5,
-    SignalErrorFutureMessage = 6,
-    /** Explicit MAC failure - session is definitely out of sync */
-    SignalErrorBadMac = 7,
-    SignalErrorInvalidSession = 8,
-    SignalErrorInvalidMsgKey = 9,
-    BadBroadcastEphemeralSetting = 10,
-    UnknownCompanionNoPrekey = 11,
-    AdvFailure = 12,
-    StatusRevokeDelay = 13
-}
-export declare class MessageRetryManager {
-    private logger;
-    private recentMessagesMap;
-    private messageKeyIndex;
-    private sessionRecreateHistory;
-    private retryCounters;
-    private baseKeys;
-    private pendingPhoneRequests;
-    private readonly maxMsgRetryCount;
-    private statistics;
-    constructor(logger: ILogger, maxMsgRetryCount: number);
-    /**
-     * Add a recent message to the cache for retry handling
-     */
-    addRecentMessage(to: string, id: string, message: proto.IMessage): void;
-    /**
-     * Get a recent message from the cache
-     */
-    getRecentMessage(to: string, id: string): RecentMessage | undefined;
-    /**
-     * Check if a session should be recreated based on retry count, history, and error code.
-     * MAC errors (codes 4 and 7) trigger immediate session recreation regardless of timeout.
-     */
-    shouldRecreateSession(jid: string, hasSession: boolean, errorCode?: RetryReason): {
-        reason: string;
-        recreate: boolean;
-    };
-    /**
-     * Parse error code from retry receipt's retry node.
-     * Returns undefined if no error code is present.
-     */
-    parseRetryErrorCode(errorAttr: string | undefined): RetryReason | undefined;
-    /**
-     * Check if an error code indicates a MAC failure
-     */
-    isMacError(errorCode: RetryReason | undefined): boolean;
-    /**
-     * Increment retry counter for a message
-     */
-    incrementRetryCount(messageId: string): number;
-    /**
-     * Get retry count for a message
-     */
-    getRetryCount(messageId: string): number;
-    /**
-     * Check if message has exceeded maximum retry attempts
-     */
-    hasExceededMaxRetries(messageId: string): boolean;
-    /**
-     * Mark retry as successful
-     */
-    markRetrySuccess(messageId: string): void;
-    /**
-     * Mark retry as failed
-     */
-    markRetryFailed(messageId: string): void;
-    /**
-     * Schedule a phone request with delay
-     */
-    schedulePhoneRequest(messageId: string, callback: () => void, delay?: number): void;
-    /**
-     * Cancel pending phone request
-     */
-    cancelPendingPhoneRequest(messageId: string): void;
-    clear(): void;
-    saveBaseKey(addr: string, msgId: string, baseKey: Uint8Array): void;
-    hasSameBaseKey(addr: string, msgId: string, baseKey: Uint8Array): boolean;
-    deleteBaseKey(addr: string, msgId: string): void;
-    private keyToString;
-    private removeRecentMessage;
-}
-//# sourceMappingURL=message-retry-manager.d.ts.map

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

@@ -1,133 +0,0 @@
-import { Boom } from '@hapi/boom';
-import type { Agent } from 'https';
-import { Readable, Transform } from 'stream';
-import { URL } from 'url';
-import { proto } from '../../WAProto/index.js';
-import { type MediaType } from '../Defaults/index.js';
-import type { DownloadableMessage, MediaConnInfo, MediaDecryptionKeyInfo, SocketConfig, WAMediaUpload, WAMediaUploadFunction, WAMessageContent, WAMessageKey } from '../Types/index.js';
-import { type BinaryNode } from '../WABinary/index.js';
-import type { ILogger } from './logger.js';
-export declare const hkdfInfoKey: (type: MediaType) => string;
-export declare const getRawMediaUploadData: (media: WAMediaUpload, mediaType: MediaType, logger?: ILogger) => Promise<{
-    filePath: string;
-    fileSha256: Buffer<ArrayBufferLike>;
-    fileLength: number;
-}>;
-/** generates all the keys required to encrypt/decrypt & sign a media message */
-export declare function getMediaKeys(buffer: Uint8Array | string | null | undefined, mediaType: MediaType): Promise<MediaDecryptionKeyInfo>;
-export declare const extractImageThumb: (bufferOrFilePath: Readable | Buffer | string, width?: number) => Promise<{
-    buffer: any;
-    original: {
-        width: any;
-        height: any;
-    };
-}>;
-export declare const encodeBase64EncodedStringForUpload: (b64: string) => string;
-export declare const generateProfilePicture: (mediaUpload: WAMediaUpload, dimensions?: {
-    width: number;
-    height: number;
-}) => Promise<{
-    img: Buffer<ArrayBufferLike>;
-}>;
-/** gets the SHA256 of the given media message */
-export declare const mediaMessageSHA256B64: (message: WAMessageContent) => string | null | undefined;
-export declare function getAudioDuration(buffer: Buffer | string | Readable): Promise<number | undefined>;
-/**
-  referenced from and modifying https://github.com/wppconnect-team/wa-js/blob/main/src/chat/functions/prepareAudioWaveform.ts
- */
-export declare function getAudioWaveform(buffer: Buffer | string | Readable, logger?: ILogger): Promise<Uint8Array<ArrayBuffer> | undefined>;
-export declare const toReadable: (buffer: Buffer) => Readable;
-export declare const toBuffer: (stream: Readable) => Promise<Buffer<ArrayBuffer>>;
-export declare const getStream: (item: WAMediaUpload, opts?: RequestInit & {
-    maxContentLength?: number;
-}) => Promise<{
-    readonly stream: Readable;
-    readonly type: "buffer";
-} | {
-    readonly stream: Readable;
-    readonly type: "readable";
-} | {
-    readonly stream: Readable;
-    readonly type: "remote";
-} | {
-    readonly stream: import("fs").ReadStream;
-    readonly type: "file";
-}>;
-/** generates a thumbnail for a given media, if required */
-export declare function generateThumbnail(file: string, mediaType: 'video' | 'image', options: {
-    logger?: ILogger;
-}): Promise<{
-    thumbnail: string | undefined;
-    originalImageDimensions: {
-        width: number;
-        height: number;
-    } | undefined;
-}>;
-export declare const getHttpStream: (url: string | URL, options?: RequestInit & {
-    isStream?: true;
-}) => Promise<Readable>;
-type EncryptedStreamOptions = {
-    saveOriginalFileIfRequired?: boolean;
-    logger?: ILogger;
-    opts?: RequestInit;
-};
-export declare const encryptedStream: (media: WAMediaUpload, mediaType: MediaType, { logger, saveOriginalFileIfRequired, opts }?: EncryptedStreamOptions) => Promise<{
-    mediaKey: Buffer<ArrayBufferLike>;
-    originalFilePath: string | undefined;
-    encFilePath: string;
-    mac: Buffer<ArrayBuffer>;
-    fileEncSha256: Buffer<ArrayBufferLike>;
-    fileSha256: Buffer<ArrayBufferLike>;
-    fileLength: number;
-}>;
-export declare const DEF_MEDIA_HOST = "mmg.whatsapp.net";
-export type MediaDownloadOptions = {
-    startByte?: number;
-    endByte?: number;
-    options?: RequestInit;
-    /** Optional media host override; falls back to DEF_MEDIA_HOST when not provided. */
-    host?: string;
-};
-export declare const getUrlFromDirectPath: (directPath: string, host?: string) => string;
-export declare const downloadContentFromMessage: ({ mediaKey, directPath, url }: DownloadableMessage, type: MediaType, opts?: MediaDownloadOptions) => Promise<Transform>;
-/**
- * Decrypts and downloads an AES256-CBC encrypted file given the keys.
- * Assumes the SHA256 of the plaintext is appended to the end of the ciphertext
- * */
-export declare const downloadEncryptedContent: (downloadUrl: string, { cipherKey, iv }: MediaDecryptionKeyInfo, { startByte, endByte, options }?: MediaDownloadOptions) => Promise<Transform>;
-export declare function extensionForMediaMessage(message: WAMessageContent): string;
-type MediaUploadResult = {
-    url?: string;
-    direct_path?: string;
-    meta_hmac?: string;
-    ts?: number;
-    fbid?: number;
-};
-export type UploadParams = {
-    url: string;
-    filePath: string;
-    headers: Record<string, string>;
-    timeoutMs?: number;
-    agent?: Agent;
-};
-export declare const uploadWithNodeHttp: ({ url, filePath, headers, timeoutMs, agent }: UploadParams, redirectCount?: number) => Promise<MediaUploadResult | undefined>;
-export declare const getWAUploadToServer: ({ customUploadHosts, fetchAgent, logger, options }: SocketConfig, refreshMediaConn: (force: boolean) => Promise<MediaConnInfo>) => WAMediaUploadFunction;
-/**
- * Generate a binary node that will request the phone to re-upload the media & return the newly uploaded URL
- */
-export declare const encryptMediaRetryRequest: (key: WAMessageKey, mediaKey: Buffer | Uint8Array, meId: string) => BinaryNode;
-export declare const decodeMediaRetryNode: (node: BinaryNode) => {
-    key: WAMessageKey;
-    media?: {
-        ciphertext: Uint8Array;
-        iv: Uint8Array;
-    };
-    error?: Boom;
-};
-export declare const decryptMediaRetryData: ({ ciphertext, iv }: {
-    ciphertext: Uint8Array;
-    iv: Uint8Array;
-}, mediaKey: Uint8Array, msgId: string) => proto.MediaRetryNotification;
-export declare const getStatusCodeForMediaRetry: (code: number) => 200 | 412 | 404 | 418;
-export {};
-//# sourceMappingURL=messages-media.d.ts.map

package/lib/Utils/messages.d.ts

@@ -1,91 +0,0 @@
-import { type Transform } from 'stream';
-import { proto } from '../../WAProto/index.js';
-import type { AnyMediaMessageContent, AnyMessageContent, MessageContentGenerationOptions, MessageGenerationOptions, MessageGenerationOptionsFromContent, MessageUserReceipt, WAMessage, WAMessageContent, WAMessageKey } from '../Types/index.js';
-import type { ILogger } from './logger.js';
-import { type MediaDownloadOptions } from './messages-media.js';
-type ExtractByKey<T, K extends PropertyKey> = T extends Record<K, any> ? T : never;
-/**
- * Uses a regex to test whether the string contains a URL, and returns the URL if it does.
- * @param text eg. hello https://google.com
- * @returns the URL, eg. https://google.com
- */
-export declare const extractUrlFromText: (text: string) => string | undefined;
-export declare const generateLinkPreviewIfRequired: (text: string, getUrlInfo: MessageGenerationOptions["getUrlInfo"], logger: MessageGenerationOptions["logger"]) => Promise<import("../Types/index.js").WAUrlInfo | undefined>;
-export declare const prepareWAMessageMedia: (message: AnyMediaMessageContent, options: MessageContentGenerationOptions) => Promise<proto.Message>;
-export declare const prepareDisappearingMessageSettingContent: (ephemeralExpiration?: number) => proto.Message;
-/**
- * Generate forwarded message content like WA does
- * @param message the message to forward
- * @param options.forceForward will show the message as forwarded even if it is from you
- */
-export declare const generateForwardMessageContent: (message: WAMessage, forceForward?: boolean) => proto.IMessage;
-export declare const hasNonNullishProperty: <K extends PropertyKey>(message: AnyMessageContent, key: K) => message is ExtractByKey<AnyMessageContent, K>;
-export declare const generateWAMessageContent: (message: AnyMessageContent, options: MessageContentGenerationOptions) => Promise<proto.Message>;
-export declare const generateWAMessageFromContent: (jid: string, message: WAMessageContent, options: MessageGenerationOptionsFromContent) => WAMessage;
-export declare const generateWAMessage: (jid: string, content: AnyMessageContent, options: MessageGenerationOptions) => Promise<WAMessage>;
-/** Get the key to access the true type of content */
-export declare const getContentType: (content: proto.IMessage | undefined) => keyof proto.IMessage | undefined;
-/**
- * Normalizes ephemeral, view once messages to regular message content
- * Eg. image messages in ephemeral messages, in view once messages etc.
- * @param content
- * @returns
- */
-export declare const normalizeMessageContent: (content: WAMessageContent | null | undefined) => WAMessageContent | undefined;
-/**
- * Extract the true message content from a message
- * Eg. extracts the inner message from a disappearing message/view once message
- */
-export declare const extractMessageContent: (content: WAMessageContent | undefined | null) => WAMessageContent | undefined;
-/**
- * Returns the device predicted by message ID
- */
-export declare const getDevice: (id: string) => "web" | "unknown" | "android" | "ios" | "desktop";
-/** Upserts a receipt in the message */
-export declare const updateMessageWithReceipt: (msg: Pick<WAMessage, "userReceipt">, receipt: MessageUserReceipt) => void;
-/** Update the message with a new reaction */
-export declare const updateMessageWithReaction: (msg: Pick<WAMessage, "reactions">, reaction: proto.IReaction) => void;
-/** Update the message with a new poll update */
-export declare const updateMessageWithPollUpdate: (msg: Pick<WAMessage, "pollUpdates">, update: proto.IPollUpdate) => void;
-/** Update the message with a new event response */
-export declare const updateMessageWithEventResponse: (msg: Pick<WAMessage, "eventResponses">, update: proto.IEventResponse) => void;
-type VoteAggregation = {
-    name: string;
-    voters: string[];
-};
-/**
- * Aggregates all poll updates in a poll.
- * @param msg the poll creation message
- * @param meId your jid
- * @returns A list of options & their voters
- */
-export declare function getAggregateVotesInPollMessage({ message, pollUpdates }: Pick<WAMessage, 'pollUpdates' | 'message'>, meId?: string): VoteAggregation[];
-type ResponseAggregation = {
-    response: string;
-    responders: string[];
-};
-/**
- * Aggregates all event responses in an event message.
- * @param msg the event creation message
- * @param meId your jid
- * @returns A list of response types & their responders
- */
-export declare function getAggregateResponsesInEventMessage({ eventResponses }: Pick<WAMessage, 'eventResponses'>, meId?: string): ResponseAggregation[];
-/** Given a list of message keys, aggregates them by chat & sender. Useful for sending read receipts in bulk */
-export declare const aggregateMessageKeysNotFromMe: (keys: WAMessageKey[]) => {
-    jid: string;
-    participant: string | undefined;
-    messageIds: string[];
-}[];
-type DownloadMediaMessageContext = {
-    reuploadRequest: (msg: WAMessage) => Promise<WAMessage>;
-    logger: ILogger;
-};
-/**
- * Downloads the given message. Throws an error if it's not a media message
- */
-export declare const downloadMediaMessage: <Type extends "buffer" | "stream">(message: WAMessage, type: Type, options: MediaDownloadOptions, ctx?: DownloadMediaMessageContext) => Promise<Type extends "buffer" ? Buffer<ArrayBufferLike> : Transform>;
-/** Checks whether the given message is a media message; if it is returns the inner content */
-export declare const assertMediaContent: (content: proto.IMessage | null | undefined) => proto.Message.IVideoMessage | proto.Message.IImageMessage | proto.Message.IAudioMessage | proto.Message.IDocumentMessage | proto.Message.IStickerMessage;
-export {};
-//# sourceMappingURL=messages.d.ts.map

package/lib/Utils/noise-handler.d.ts

@@ -1,20 +0,0 @@
-import { proto } from '../../WAProto/index.js';
-import type { KeyPair } from '../Types/index.js';
-import type { BinaryNode } from '../WABinary/index.js';
-import type { ILogger } from './logger.js';
-export declare const makeNoiseHandler: ({ keyPair: { private: privateKey, public: publicKey }, NOISE_HEADER, logger, routingInfo }: {
-    keyPair: KeyPair;
-    NOISE_HEADER: Uint8Array;
-    logger: ILogger;
-    routingInfo?: Buffer | undefined;
-}) => {
-    encrypt: (plaintext: Uint8Array) => Uint8Array;
-    decrypt: (ciphertext: Uint8Array) => Uint8Array;
-    authenticate: (data: Uint8Array) => void;
-    mixIntoKey: (data: Uint8Array) => void;
-    finishInit: () => Promise<void>;
-    processHandshake: ({ serverHello }: proto.HandshakeMessage, noiseKey: KeyPair) => Uint8Array<ArrayBufferLike>;
-    encodeFrame: (data: Buffer | Uint8Array) => Buffer<ArrayBuffer>;
-    decodeFrame: (newData: Buffer | Uint8Array, onFrame: (buff: Uint8Array | BinaryNode) => void) => Promise<void>;
-};
-//# sourceMappingURL=noise-handler.d.ts.map

package/lib/Utils/offline-node-processor.d.ts

@@ -1,17 +0,0 @@
-import type { BinaryNode } from '../WABinary/index.js';
-export type MessageType = 'message' | 'call' | 'receipt' | 'notification';
-export type OfflineNodeProcessorDeps = {
-    isWsOpen: () => boolean;
-    onUnexpectedError: (error: Error, msg: string) => void;
-    yieldToEventLoop: () => Promise<void>;
-};
-/**
- * Creates a processor for offline stanza nodes that:
- * - Queues nodes for sequential processing
- * - Yields to the event loop periodically to avoid blocking
- * - Catches handler errors to prevent the processing loop from crashing
- */
-export declare function makeOfflineNodeProcessor(nodeProcessorMap: Map<MessageType, (node: BinaryNode) => Promise<void>>, deps: OfflineNodeProcessorDeps, batchSize?: number): {
-    enqueue: (type: MessageType, node: BinaryNode) => void;
-};
-//# sourceMappingURL=offline-node-processor.d.ts.map

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

@@ -1,28 +0,0 @@
-import type { SignalDataSet, SignalDataTypeMap, SignalKeyStore } from '../Types/index.js';
-import type { ILogger } from './logger.js';
-/**
- * Manages pre-key operations with proper concurrency control
- */
-export declare class PreKeyManager {
-    private readonly store;
-    private readonly logger;
-    private readonly queues;
-    constructor(store: SignalKeyStore, logger: ILogger);
-    /**
-     * Get or create a queue for a specific key type
-     */
-    private getQueue;
-    /**
-     * Process pre-key operations (updates and deletions)
-     */
-    processOperations(data: SignalDataSet, keyType: keyof SignalDataTypeMap, transactionCache: SignalDataSet, mutations: SignalDataSet, isInTransaction: boolean): Promise<void>;
-    /**
-     * Process deletions with validation
-     */
-    private processDeletions;
-    /**
-     * Validate and process pre-key deletions outside transactions
-     */
-    validateDeletions(data: SignalDataSet, keyType: keyof SignalDataTypeMap): Promise<void>;
-}
-//# sourceMappingURL=pre-key-manager.d.ts.map