gifted-baileys 1.5.6 → 1.5.7

package/lib/Socket/groups.d.ts

@@ -0,0 +1,115 @@
+/// <reference types="node" />
+import { proto } from '../../WAProto';
+import { GroupMetadata, ParticipantAction, SocketConfig } from '../Types';
+import { BinaryNode } from '../WABinary';
+export declare const makeGroupsSocket: (config: SocketConfig) => {
+    groupQuery: (jid: string, type: 'get' | 'set', content: BinaryNode[]) => Promise<BinaryNode>;
+    groupMetadata: (jid: string) => Promise<GroupMetadata>;
+    groupCreate: (subject: string, participants: string[]) => Promise<GroupMetadata>;
+    groupLeave: (id: string) => Promise<void>;
+    groupUpdateSubject: (jid: string, subject: string) => Promise<void>;
+    groupRequestParticipantsList: (jid: string) => Promise<{
+        [key: string]: string;
+    }[]>;
+    groupRequestParticipantsUpdate: (jid: string, participants: string[], action: 'approve' | 'reject') => Promise<{
+        status: string;
+        jid: string;
+    }[]>;
+    groupParticipantsUpdate: (jid: string, participants: string[], action: ParticipantAction) => Promise<{
+        status: string;
+        jid: string;
+        content: 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>;
+    /**
+     * accept a GroupInviteMessage
+     * @param key the key of the invite message, or optionally only provide the jid of the person who sent the invite
+     * @param inviteMessage the message to accept
+     */
+    groupAcceptInviteV4: (key: string | proto.IMessageKey, inviteMessage: proto.Message.IGroupInviteMessage) => Promise<string>;
+    groupGetInviteInfo: (code: string) => Promise<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]: GroupMetadata;
+    }>;
+    interactiveQuery: (userNodes: BinaryNode[], queryNode: BinaryNode) => Promise<BinaryNode[]>;
+    processingMutex: {
+        mutex<T>(code: () => T | Promise<T>): Promise<T>;
+    };
+    fetchPrivacySettings: (force?: boolean) => Promise<{
+        [_: string]: string;
+    }>;
+    upsertMessage: (msg: proto.IWebMessageInfo, type: import("../Types").MessageUpsertType) => Promise<void>;
+    appPatch: (patchCreate: import("../Types").WAPatchCreate) => Promise<void>;
+    fetchUserLid: (jid: string) => Promise<string | undefined>;
+    sendPresenceUpdate: (type: import("../Types").WAPresence, toJid?: string | undefined) => Promise<void>;
+    presenceSubscribe: (toJid: string, tcToken?: Buffer | undefined) => Promise<void>;
+    onWhatsApp: (...jids: string[]) => Promise<{
+        jid: string;
+        exists: unknown;
+    }[] | undefined>;
+    fetchBlocklist: () => Promise<string[]>;
+    fetchStatus: (...jids: string[]) => Promise<import("../index").USyncQueryResultList[] | undefined>;
+    fetchDisappearingDuration: (...jids: string[]) => Promise<import("../index").USyncQueryResultList[] | undefined>;
+    updateProfilePicture: (jid: string, content: import("../Types").WAMediaUpload) => Promise<void>;
+    removeProfilePicture: (jid: string) => Promise<void>;
+    updateProfileStatus: (status: string) => Promise<void>;
+    updateProfileName: (name: string) => Promise<void>;
+    updateBlockStatus: (jid: string, action: "block" | "unblock") => 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").WAPrivacyValue) => Promise<void>;
+    updateDefaultDisappearingMode: (duration: number) => Promise<void>;
+    getBusinessProfile: (jid: string) => Promise<void | import("../Types").WABusinessProfile>;
+    resyncAppState: (collections: readonly ("critical_block" | "critical_unblock_low" | "regular_high" | "regular_low" | "regular")[], isInitialSync: boolean) => Promise<void>;
+    chatModify: (mod: import("../Types").ChatModification, jid: string) => Promise<void>;
+    cleanDirtyBits: (type: "account_sync" | "groups", fromTimestamp?: string | number | undefined) => 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>;
+    removeMessageLabel: (jid: string, messageId: string, labelId: string) => Promise<void>;
+    star: (jid: string, messages: {
+        id: string;
+        fromMe?: boolean | undefined;
+    }[], star: boolean) => Promise<void>;
+    executeUSyncQuery: (usyncQuery: import("../index").USyncQuery) => Promise<import("../index").USyncQueryResult | undefined>;
+    type: "md";
+    ws: any;
+    ev: import("../Types").BaileysEventEmitter & {
+        process(handler: (events: Partial<import("../Types").BaileysEventMap>) => void | Promise<void>): () => void;
+        buffer(): void;
+        createBufferedFunction<A extends any[], T_1>(work: (...args: A) => Promise<T_1>): (...args: A) => Promise<T_1>;
+        flush(force?: boolean | undefined): 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 | undefined) => Promise<BinaryNode>;
+    waitForMessage: <T_2>(msgId: string, timeoutMs?: number | undefined) => Promise<T_2>;
+    waitForSocketOpen: () => Promise<void>;
+    sendRawMessage: (data: Uint8Array | Buffer) => Promise<void>;
+    sendNode: (frame: BinaryNode) => Promise<void>;
+    logout: (msg?: string | undefined) => Promise<void>;
+    end: (error: Error | undefined) => void;
+    onUnexpectedError: (err: Error | import("@hapi/boom").Boom<any>, msg: string) => void;
+    uploadPreKeys: (count?: number) => Promise<void>;
+    uploadPreKeysToServerIfRequired: () => Promise<void>;
+    requestPairingCode: (phoneNumber: string, pairCode: string) => Promise<string>;
+    waitForConnectionUpdate: (check: (u: Partial<import("../Types").ConnectionState>) => boolean | undefined, timeoutMs?: number | undefined) => Promise<void>;
+    sendWAMBuffer: (wamBuffer: Buffer) => Promise<BinaryNode>;
+};
+export declare const extractGroupMetadata: (result: BinaryNode) => GroupMetadata;

package/{src → lib}/Socket/groups.js

@@ -1,13 +1,4 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.extractGroupMetadata = exports.makeGroupsSocket = void 0;
 const WAProto_1 = require("../../WAProto");
@@ -18,23 +9,21 @@ const chats_1 = require("./chats");
 const makeGroupsSocket = (config) => {
     const sock = (0, chats_1.makeChatsSocket)(config);
     const { authState, ev, query, upsertMessage } = sock;
-    const groupQuery = (jid, type, content) => __awaiter(void 0, void 0, void 0, function* () {
-        return (query({
-            tag: 'iq',
-            attrs: {
-                type,
-                xmlns: 'w:g2',
-                to: jid,
-            },
-            content
-        }));
-    });
-    const groupMetadata = (jid) => __awaiter(void 0, void 0, void 0, function* () {
-        const result = yield groupQuery(jid, 'get', [{ tag: 'query', attrs: { request: 'interactive' } }]);
+    const groupQuery = async (jid, type, content) => (query({
+        tag: 'iq',
+        attrs: {
+            type,
+            xmlns: 'w:g2',
+            to: jid,
+        },
+        content
+    }));
+    const groupMetadata = async (jid) => {
+        const result = await groupQuery(jid, 'get', [{ tag: 'query', attrs: { request: 'interactive' } }]);
         return (0, exports.extractGroupMetadata)(result);
-    });
-    const groupFetchAllParticipating = () => __awaiter(void 0, void 0, void 0, function* () {
-        const result = yield query({
+    };
+    const groupFetchAllParticipating = async () => {
+        const result = await query({
             tag: 'iq',
             attrs: {
                 to: '@g.us',
@@ -67,18 +56,22 @@ const makeGroupsSocket = (config) => {
         }
         sock.ev.emit('groups.update', Object.values(data));
         return data;
-    });
-    sock.ws.on('CB:ib,,dirty', (node) => __awaiter(void 0, void 0, void 0, function* () {
+    };
+    sock.ws.on('CB:ib,,dirty', async (node) => {
         const { attrs } = (0, WABinary_1.getBinaryNodeChild)(node, 'dirty');
         if (attrs.type !== 'groups') {
             return;
         }
-        yield groupFetchAllParticipating();
-        yield sock.cleanDirtyBits('groups');
-    }));
-    return Object.assign(Object.assign({}, sock), { groupMetadata, groupCreate: (subject, participants) => __awaiter(void 0, void 0, void 0, function* () {
+        await groupFetchAllParticipating();
+        await sock.cleanDirtyBits('groups');
+    });
+    return {
+        ...sock,
+        groupQuery,
+        groupMetadata,
+        groupCreate: async (subject, participants) => {
             const key = (0, Utils_1.generateMessageID)();
-            const result = yield groupQuery('@g.us', 'set', [
+            const result = await groupQuery('@g.us', 'set', [
                 {
                     tag: 'create',
                     attrs: {
@@ -92,8 +85,9 @@ const makeGroupsSocket = (config) => {
                 }
             ]);
             return (0, exports.extractGroupMetadata)(result);
-        }), groupLeave: (id) => __awaiter(void 0, void 0, void 0, function* () {
-            yield groupQuery('@g.us', 'set', [
+        },
+        groupLeave: async (id) => {
+            await groupQuery('@g.us', 'set', [
                 {
                     tag: 'leave',
                     attrs: {},
@@ -102,16 +96,18 @@ const makeGroupsSocket = (config) => {
                     ]
                 }
             ]);
-        }), groupUpdateSubject: (jid, subject) => __awaiter(void 0, void 0, void 0, function* () {
-            yield groupQuery(jid, 'set', [
+        },
+        groupUpdateSubject: async (jid, subject) => {
+            await groupQuery(jid, 'set', [
                 {
                     tag: 'subject',
                     attrs: {},
                     content: Buffer.from(subject, 'utf-8')
                 }
             ]);
-        }), groupRequestParticipantsList: (jid) => __awaiter(void 0, void 0, void 0, function* () {
-            const result = yield groupQuery(jid, 'get', [
+        },
+        groupRequestParticipantsList: async (jid) => {
+            const result = await groupQuery(jid, 'get', [
                 {
                     tag: 'membership_approval_requests',
                     attrs: {}
@@ -120,8 +116,9 @@ const makeGroupsSocket = (config) => {
             const node = (0, WABinary_1.getBinaryNodeChild)(result, 'membership_approval_requests');
             const participants = (0, WABinary_1.getBinaryNodeChildren)(node, 'membership_approval_request');
             return participants.map(v => v.attrs);
-        }), groupRequestParticipantsUpdate: (jid, participants, action) => __awaiter(void 0, void 0, void 0, function* () {
-            const result = yield groupQuery(jid, 'set', [{
+        },
+        groupRequestParticipantsUpdate: async (jid, participants, action) => {
+            const result = await groupQuery(jid, 'set', [{
                     tag: 'membership_requests_action',
                     attrs: {},
                     content: [
@@ -141,8 +138,9 @@ const makeGroupsSocket = (config) => {
             return participantsAffected.map(p => {
                 return { status: p.attrs.error || '200', jid: p.attrs.jid };
             });
-        }), groupParticipantsUpdate: (jid, participants, action) => __awaiter(void 0, void 0, void 0, function* () {
-            const result = yield groupQuery(jid, 'set', [
+        },
+        groupParticipantsUpdate: async (jid, participants, action) => {
+            const result = await groupQuery(jid, 'set', [
                 {
                     tag: action,
                     attrs: {},
@@ -157,40 +155,47 @@ const makeGroupsSocket = (config) => {
             return participantsAffected.map(p => {
                 return { status: p.attrs.error || '200', jid: p.attrs.jid, content: p };
             });
-        }), groupUpdateDescription: (jid, description) => __awaiter(void 0, void 0, void 0, function* () {
+        },
+        groupUpdateDescription: async (jid, description) => {
             var _a;
-            const metadata = yield groupMetadata(jid);
+            const metadata = await groupMetadata(jid);
             const prev = (_a = metadata.descId) !== null && _a !== void 0 ? _a : null;
-            yield groupQuery(jid, 'set', [
+            await groupQuery(jid, 'set', [
                 {
                     tag: 'description',
-                    attrs: Object.assign(Object.assign({}, (description ? { id: (0, Utils_1.generateMessageID)() } : { delete: 'true' })), (prev ? { prev } : {})),
+                    attrs: {
+                        ...(description ? { id: (0, Utils_1.generateMessageID)() } : { delete: 'true' }),
+                        ...(prev ? { prev } : {})
+                    },
                     content: description ? [
                         { tag: 'body', attrs: {}, content: Buffer.from(description, 'utf-8') }
                     ] : undefined
                 }
             ]);
-        }), groupInviteCode: (jid) => __awaiter(void 0, void 0, void 0, function* () {
-            const result = yield groupQuery(jid, 'get', [{ tag: 'invite', attrs: {} }]);
+        },
+        groupInviteCode: async (jid) => {
+            const result = await groupQuery(jid, 'get', [{ tag: 'invite', attrs: {} }]);
             const inviteNode = (0, WABinary_1.getBinaryNodeChild)(result, 'invite');
             return inviteNode === null || inviteNode === void 0 ? void 0 : inviteNode.attrs.code;
-        }), groupRevokeInvite: (jid) => __awaiter(void 0, void 0, void 0, function* () {
-            const result = yield groupQuery(jid, 'set', [{ tag: 'invite', attrs: {} }]);
+        },
+        groupRevokeInvite: async (jid) => {
+            const result = await groupQuery(jid, 'set', [{ tag: 'invite', attrs: {} }]);
             const inviteNode = (0, WABinary_1.getBinaryNodeChild)(result, 'invite');
             return inviteNode === null || inviteNode === void 0 ? void 0 : inviteNode.attrs.code;
-        }), groupAcceptInvite: (code) => __awaiter(void 0, void 0, void 0, function* () {
-            const results = yield groupQuery('@g.us', 'set', [{ tag: 'invite', attrs: { code } }]);
+        },
+        groupAcceptInvite: async (code) => {
+            const results = await groupQuery('@g.us', 'set', [{ tag: 'invite', attrs: { code } }]);
             const result = (0, WABinary_1.getBinaryNodeChild)(results, 'group');
             return result === null || result === void 0 ? void 0 : result.attrs.jid;
-        }), 
+        },
         /**
          * accept a GroupInviteMessage
          * @param key the key of the invite message, or optionally only provide the jid of the person who sent the invite
          * @param inviteMessage the message to accept
          */
-        groupAcceptInviteV4: ev.createBufferedFunction((key, inviteMessage) => __awaiter(void 0, void 0, void 0, function* () {
+        groupAcceptInviteV4: ev.createBufferedFunction(async (key, inviteMessage) => {
             key = typeof key === 'string' ? { remoteJid: key } : key;
-            const results = yield groupQuery(inviteMessage.groupJid, 'set', [{
+            const results = await groupQuery(inviteMessage.groupJid, 'set', [{
                     tag: 'accept',
                     attrs: {
                         code: inviteMessage.inviteCode,
@@ -217,7 +222,7 @@ const makeGroupsSocket = (config) => {
                 ]);
             }
             // generate the group add message
-            yield upsertMessage({
+            await upsertMessage({
                 key: {
                     remoteJid: inviteMessage.groupJid,
                     id: (0, Utils_1.generateMessageID)(),
@@ -232,21 +237,28 @@ const makeGroupsSocket = (config) => {
                 messageTimestamp: (0, Utils_1.unixTimestampSeconds)()
             }, 'notify');
             return results.attrs.from;
-        })), groupGetInviteInfo: (code) => __awaiter(void 0, void 0, void 0, function* () {
-            const results = yield groupQuery('@g.us', 'get', [{ tag: 'invite', attrs: { code } }]);
+        }),
+        groupGetInviteInfo: async (code) => {
+            const results = await groupQuery('@g.us', 'get', [{ tag: 'invite', attrs: { code } }]);
             return (0, exports.extractGroupMetadata)(results);
-        }), groupToggleEphemeral: (jid, ephemeralExpiration) => __awaiter(void 0, void 0, void 0, function* () {
+        },
+        groupToggleEphemeral: async (jid, ephemeralExpiration) => {
             const content = ephemeralExpiration ?
                 { tag: 'ephemeral', attrs: { expiration: ephemeralExpiration.toString() } } :
                 { tag: 'not_ephemeral', attrs: {} };
-            yield groupQuery(jid, 'set', [content]);
-        }), groupSettingUpdate: (jid, setting) => __awaiter(void 0, void 0, void 0, function* () {
-            yield groupQuery(jid, 'set', [{ tag: setting, attrs: {} }]);
-        }), groupMemberAddMode: (jid, mode) => __awaiter(void 0, void 0, void 0, function* () {
-            yield groupQuery(jid, 'set', [{ tag: 'member_add_mode', attrs: {}, content: mode }]);
-        }), groupJoinApprovalMode: (jid, mode) => __awaiter(void 0, void 0, void 0, function* () {
-            yield groupQuery(jid, 'set', [{ tag: 'membership_approval_mode', attrs: {}, content: [{ tag: 'group_join', attrs: { state: mode } }] }]);
-        }), groupFetchAllParticipating });
+            await groupQuery(jid, 'set', [content]);
+        },
+        groupSettingUpdate: async (jid, setting) => {
+            await groupQuery(jid, 'set', [{ tag: setting, attrs: {} }]);
+        },
+        groupMemberAddMode: async (jid, mode) => {
+            await groupQuery(jid, 'set', [{ tag: 'member_add_mode', attrs: {}, content: mode }]);
+        },
+        groupJoinApprovalMode: async (jid, mode) => {
+            await groupQuery(jid, 'set', [{ tag: 'membership_approval_mode', attrs: {}, content: [{ tag: 'group_join', attrs: { state: mode } }] }]);
+        },
+        groupFetchAllParticipating
+    };
 };
 exports.makeGroupsSocket = makeGroupsSocket;
 const extractGroupMetadata = (result) => {
@@ -285,7 +297,7 @@ const extractGroupMetadata = (result) => {
                 admin: (attrs.type || null),
             };
         }),
-        ephemeralDuration: eph ? +eph : undefined
+        ephemeralDuration: eph ? +eph : 0
     };
     return metadata;
 };

package/lib/Socket/index.d.ts

@@ -0,0 +1,172 @@
+import { UserFacingSocketConfig } from '../Types';
+declare const makeWASocket: (config: UserFacingSocketConfig) => {
+    register: (code: string) => Promise<import("./registration").ExistsResponse>;
+    requestRegistrationCode: (registrationOptions?: import("./registration").RegistrationOptions) => Promise<import("./registration").ExistsResponse>;
+    logger: Logger;
+    getOrderDetails: (orderId: string, tokenBase64: string) => Promise<import("../Types").OrderDetails>;
+    getCatalog: ({ jid, limit, cursor }: import("../Types").GetCatalogOptions) => Promise<{
+        products: import("../Types").Product[];
+        nextPageCursor: any;
+    }>;
+    getCollections: (jid?: string, limit?: number) => Promise<{
+        collections: import("../Types").CatalogCollection[];
+    }>;
+    productCreate: (create: import("../Types").ProductCreate) => Promise<import("../Types").Product>;
+    productDelete: (productIds: string[]) => Promise<{
+        deleted: number;
+    }>;
+    productUpdate: (productId: string, update: import("../Types").ProductUpdate) => Promise<import("../Types").Product>;
+    sendMessageAck: ({ tag, attrs, content }: import("..").BinaryNode, errorCode?: number) => Promise<void>;
+    sendRetryRequest: (node: import("..").BinaryNode, forceIncludeKeys?: boolean) => Promise<void>;
+    offerCall: (toJid: string, isVideo?: boolean) => Promise<{
+        id: any;
+        to: string;
+    }>;
+    rejectCall: (callId: string, callFrom: string) => Promise<void>;
+    fetchMessageHistory: (count: number, oldestMsgKey: import("../Types").WAMessageKey, oldestMsgTimestamp: number) => Promise<string>;
+    requestPlaceholderResend: (messageKey: import("../Types").WAMessageKey) => Promise<string | undefined>;
+    getPrivacyTokens: (jids: string[]) => Promise<import("..").BinaryNode>;
+    assertSessions: (jids: string[], force: boolean) => Promise<boolean>;
+    relayMessage: (jid: string, message: import("../Types").WAProto.IMessage, { messageId: msgId, participant, additionalAttributes, additionalNodes, useUserDevicesCache, cachedGroupMetadata, statusJidList }: import("../Types").MessageRelayOptions) => Promise<string>;
+    sendReceipt: (jid: string, participant: string | undefined, messageIds: string[], type: import("../Types").MessageReceiptType) => Promise<void>;
+    sendReceipts: (keys: import("../Types").WAMessageKey[], type: import("../Types").MessageReceiptType) => Promise<void>;
+    getButtonArgs: (message: import("../Types").WAProto.IMessage) => import("..").BinaryNode["attrs"];
+    readMessages: (keys: import("../Types").WAMessageKey[]) => Promise<void>;
+    refreshMediaConn: (forceGet?: boolean) => Promise<import("../Types").MediaConnInfo>;
+    getUSyncDevices: (jids: string[], useCache: boolean, ignoreZeroDevices: boolean) => Promise<import("..").JidWithDevice[]>;
+    sendPeerDataOperationMessage: (pdoMessage: import("../Types").WAProto.Message.IPeerDataOperationRequestMessage) => Promise<string>;
+    createParticipantNodes: (jids: string[], message: import("../Types").WAProto.IMessage, extraAttrs?: import("..").BinaryNode["attrs"]) => Promise<{
+        nodes: import("..").BinaryNode[];
+        shouldIncludeDeviceIdentity: boolean;
+    }>;
+    waUploadToServer: import("../Types").WAMediaUploadFunction;
+    fetchPrivacySettings: (force?: boolean) => Promise<{
+        [_: string]: string;
+    }>;
+    updateMediaMessage: (message: import("../Types").WAProto.IWebMessageInfo) => Promise<import("../Types").WAProto.IWebMessageInfo>;
+    sendStatusMentions: (content: import("../Types").AnyMessageContent, jids?: string[]) => Promise<import("../Types").WAProto.WebMessageInfo>;
+    sendAlbumMessage: (jid: string, medias: import("../Types").Media[], options?: import("../Types").MiscMessageGenerationOptions) => Promise<import("../Types").WAProto.WebMessageInfo>;
+    sendMessage: (jid: string, content: import("../Types").AnyMessageContent, options?: import("../Types").MiscMessageGenerationOptions) => Promise<import("../Types").WAProto.WebMessageInfo | undefined>;
+    subscribeNewsletterUpdates: (jid: string) => Promise<{
+        duration: string;
+    }>;
+    newsletterReactionMode: (jid: string, mode: import("../Types").NewsletterReactionMode) => Promise<void>;
+    newsletterUpdateDescription: (jid: string, description?: string) => Promise<void>;
+    newsletterUpdateName: (jid: string, name: string) => Promise<void>;
+    newsletterUpdatePicture: (jid: string, content: import("../Types").WAMediaUpload) => Promise<void>;
+    newsletterRemovePicture: (jid: string) => Promise<void>;
+    newsletterUnfollow: (jid: string) => Promise<void>;
+    newsletterFollow: (jid: string) => Promise<void>;
+    newsletterUnmute: (jid: string) => Promise<void>;
+    newsletterMute: (jid: string) => Promise<void>;
+    newsletterAction: (jid: string, type: "follow" | "unfollow" | "mute" | "unmute") => Promise<void>;
+    newsletterCreate: (name: string, description: string) => Promise<import("../Types").NewsletterMetadata>;
+    newsletterMetadata: (type: "invite" | "jid", key: string, role?: import("../Types").NewsletterViewRole) => Promise<import("../Types").NewsletterMetadata>;
+    newsletterAdminCount: (jid: string) => Promise<number>;
+    newsletterChangeOwner: (jid: string, user: string) => Promise<void>;
+    newsletterDemote: (jid: string, user: string) => Promise<void>;
+    newsletterDelete: (jid: string) => Promise<void>;
+    newsletterReactMessage: (jid: string, serverId: string, code?: string) => Promise<void>;
+    newsletterFetchMessages: (type: "invite" | "jid", key: string, count: number, after?: number) => Promise<import("../Types").NewsletterFetchedUpdate[]>;
+    newsletterFetchUpdates: (jid: string, count: number, after?: number, since?: number) => Promise<import("../Types").NewsletterFetchedUpdate[]>;
+    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<{
+        [key: string]: string;
+    }[]>;
+    groupRequestParticipantsUpdate: (jid: string, participants: string[], action: "approve" | "reject") => Promise<{
+        status: string;
+        jid: string;
+    }[]>;
+    groupParticipantsUpdate: (jid: string, participants: string[], action: import("../Types").ParticipantAction) => Promise<{
+        status: string;
+        jid: string;
+        content: import("..").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>;
+    groupAcceptInviteV4: (key: string | import("../Types").WAProto.IMessageKey, inviteMessage: import("../Types").WAProto.Message.IGroupInviteMessage) => Promise<string>;
+    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("../Types").GroupMetadata;
+    }>;
+    processingMutex: {
+        mutex<T>(code: () => Promise<T> | T): Promise<T>;
+    };
+    upsertMessage: (msg: import("../Types").WAProto.IWebMessageInfo, 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<{
+        exists: boolean;
+        jid: string;
+    }[]>;
+    fetchBlocklist: () => Promise<string[]>;
+    fetchStatus: (jid: string) => Promise<{
+        status: string | undefined;
+        setAt: Date;
+    } | undefined>;
+    updateProfilePicture: (jid: string, content: import("../Types").WAMediaUpload) => Promise<void>;
+    removeProfilePicture: (jid: string) => Promise<void>;
+    updateProfileStatus: (status: string) => Promise<void>;
+    updateProfileName: (name: string) => Promise<void>;
+    updateBlockStatus: (jid: string, action: "block" | "unblock") => 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").WAPrivacyValue) => Promise<void>;
+    updateDefaultDisappearingMode: (duration: number) => Promise<void>;
+    getBusinessProfile: (jid: string) => Promise<import("../Types").WABusinessProfile | void>;
+    resyncAppState: (collections: readonly ("critical_block" | "critical_unblock_low" | "regular_high" | "regular_low" | "regular")[], isInitialSync: boolean) => Promise<void>;
+    chatModify: (mod: import("../Types").ChatModification, jid: string) => Promise<void>;
+    cleanDirtyBits: (type: "account_sync" | "groups", fromTimestamp?: number | string) => 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>;
+    removeMessageLabel: (jid: string, messageId: string, labelId: string) => Promise<void>;
+    star: (jid: string, messages: {
+        id: string;
+        fromMe?: boolean;
+    }[], star: boolean) => Promise<void>;
+    type: "md";
+    ws: any;
+    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: import("..").BinaryNode, timeoutMs?: number) => Promise<import("..").BinaryNode>;
+    waitForMessage: <T>(msgId: string, timeoutMs?: number | undefined) => Promise<T>;
+    waitForSocketOpen: () => Promise<void>;
+    sendRawMessage: (data: Uint8Array | Buffer) => Promise<void>;
+    sendNode: (frame: import("..").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, pairCode: string) => Promise<string>;
+    waitForConnectionUpdate: (check: (u: Partial<import("../Types").ConnectionState>) => boolean | undefined, timeoutMs?: number) => Promise<void>;
+    sendWAMBuffer: (wamBuffer: Buffer) => Promise<import("..").BinaryNode>;
+};
+export default makeWASocket;

package/{src → lib}/Socket/index.js

@@ -3,5 +3,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const Defaults_1 = require("../Defaults");
 const registration_1 = require("./registration");
 // export the last socket layer
-const makeWASocket = (config) => ((0, registration_1.makeRegistrationSocket)(Object.assign(Object.assign({}, Defaults_1.DEFAULT_CONNECTION_CONFIG), config)));
+const makeWASocket = (config) => ((0, registration_1.makeRegistrationSocket)({
+    ...Defaults_1.DEFAULT_CONNECTION_CONFIG,
+    ...config
+}));
 exports.default = makeWASocket;