@d0v3riz/baileys 6.7.21 → 6.7.22

package/lib/Socket/newsletter.d.ts

@@ -1,6 +1,6 @@
-import type { WAMediaUpload } from '../Types/index.js';
-import type { NewsletterMetadata, NewsletterUpdate } from '../Types/index.js';
-import type { GroupsSocket } from './groups.js';
+import type { WAMediaUpload } from '../Types';
+import { NewsletterMetadata, NewsletterUpdate } from '../Types';
+import { GroupsSocket } from './groups';
 export declare const makeNewsletterSocket: (sock: GroupsSocket) => {
     newsletterCreate: (name: string, description?: string) => Promise<NewsletterMetadata>;
     newsletterUpdate: (jid: string, updates: NewsletterUpdate) => Promise<unknown>;
@@ -25,8 +25,8 @@ export declare const makeNewsletterSocket: (sock: GroupsSocket) => {
     newsletterChangeOwner: (jid: string, newOwnerJid: string) => Promise<void>;
     newsletterDemote: (jid: string, userJid: string) => Promise<void>;
     newsletterDelete: (jid: string) => Promise<void>;
-    groupMetadata: (jid: string) => Promise<import("../index.js").GroupMetadata>;
-    groupCreate: (subject: string, participants: string[]) => Promise<import("../index.js").GroupMetadata>;
+    groupMetadata: (jid: string) => Promise<import("../Types").GroupMetadata>;
+    groupCreate: (subject: string, participants: string[]) => Promise<import("../Types").GroupMetadata>;
     groupLeave: (id: string) => Promise<void>;
     groupUpdateSubject: (jid: string, subject: string) => Promise<void>;
     groupRequestParticipantsList: (jid: string) => Promise<{
@@ -34,37 +34,37 @@ export declare const makeNewsletterSocket: (sock: GroupsSocket) => {
     }[]>;
     groupRequestParticipantsUpdate: (jid: string, participants: string[], action: "approve" | "reject") => Promise<{
         status: string;
-        jid: string | undefined;
+        jid: string;
     }[]>;
-    groupParticipantsUpdate: (jid: string, participants: string[], action: import("../index.js").ParticipantAction) => Promise<{
+    groupParticipantsUpdate: (jid: string, participants: string[], action: import("../Types").ParticipantAction) => Promise<{
         status: string;
-        jid: string | undefined;
-        content: import("../index.js").BinaryNode;
+        jid: string;
+        content: import("../WABinary").BinaryNode;
     }[]>;
     groupUpdateDescription: (jid: string, description?: string) => Promise<void>;
     groupInviteCode: (jid: string) => Promise<string | undefined>;
     groupRevokeInvite: (jid: string) => Promise<string | undefined>;
     groupAcceptInvite: (code: string) => Promise<string | undefined>;
     groupRevokeInviteV4: (groupJid: string, invitedJid: string) => Promise<boolean>;
-    groupAcceptInviteV4: (key: string | import("../index.js").WAMessageKey, inviteMessage: import("../index.js").proto.Message.IGroupInviteMessage) => Promise<any>;
-    groupGetInviteInfo: (code: string) => Promise<import("../index.js").GroupMetadata>;
+    groupAcceptInviteV4: (key: string | import("../Types").WAMessageKey, inviteMessage: import("../Types").WAProto.Message.IGroupInviteMessage) => Promise<any>;
+    groupGetInviteInfo: (code: string) => Promise<import("../Types").GroupMetadata>;
     groupToggleEphemeral: (jid: string, ephemeralExpiration: number) => Promise<void>;
     groupSettingUpdate: (jid: string, setting: "announcement" | "not_announcement" | "locked" | "unlocked") => Promise<void>;
     groupMemberAddMode: (jid: string, mode: "admin_add" | "all_member_add") => Promise<void>;
     groupJoinApprovalMode: (jid: string, mode: "on" | "off") => Promise<void>;
     groupFetchAllParticipating: () => Promise<{
-        [_: string]: import("../index.js").GroupMetadata;
+        [_: string]: import("../Types").GroupMetadata;
     }>;
-    getBotListV2: () => Promise<import("../index.js").BotListInfo[]>;
+    getBotListV2: () => Promise<import("../Types").BotListInfo[]>;
     processingMutex: {
         mutex<T>(code: () => Promise<T> | T): Promise<T>;
     };
     fetchPrivacySettings: (force?: boolean) => Promise<{
         [_: string]: string;
     }>;
-    upsertMessage: (msg: import("../index.js").WAMessage, type: import("../index.js").MessageUpsertType) => Promise<void>;
-    appPatch: (patchCreate: import("../index.js").WAPatchCreate) => Promise<void>;
-    sendPresenceUpdate: (type: import("../index.js").WAPresence, toJid?: string) => Promise<void>;
+    upsertMessage: (msg: import("../Types").WAMessage, type: import("../Types").MessageUpsertType) => Promise<void>;
+    appPatch: (patchCreate: import("../Types").WAPatchCreate) => Promise<void>;
+    sendPresenceUpdate: (type: import("../Types").WAPresence, toJid?: string) => Promise<void>;
     presenceSubscribe: (toJid: string, tcToken?: Buffer) => Promise<void>;
     profilePictureUrl: (jid: string, type?: "preview" | "image", timeoutMs?: number) => Promise<string | undefined>;
     onWhatsApp: (...jids: string[]) => Promise<{
@@ -72,9 +72,9 @@ export declare const makeNewsletterSocket: (sock: GroupsSocket) => {
         exists: unknown;
         lid: unknown;
     }[] | undefined>;
-    fetchBlocklist: () => Promise<(string | undefined)[]>;
-    fetchStatus: (...jids: string[]) => Promise<import("../index.js").USyncQueryResultList[] | undefined>;
-    fetchDisappearingDuration: (...jids: string[]) => Promise<import("../index.js").USyncQueryResultList[] | undefined>;
+    fetchBlocklist: () => Promise<string[]>;
+    fetchStatus: (...jids: string[]) => Promise<import("..").USyncQueryResultList[] | undefined>;
+    fetchDisappearingDuration: (...jids: string[]) => Promise<import("..").USyncQueryResultList[] | undefined>;
     updateProfilePicture: (jid: string, content: WAMediaUpload, dimensions?: {
         width: number;
         height: number;
@@ -83,23 +83,22 @@ export declare const makeNewsletterSocket: (sock: GroupsSocket) => {
     updateProfileStatus: (status: string) => Promise<void>;
     updateProfileName: (name: string) => Promise<void>;
     updateBlockStatus: (jid: string, action: "block" | "unblock") => Promise<void>;
-    updateDisableLinkPreviewsPrivacy: (isPreviewsDisabled: boolean) => Promise<void>;
-    updateCallPrivacy: (value: import("../index.js").WAPrivacyCallValue) => Promise<void>;
-    updateMessagesPrivacy: (value: import("../index.js").WAPrivacyMessagesValue) => Promise<void>;
-    updateLastSeenPrivacy: (value: import("../index.js").WAPrivacyValue) => Promise<void>;
-    updateOnlinePrivacy: (value: import("../index.js").WAPrivacyOnlineValue) => Promise<void>;
-    updateProfilePicturePrivacy: (value: import("../index.js").WAPrivacyValue) => Promise<void>;
-    updateStatusPrivacy: (value: import("../index.js").WAPrivacyValue) => Promise<void>;
-    updateReadReceiptsPrivacy: (value: import("../index.js").WAReadReceiptsValue) => Promise<void>;
-    updateGroupsAddPrivacy: (value: import("../index.js").WAPrivacyGroupAddValue) => Promise<void>;
+    updateCallPrivacy: (value: import("../Types").WAPrivacyCallValue) => Promise<void>;
+    updateMessagesPrivacy: (value: import("../Types").WAPrivacyMessagesValue) => Promise<void>;
+    updateLastSeenPrivacy: (value: import("../Types").WAPrivacyValue) => Promise<void>;
+    updateOnlinePrivacy: (value: import("../Types").WAPrivacyOnlineValue) => Promise<void>;
+    updateProfilePicturePrivacy: (value: import("../Types").WAPrivacyValue) => Promise<void>;
+    updateStatusPrivacy: (value: import("../Types").WAPrivacyValue) => Promise<void>;
+    updateReadReceiptsPrivacy: (value: import("../Types").WAReadReceiptsValue) => Promise<void>;
+    updateGroupsAddPrivacy: (value: import("../Types").WAPrivacyGroupAddValue) => Promise<void>;
     updateDefaultDisappearingMode: (duration: number) => Promise<void>;
-    getBusinessProfile: (jid: string) => Promise<import("../index.js").WABusinessProfile | void>;
+    getBusinessProfile: (jid: string) => Promise<import("../Types").WABusinessProfile | void>;
     resyncAppState: (collections: readonly ("critical_unblock_low" | "regular_high" | "regular_low" | "critical_block" | "regular")[], isInitialSync: boolean) => Promise<void>;
-    chatModify: (mod: import("../index.js").ChatModification, jid: string) => Promise<void>;
+    chatModify: (mod: import("../Types").ChatModification, jid: string) => Promise<void>;
     cleanDirtyBits: (type: "account_sync" | "groups", fromTimestamp?: number | string) => Promise<void>;
-    addOrEditContact: (jid: string, contact: import("../index.js").proto.SyncActionValue.IContactAction) => Promise<void>;
+    addOrEditContact: (jid: string, contact: import("../Types").WAProto.SyncActionValue.IContactAction) => Promise<void>;
     removeContact: (jid: string) => Promise<void>;
-    addLabel: (jid: string, labels: import("../Types/Label.js").LabelActionBody) => Promise<void>;
+    addLabel: (jid: string, labels: import("../Types/Label").LabelActionBody) => Promise<void>;
     addChatLabel: (jid: string, labelId: string) => Promise<void>;
     removeChatLabel: (jid: string, labelId: string) => Promise<void>;
     addMessageLabel: (jid: string, messageId: string, labelId: string) => Promise<void>;
@@ -108,36 +107,35 @@ export declare const makeNewsletterSocket: (sock: GroupsSocket) => {
         id: string;
         fromMe?: boolean;
     }[], star: boolean) => Promise<void>;
-    executeUSyncQuery: (usyncQuery: import("../index.js").USyncQuery) => Promise<import("../index.js").USyncQueryResult | undefined>;
+    executeUSyncQuery: (usyncQuery: import("..").USyncQuery) => Promise<import("..").USyncQueryResult | undefined>;
     type: "md";
-    ws: import("./Client/index.js").WebSocketClient;
-    ev: import("../index.js").BaileysEventEmitter & {
-        process(handler: (events: Partial<import("../index.js").BaileysEventMap>) => void | Promise<void>): () => void;
+    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(): boolean;
+        flush(force?: boolean): boolean;
         isBuffering(): boolean;
     };
     authState: {
-        creds: import("../index.js").AuthenticationCreds;
-        keys: import("../index.js").SignalKeyStoreWithTransaction;
+        creds: import("../Types").AuthenticationCreds;
+        keys: import("../Types").SignalKeyStoreWithTransaction;
     };
-    signalRepository: import("../index.js").SignalRepository;
-    user: import("../index.js").Contact | undefined;
+    signalRepository: import("../Types").SignalRepository;
+    user: import("../Types").Contact | undefined;
     generateMessageTag: () => string;
-    query: (node: import("../index.js").BinaryNode, timeoutMs?: number) => Promise<any>;
-    waitForMessage: <T>(msgId: string, timeoutMs?: number | undefined) => Promise<T | undefined>;
+    query: (node: import("../WABinary").BinaryNode, timeoutMs?: number) => Promise<any>;
+    waitForMessage: <T>(msgId: string, timeoutMs?: number | undefined) => Promise<any>;
     waitForSocketOpen: () => Promise<void>;
     sendRawMessage: (data: Uint8Array | Buffer) => Promise<void>;
-    sendNode: (frame: import("../index.js").BinaryNode) => Promise<void>;
+    sendNode: (frame: import("../WABinary").BinaryNode) => Promise<void>;
     logout: (msg?: string) => Promise<void>;
     end: (error: Error | undefined) => void;
     onUnexpectedError: (err: Error | import("@hapi/boom").Boom, msg: string) => void;
     uploadPreKeys: (count?: number) => Promise<void>;
     uploadPreKeysToServerIfRequired: () => Promise<void>;
     requestPairingCode: (phoneNumber: string, customPairingCode?: string) => Promise<string>;
-    waitForConnectionUpdate: (check: (u: Partial<import("../index.js").ConnectionState>) => Promise<boolean | undefined>, timeoutMs?: number) => Promise<void>;
+    waitForConnectionUpdate: (check: (u: Partial<import("../Types").ConnectionState>) => Promise<boolean | undefined>, timeoutMs?: number) => Promise<void>;
     sendWAMBuffer: (wamBuffer: Buffer) => Promise<any>;
 };
 export type NewsletterSocket = ReturnType<typeof makeNewsletterSocket>;
-//# sourceMappingURL=newsletter.d.ts.map

package/lib/Socket/newsletter.js

@@ -1,7 +1,10 @@
-import { QueryIds, XWAPaths } from '../Types/index.js';
-import { generateProfilePicture } from '../Utils/messages-media.js';
-import { getBinaryNodeChild } from '../WABinary/index.js';
-import { executeWMexQuery as genericExecuteWMexQuery } from './mex.js';
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeNewsletterSocket = void 0;
+const Types_1 = require("../Types");
+const messages_media_1 = require("../Utils/messages-media");
+const WABinary_1 = require("../WABinary");
+const mex_1 = require("./mex");
 const parseNewsletterCreateResponse = (response) => {
     const { id, thread_metadata: thread, viewer_metadata: viewer } = response;
     return {
@@ -32,10 +35,10 @@ const parseNewsletterMetadata = (result) => {
     }
     return null;
 };
-export const makeNewsletterSocket = (sock) => {
+const makeNewsletterSocket = (sock) => {
     const { query, generateMessageTag } = sock;
     const executeWMexQuery = (variables, queryId, dataPath) => {
-        return genericExecuteWMexQuery(variables, queryId, dataPath, query, generateMessageTag);
+        return (0, mex_1.executeWMexQuery)(variables, queryId, dataPath, query, generateMessageTag);
     };
     const newsletterUpdate = async (jid, updates) => {
         const variables = {
@@ -45,7 +48,7 @@ export const makeNewsletterSocket = (sock) => {
                 settings: null
             }
         };
-        return executeWMexQuery(variables, QueryIds.UPDATE_METADATA, 'xwa2_newsletter_update');
+        return executeWMexQuery(variables, Types_1.QueryIds.UPDATE_METADATA, 'xwa2_newsletter_update');
     };
     return {
         ...sock,
@@ -53,15 +56,15 @@ export const makeNewsletterSocket = (sock) => {
             const variables = {
                 input: {
                     name,
-                    description: description ?? null
+                    description: description !== null && description !== void 0 ? description : null
                 }
             };
-            const rawResponse = await executeWMexQuery(variables, QueryIds.CREATE, XWAPaths.xwa2_newsletter_create);
+            const rawResponse = await executeWMexQuery(variables, Types_1.QueryIds.CREATE, Types_1.XWAPaths.xwa2_newsletter_create);
             return parseNewsletterCreateResponse(rawResponse);
         },
         newsletterUpdate,
         newsletterSubscribers: async (jid) => {
-            return executeWMexQuery({ newsletter_id: jid }, QueryIds.SUBSCRIBERS, XWAPaths.xwa2_newsletter_subscribers);
+            return executeWMexQuery({ newsletter_id: jid }, Types_1.QueryIds.SUBSCRIBERS, Types_1.XWAPaths.xwa2_newsletter_subscribers);
         },
         newsletterMetadata: async (type, key) => {
             const variables = {
@@ -73,20 +76,20 @@ export const makeNewsletterSocket = (sock) => {
                     type: type.toUpperCase()
                 }
             };
-            const result = await executeWMexQuery(variables, QueryIds.METADATA, XWAPaths.xwa2_newsletter_metadata);
+            const result = await executeWMexQuery(variables, Types_1.QueryIds.METADATA, Types_1.XWAPaths.xwa2_newsletter_metadata);
             return parseNewsletterMetadata(result);
         },
         newsletterFollow: (jid) => {
-            return executeWMexQuery({ newsletter_id: jid }, QueryIds.FOLLOW, XWAPaths.xwa2_newsletter_follow);
+            return executeWMexQuery({ newsletter_id: jid }, Types_1.QueryIds.FOLLOW, Types_1.XWAPaths.xwa2_newsletter_follow);
         },
         newsletterUnfollow: (jid) => {
-            return executeWMexQuery({ newsletter_id: jid }, QueryIds.UNFOLLOW, XWAPaths.xwa2_newsletter_unfollow);
+            return executeWMexQuery({ newsletter_id: jid }, Types_1.QueryIds.UNFOLLOW, Types_1.XWAPaths.xwa2_newsletter_unfollow);
         },
         newsletterMute: (jid) => {
-            return executeWMexQuery({ newsletter_id: jid }, QueryIds.MUTE, XWAPaths.xwa2_newsletter_mute_v2);
+            return executeWMexQuery({ newsletter_id: jid }, Types_1.QueryIds.MUTE, Types_1.XWAPaths.xwa2_newsletter_mute_v2);
         },
         newsletterUnmute: (jid) => {
-            return executeWMexQuery({ newsletter_id: jid }, QueryIds.UNMUTE, XWAPaths.xwa2_newsletter_unmute_v2);
+            return executeWMexQuery({ newsletter_id: jid }, Types_1.QueryIds.UNMUTE, Types_1.XWAPaths.xwa2_newsletter_unmute_v2);
         },
         newsletterUpdateName: async (jid, name) => {
             return await newsletterUpdate(jid, { name });
@@ -95,7 +98,7 @@ export const makeNewsletterSocket = (sock) => {
             return await newsletterUpdate(jid, { description });
         },
         newsletterUpdatePicture: async (jid, content) => {
-            const { img } = await generateProfilePicture(content);
+            const { img } = await (0, messages_media_1.generateProfilePicture)(content);
             return await newsletterUpdate(jid, { picture: img.toString('base64') });
         },
         newsletterRemovePicture: async (jid) => {
@@ -147,6 +150,7 @@ export const makeNewsletterSocket = (sock) => {
             return result;
         },
         subscribeNewsletterUpdates: async (jid) => {
+            var _a;
             const result = await query({
                 tag: 'iq',
                 attrs: {
@@ -157,23 +161,23 @@ export const makeNewsletterSocket = (sock) => {
                 },
                 content: [{ tag: 'live_updates', attrs: {}, content: [] }]
             });
-            const liveUpdatesNode = getBinaryNodeChild(result, 'live_updates');
-            const duration = liveUpdatesNode?.attrs?.duration;
+            const liveUpdatesNode = (0, WABinary_1.getBinaryNodeChild)(result, 'live_updates');
+            const duration = (_a = liveUpdatesNode === null || liveUpdatesNode === void 0 ? void 0 : liveUpdatesNode.attrs) === null || _a === void 0 ? void 0 : _a.duration;
             return duration ? { duration: duration } : null;
         },
         newsletterAdminCount: async (jid) => {
-            const response = await executeWMexQuery({ newsletter_id: jid }, QueryIds.ADMIN_COUNT, XWAPaths.xwa2_newsletter_admin_count);
+            const response = await executeWMexQuery({ newsletter_id: jid }, Types_1.QueryIds.ADMIN_COUNT, Types_1.XWAPaths.xwa2_newsletter_admin_count);
             return response.admin_count;
         },
         newsletterChangeOwner: async (jid, newOwnerJid) => {
-            await executeWMexQuery({ newsletter_id: jid, user_id: newOwnerJid }, QueryIds.CHANGE_OWNER, XWAPaths.xwa2_newsletter_change_owner);
+            await executeWMexQuery({ newsletter_id: jid, user_id: newOwnerJid }, Types_1.QueryIds.CHANGE_OWNER, Types_1.XWAPaths.xwa2_newsletter_change_owner);
         },
         newsletterDemote: async (jid, userJid) => {
-            await executeWMexQuery({ newsletter_id: jid, user_id: userJid }, QueryIds.DEMOTE, XWAPaths.xwa2_newsletter_demote);
+            await executeWMexQuery({ newsletter_id: jid, user_id: userJid }, Types_1.QueryIds.DEMOTE, Types_1.XWAPaths.xwa2_newsletter_demote);
         },
         newsletterDelete: async (jid) => {
-            await executeWMexQuery({ newsletter_id: jid }, QueryIds.DELETE, XWAPaths.xwa2_newsletter_delete_v2);
+            await executeWMexQuery({ newsletter_id: jid }, Types_1.QueryIds.DELETE, Types_1.XWAPaths.xwa2_newsletter_delete_v2);
         }
     };
 };
-//# sourceMappingURL=newsletter.js.map
+exports.makeNewsletterSocket = makeNewsletterSocket;

package/lib/Socket/socket.d.ts

@@ -1,7 +1,7 @@
 import { Boom } from '@hapi/boom';
-import type { SocketConfig } from '../Types/index.js';
-import { type BinaryNode } from '../WABinary/index.js';
-import { WebSocketClient } from './Client/index.js';
+import { SocketConfig } from '../Types';
+import { BinaryNode } from '../WABinary';
+import { WebSocketClient } from './Client';
 /**
  * Connects to WA servers and performs:
  * - simple queries (no retry mechanism, wait for connection establishment)
@@ -11,22 +11,22 @@ import { WebSocketClient } from './Client/index.js';
 export declare const makeSocket: (config: SocketConfig) => {
     type: "md";
     ws: WebSocketClient;
-    ev: import("../Types/index.js").BaileysEventEmitter & {
-        process(handler: (events: Partial<import("../Types/index.js").BaileysEventMap>) => void | Promise<void>): () => void;
+    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(): boolean;
+        flush(force?: boolean): boolean;
         isBuffering(): boolean;
     };
     authState: {
-        creds: import("../Types/index.js").AuthenticationCreds;
-        keys: import("../Types/index.js").SignalKeyStoreWithTransaction;
+        creds: import("../Types").AuthenticationCreds;
+        keys: import("../Types").SignalKeyStoreWithTransaction;
     };
-    signalRepository: import("../Types/index.js").SignalRepository;
-    readonly user: import("../Types/index.js").Contact | undefined;
+    signalRepository: import("../Types").SignalRepository;
+    readonly user: import("../Types").Contact | undefined;
     generateMessageTag: () => string;
     query: (node: BinaryNode, timeoutMs?: number) => Promise<any>;
-    waitForMessage: <T>(msgId: string, timeoutMs?: number | undefined) => Promise<T | undefined>;
+    waitForMessage: <T>(msgId: string, timeoutMs?: number | undefined) => Promise<any>;
     waitForSocketOpen: () => Promise<void>;
     sendRawMessage: (data: Uint8Array | Buffer) => Promise<void>;
     sendNode: (frame: BinaryNode) => Promise<void>;
@@ -37,7 +37,6 @@ export declare const makeSocket: (config: SocketConfig) => {
     uploadPreKeysToServerIfRequired: () => Promise<void>;
     requestPairingCode: (phoneNumber: string, customPairingCode?: string) => Promise<string>;
     /** Waits for the connection to WA to reach a state */
-    waitForConnectionUpdate: (check: (u: Partial<import("../Types/index.js").ConnectionState>) => Promise<boolean | undefined>, timeoutMs?: number) => Promise<void>;
+    waitForConnectionUpdate: (check: (u: Partial<import("../Types").ConnectionState>) => Promise<boolean | undefined>, timeoutMs?: number) => Promise<void>;
     sendWAMBuffer: (wamBuffer: Buffer) => Promise<any>;
 };
-//# sourceMappingURL=socket.d.ts.map