dcodeindra-baileyspro 2.3.9

package/lib/Socket/groups.js

@@ -0,0 +1,360 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+
+const WAProto_1 = require("../../WAProto");
+const Types_1 = require("../Types");
+const Utils_1 = require("../Utils");
+const WABinary_1 = require("../WABinary");
+const chats_1 = require("./chats");
+
+const makeGroupsSocket = (config) => {
+    const sock = chats_1.makeChatsSocket(config);
+    const { authState, ev, query, upsertMessage } = sock;
+
+    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 extractGroupMetadata(result);
+    };
+
+    const groupFetchAllParticipating = async () => {
+        const result = await query({
+            tag: 'iq',
+            attrs: {
+                to: '@g.us',
+                xmlns: 'w:g2',
+                type: 'get',
+            },
+            content: [
+                {
+                    tag: 'participating',
+                    attrs: {},
+                    content: [
+                        { tag: 'participants', attrs: {} },
+                        { tag: 'description', attrs: {} }
+                    ]
+                }
+            ]
+        });
+
+        const data = {};
+        const groupsChild = WABinary_1.getBinaryNodeChild(result, 'groups');
+
+        if (groupsChild) {
+            const groups = WABinary_1.getBinaryNodeChildren(groupsChild, 'group');
+            for (const groupNode of groups) {
+                const meta = extractGroupMetadata({
+                    tag: 'result',
+                    attrs: {},
+                    content: [groupNode]
+                });
+                data[meta.id] = meta;
+            }
+        }
+
+        sock.ev.emit('groups.update', Object.values(data));
+        return data;
+    };
+
+    sock.ws.on('CB:ib,,dirty', async (node) => {
+        const { attrs } = WABinary_1.getBinaryNodeChild(node, 'dirty') || {};
+        if (!attrs || attrs.type !== 'groups') {
+            return;
+        }
+
+        await groupFetchAllParticipating();
+        await sock.cleanDirtyBits('groups');
+    });
+
+    return {
+        ...sock,
+        groupQuery,
+        groupMetadata,
+        groupCreate: async (subject, participants) => {
+            const key = Utils_1.generateMessageID();
+
+            const result = await groupQuery('@g.us', 'set', [
+                {
+                    tag: 'create',
+                    attrs: {
+                        subject,
+                        key
+                    },
+                    content: participants.map(jid => ({
+                        tag: 'participant',
+                        attrs: { jid }
+                    }))
+                }
+            ]);
+
+            return extractGroupMetadata(result);
+        },
+        groupLeave: async (id) => {
+            await groupQuery('@g.us', 'set', [
+                {
+                    tag: 'leave',
+                    attrs: {},
+                    content: [
+                        { tag: 'group', attrs: { id } }
+                    ]
+                }
+            ]);
+        },
+        groupUpdateSubject: async (jid, subject) => {
+            await groupQuery(jid, 'set', [
+                {
+                    tag: 'subject',
+                    attrs: {},
+                    content: Buffer.from(subject, 'utf-8')
+                }
+            ]);
+        },
+        groupRequestParticipantsList: async (jid) => {
+            const result = await groupQuery(jid, 'get', [
+                {
+                    tag: 'membership_approval_requests',
+                    attrs: {}
+                }
+            ]);
+
+            const node = WABinary_1.getBinaryNodeChild(result, 'membership_approval_requests');
+            const participants = WABinary_1.getBinaryNodeChildren(node, 'membership_approval_request');
+
+            return participants.map(v => v.attrs);
+        },
+        groupRequestParticipantsUpdate: async (jid, participants, action) => {
+            const result = await groupQuery(jid, 'set', [{
+                    tag: 'membership_requests_action',
+                    attrs: {},
+                    content: [
+                        {
+                            tag: action,
+                            attrs: {},
+                            content: participants.map(jid => ({
+                                tag: 'participant',
+                                attrs: { jid }
+                            }))
+                        }
+                    ]
+                }]);
+
+            const node = WABinary_1.getBinaryNodeChild(result, 'membership_requests_action');
+            const nodeAction = WABinary_1.getBinaryNodeChild(node, action);
+            const participantsAffected = WABinary_1.getBinaryNodeChildren(nodeAction, 'participant');
+
+            return participantsAffected.map(p => {
+                return { status: p.attrs.error || '200', jid: p.attrs.jid };
+            });
+        },
+        groupParticipantsUpdate: async (jid, participants, action) => {
+            const result = await groupQuery(jid, 'set', [
+                {
+                    tag: action,
+                    attrs: {},
+                    content: participants.map(jid => ({
+                        tag: 'participant',
+                        attrs: { jid }
+                    }))
+                }
+            ]);
+            const node = WABinary_1.getBinaryNodeChild(result, action);
+            const participantsAffected = WABinary_1.getBinaryNodeChildren(node, 'participant');
+
+            return participantsAffected.map(p => {
+                return { status: p.attrs.error || '200', jid: p.attrs.jid, content: p };
+            });
+        },
+        groupUpdateDescription: async (jid, description) => {
+            const metadata = await groupMetadata(jid);
+            const prev = metadata.descId ? metadata.descId : null;
+
+            await groupQuery(jid, 'set', [
+                {
+                    tag: 'description',
+                    attrs: {
+                        ...(description ? { id: Utils_1.generateMessageID() } : { delete: 'true' }),
+                        ...(prev ? { prev } : {})
+                    },
+                    content: description ? [
+                        { tag: 'body', attrs: {}, content: Buffer.from(description, 'utf-8') }
+                    ] : undefined
+                }
+            ]);
+        },
+        groupInviteCode: async (jid) => {
+            const result = await groupQuery(jid, 'get', [{ tag: 'invite', attrs: {} }]);
+            const inviteNode = WABinary_1.getBinaryNodeChild(result, 'invite');
+
+            return inviteNode?.attrs?.code;
+        },
+        groupRevokeInvite: async (jid) => {
+            const result = await groupQuery(jid, 'set', [{ tag: 'invite', attrs: {} }]);
+            const inviteNode = WABinary_1.getBinaryNodeChild(result, 'invite');
+
+            return inviteNode?.attrs?.code;
+        },
+        groupAcceptInvite: async (code) => {
+            const results = await groupQuery('@g.us', 'set', [{ tag: 'invite', attrs: { code } }]);
+            const result = WABinary_1.getBinaryNodeChild(results, 'group');
+
+            return result?.attrs?.jid;
+        },
+groupRevokeInviteV4: async (groupJid, invitedJid) => {
+    const result = await groupQuery(groupJid, 'set', [
+        { 
+            tag: 'revoke', 
+            attrs: {}, 
+            content: [{ tag: 'participant', attrs: { jid: invitedJid } }] 
+        }
+    ]);
+
+    return !!result;
+},
+        groupAcceptInviteV4: ev.createBufferedFunction(async (key, inviteMessage) => {
+            key = typeof key === 'string' ? { remoteJid: key } : key;
+            const results = await groupQuery(inviteMessage.groupJid, 'set', [{
+                    tag: 'accept',
+                    attrs: {
+                        code: inviteMessage.inviteCode,
+                        expiration: inviteMessage.inviteExpiration.toString(),
+                        admin: key.remoteJid
+                    }
+                }]);
+
+            if (key.id) {
+                inviteMessage = WAProto_1.proto.Message.GroupInviteMessage.fromObject(inviteMessage);
+                inviteMessage.inviteExpiration = 0;
+                inviteMessage.inviteCode = '';
+                ev.emit('messages.update', [
+                    {
+                        key,
+                        update: {
+                            message: {
+                                groupInviteMessage: inviteMessage
+                            }
+                        }
+                    }
+                ]);
+            }
+
+            await upsertMessage({
+                key: {
+                    remoteJid: inviteMessage.groupJid,
+                    id: Utils_1.generateMessageID(authState.creds.me?.id),
+                    fromMe: false,
+                    participant: key.remoteJid,
+                },
+                messageStubType: Types_1.WAMessageStubType.GROUP_PARTICIPANT_ADD,
+                messageStubParameters: [
+                    authState.creds.me.id
+                ],
+                participant: key.remoteJid,
+                messageTimestamp: Utils_1.unixTimestampSeconds()
+            }, 'notify');
+
+            return results.attrs.from;
+        }),
+        groupGetInviteInfo: async (code) => {
+            const results = await groupQuery('@g.us', 'get', [{ tag: 'invite', attrs: { code } }]);
+
+            return extractGroupMetadata(results);
+        },
+        groupToggleEphemeral: async (jid, ephemeralExpiration) => {
+            const content = ephemeralExpiration ?
+                { tag: 'ephemeral', attrs: { expiration: ephemeralExpiration.toString() } } :
+                { tag: 'not_ephemeral', attrs: {} };
+            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
+    };
+};
+
+const extractGroupMetadata = (result) => {
+    const group = WABinary_1.getBinaryNodeChild(result, 'group');
+    if (!group) return null;
+
+    const descChild = WABinary_1.getBinaryNodeChild(group, 'description');
+
+    let desc;
+    let descId;
+    let descOwner;
+    let descOwnerJid;
+    let descTime;
+
+    if (descChild) {
+        desc = WABinary_1.getBinaryNodeChildString(descChild, 'body');
+        descOwner = descChild.attrs.participant ? WABinary_1.jidNormalizedUser(descChild.attrs.participant) : undefined;
+        descOwnerJid = descChild.attrs.participant_pn ? WABinary_1.jidNormalizedUser(descChild.attrs.participant_pn) : undefined;
+        descTime = +descChild.attrs.t;
+        descId = descChild.attrs.id;
+    }
+
+    const groupId = group.attrs.id.includes('@') ? group.attrs.id : WABinary_1.jidEncode(group.attrs.id, 'g.us');
+    const eph = WABinary_1.getBinaryNodeChild(group, 'ephemeral')?.attrs?.expiration;
+    const memberAddMode = WABinary_1.getBinaryNodeChildString(group, 'member_add_mode') === 'all_member_add';
+
+    const participants = WABinary_1.getBinaryNodeChildren(group, 'participant').map(({ attrs }) => {
+        const isUserJid = WABinary_1.isJidUser(attrs.jid);
+        const isLidJid = WABinary_1.isLidUser && WABinary_1.isLidUser(attrs.jid); // Soporte condicional para LID
+        
+        return {
+            id: attrs.jid,
+            jid: isUserJid ? attrs.jid : (attrs.phone_number ? WABinary_1.jidNormalizedUser(attrs.phone_number) : undefined),
+            lid: isLidJid ? attrs.jid : attrs.lid,
+            admin: (attrs.type || null),
+        };
+    });
+
+
+    const metadata = {
+        id: groupId,
+        addressingMode: group.attrs.addressing_mode,
+        subject: group.attrs.subject,
+        subjectOwner: group.attrs.s_o,
+        subjectOwnerJid: group.attrs.s_o_pn,
+        subjectTime: +group.attrs.s_t,
+        size: participants.length,
+        creation: +group.attrs.creation,
+        owner: group.attrs.creator ? WABinary_1.jidNormalizedUser(group.attrs.creator) : undefined,
+        ownerJid: group.attrs.creator_pn ? WABinary_1.jidNormalizedUser(group.attrs.creator_pn) : undefined,
+        desc,
+        descId,
+        descOwner,
+        descOwnerJid,
+        descTime,
+        linkedParent: WABinary_1.getBinaryNodeChild(group, 'linked_parent')?.attrs?.jid || undefined,
+        restrict: !!WABinary_1.getBinaryNodeChild(group, 'locked'),
+        announce: !!WABinary_1.getBinaryNodeChild(group, 'announcement'),
+        isCommunity: !!WABinary_1.getBinaryNodeChild(group, 'parent'),
+        isCommunityAnnounce: !!WABinary_1.getBinaryNodeChild(group, 'default_sub_group'),
+        joinApprovalMode: !!WABinary_1.getBinaryNodeChild(group, 'membership_approval_mode'),
+        memberAddMode,
+        participants,
+        ephemeralDuration: eph ? +eph : undefined
+    };
+
+    return metadata;
+};
+
+exports.makeGroupsSocket = makeGroupsSocket;
+exports.extractGroupMetadata = extractGroupMetadata;

package/lib/Socket/index.d.ts

@@ -0,0 +1,183 @@
+import { UserFacingSocketConfig, ContactAction } from '../Types'
+declare const makeWASocket: (config: UserFacingSocketConfig) => {
+logger: import("../Utils/logger").ILogger
+getOrderDetails: (orderId: string, tokenBase64: string) => Promise<import("../Types").OrderDetails>
+getCatalog: ({ jid, limit, cursor }: import("../Types").GetCatalogOptions) => Promise<{
+products: import("../Types").Product[]
+nextPageCursor: string | undefined
+}>
+getCollections: (jid?: string | undefined, 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 | undefined) => 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").WAProto.IMessageKey, oldestMsgTimestamp: number | import("long").Long) => Promise<string>
+requestPlaceholderResend: (messageKey: import("../Types").WAProto.IMessageKey) => 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, useCachedGroupMetadata, statusJidList }: import("../Types").MessageRelayOptions) => Promise<string>
+sendReceipt: (jid: string, participant: string | undefined, messageIds: string[], type: import("../Types").MessageReceiptType) => Promise<void>
+sendReceipts: (keys: import("../Types").WAProto.IMessageKey[], type: import("../Types").MessageReceiptType) => Promise<void>
+readMessages: (keys: import("../Types").WAProto.IMessageKey[]) => Promise<void>
+refreshMediaConn: (forceGet?: boolean) => Promise<import("../Types").MediaConnInfo>
+waUploadToServer: import("../Types").WAMediaUploadFunction
+fetchPrivacySettings: (force?: boolean) => Promise<{
+[_: string]: string
+}>
+sendPeerDataOperationMessage: (pdoMessage: import("../Types").WAProto.Message.IPeerDataOperationRequestMessage) => Promise<string>
+createParticipantNodes: (jids: string[], message: import("../Types").WAProto.IMessage, extraAttrs?: {
+[key: string]: string
+} | undefined) => Promise<{
+nodes: import("..").BinaryNode[]
+shouldIncludeDeviceIdentity: boolean
+}>
+profilePictureUrl: (jids: string) => Promise<string>
+getUSyncDevices: (jids: string[], useCache: boolean, ignoreZeroDevices: boolean) => Promise<import("..").JidWithDevice[]>
+updateMediaMessage: (message: import("../Types").WAProto.IWebMessageInfo) => Promise<import("../Types").WAProto.IWebMessageInfo>
+sendStatusMentions: (content: import("../Types").WAProto.IMessage, jid: string, Private?: boolean) => Promise<string>
+sendAlbumMessage: (jid: string, medias: import("../Types").WAProto.IMessage, options?: import("../Types").MiscMessageGenerationOptions) => Promise<string>
+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 | undefined) => 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>
+newsletterCreate: (name: string, description?: string, picture?: import("../Types").WAMediaUpload) => Promise<import("../Types").NewsletterMetadata>
+newsletterQuery: (jid: string, type: string, content: BinaryNode) => Promise<BinaryNode>
+newsletterWMexQuery: (jid?: string | undefined, query_id: number, content: BinaryNode) => Promise<BinaryNode>
+newsletterMetadata: (type: "invite" | "jid", key: string, role?: import("../Types").NewsletterViewRole | undefined) => Promise<import("../Types").NewsletterMetadata>
+newsletterAdminCount: (jid: string) => Promise<number>
+newsletterChangeOwner: (jid: string, userLid: string) => Promise<void>
+newsletterDemote: (jid: string, userLid: string) => Promise<void>
+newsletterDelete: (jid: string) => Promise<void>
+newsletterReactMessage: (jid: string, server_id: string, code?: string | undefined) => Promise<void>
+newsletterFetchMessages: (type: "invite" | "jid", key: string, count: number, after?: number | undefined) => Promise<import("../Types").NewsletterFetchedUpdate[]>
+newsletterFetchUpdates: (jid: string, count: number, after?: number | undefined, since?: number | undefined) => Promise<import("../Types").NewsletterFetchedUpdate[]>
+groupQuery: (jid: string, type: string, content: BinaryNode) => Promise<BinaryNode>
+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: "reject" | "approve") => 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 | undefined) => 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("../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" | "locked" | "not_announcement" | "unlocked") => Promise<void>
+groupMemberAddMode: (jid: string, mode: "all_member_add" | "admin_add") => Promise<void>
+groupJoinApprovalMode: (jid: string, mode: "on" | "off") => Promise<void>
+groupFetchAllParticipating: () => Promise<{
+[_: string]: import("../Types").GroupMetadata
+}>
+processingMutex: {
+mutex<T>(code: () => T | Promise<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 | undefined) => Promise<void>
+presenceSubscribe: (toJid: string, tcToken?: Buffer | undefined) => Promise<void>    
+getBotListV2: () => Promise<BotListInfo[]>
+getLidUser: (jid: string) => Promise<{
+lid: string
+id: string
+}[] | undefined>
+onWhatsApp: (...jids: string[]) => Promise<{
+jid: string
+exists: unknown
+}[] | undefined>
+fetchBlocklist: () => Promise<string[]>
+fetchStatus: (...jids: string[]) => Promise<import("..").USyncQueryResultList[] | undefined>
+fetchDisappearingDuration: (...jids: string[]) => Promise<import("..").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>
+updateCallPrivacy: (value: import("../Types").WAPrivacyCallValue) => 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<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>
+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>
+removeMessageLabel: (jid: string, messageId: string, labelId: string) => Promise<void>
+clearMessage: (jid: string, key: import("../Types").WAProto.IMessageKey, timeStamp: number | import("long").Long) => Promise<void>
+star: (jid: string, messages: {
+id: string
+fromMe?: boolean | undefined
+}[], star: boolean) => Promise<void>
+addOrEditContact: (jid: string, contact: ContactAction) => Promise<void>
+removeContact: (jid: string) => Promise<void>
+executeUSyncQuery: (usyncQuery: import("..").USyncQuery) => Promise<import("..").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_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: import("..").BinaryNode, timeoutMs?: number | undefined) => Promise<import("..").BinaryNode>
+waitForMessage: <T_2>(msgId: string, timeoutMs?: number | undefined) => Promise<T_2>
+waitForSocketOpen: () => Promise<void>
+sendRawMessage: (data: Uint8Array | Buffer) => Promise<void>
+sendNode: (frame: import("..").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, code?: string) => Promise<string>
+waitForConnectionUpdate: (check: (u: Partial<import("../Types").ConnectionState>) => boolean | undefined, timeoutMs?: number | undefined) => Promise<void>
+sendWAMBuffer: (wamBuffer: Buffer) => Promise<import("..").BinaryNode>
+}
+export default makeWASocket

package/lib/Socket/index.js

@@ -0,0 +1,10 @@
+"use strict"
+Object.defineProperty(exports, "__esModule", { value: true })
+const Defaults_1 = require("../Defaults")
+const business_1 = require("./business")
+// export the last socket layer
+const makeWASocket = (config) => (business_1.makeBusinessSocket({
+...Defaults_1.DEFAULT_CONNECTION_CONFIG,
+...config
+}))
+exports.default = makeWASocket