neroxbailx/lib/Types/Events.d.ts

baileys whatsapp-api

import type { Boom } from '@hapi/boom'
import { proto } from '../../WAProto'
import { AuthenticationCreds } from './Auth'
import { WACallEvent } from './Call'
import { Chat, ChatUpdate, PresenceData } from './Chat'
import { Contact } from './Contact'
import { GroupMetadata, ParticipantAction, RequestJoinAction, RequestJoinMethod } from './GroupMetadata'
import { Label } from './Label'
import { LabelAssociation } from './LabelAssociation'
import { MessageUpsertType, MessageUserReceiptUpdate, WAMessage, WAMessageKey, WAMessageUpdate } from './Message'
import { NewsletterViewRole, SubscriberAction, NewsletterSettingsUpdate } from './Newsletter'
import { ConnectionState } from './State'
export type BaileysEventMap = {
/** connection state has been updated -- WS closed, opened, connecting etc. */
'connection.update': Partial<ConnectionState>
/** credentials updated -- some metadata, keys or something */
'creds.update': Partial<AuthenticationCreds>
/** set chats (history sync), everything is reverse chronologically sorted */
'messaging-history.set': {
chats: Chat[]
contacts: Contact[]
messages: WAMessage[]
isLatest?: boolean
progress?: number | null
syncType?: proto.HistorySync.HistorySyncType
peerDataRequestSessionId?: string | null
}
/** upsert chats */
'chats.upsert': Chat[]
/** update the given chats */
'chats.update': ChatUpdate[]
'chats.phoneNumberShare': {
lid: string
jid: string
}
/** delete chats with given ID */
'chats.delete': string[]
/** presence of contact in a chat updated */
'presence.update': {
id: string
presences: {
[participant: string]: PresenceData
}
}
'contacts.upsert': Contact[]
'contacts.update': Partial<Contact>[]
'messages.delete': {
keys: WAMessageKey[]
} | {
jid: string
all: true
}
'messages.update': WAMessageUpdate[]
'messages.media-update': {
key: WAMessageKey
media?: {
ciphertext: Uint8Array
iv: Uint8Array
}
error?: Boom
}[]
/**
* add/update the given messages. If they were received while the connection was online,
* the update will have type: "notify"
* if requestId is provided, then the messages was received from the phone due to it being unavailable
*  */
'messages.upsert': {
messages: WAMessage[]
type: MessageUpsertType
requestId?: string
}
// 'messages.poll': {
// 	key: WAMessageKey
//     pollUpdates: proto.IPollUpdateMessage
// }[]
/** message was reacted to. If reaction was removed -- then "reaction.text" will be falsey */
'messages.reaction': {
key: WAMessageKey
reaction: proto.IReaction
}[]
'message-receipt.update': MessageUserReceiptUpdate[]
'groups.upsert': GroupMetadata[]
'groups.update': Partial<GroupMetadata>[]
/** apply an action to participants in a group */
'group-participants.update': {
id: string
author: string
participants: string[]
action: ParticipantAction
}
'group.join-request': {
id: string
author: string
participant: string
action: RequestJoinAction
method: RequestJoinMethod
}
'newsletter.reaction': {
id: string
newsletter_server_id: string
reaction: {
code?: string
count?: number
removed?: boolean
}
}
'newsletter.view': {
id: string
newsletter_server_id: string
count: number
}
'newsletter-participants.update': {
id: string
author: string
user: string
new_role: NewsletterViewRole
action: SubscriberAction
}
'newsletter-settings.update': {
id: string
update: NewsletterSettingsUpdate
}
'blocklist.set': {
blocklist: string[]
}
'blocklist.update': {
blocklist: string[]
type: 'add' | 'remove'
}
/** Receive an update on a call, including when the call was received, rejected, accepted */
'call': WACallEvent[]
'labels.edit': Label
'labels.association': {
association: LabelAssociation
type: 'add' | 'remove'
}
}
export type BufferedEventData = {
historySets: {
chats: {
[jid: string]: Chat
}
contacts: {
[jid: string]: Contact
}
messages: {
[uqId: string]: WAMessage
}
empty: boolean
isLatest: boolean
progress?: number | null
syncType?: proto.HistorySync.HistorySyncType
peerDataRequestSessionId?: string
}
chatUpserts: {
[jid: string]: Chat
}
chatUpdates: {
[jid: string]: ChatUpdate
}
chatDeletes: Set<string>
contactUpserts: {
[jid: string]: Contact
}
contactUpdates: {
[jid: string]: Partial<Contact>
}
messageUpserts: {
[key: string]: {
type: MessageUpsertType
message: WAMessage
}
}
messageUpdates: {
[key: string]: WAMessageUpdate
}
messageDeletes: {
[key: string]: WAMessageKey
}
// messagePollings: {
//     [key: string]: {
//        key: WAMessageKey
//        pollUpdates: proto.IPollUpdateMessage[]
//    }
// }
messageReactions: {
[key: string]: {
key: WAMessageKey
reactions: proto.IReaction[]
}
}
messageReceipts: {
[key: string]: {
key: WAMessageKey
userReceipt: proto.IUserReceipt[]
}
}
groupUpdates: {
[jid: string]: Partial<GroupMetadata>
}
}
export type BaileysEvent = keyof BaileysEventMap
export interface BaileysEventEmitter {
on<T extends keyof BaileysEventMap>(event: T, listener: (arg: BaileysEventMap[T]) => void): void
off<T extends keyof BaileysEventMap>(event: T, listener: (arg: BaileysEventMap[T]) => void): void
removeAllListeners<T extends keyof BaileysEventMap>(event: T): void
emit<T extends keyof BaileysEventMap>(event: T, arg: BaileysEventMap[T]): boolean
}