gifted-baileys 1.5.0 → 1.5.5

package/src/Types/Chat.ts

@@ -0,0 +1,106 @@
+import type { proto } from '../../WAProto'
+import type { AccountSettings } from './Auth'
+import type { BufferedEventData } from './Events'
+import type { ChatLabelAssociationActionBody } from './LabelAssociation'
+import type { MessageLabelAssociationActionBody } from './LabelAssociation'
+import type { MinimalMessage } from './Message'
+
+/** privacy settings in WhatsApp Web */
+export type WAPrivacyValue = 'all' | 'contacts' | 'contact_blacklist' | 'none'
+
+export type WAPrivacyOnlineValue = 'all' | 'match_last_seen'
+
+export type WAReadReceiptsValue = 'all' | 'none'
+
+/** set of statuses visible to other people; see updatePresence() in WhatsAppWeb.Send */
+export type WAPresence = 'unavailable' | 'available' | 'composing' | 'recording' | 'paused'
+
+export const ALL_WA_PATCH_NAMES = ['critical_block', 'critical_unblock_low', 'regular_high', 'regular_low', 'regular'] as const
+
+export type WAPatchName = typeof ALL_WA_PATCH_NAMES[number]
+
+export interface PresenceData {
+    lastKnownPresence: WAPresence
+    lastSeen?: number
+}
+
+export type ChatMutation = {
+    syncAction: proto.ISyncActionData
+    index: string[]
+}
+
+export type WAPatchCreate = {
+    syncAction: proto.ISyncActionValue
+    index: string[]
+    type: WAPatchName
+    apiVersion: number
+    operation: proto.SyncdMutation.SyncdOperation
+}
+
+export type Chat = proto.IConversation & {
+    /** unix timestamp of when the last message was received in the chat */
+    lastMessageRecvTimestamp?: number
+}
+
+export type ChatUpdate = Partial<Chat & {
+    /**
+     * if specified in the update,
+     * the EV buffer will check if the condition gets fulfilled before applying the update
+     * Right now, used to determine when to release an app state sync event
+     *
+     * @returns true, if the update should be applied;
+     * false if it can be discarded;
+     * undefined if the condition is not yet fulfilled
+     * */
+    conditional: (bufferedData: BufferedEventData) => boolean | undefined
+}>
+
+/**
+ * the last messages in a chat, sorted reverse-chronologically. That is, the latest message should be first in the chat
+ * for MD modifications, the last message in the array (i.e. the earlist message) must be the last message recv in the chat
+ * */
+export type LastMessageList = MinimalMessage[] | proto.SyncActionValue.ISyncActionMessageRange
+
+export type ChatModification =
+    {
+        archive: boolean
+        lastMessages: LastMessageList
+    }
+    | { pushNameSetting: string }
+    | { pin: boolean }
+    | {
+        /** mute for duration, or provide timestamp of mute to remove*/
+        mute: number | null
+    }
+    | {
+        clear: 'all' | { messages: { id: string, fromMe?: boolean, timestamp: number }[] }
+    }
+    | {
+        star: {
+            messages: { id: string, fromMe?: boolean }[]
+            star: boolean
+        }
+    }
+    | {
+        markRead: boolean
+        lastMessages: LastMessageList
+    }
+    | { delete: true, lastMessages: LastMessageList }
+    // Label assosiation
+    | { addChatLabel: ChatLabelAssociationActionBody }
+    | { removeChatLabel: ChatLabelAssociationActionBody }
+    | { addMessageLabel: MessageLabelAssociationActionBody }
+    | { removeMessageLabel: MessageLabelAssociationActionBody }
+
+export type InitialReceivedChatsState = {
+    [jid: string]: {
+        /** the last message received from the other party */
+        lastMsgRecvTimestamp?: number
+        /** the absolute last message in the chat */
+        lastMsgTimestamp: number
+    }
+}
+
+export type InitialAppStateSyncOptions = {
+    accountSettings: AccountSettings
+}

package/{lib/Types/Contact.d.ts → src/Types/Contact.ts}

@@ -1,12 +1,13 @@
 export interface Contact {
-    id: string;
-    lid?: string;
+    id: string
+    lid?: string
     /** name of the contact, you have saved on your WA */
-    name?: string;
+    name?: string
     /** name of the contact, the contact has set on their own on WA */
-    notify?: string;
+    notify?: string
     /** I have no idea */
-    verifiedName?: string;
+    verifiedName?: string
+    // Baileys Added
     /**
      * Url of the profile picture of the contact
      *
@@ -14,6 +15,6 @@ export interface Contact {
      * null => if the profile picture has not been set (default profile picture)
      * any other string => url of the profile picture
      */
-    imgUrl?: string | null | 'changed';
-    status?: string;
-}
+    imgUrl?: string | null | 'changed'
+    status?: string
+}

package/src/Types/Events.ts

@@ -0,0 +1,93 @@
+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 } from './GroupMetadata'
+import { Label } from './Label'
+import { LabelAssociation } from './LabelAssociation'
+import { MessageUpsertType, MessageUserReceiptUpdate, WAMessage, WAMessageKey, WAMessageUpdate } from './Message'
+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
+    }
+    /** 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"
+     *  */
+    'messages.upsert': { messages: WAMessage[], type: MessageUpsertType }
+    /** 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 }
+
+    '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
+    }
+    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 }
+    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
+}

package/src/Types/GroupMetadata.ts

@@ -0,0 +1,53 @@
+import { Contact } from './Contact'
+
+export type GroupParticipant = (Contact & { isAdmin?: boolean, isSuperAdmin?: boolean, admin?: 'admin' | 'superadmin' | null })
+
+export type ParticipantAction = 'add' | 'remove' | 'promote' | 'demote'
+
+export interface GroupMetadata {
+    id: string
+    owner: string | undefined
+    subject: string
+    /** group subject owner */
+    subjectOwner?: string
+    /** group subject modification date */
+    subjectTime?: number
+    creation?: number
+    desc?: string
+    descOwner?: string
+    descId?: string
+    /** if this group is part of a community, it returns the jid of the community to which it belongs */
+    linkedParent?: string
+    /** is set when the group only allows admins to change group settings */
+    restrict?: boolean
+    /** is set when the group only allows admins to write messages */
+    announce?: boolean
+    /** is set when the group also allows members to add participants */
+    memberAddMode?: boolean
+    /** Request approval to join the group */
+    joinApprovalMode?: boolean
+    /** is this a community */
+    isCommunity?: boolean
+    /** is this the announce of a community */
+    isCommunityAnnounce?: boolean
+    /** number of group participants */
+    size?: number
+    // Baileys modified array
+    participants: GroupParticipant[]
+    ephemeralDuration?: number
+    inviteCode?: string
+    /** the person who added you to group or changed some setting in group */
+    author?: string
+}
+
+
+export interface WAGroupCreateResponse {
+    status: number
+    gid?: string
+    participants?: [{ [key: string]: {} }]
+}
+
+export interface GroupModificationResponse {
+    status: number
+    participants?: { [key: string]: {} }
+}

package/{lib → src}/Types/Label.js

@@ -24,4 +24,4 @@ var LabelColor;
     LabelColor[LabelColor["Color18"] = 17] = "Color18";
     LabelColor[LabelColor["Color19"] = 18] = "Color19";
     LabelColor[LabelColor["Color20"] = 19] = "Color20";
-})(LabelColor = exports.LabelColor || (exports.LabelColor = {}));
+})(LabelColor || (exports.LabelColor = LabelColor = {}));

package/src/Types/Label.ts

@@ -0,0 +1,36 @@
+export interface Label {
+    /** Label uniq ID */
+    id: string
+    /** Label name */
+    name: string
+    /** Label color ID */
+    color: number
+    /** Is label has been deleted */
+    deleted: boolean
+    /** WhatsApp has 5 predefined labels (New customer, New order & etc) */
+    predefinedId?: string
+}
+
+/** WhatsApp has 20 predefined colors */
+export enum LabelColor {
+    Color1 = 0,
+    Color2,
+    Color3,
+    Color4,
+    Color5,
+    Color6,
+    Color7,
+    Color8,
+    Color9,
+    Color10,
+    Color11,
+    Color12,
+    Color13,
+    Color14,
+    Color15,
+    Color16,
+    Color17,
+    Color18,
+    Color19,
+    Color20,
+}

package/{lib → src}/Types/LabelAssociation.js

@@ -6,4 +6,4 @@ var LabelAssociationType;
 (function (LabelAssociationType) {
     LabelAssociationType["Chat"] = "label_jid";
     LabelAssociationType["Message"] = "label_message";
-})(LabelAssociationType = exports.LabelAssociationType || (exports.LabelAssociationType = {}));
+})(LabelAssociationType || (exports.LabelAssociationType = LabelAssociationType = {}));

package/{lib/Types/LabelAssociation.d.ts → src/Types/LabelAssociation.ts}

@@ -1,29 +1,35 @@
 /** Association type */
-export declare enum LabelAssociationType {
-    Chat = "label_jid",
-    Message = "label_message"
+export enum LabelAssociationType {
+  Chat = 'label_jid',
+  Message = 'label_message'
 }
-export type LabelAssociationTypes = `${LabelAssociationType}`;
+
+export type LabelAssociationTypes = `${LabelAssociationType}`
+
 /** Association for chat */
 export interface ChatLabelAssociation {
-    type: LabelAssociationType.Chat;
-    chatId: string;
-    labelId: string;
+  type: LabelAssociationType.Chat
+  chatId: string
+  labelId: string
 }
+
 /** Association for message */
 export interface MessageLabelAssociation {
-    type: LabelAssociationType.Message;
-    chatId: string;
-    messageId: string;
-    labelId: string;
+  type: LabelAssociationType.Message
+  chatId: string
+  messageId: string
+  labelId: string
 }
-export type LabelAssociation = ChatLabelAssociation | MessageLabelAssociation;
+
+export type LabelAssociation = ChatLabelAssociation | MessageLabelAssociation
+
 /** Body for add/remove chat label association action */
 export interface ChatLabelAssociationActionBody {
-    labelId: string;
+  labelId: string
 }
+
 /** body for add/remove message label association action */
 export interface MessageLabelAssociationActionBody {
-    labelId: string;
-    messageId: string;
-}
+  labelId: string
+  messageId: string
+}

package/src/Types/Message.ts

@@ -0,0 +1,288 @@
+import { AxiosRequestConfig } from 'axios'
+import type { Logger } from 'pino'
+import type { Readable } from 'stream'
+import type { URL } from 'url'
+import { BinaryNode } from '../WABinary'
+import { proto } from '../../WAProto'
+import { MEDIA_HKDF_KEY_MAPPING } from '../Defaults'
+import type { GroupMetadata } from './GroupMetadata'
+import { CacheStore } from './Socket'
+
+// export the WAMessage Prototypes
+export { proto as WAProto }
+export type WAMessage = proto.IWebMessageInfo
+export type WAMessageContent = proto.IMessage
+export type WAContactMessage = proto.Message.IContactMessage
+export type WAContactsArrayMessage = proto.Message.IContactsArrayMessage
+export type WAMessageKey = proto.IMessageKey
+export type WATextMessage = proto.Message.IExtendedTextMessage
+export type WAContextInfo = proto.IContextInfo
+export type WALocationMessage = proto.Message.ILocationMessage
+export type WAGenericMediaMessage = proto.Message.IVideoMessage | proto.Message.IImageMessage | proto.Message.IAudioMessage | proto.Message.IDocumentMessage | proto.Message.IStickerMessage
+// eslint-disable-next-line no-unused-vars, @typescript-eslint/no-unused-vars
+export import WAMessageStubType = proto.WebMessageInfo.StubType
+// eslint-disable-next-line no-unused-vars, @typescript-eslint/no-unused-vars
+export import WAMessageStatus = proto.WebMessageInfo.Status
+export type WAMediaUpload = Buffer | { url: URL | string } | { stream: Readable }
+/** Set of message types that are supported by the library */
+export type MessageType = keyof proto.Message
+
+export type DownloadableMessage = { mediaKey?: Uint8Array | null, directPath?: string | null, url?: string | null }
+
+export type MessageReceiptType = 'read' | 'read-self' | 'hist_sync' | 'peer_msg' | 'sender' | 'inactive' | 'played' | undefined
+
+export type MediaConnInfo = {
+    auth: string
+    ttl: number
+    hosts: { hostname: string, maxContentLengthBytes: number }[]
+    fetchDate: Date
+}
+
+export interface WAUrlInfo {
+    'canonical-url': string
+    'matched-text': string
+    title: string
+    description?: string
+    jpegThumbnail?: Buffer
+    highQualityThumbnail?: proto.Message.IImageMessage
+    originalThumbnailUrl?: string
+}
+
+// types to generate WA messages
+type Mentionable = {
+    /** list of jids that are mentioned in the accompanying text */
+    mentions?: string[]
+}
+type Contextable = {
+    /** add contextInfo to the message */
+    contextInfo?: proto.IContextInfo
+}
+type ViewOnce = {
+    viewOnce?: boolean
+}
+
+type Buttonable = {
+    /** add buttons to the message  */
+    buttons?: proto.Message.ButtonsMessage.IButton[]
+}
+type Templatable = {
+    /** add buttons to the message (conflicts with normal buttons)*/
+    templateButtons?: proto.IHydratedTemplateButton[]
+
+    footer?: string
+}
+type Editable = {
+  edit?: WAMessageKey
+}
+type Listable = {
+    /** Sections of the List */
+    sections?: proto.Message.ListMessage.ISection[]
+
+    /** Title of a List Message only */
+    title?: string
+
+    /** Text of the bnutton on the list (required) */
+    buttonText?: string
+}
+type WithDimensions = {
+    width?: number
+    height?: number
+}
+
+export type PollMessageOptions = {
+    name: string
+    selectableCount?: number
+    values: string[]
+    /** 32 byte message secret to encrypt poll selections */
+    messageSecret?: Uint8Array
+}
+
+type SharePhoneNumber = {
+    sharePhoneNumber: boolean
+}
+
+type RequestPhoneNumber = {
+    requestPhoneNumber: boolean
+}
+
+export type MediaType = keyof typeof MEDIA_HKDF_KEY_MAPPING
+export type AnyMediaMessageContent = (
+    ({
+        image: WAMediaUpload
+        caption?: string
+        jpegThumbnail?: string
+    } & Mentionable & Contextable & Buttonable & Templatable & WithDimensions)
+    | ({
+        video: WAMediaUpload
+        caption?: string
+        gifPlayback?: boolean
+        jpegThumbnail?: string
+        /** if set to true, will send as a `video note` */
+        ptv?: boolean
+    } & Mentionable & Contextable & Buttonable & Templatable & WithDimensions)
+    | {
+        audio: WAMediaUpload
+        /** if set to true, will send as a `voice note` */
+        ptt?: boolean
+        /** optionally tell the duration of the audio */
+        seconds?: number
+    }
+    | ({
+        sticker: WAMediaUpload
+        isAnimated?: boolean
+    } & WithDimensions) | ({
+        document: WAMediaUpload
+        mimetype: string
+        fileName?: string
+        caption?: string
+    } & Contextable & Buttonable & Templatable))
+    & { mimetype?: string } & Editable
+
+export type ButtonReplyInfo = {
+    displayText: string
+    id: string
+    index: number
+}
+
+export type WASendableProduct = Omit<proto.Message.ProductMessage.IProductSnapshot, 'productImage'> & {
+    productImage: WAMediaUpload
+}
+
+export type AnyRegularMessageContent = (
+    ({
+	    text: string
+        linkPreview?: WAUrlInfo | null
+    }
+    & Mentionable & Contextable & Buttonable & Templatable & Listable & Editable)
+    | AnyMediaMessageContent
+    | ({
+        poll: PollMessageOptions
+    } & Mentionable & Contextable & Buttonable & Templatable & Editable)
+    | {
+        contacts: {
+            displayName?: string
+            contacts: proto.Message.IContactMessage[]
+        }
+    }
+    | {
+        location: WALocationMessage
+    }
+    | { react: proto.Message.IReactionMessage }
+    | {
+        buttonReply: ButtonReplyInfo
+        type: 'template' | 'plain'
+    }
+    | {
+        listReply: Omit<proto.Message.IListResponseMessage, 'contextInfo'>
+    }
+    | {
+        product: WASendableProduct
+        businessOwnerJid?: string
+        body?: string
+        footer?: string
+    } | SharePhoneNumber | RequestPhoneNumber
+) & ViewOnce
+
+export type AnyMessageContent = AnyRegularMessageContent | {
+	forward: WAMessage
+	force?: boolean
+} | {
+    /** Delete your message or anyone's message in a group (admin required) */
+	delete: WAMessageKey
+} | {
+	disappearingMessagesInChat: boolean | number
+}
+
+export type GroupMetadataParticipants = Pick<GroupMetadata, 'participants'>
+
+type MinimalRelayOptions = {
+    /** override the message ID with a custom provided string */
+    messageId?: string
+    /** cached group metadata, use to prevent redundant requests to WA & speed up msg sending */
+    cachedGroupMetadata?: (jid: string) => Promise<GroupMetadataParticipants | undefined>
+}
+
+export type MessageRelayOptions = MinimalRelayOptions & {
+    /** only send to a specific participant; used when a message decryption fails for a single user */
+    participant?: { jid: string, count: number }
+    /** additional attributes to add to the WA binary node */
+    additionalAttributes?: { [_: string]: string }    
+    additionalNodes?: BinaryNode[];
+    /** should we use the devices cache, or fetch afresh from the server; default assumed to be "true" */
+    useUserDevicesCache?: boolean
+    /** jid list of participants for status@broadcast */
+    statusJidList?: string[]
+}
+
+export type MiscMessageGenerationOptions = MinimalRelayOptions & {
+    /** optional, if you want to manually set the timestamp of the message */
+	timestamp?: Date
+    /** the message you want to quote */
+	quoted?: WAMessage
+    additionalNodes?: BinaryNode[];
+    /** disappearing messages settings */
+    ephemeralExpiration?: number | string
+    /** timeout for media upload to WA server */
+    mediaUploadTimeoutMs?: number
+    /** jid list of participants for status@broadcast */
+    statusJidList?: string[]
+    /** backgroundcolor for status */
+    backgroundColor?: string
+    /** font type for status */
+    font?: number
+    /** if it is broadcast */
+    broadcast?: boolean
+}
+export type MessageGenerationOptionsFromContent = MiscMessageGenerationOptions & {
+	userJid: string
+}
+
+export type WAMediaUploadFunctionOpts = { fileEncSha256B64: string, mediaType: MediaType, newsletter?: boolean, timeoutMs?: number }
+
+export type WAMediaUploadFunction = (readStream: Readable | Buffer, opts: WAMediaUploadFunctionOpts) => Promise<{ mediaUrl: string, directPath: string, handle?: string }>
+
+export type MediaGenerationOptions = {
+	logger?: Logger
+    mediaTypeOverride?: MediaType
+    upload: WAMediaUploadFunction
+    /** cache media so it does not have to be uploaded again */
+    mediaCache?: CacheStore
+
+    mediaUploadTimeoutMs?: number
+
+    options?: AxiosRequestConfig
+
+    backgroundColor?: string
+
+    font?: number
+
+    /** The message is for newsletter? */
+    newsletter?: boolean
+}
+export type MessageContentGenerationOptions = MediaGenerationOptions & {
+	getUrlInfo?: (text: string) => Promise<WAUrlInfo | undefined>
+}
+export type MessageGenerationOptions = MessageContentGenerationOptions & MessageGenerationOptionsFromContent
+
+/**
+ * Type of message upsert
+ * 1. notify => notify the user, this message was just received
+ * 2. append => append the message to the chat history, no notification required
+ */
+export type MessageUpsertType = 'append' | 'notify'
+
+export type MessageUserReceipt = proto.IUserReceipt
+
+export type WAMessageUpdate = { update: Partial<WAMessage>, key: proto.IMessageKey }
+
+export type WAMessageCursor = { before: WAMessageKey | undefined } | { after: WAMessageKey | undefined }
+
+export type MessageUserReceiptUpdate = { key: proto.IMessageKey, receipt: MessageUserReceipt }
+
+export type MediaDecryptionKeyInfo = {
+    iv: Buffer
+    cipherKey: Buffer
+    macKey?: Buffer
+}
+
+export type MinimalMessage = Pick<proto.IWebMessageInfo, 'key' | 'messageTimestamp'>