@hbmodsofc/baileys 1.7.8 → 2.0.0

package/lib/Socket/usync.d.ts

@@ -0,0 +1,36 @@
+import { Boom } from '@hapi/boom';
+import { SocketConfig } from '../Types';
+import { BinaryNode } from '../WABinary';
+import { USyncQuery } from '../WAUSync';
+export declare const makeUSyncSocket: (config: SocketConfig) => {
+    executeUSyncQuery: (usyncQuery: USyncQuery) => Promise<import("../WAUSync").USyncQueryResult | undefined>;
+    type: "md";
+    ws: import("./Client").WebSocketClient;
+    ev: import("../Types").BaileysEventEmitter & {
+        process(handler: (events: Partial<import("../Types").BaileysEventMap>) => void | Promise<void>): (() => void);
+        buffer(): void;
+        createBufferedFunction<A extends any[], T>(work: (...args: A) => Promise<T>): ((...args: A) => Promise<T>);
+        flush(force?: boolean): boolean;
+        isBuffering(): boolean;
+    };
+    authState: {
+        creds: import("../Types").AuthenticationCreds;
+        keys: import("../Types").SignalKeyStoreWithTransaction;
+    };
+    signalRepository: import("../Types").SignalRepository;
+    user: import("../Types").Contact | undefined;
+    generateMessageTag: () => string;
+    query: (node: BinaryNode, timeoutMs?: number) => Promise<BinaryNode>;
+    waitForMessage: <T>(msgId: string, timeoutMs?: number | undefined) => Promise<any>;
+    waitForSocketOpen: () => Promise<void>;
+    sendRawMessage: (data: Uint8Array | Buffer) => Promise<void>;
+    sendNode: (frame: BinaryNode) => Promise<void>;
+    logout: (msg?: string) => Promise<void>;
+    end: (error: Error | undefined) => void;
+    onUnexpectedError: (err: Error | Boom, msg: string) => void;
+    uploadPreKeys: (count?: number) => Promise<void>;
+    uploadPreKeysToServerIfRequired: () => Promise<void>;
+    requestPairingCode: (phoneNumber: string, customPairingCode?: string) => Promise<string>;
+    waitForConnectionUpdate: (check: (u: Partial<import("../Types").ConnectionState>) => Promise<boolean | undefined>, timeoutMs?: number) => Promise<void>;
+    sendWAMBuffer: (wamBuffer: Buffer) => Promise<BinaryNode>;
+};

package/lib/Socket/usync.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeUSyncSocket = void 0;
+const boom_1 = require("@hapi/boom");
+const WABinary_1 = require("../WABinary");
+const socket_1 = require("./socket");
+const makeUSyncSocket = (config) => {
+    const sock = (0, socket_1.makeSocket)(config);
+    const { generateMessageTag, query, } = sock;
+    const executeUSyncQuery = async (usyncQuery) => {
+        if (usyncQuery.protocols.length === 0) {
+            throw new boom_1.Boom('USyncQuery must have at least one protocol');
+        }
+        // todo: validate users, throw WARNING on no valid users
+        // variable below has only validated users
+        const validUsers = usyncQuery.users;
+        const userNodes = validUsers.map((user) => {
+            return {
+                tag: 'user',
+                attrs: {
+                    jid: !user.phone ? user.id : undefined,
+                },
+                content: usyncQuery.protocols
+                    .map((a) => a.getUserElement(user))
+                    .filter(a => a !== null)
+            };
+        });
+        const listNode = {
+            tag: 'list',
+            attrs: {},
+            content: userNodes
+        };
+        const queryNode = {
+            tag: 'query',
+            attrs: {},
+            content: usyncQuery.protocols.map((a) => a.getQueryElement())
+        };
+        const iq = {
+            tag: 'iq',
+            attrs: {
+                to: WABinary_1.S_WHATSAPP_NET,
+                type: 'get',
+                xmlns: 'usync',
+            },
+            content: [
+                {
+                    tag: 'usync',
+                    attrs: {
+                        context: usyncQuery.context,
+                        mode: usyncQuery.mode,
+                        sid: generateMessageTag(),
+                        last: 'true',
+                        index: '0',
+                    },
+                    content: [
+                        queryNode,
+                        listNode
+                    ]
+                }
+            ],
+        };
+        const result = await query(iq);
+        return usyncQuery.parseUSyncQueryResult(result);
+    };
+    return {
+        ...sock,
+        executeUSyncQuery,
+    };
+};
+exports.makeUSyncSocket = makeUSyncSocket;

package/lib/Types/Auth.d.ts

@@ -1,4 +1,6 @@
-import type { proto } from '../../WAProto/index.js';
+/// <reference types="node" />
+import type { proto } from '../../WAProto';
+import { RegistrationOptions } from '../Socket/registration';
 import type { Contact } from './Contact';
 import type { MinimalMessage } from './Message';
 export type KeyPair = {
@@ -55,21 +57,25 @@ export type AuthenticationCreds = SignalCreds & {
     /** number of times history & app state has been synced */
     accountSyncCounter: number;
     accountSettings: AccountSettings;
+    deviceId: string;
+    phoneId: string;
+    identityId: Buffer;
     registered: boolean;
+    backupToken: Buffer;
+    registration: RegistrationOptions;
     pairingCode: string | undefined;
     lastPropHash: string | undefined;
     routingInfo: Buffer | undefined;
 };
 export type SignalDataTypeMap = {
     'pre-key': KeyPair;
-    session: Uint8Array;
+    'session': Uint8Array;
     'sender-key': Uint8Array;
     'sender-key-memory': {
         [jid: string]: boolean;
     };
     'app-state-sync-key': proto.Message.IAppStateSyncKeyData;
     'app-state-sync-version': LTHashState;
-    'lid-mapping': string;
 };
 export type SignalDataSet = {
     [T in keyof SignalDataTypeMap]?: {
@@ -87,7 +93,7 @@ export type SignalKeyStore = {
 };
 export type SignalKeyStoreWithTransaction = SignalKeyStore & {
     isInTransaction: () => boolean;
-    transaction<T>(exec: () => Promise<T>, key: string): Promise<T>;
+    transaction<T>(exec: () => Promise<T>): Promise<T>;
 };
 export type TransactionCapabilityOptions = {
     maxCommitRetries: number;

package/lib/Types/Call.d.ts

@@ -1,4 +1,4 @@
-export type WACallUpdateType = 'offer' | 'ringing' | 'timeout' | 'reject' | 'accept' | 'terminate';
+export type WACallUpdateType = 'offer' | 'ringing' | 'timeout' | 'reject' | 'accept';
 export type WACallEvent = {
     chatId: string;
     from: string;

package/lib/Types/Chat.d.ts

@@ -1,30 +1,21 @@
-import type { proto } from '../../WAProto/index.js';
+import type { proto } from '../../WAProto';
 import type { AccountSettings } from './Auth';
-import type { QuickReplyAction } from './Bussines.js';
 import type { BufferedEventData } from './Events';
-import type { LabelActionBody } from './Label';
 import type { ChatLabelAssociationActionBody } from './LabelAssociation';
 import type { MessageLabelAssociationActionBody } from './LabelAssociation';
-import type { MinimalMessage, WAMessageKey } from './Message';
+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 WAPrivacyGroupAddValue = 'all' | 'contacts' | 'contact_blacklist';
 export type WAReadReceiptsValue = 'all' | 'none';
-export type WAPrivacyCallValue = 'all' | 'known';
-export type WAPrivacyMessagesValue = 'all' | 'contacts';
 /** set of statuses visible to other people; see updatePresence() in WhatsAppWeb.Send */
 export type WAPresence = 'unavailable' | 'available' | 'composing' | 'recording' | 'paused';
 export declare const ALL_WA_PATCH_NAMES: readonly ["critical_block", "critical_unblock_low", "regular_high", "regular_low", "regular"];
-export type WAPatchName = (typeof ALL_WA_PATCH_NAMES)[number];
+export type WAPatchName = typeof ALL_WA_PATCH_NAMES[number];
 export interface PresenceData {
     lastKnownPresence: WAPresence;
     lastSeen?: number;
 }
-export type BotListInfo = {
-    jid: string;
-    personaId: string;
-};
 export type ChatMutation = {
     syncAction: proto.ISyncActionData;
     index: string[];
@@ -51,8 +42,6 @@ export type ChatUpdate = Partial<Chat & {
      * undefined if the condition is not yet fulfilled
      * */
     conditional: (bufferedData: BufferedEventData) => boolean | undefined;
-    /** last update time */
-    timestamp?: number;
 }>;
 /**
  * the last messages in a chat, sorted reverse-chronologically. That is, the latest message should be first in the chat
@@ -70,13 +59,12 @@ export type ChatModification = {
     /** mute for duration, or provide timestamp of mute to remove*/
     mute: number | null;
 } | {
-    clear: boolean;
-    lastMessages: LastMessageList;
-} | {
-    deleteForMe: {
-        deleteMedia: boolean;
-        key: WAMessageKey;
-        timestamp: number;
+    clear: 'all' | {
+        messages: {
+            id: string;
+            fromMe?: boolean;
+            timestamp: number;
+        }[];
     };
 } | {
     star: {
@@ -92,12 +80,6 @@ export type ChatModification = {
 } | {
     delete: true;
     lastMessages: LastMessageList;
-} | {
-    contact: proto.SyncActionValue.IContactAction | null;
-} | {
-    disableLinkPreviews: proto.SyncActionValue.IPrivacySettingDisableLinkPreviewsAction;
-} | {
-    addLabel: LabelActionBody;
 } | {
     addChatLabel: ChatLabelAssociationActionBody;
 } | {
@@ -106,8 +88,6 @@ export type ChatModification = {
     addMessageLabel: MessageLabelAssociationActionBody;
 } | {
     removeMessageLabel: MessageLabelAssociationActionBody;
-} | {
-    quickReply: QuickReplyAction;
 };
 export type InitialReceivedChatsState = {
     [jid: string]: {

package/lib/Types/Chat.js

@@ -1,10 +1,4 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ALL_WA_PATCH_NAMES = void 0;
-exports.ALL_WA_PATCH_NAMES = [
-    'critical_block',
-    'critical_unblock_low',
-    'regular_high',
-    'regular_low',
-    'regular'
-];
+exports.ALL_WA_PATCH_NAMES = ['critical_block', 'critical_unblock_low', 'regular_high', 'regular_low', 'regular'];

package/lib/Types/Contact.d.ts

@@ -1,10 +1,6 @@
 export interface Contact {
-    /** ID either in lid or jid format (preferred) **/
     id: string;
-    /** ID in LID format (@lid) **/
     lid?: string;
-    /** ID in PN format (@s.whatsapp.net)  **/
-    phoneNumber?: string;
     /** name of the contact, you have saved on your WA */
     name?: string;
     /** name of the contact, the contact has set on their own on WA */
@@ -18,6 +14,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;
+    imgUrl?: string | null | 'changed';
     status?: string;
 }

package/lib/Types/Events.d.ts

@@ -1,14 +1,14 @@
 import type { Boom } from '@hapi/boom';
-import { proto } from '../../WAProto/index.js';
-import type { AuthenticationCreds } from './Auth';
-import type { WACallEvent } from './Call';
-import type { Chat, ChatUpdate, PresenceData } from './Chat';
-import type { Contact } from './Contact';
-import type { GroupMetadata, ParticipantAction, RequestJoinAction, RequestJoinMethod } from './GroupMetadata';
-import type { Label } from './Label';
-import type { LabelAssociation } from './LabelAssociation';
-import type { MessageUpsertType, MessageUserReceiptUpdate, WAMessage, WAMessageKey, WAMessageUpdate } from './Message';
-import type { ConnectionState } from './State';
+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>;
@@ -19,18 +19,15 @@ export type BaileysEventMap = {
         chats: Chat[];
         contacts: Contact[];
         messages: WAMessage[];
-        isLatest?: boolean;
-        progress?: number | null;
-        syncType?: proto.HistorySync.HistorySyncType;
-        peerDataRequestSessionId?: string | null;
+        isLatest: boolean;
     };
     /** upsert chats */
     'chats.upsert': Chat[];
     /** update the given chats */
     'chats.update': ChatUpdate[];
-    'lid-mapping.update': {
+    'chats.phoneNumberShare': {
         lid: string;
-        pn: string;
+        jid: string;
     };
     /** delete chats with given ID */
     'chats.delete': string[];
@@ -61,12 +58,10 @@ export type BaileysEventMap = {
     /**
      * 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;
     };
     /** message was reacted to. If reaction was removed -- then "reaction.text" will be falsey */
     'messages.reaction': {
@@ -83,13 +78,6 @@ export type BaileysEventMap = {
         participants: string[];
         action: ParticipantAction;
     };
-    'group.join-request': {
-        id: string;
-        author: string;
-        participant: string;
-        action: RequestJoinAction;
-        method: RequestJoinMethod;
-    };
     'blocklist.set': {
         blocklist: string[];
     };
@@ -98,38 +86,12 @@ export type BaileysEventMap = {
         type: 'add' | 'remove';
     };
     /** Receive an update on a call, including when the call was received, rejected, accepted */
-    call: WACallEvent[];
+    'call': WACallEvent[];
     'labels.edit': Label;
     'labels.association': {
         association: LabelAssociation;
         type: 'add' | 'remove';
     };
-    /** Newsletter-related events */
-    'newsletter.reaction': {
-        id: string;
-        server_id: string;
-        reaction: {
-            code?: string;
-            count?: number;
-            removed?: boolean;
-        };
-    };
-    'newsletter.view': {
-        id: string;
-        server_id: string;
-        count: number;
-    };
-    'newsletter-participants.update': {
-        id: string;
-        author: string;
-        user: string;
-        new_role: string;
-        action: string;
-    };
-    'newsletter-settings.update': {
-        id: string;
-        update: any;
-    };
 };
 export type BufferedEventData = {
     historySets: {
@@ -144,9 +106,6 @@ export type BufferedEventData = {
         };
         empty: boolean;
         isLatest: boolean;
-        progress?: number | null;
-        syncType?: proto.HistorySync.HistorySyncType;
-        peerDataRequestSessionId?: string;
     };
     chatUpserts: {
         [jid: string]: Chat;

package/lib/Types/GroupMetadata.d.ts

@@ -1,33 +1,23 @@
-import type { Contact } from './Contact';
-import type { WAMessageAddressingMode } from './Message';
-export type GroupParticipant = Contact & {
+import { Contact } from './Contact';
+export type GroupParticipant = (Contact & {
     isAdmin?: boolean;
     isSuperAdmin?: boolean;
     admin?: 'admin' | 'superadmin' | null;
-};
-export type ParticipantAction = 'add' | 'remove' | 'promote' | 'demote' | 'modify';
-export type RequestJoinAction = 'created' | 'revoked' | 'rejected';
-export type RequestJoinMethod = 'invite_link' | 'linked_group_join' | 'non_admin_add' | undefined;
+});
+export type ParticipantAction = 'add' | 'remove' | 'promote' | 'demote';
 export interface GroupMetadata {
     id: string;
-    notify?: string;
-    /** group uses 'lid' or 'pn' to send messages */
-    addressingMode?: WAMessageAddressingMode;
     owner: string | undefined;
-    ownerPn?: string | undefined;
-    owner_country_code?: string | undefined;
     subject: string;
+    addressingMode: "pn" | "lid";
     /** group subject owner */
     subjectOwner?: string;
-    subjectOwnerPn?: string;
     /** group subject modification date */
     subjectTime?: number;
     creation?: number;
     desc?: string;
     descOwner?: string;
-    descOwnerPn?: string;
     descId?: string;
-    descTime?: number;
     /** 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 */

package/lib/Types/Label.d.ts

@@ -10,17 +10,6 @@ export interface Label {
     /** WhatsApp has 5 predefined labels (New customer, New order & etc) */
     predefinedId?: string;
 }
-export interface LabelActionBody {
-    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?: number;
-}
 /** WhatsApp has 20 predefined colors */
 export declare enum LabelColor {
     Color1 = 0,

package/lib/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 = LabelColor = {}));
+})(LabelColor = exports.LabelColor || (exports.LabelColor = {}));

package/lib/Types/LabelAssociation.js

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