@hansaka02/baileys 7.3.2 → 7.3.4

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

@@ -1,39 +0,0 @@
-import { BaileysEventEmitter, BaileysEventMap } from '../Types'
-import { ILogger } from './logger'
-
-/**
- * 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: ILogger) => BaileysBufferableEventEmitter
-
-export {}

package/lib/Utils/generics.d.ts

@@ -1,117 +0,0 @@
-import { AxiosRequestConfig } from 'axios'
-import { ILogger } from './logger'
-import { proto } from '../../WAProto'
-import { BaileysEventEmitter, BaileysEventMap, BrowsersMap, ConnectionState, WACallUpdateType, WAVersion } from '../Types'
-import { BinaryNode } from '../WABinary'
-
-export declare const Browsers: BrowsersMap
-
-export declare const getPlatformId: (browser: string) => any
-
-export declare const BufferJSON: {
-    replacer: (k: any, value: any) => any
-    reviver: (_: any, value: any) => 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 encodeNewsletterMessage: (message: proto.IMessage) => Uint8Array
-
-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 generateMessageID: (userId?: string) => string
-
-export declare const generateParticipantHashV2: (participants: string[]) => 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<ConnectionState>) => boolean | undefined, timeoutMs?: number) => Promise<void>
-
-export declare const printQRIfNecessaryListener: (ev: BaileysEventEmitter, logger: ILogger) => 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<{}>) => 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: {
-    [_: string]: any
-}): {
-    [_: string]: any
-}
-
-export declare function bytesToCrockford(buffer: Buffer): string
-
-export declare function toUnicodeEscape(text: string): string
-
-export declare function fromUnicodeEscape(escapedText: string): string
-
-export declare function asciiEncode(text: string): string
-
-export declare function asciiDecode(...codes: string[]): string[]

package/lib/Utils/history.d.ts

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

package/lib/Utils/index.d.ts

@@ -1,20 +0,0 @@
-export * from './generics'
-export * from './decode-wa-message'
-export * from './messages'
-export * from './messages-media'
-export * from './message-retry-manager'
-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-mongo-file-auth-state'
-export * from './use-single-file-auth-state'
-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

@@ -1,23 +0,0 @@
-import { AxiosRequestConfig } from 'axios'
-import { WAMediaUploadFunction, WAUrlInfo } from '../Types'
-import { ILogger } from './logger'
-
-export type URLGenerationOptions = {
-    thumbnailWidth: number
-    fetchOpts: {
-        /** Timeout in ms */
-        timeout: number
-        proxyUrl?: string
-        headers?: AxiosRequestConfig<{}>['headers']
-    }
-    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>

package/lib/Utils/logger.d.ts

@@ -1,13 +0,0 @@
-export interface ILogger {
-    level: string
-    child(obj: Record<string, unknown>): ILogger
-    trace(obj: unknown, msg?: string): any
-    debug(obj: unknown, msg?: string): any
-    info(obj: unknown, msg?: string): any
-    warn(obj: unknown, msg?: string): any
-    error(obj: unknown, msg?: string): any
-}
-
-declare const _default: import("pino").Logger<never, boolean>
-
-export default _default

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

@@ -1,14 +0,0 @@
-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): Promise<ArrayBuffer>
-    _subtractSingle(e: any, t: any): Promise<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

@@ -1,9 +0,0 @@
-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>
-}

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

@@ -1,88 +0,0 @@
-import { proto } from '../../WAProto'
-import { ILogger } from './logger'
-
-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 interface PendingPhoneRequest {
-    [messageId: string]: NodeJS.Timeout
-}
-
-export interface RetryStatistics {
-    totalRetries: number
-    successfulRetries: number
-    failedRetries: number
-    mediaRetries: number
-    sessionRecreations: number
-    phoneRequests: number
-}
-
-export declare class MessageRetryManager {
-    private logger
-    private recentMessagesMap
-    private sessionRecreateHistory
-    private retryCounters
-    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 and history
-     */
-    shouldRecreateSession(jid: string, retryCount: number, hasSession: boolean): {
-        reason: string
-        recreate: 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
-    private keyToString
-}

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

@@ -1,135 +0,0 @@
-import { Boom } from '@hapi/boom'
-import { AxiosRequestConfig } from 'axios'
-import { Readable, Transform } from 'stream'
-import { URL } from 'url'
-import { proto } from '../../WAProto'
-import { DownloadableMessage, MediaConnInfo, MediaDecryptionKeyInfo, MediaType, SocketConfig, WAMediaUpload, WAMediaUploadFunction, WAMessageContent } from '../Types'
-import { BinaryNode } from '../WABinary'
-import { ILogger } from './logger'
-
-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): MediaDecryptionKeyInfo
-
-export declare const extractImageThumb: (bufferOrFilePath: Readable | Buffer | string, width?: number) => Promise<{
-    buffer: Buffer
-    original: {
-        width: number | undefined
-        height: number | undefined
-    }
-}>
-
-export declare const encodeBase64EncodedStringForUpload: (b64: string) => string
-
-export declare const generateProfilePicture: (mediaUpload: WAMediaUpload) => Promise<{
-    img: Buffer
-}>
-
-/** 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 | undefined>
-
-export declare const toReadable: (buffer: Buffer) => Readable
-
-export declare const toBuffer: (stream: Readable) => Promise<Buffer>
-
-export declare const getStream: (item: WAMediaUpload, opts?: AxiosRequestConfig) => 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?: Logger
-}): Promise<{
-    thumbnail: string | undefined
-    originalImageDimensions: {
-        width: number
-        height: number
-    } | undefined
-}>
-
-export declare const getHttpStream: (url: string | URL, options?: AxiosRequestConfig & {
-    isStream?: true
-}) => Promise<Readable>
-
-type EncryptedStreamOptions = {
-    saveOriginalFileIfRequired?: boolean
-    logger?: Logger
-    opts?: AxiosRequestConfig
-}
-
-export declare const encryptedStream: (media: WAMediaUpload, mediaType: MediaType, { logger, saveOriginalFileIfRequired, opts }?: EncryptedStreamOptions) => Promise<{
-    mediaKey: Buffer
-    encWriteStream: Readable
-    bodyPath: string | undefined
-    mac: Buffer
-    fileEncSha256: Buffer
-    fileSha256: Buffer
-    fileLength: number
-    didSaveToTmpPath: boolean
-}>
-
-export type MediaDownloadOptions = {
-    startByte?: number
-    endByte?: number
-    options?: AxiosRequestConfig<{}>
-}
-
-export declare const getUrlFromDirectPath: (directPath: 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
-
-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: proto.IMessageKey, mediaKey: Buffer | Uint8Array, meId: string) => BinaryNode
-
-export declare const decodeMediaRetryNode: (node: BinaryNode) => {
-    key: proto.IMessageKey
-    media?: {
-        ciphertext: Uint8Array
-        iv: Uint8Array
-    } | undefined
-    error?: Boom<any> | undefined
-}
-
-export declare const decryptMediaRetryData: ({ ciphertext, iv }: {
-    ciphertext: Uint8Array
-    iv: Uint8Array
-}, mediaKey: Uint8Array, msgId: string) => Promise<proto.MediaRetryNotification>
-
-export declare const getStatusCodeForMediaRetry: (code: number) => any
-
-export {}

package/lib/Utils/messages.d.ts

@@ -1,105 +0,0 @@
-import { ILogger } from './logger'
-import { type Transform } from 'stream'
-import { proto } from '../../WAProto'
-import { AnyMediaMessageContent, AnyMessageContent, MediaGenerationOptions, MessageContentGenerationOptions, MessageGenerationOptions, MessageGenerationOptionsFromContent, MessageUserReceipt, WAMessage, WAMessageContent, WAProto } from '../Types'
-import { MediaDownloadOptions } from './messages-media'
-
-/**
- * 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").WAUrlInfo | undefined>
-
-export declare const prepareWAMessageMedia: (message: AnyMediaMessageContent, options: MediaGenerationOptions) => Promise<proto.Message>
-
-export declare const prepareAlbumMessageContent: (jid: string, albums: WAProto.IMessage, 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 generateWAMessageContent: (message: AnyMessageContent, options: MessageContentGenerationOptions) => Promise<proto.Message>
-
-export declare const generateWAMessageFromContent: (jid: string, message: WAMessageContent, options: MessageGenerationOptionsFromContent) => proto.WebMessageInfo
-
-export declare const generateWAMessage: (jid: string, content: AnyMessageContent, options: MessageGenerationOptions) => Promise<proto.WebMessageInfo>
-
-/** Get the key to access the true type of content */
-export declare const getContentType: (content: WAProto.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) => "android" | "unknown" | "web" | "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
-
-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[]
-
-/** Given a list of message keys, aggregates them by chat & sender. Useful for sending read receipts in bulk */
-export declare const aggregateMessageKeysNotFromMe: (keys: proto.IMessageKey[]) => {
-    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 "stream" | "buffer">(message: WAMessage, type: Type, options: MediaDownloadOptions, ctx?: DownloadMediaMessageContext) => Promise<Type extends "buffer" ? Buffer : 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
-
-/**
- * this is an experimental patch to make buttons work
- * Don't know how it works, but it does for now
- */
-export declare const patchMessageForMdIfRequired: (message: proto.IMessage) => proto.IMessage
-
-export {}

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

@@ -1,20 +0,0 @@
-import { proto } from '../../WAProto'
-import { KeyPair } from '../Types'
-import { BinaryNode } from '../WABinary'
-import { ILogger } from './logger'
-
-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) => Buffer
-    decrypt: (ciphertext: Uint8Array) => Buffer
-    authenticate: (data: Uint8Array) => void
-    mixIntoKey: (data: Uint8Array) => Promise<void>
-    finishInit: () => Promise<void>
-    processHandshake: ({ serverHello }: proto.HandshakeMessage, noiseKey: KeyPair) => Promise<Buffer>
-    encodeFrame: (data: Buffer | Uint8Array) => Buffer
-    decodeFrame: (newData: Buffer | Uint8Array, onFrame: (buff: Uint8Array | BinaryNode) => void) => Promise<void>
-}

package/lib/Utils/process-message.d.ts

@@ -1,49 +0,0 @@
-import { AxiosRequestConfig } from 'axios'
-import { proto } from '../../WAProto'
-import { AuthenticationCreds, BaileysEventEmitter, CacheStore, SignalKeyStoreWithTransaction, SocketConfig } from '../Types'
-import { ILogger } from './logger'
-
-type ProcessMessageContext = {
-    shouldProcessHistoryMsg: boolean
-    placeholderResendCache?: CacheStore
-    creds: AuthenticationCreds
-    keyStore: SignalKeyStoreWithTransaction
-    ev: BaileysEventEmitter
-    getMessage: SocketConfig['getMessage']
-    logger?: ILogger
-    options: AxiosRequestConfig<{}>
-}
-
-/** Cleans a received message to further processing */
-export declare const cleanMessage: (message: proto.IWebMessageInfo, meId: string) => void
-
-export declare const isRealMessage: (message: proto.IWebMessageInfo, meId: string) => boolean | undefined
-
-export declare const shouldIncrementChatUnread: (message: proto.IWebMessageInfo) => boolean
-
-/**
- * Get the ID of the chat from the given key.
- * Typically -- that'll be the remoteJid, but for broadcasts, it'll be the participant
- */
-export declare const getChatId: ({ remoteJid, participant, fromMe }: proto.IMessageKey) => string
-
-type PollContext = {
-    /** normalised jid of the person that created the poll */
-    pollCreatorJid: string
-    /** ID of the poll creation message */
-    pollMsgId: string
-    /** poll creation message enc key */
-    pollEncKey: Uint8Array
-    /** jid of the person that voted */
-    voterJid: string
-}
-
-/**
- * Decrypt a poll vote
- * @param vote encrypted vote
- * @param ctx additional info about the poll required for decryption
- * @returns list of SHA256 options
- */
-export declare function decryptPollVote({ encPayload, encIv }: proto.Message.IPollEncValue, { pollCreatorJid, pollMsgId, pollEncKey, voterJid, }: PollContext): proto.Message.PollVoteMessage
-
-export declare const processMessage: (message: proto.IWebMessageInfo, { shouldProcessHistoryMsg, placeholderResendCache, ev, creds, keyStore, logger, options, getMessage }: ProcessMessageContext) => Promise<void>