gifted-baileys 1.5.6 → 1.5.7

package/src/Types/Chat.ts

@@ -1,106 +0,0 @@
-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/src/Types/Events.ts

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

@@ -1,53 +0,0 @@
-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/src/Types/Label.ts

@@ -1,36 +0,0 @@
-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/src/Types/Message.ts

@@ -1,288 +0,0 @@
-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'>

package/src/Types/Newsletter.ts

@@ -1,98 +0,0 @@
-import { proto } from '../../WAProto'
-
-export type NewsletterReactionMode = 'ALL' | 'BASIC' | 'NONE'
-
-export type NewsletterState = 'ACTIVE' | 'GEOSUSPENDED' | 'SUSPENDED'
-
-export type NewsletterVerification = 'VERIFIED' | 'UNVERIFIED'
-
-export type NewsletterMute = 'ON' | 'OFF' | 'UNDEFINED'
-
-export type NewsletterViewRole = 'ADMIN' | 'GUEST' | 'OWNER' | 'SUBSCRIBER'
-
-export type NewsletterViewerMetadata = {
-    mute: NewsletterMute
-    view_role: NewsletterViewRole
-}
-
-export type NewsletterMetadata = {
-    /**jid of newsletter */
-    id: string
-    /**state of newsletter */
-    state: NewsletterState
-    /**creation timestamp of newsletter */
-    creation_time: number
-    /**name of newsletter */
-    name: string
-    /**timestamp of last name modification of newsletter */
-    nameTime: number
-    /**description of newsletter */
-    description: string
-    /**timestamp of last description modification of newsletter */
-    descriptionTime: number
-    /**invite code of newsletter */
-    invite: string
-    /**i dont know */
-    handle: null
-    /**direct path of picture */
-    picture: string | null
-    /**direct path of picture preview (lower quality) */
-    preview: string | null
-    /**reaction mode of newsletter */
-    reaction_codes?: NewsletterReactionMode
-    /**subscribers count of newsletter */
-    subscribers: number
-    /**verification state of newsletter */
-    verification: NewsletterVerification
-    /**viewer metadata */
-    viewer_metadata: NewsletterViewerMetadata
-}
-
-export type SubscriberAction = 'promote' | 'demote'
-
-export type ReactionModeUpdate = {reaction_codes: {blocked_codes: null, enabled_ts_sec: null, value: NewsletterReactionMode}}
-
-/**only exists reaction mode update */
-export type NewsletterSettingsUpdate = ReactionModeUpdate
-
-export type NewsletterReaction = {count: number, code: string}
-
-export type NewsletterFetchedUpdate = {
-    /**id of message in newsletter, starts from 100 */
-    server_id: string
-    /**count of views in this message */
-    views?: number
-    /**reactions in this message */
-    reactions: NewsletterReaction[]
-    /**the message, if you requested only updates, you will not receive message */
-    message?: proto.IWebMessageInfo
-}
-
-export enum MexOperations {
-    PROMOTE = 'NotificationNewsletterAdminPromote',
-    DEMOTE = 'NotificationNewsletterAdminDemote',
-    UPDATE = 'NotificationNewsletterUpdate'
-}
-
-export enum XWAPaths {
-    PROMOTE = 'xwa2_notify_newsletter_admin_promote',
-    DEMOTE = 'xwa2_notify_newsletter_admin_demote',
-    ADMIN_COUNT = 'xwa2_newsletter_admin',
-    CREATE = 'xwa2_newsletter_create',
-    NEWSLETTER = 'xwa2_newsletter',
-    METADATA_UPDATE = 'xwa2_notify_newsletter_on_metadata_update'
-}
-
-export enum QueryIds {
-    JOB_MUTATION = '7150902998257522',
-    METADATA = '6620195908089573',
-    UNFOLLOW = '7238632346214362',
-    FOLLOW = '7871414976211147',
-    UNMUTE = '7337137176362961',
-    MUTE = '25151904754424642',
-    CREATE = '6996806640408138',
-    ADMIN_COUNT = '7130823597031706',
-    CHANGE_OWNER = '7341777602580933',
-    DELETE = '8316537688363079',
-    DEMOTE = '6551828931592903'
-}