trompot 1.0.0

package/lib/wa/WhatsAppBot.js

@@ -0,0 +1,980 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const baileys_1 = __importStar(require("@whiskeysockets/baileys"));
+const node_cache_1 = __importDefault(require("node-cache"));
+const pino_1 = __importDefault(require("pino"));
+const long_1 = __importDefault(require("long"));
+const messages_1 = require("../messages");
+const Generic_1 = require("../utils/Generic");
+const Auth_1 = require("./Auth");
+const Message_1 = require("../messages/Message");
+const ConvertToWAMessage_1 = __importDefault(require("./ConvertToWAMessage"));
+const makeInMemoryStore_1 = __importDefault(require("./makeInMemoryStore"));
+const ConfigWAEvents_1 = __importDefault(require("./ConfigWAEvents"));
+const ID_1 = require("./ID");
+const BotStatus_1 = require("../bot/BotStatus");
+const ChatType_1 = __importDefault(require("../modules/chat/ChatType"));
+const BotEvents_1 = __importDefault(require("../bot/BotEvents"));
+const WAStatus_1 = require("./WAStatus");
+const User_1 = __importDefault(require("../modules/user/User"));
+const Chat_1 = __importDefault(require("../modules/chat/Chat"));
+class WhatsAppBot extends BotEvents_1.default {
+    constructor(config) {
+        super();
+        //@ts-ignore
+        this.sock = {};
+        this.auth = new Auth_1.MultiFileAuthState('./session', undefined, false);
+        this.messagesCached = [];
+        this.msgRetryCountercache = new node_cache_1.default({
+            stdTTL: baileys_1.DEFAULT_CACHE_TTLS.MSG_RETRY, // 1 hour
+            useClones: false,
+        });
+        this.saveCreds = (creds) => new Promise((res) => res);
+        this.connectionListeners = [];
+        this.DisconnectReason = baileys_1.DisconnectReason;
+        this.logger = (0, pino_1.default)({ level: 'silent' });
+        this.id = '';
+        this.status = BotStatus_1.BotStatus.Offline;
+        this.phoneNumber = '';
+        this.name = '';
+        this.profileUrl = '';
+        this.lastConnectionUpdateDate = Date.now();
+        this.checkConnectionInterval = null;
+        this.configEvents = new ConfigWAEvents_1.default(this);
+        this.groupMetadataCache = new node_cache_1.default();
+        const store = (0, makeInMemoryStore_1.default)({ logger: this.logger });
+        this.store = store;
+        const waBot = this;
+        this.config = {
+            ...baileys_1.DEFAULT_CONNECTION_CONFIG,
+            logger: this.logger,
+            qrTimeout: 60000,
+            defaultQueryTimeoutMs: 10000,
+            retryRequestDelayMs: 500,
+            maxMsgRetryCount: 5,
+            readAllFailedMessages: false,
+            msgRetryCounterCache: this.msgRetryCountercache,
+            autoRestartInterval: 1000 * 60 * 30, // 30 minutes (recommended)
+            useExperimentalServers: false,
+            autoSyncHistory: false,
+            autoLoadContactInfo: false,
+            autoLoadGroupInfo: false,
+            shouldIgnoreJid: () => false,
+            async patchMessageBeforeSending(msg) {
+                var _a, _b, _c, _d;
+                if (((_c = (_b = (_a = msg.deviceSentMessage) === null || _a === void 0 ? void 0 : _a.message) === null || _b === void 0 ? void 0 : _b.listMessage) === null || _c === void 0 ? void 0 : _c.listType) ==
+                    baileys_1.proto.Message.ListMessage.ListType.PRODUCT_LIST) {
+                    msg = JSON.parse(JSON.stringify(msg));
+                    msg.deviceSentMessage.message.listMessage.listType =
+                        baileys_1.proto.Message.ListMessage.ListType.SINGLE_SELECT;
+                }
+                if (((_d = msg.listMessage) === null || _d === void 0 ? void 0 : _d.listType) ==
+                    baileys_1.proto.Message.ListMessage.ListType.PRODUCT_LIST) {
+                    msg = JSON.parse(JSON.stringify(msg));
+                    msg.listMessage.listType =
+                        baileys_1.proto.Message.ListMessage.ListType.SINGLE_SELECT;
+                }
+                return msg;
+            },
+            async getMessage(key) {
+                var _a;
+                return (((_a = (await waBot.store.loadMessage((0, ID_1.fixID)(key.remoteJid), key.id))) === null || _a === void 0 ? void 0 : _a.message) || undefined);
+            },
+            cachedGroupMetadata: async (jid) => this.groupMetadataCache.get(jid),
+            ...config,
+        };
+        delete this.config.auth;
+        // Listeners de eventos Baileys
+        setTimeout(() => {
+            if (this.sock && this.sock.ev) {
+                this.sock.ev.on('messages.upsert', async ({ type, messages }) => {
+                    // Exemplo: processa todas as mensagens recebidas
+                    for (const msg of messages) {
+                        // Aqui você pode converter proto.IMessage para Message do Rompot
+                        // e emitir eventos ou chamar handlers do seu fluxo
+                        // Exemplo:
+                        // const rompotMsg = await ConvertWAMessage.fromBaileys(this, msg, type);
+                        // this.emit('message', rompotMsg);
+                    }
+                });
+                this.sock.ev.on('messages.update', (updates) => {
+                    // Handler para mensagens editadas, deletadas, etc.
+                });
+                this.sock.ev.on('messages.delete', (deletes) => {
+                    // Handler para deleção de mensagens
+                });
+                this.sock.ev.on('messages.reaction', (reaction) => {
+                    // Handler para reações em mensagens
+                });
+                // Listener para histórico de mensagens (history sync)
+                this.sock.ev.on('messaging-history.set', async ({ chats, contacts, messages, syncType }) => {
+                    // Armazena chats
+                    if (chats && Array.isArray(chats)) {
+                        for (const chat of chats) {
+                            await this.auth.set(`chats-${chat.id}`, chat);
+                        }
+                    }
+                    // Armazena contatos
+                    if (contacts && Array.isArray(contacts)) {
+                        for (const contact of contacts) {
+                            await this.auth.set(`users-${contact.id}`, contact);
+                        }
+                    }
+                    // Armazena mensagens
+                    if (messages && Array.isArray(messages)) {
+                        for (const msg of messages) {
+                            if (msg.key && msg.key.id && msg.key.remoteJid) {
+                                await this.store.saveMessage(msg.key.remoteJid, msg, false);
+                            }
+                        }
+                    }
+                    // Você pode emitir eventos ou processar syncType conforme necessário
+                });
+                // Exibe QR code no terminal ao receber
+                this.sock.ev.on('connection.update', async (update) => {
+                    const { qr } = update;
+                    if (qr) {
+                        try {
+                            const QRCode = (await Promise.resolve().then(() => __importStar(require('qrcode')))).default;
+                            // Exibe o QR code no terminal
+                            console.log(await QRCode.toString(qr, { type: 'terminal' }));
+                        }
+                        catch (err) {
+                            console.log('QRCode:', qr);
+                        }
+                    }
+                });
+            }
+        }, 0);
+    }
+    async connect(auth) {
+        var _a, _b, _c;
+        if (!auth || typeof auth == 'string') {
+            this.auth = new Auth_1.MultiFileAuthState(`${auth || './session'}`);
+        }
+        else {
+            this.auth = auth;
+        }
+        if (!this.auth.botPhoneNumber) {
+            await this.internalConnect({ browser: baileys_1.Browsers.windows('Rompot') });
+        }
+        else {
+            await this.internalConnect({
+                browser: ['Chrome (linux)', 'Rompot', '22.5.0'],
+            });
+            if (!((_c = (_b = (_a = this.sock) === null || _a === void 0 ? void 0 : _a.authState) === null || _b === void 0 ? void 0 : _b.creds) === null || _c === void 0 ? void 0 : _c.registered)) {
+                await this.sock.waitForConnectionUpdate(async (update) => Promise.resolve(!!update.qr));
+                const code = await this.sock.requestPairingCode(this.auth.botPhoneNumber);
+                this.emit('code', code);
+            }
+        }
+        await this.awaitConnectionState('open');
+    }
+    async internalConnect(additionalOptions = {}) {
+        return new Promise(async (resolve, reject) => {
+            try {
+                const { state, saveCreds } = await (0, Auth_1.getBaileysAuth)(this.auth);
+                this.saveCreds = saveCreds;
+                this.sock = (0, baileys_1.default)({
+                    auth: {
+                        creds: state.creds,
+                        keys: (0, baileys_1.makeCacheableSignalKeyStore)(state.keys, this.config.logger || this.logger),
+                    },
+                    ...additionalOptions,
+                    ...this.config,
+                });
+                this.store.bind(this.sock.ev);
+                this.configEvents.configureAll();
+                resolve();
+                await this.awaitConnectionState('open');
+                this.sock.ev.on('creds.update', saveCreds);
+            }
+            catch (err) {
+                this.ev.emit('error', err);
+            }
+        });
+    }
+    /**
+     * * Reconecta ao servidor do WhatsApp
+     * @returns
+     */
+    async reconnect(stopEvents = false, showOpen) {
+        if (stopEvents) {
+            this.eventsIsStoped = true;
+            let state = this.status == BotStatus_1.BotStatus.Online ? 'close' : 'connecting';
+            let status = baileys_1.DisconnectReason.connectionClosed;
+            let retryCount = 0;
+            this.connectionListeners.push((update) => {
+                var _a, _b, _c, _d, _e, _f, _g, _h;
+                if (!update.connection)
+                    return false;
+                if (retryCount >= 3) {
+                    this.eventsIsStoped = false;
+                    return true;
+                }
+                if (update.connection != state) {
+                    if (update.connection == 'close') {
+                        state = 'connecting';
+                        status =
+                            ((_c = (_b = (_a = update.lastDisconnect) === null || _a === void 0 ? void 0 : _a.error) === null || _b === void 0 ? void 0 : _b.output) === null || _c === void 0 ? void 0 : _c.statusCode) ||
+                                ((_d = update.lastDisconnect) === null || _d === void 0 ? void 0 : _d.error) ||
+                                baileys_1.DisconnectReason.connectionClosed;
+                        retryCount++;
+                    }
+                    else {
+                        this.eventsIsStoped = false;
+                        if (state == 'connecting') {
+                            this.emit('close', { reason: status });
+                        }
+                        else if (state == 'open') {
+                            this.emit('close', { reason: status });
+                            this.emit('connecting', {});
+                        }
+                    }
+                    return true;
+                }
+                if (state == 'close') {
+                    state = 'connecting';
+                    status =
+                        ((_g = (_f = (_e = update.lastDisconnect) === null || _e === void 0 ? void 0 : _e.error) === null || _f === void 0 ? void 0 : _f.output) === null || _g === void 0 ? void 0 : _g.statusCode) ||
+                            ((_h = update.lastDisconnect) === null || _h === void 0 ? void 0 : _h.error) ||
+                            baileys_1.DisconnectReason.connectionClosed;
+                }
+                else if (state == 'connecting') {
+                    state = 'open';
+                }
+                else if (state == 'open' && showOpen) {
+                    this.eventsIsStoped = !showOpen;
+                    return true;
+                }
+                return false;
+            });
+        }
+        await this.stop();
+        this.emit('reconnecting', {});
+        await this.internalConnect();
+    }
+    /**
+     * * Desliga a conexão com o servidor do WhatsApp
+     * @param reason
+     * @returns
+     */
+    async stop(reason = 402) {
+        var _a;
+        try {
+            this.status = BotStatus_1.BotStatus.Offline;
+            (_a = this.sock) === null || _a === void 0 ? void 0 : _a.end(reason);
+        }
+        catch (err) {
+            this.emit('error', err);
+        }
+    }
+    async logout() {
+        var _a;
+        await ((_a = this.sock) === null || _a === void 0 ? void 0 : _a.logout());
+    }
+    /**
+     * * Aguarda um status de conexão
+     */
+    async awaitConnectionState(connection) {
+        return new Promise((res) => {
+            this.connectionListeners.push((update) => {
+                if (update.connection != connection)
+                    return false;
+                res(update);
+                return true;
+            });
+        });
+    }
+    /**
+     * * Lê o chat
+     * @param chat Sala de bate-papo
+     */
+    async readChat(chat, metadata, updateMetadata = true) {
+        try {
+            if (!chat.id || !(chat.id.includes('@s') || chat.id.includes('@g')))
+                return;
+            chat.type = (0, baileys_1.isJidGroup)(chat.id) ? ChatType_1.default.Group : ChatType_1.default.PV;
+            if (chat.type == ChatType_1.default.Group) {
+                if (updateMetadata) {
+                    chat.profileUrl =
+                        (await this.getChatProfileUrl(new Chat_1.default(chat.id))) || undefined;
+                    if (!metadata) {
+                        try {
+                            metadata = await this.sock.groupMetadata(chat.id);
+                        }
+                        catch (_a) { }
+                    }
+                    else if (!metadata.participants) {
+                        try {
+                            metadata = {
+                                ...metadata,
+                                ...(await this.sock.groupMetadata(chat.id)),
+                            };
+                        }
+                        catch (_b) { }
+                        if (metadata.participant) {
+                            metadata.participants = [
+                                ...(metadata.participants || []),
+                                ...metadata.participant.map((p) => {
+                                    return {
+                                        id: p.userJid,
+                                        isSuperAdmin: p.rank == baileys_1.proto.GroupParticipant.Rank.SUPERADMIN,
+                                        isAdmin: p.rank == baileys_1.proto.GroupParticipant.Rank.ADMIN,
+                                    };
+                                }),
+                            ];
+                        }
+                    }
+                }
+                if (metadata === null || metadata === void 0 ? void 0 : metadata.participants) {
+                    chat.users = [];
+                    chat.admins = [];
+                    for (const p of metadata.participants) {
+                        chat.users.push(p.id);
+                        if (p.admin == 'admin' || p.isAdmin) {
+                            chat.admins.push(`${p.id}`);
+                        }
+                        else if (p.isSuperAdmin) {
+                            chat.leader = p.id;
+                            chat.admins.push(`${p.id}`);
+                        }
+                    }
+                }
+                if (metadata === null || metadata === void 0 ? void 0 : metadata.subjectOwner) {
+                    chat.leader = metadata.subjectOwner;
+                }
+            }
+            if ((metadata === null || metadata === void 0 ? void 0 : metadata.subject) || (metadata === null || metadata === void 0 ? void 0 : metadata.name)) {
+                chat.name = metadata.subject || metadata.name || undefined;
+            }
+            if ((metadata === null || metadata === void 0 ? void 0 : metadata.desc) || (metadata === null || metadata === void 0 ? void 0 : metadata.description)) {
+                chat.description = metadata.desc || metadata.description || undefined;
+            }
+            if (metadata === null || metadata === void 0 ? void 0 : metadata.unreadCount) {
+                chat.unreadCount = metadata.unreadCount || undefined;
+            }
+            if (metadata === null || metadata === void 0 ? void 0 : metadata.conversationTimestamp) {
+                if (long_1.default.isLong(metadata.conversationTimestamp)) {
+                    chat.timestamp = metadata.conversationTimestamp.toNumber() * 1000;
+                }
+                else {
+                    chat.timestamp = Number(metadata.conversationTimestamp) * 1000;
+                }
+            }
+            await this.updateChat({ id: chat.id, ...chat });
+        }
+        catch (_c) { }
+    }
+    /**
+     * * Lê o usuário
+     * @param user Usuário
+     */
+    async readUser(user, metadata) {
+        try {
+            if (!user.id || !user.id.includes('@s'))
+                return;
+            if (metadata === null || metadata === void 0 ? void 0 : metadata.imgUrl) {
+                user.profileUrl = await this.getUserProfileUrl(new User_1.default(user.id));
+            }
+            else {
+                const userData = await this.getUser(new User_1.default(user.id || ''));
+                if (userData == null || !userData.profileUrl) {
+                    user.profileUrl = await this.getUserProfileUrl(new User_1.default(user.id));
+                }
+            }
+            if ((metadata === null || metadata === void 0 ? void 0 : metadata.notify) || (metadata === null || metadata === void 0 ? void 0 : metadata.verifiedName)) {
+                user.name = (metadata === null || metadata === void 0 ? void 0 : metadata.notify) || (metadata === null || metadata === void 0 ? void 0 : metadata.verifiedName);
+            }
+            if (metadata === null || metadata === void 0 ? void 0 : metadata.name) {
+                user.savedName = metadata.name;
+            }
+            user.name = user.name || user.savedName;
+            await this.updateUser({ id: user.id || '', ...user });
+        }
+        catch (err) {
+            this.emit('error', err);
+        }
+    }
+    /**
+     * Obtem uma mensagem de enquete.
+     * @param pollMessageId - ID da mensagem de enquete que será obtida.
+     * @returns A mensagem de enquete salva.
+     */
+    async getPollMessage(pollMessageId) {
+        const pollMessage = await this.auth.get(`polls-${pollMessageId}`);
+        if (!pollMessage || !messages_1.PollMessage.isValid(pollMessage))
+            return messages_1.PollMessage.fromJSON({ id: pollMessageId });
+        if (pollMessage.type == Message_1.MessageType.PollUpdate) {
+            return messages_1.PollUpdateMessage.fromJSON(pollMessage);
+        }
+        return messages_1.PollMessage.fromJSON(pollMessage);
+    }
+    /**
+     * Salva a mensagem de enquete.
+     * @param pollMessage - Mensagem de enquete que será salva.
+     */
+    async savePollMessage(pollMessage) {
+        await this.auth.set(`polls-${pollMessage.id}`, pollMessage.toJSON());
+    }
+    /**
+     * * Trata atualizações de participantes
+     * @param action Ação realizada
+     * @param chatId Sala de bate-papo que a ação foi realizada
+     * @param userId Usuário que foi destinado a ação
+     * @param fromId Usuário que realizou a ação
+     */
+    async groupParticipantsUpdate(action, chatId, userId, fromId) {
+        if (!chatId.includes('@g'))
+            return;
+        const event = action == 'join' ? 'add' : action == 'leave' ? 'remove' : action;
+        let chat = await this.getChat(new Chat_1.default(chatId));
+        if (!chat) {
+            if (!this.config.autoLoadGroupInfo)
+                return;
+            chat = Chat_1.default.fromJSON({
+                id: chatId,
+                phoneNumber: (0, ID_1.getPhoneNumber)(chatId),
+                type: ChatType_1.default.Group,
+            });
+        }
+        const fromUser = (await this.getUser(new User_1.default(fromId))) ||
+            User_1.default.fromJSON({ id: fromId, phoneNumber: (0, ID_1.getPhoneNumber)(fromId) });
+        const user = (await this.getUser(new User_1.default(userId))) ||
+            User_1.default.fromJSON({ id: userId, phoneNumber: (0, ID_1.getPhoneNumber)(userId) });
+        let users = chat.users || [];
+        const admins = chat.admins || [];
+        if (event == 'add')
+            users.push(user.id);
+        if (event == 'remove')
+            users = users.filter((u) => u != user.id);
+        if (event == 'demote')
+            chat.admins = admins.filter((admin) => admin != user.id);
+        if (event == 'promote')
+            admins.push(user.id);
+        chat.users = users;
+        chat.admins = admins;
+        if (user.id == this.id) {
+            if (event == 'remove')
+                await this.removeChat(chat);
+            if (event == 'add')
+                await this.updateChat(chat);
+        }
+        else {
+            await this.updateChat(chat);
+        }
+        this.ev.emit('user', { action, event, user, fromUser, chat });
+    }
+    //! ********************************* CHAT *********************************
+    async getChatName(chat) {
+        var _a;
+        return ((_a = (await this.getChat(chat))) === null || _a === void 0 ? void 0 : _a.name) || '';
+    }
+    async setChatName(chat, name) {
+        if (!(0, baileys_1.isJidGroup)(chat.id))
+            return;
+        const admins = await this.getChatAdmins(chat);
+        if (admins.length && !admins.includes(this.id))
+            return;
+        await this.sock.groupUpdateSubject(chat.id, name);
+    }
+    async getChatDescription(chat) {
+        var _a;
+        return ((_a = (await this.getChat(chat))) === null || _a === void 0 ? void 0 : _a.description) || '';
+    }
+    async setChatDescription(chat, description) {
+        if (!(0, baileys_1.isJidGroup)(chat.id))
+            return;
+        const admins = await this.getChatAdmins(chat);
+        if (admins.length && !admins.includes(this.id))
+            return;
+        await this.sock.groupUpdateDescription(chat.id, description);
+    }
+    async getChatProfile(chat, lowQuality) {
+        const uri = await this.getChatProfileUrl(chat, lowQuality);
+        return await (0, Generic_1.getImageURL)(uri);
+    }
+    async getChatProfileUrl(chat, lowQuality) {
+        try {
+            return ((await this.sock.profilePictureUrl(chat.id, lowQuality ? 'preview' : 'image')) || '');
+        }
+        catch (_a) {
+            return '';
+        }
+    }
+    async setChatProfile(chat, image) {
+        if (!(0, baileys_1.isJidGroup)(chat.id))
+            return;
+        const admins = await this.getChatAdmins(chat);
+        if (admins.length && !admins.includes(this.id))
+            return;
+        await this.sock.updateProfilePicture(chat.id, image);
+    }
+    async updateChat(chat) {
+        const chatData = await this.getChat(new Chat_1.default(chat.id));
+        if (chatData != null) {
+            chat = Object.keys(chat).reduce((data, key) => {
+                if (chat[key] == undefined || chat[key] == null)
+                    return data;
+                if ((0, Generic_1.verifyIsEquals)(chat[key], chatData[key]))
+                    return data;
+                return { ...data, [key]: chat[key] };
+            }, { id: chat.id });
+            if (Object.keys(chat).length < 2)
+                return;
+        }
+        const newChat = Chat_1.default.fromJSON({ ...(chatData || {}), ...chat });
+        newChat.type = (0, baileys_1.isJidGroup)(chat.id) ? ChatType_1.default.Group : ChatType_1.default.PV;
+        newChat.phoneNumber = newChat.phoneNumber || (0, ID_1.getPhoneNumber)(chat.id);
+        await this.auth.set(`chats-${chat.id}`, newChat.toJSON());
+        this.ev.emit('chat', { action: chatData != null ? 'update' : 'add', chat });
+    }
+    async removeChat(chat) {
+        await this.auth.remove(`chats-${chat.id}`);
+        this.ev.emit('chat', { action: 'remove', chat });
+    }
+    async getChat(chat) {
+        const chatData = await this.auth.get(`chats-${chat.id}`);
+        if (!chatData)
+            return null;
+        if (!chat.name || !chat.profileUrl) {
+            const user = await this.getUser(new User_1.default(chat.id));
+            if (user != null) {
+                return Chat_1.default.fromJSON({ ...chat, ...user });
+            }
+        }
+        return Chat_1.default.fromJSON(chatData);
+    }
+    async getChats() {
+        return (await this.auth.listAll('chats-')).map((id) => id.replace('chats-', ''));
+    }
+    async setChats(chats) {
+        await Promise.all(chats.map(async (chat) => await this.updateChat(chat)));
+    }
+    async getChatUsers(chat) {
+        var _a;
+        return ((_a = (await this.getChat(chat))) === null || _a === void 0 ? void 0 : _a.users) || [];
+    }
+    async getChatAdmins(chat) {
+        var _a, _b;
+        const chatReaded = await this.getChat(chat);
+        if (!chatReaded)
+            return [];
+        if ((_a = chatReaded.admins) === null || _a === void 0 ? void 0 : _a.length) {
+            return chatReaded.admins || [];
+        }
+        if (chatReaded.type !== ChatType_1.default.Group)
+            return [];
+        await this.readChat(chat);
+        return ((_b = (await this.getChat(chat))) === null || _b === void 0 ? void 0 : _b.admins) || [];
+    }
+    async getChatLeader(chat) {
+        var _a;
+        return ((_a = (await this.getChat(chat))) === null || _a === void 0 ? void 0 : _a.leader) || '';
+    }
+    async addUserInChat(chat, user) {
+        if (!(0, baileys_1.isJidGroup)(chat.id))
+            return;
+        const admins = await this.getChatAdmins(chat);
+        if (admins.length && !admins.includes(this.id))
+            return;
+        await this.sock.groupParticipantsUpdate(chat.id, [user.id], 'add');
+    }
+    async removeUserInChat(chat, user) {
+        if (!(0, baileys_1.isJidGroup)(chat.id))
+            return;
+        const admins = await this.getChatAdmins(chat);
+        if (admins.length && !admins.includes(this.id))
+            return;
+        await this.sock.groupParticipantsUpdate(chat.id, [user.id], 'remove');
+    }
+    async promoteUserInChat(chat, user) {
+        if (!(0, baileys_1.isJidGroup)(chat.id))
+            return;
+        const admins = await this.getChatAdmins(chat);
+        if (admins.length && !admins.includes(this.id))
+            return;
+        await this.sock.groupParticipantsUpdate(chat.id, [user.id], 'promote');
+    }
+    async demoteUserInChat(chat, user) {
+        if (!(0, baileys_1.isJidGroup)(chat.id))
+            return;
+        const admins = await this.getChatAdmins(chat);
+        if (admins.length && !admins.includes(this.id))
+            return;
+        await this.sock.groupParticipantsUpdate(chat.id, [user.id], 'demote');
+    }
+    async changeChatStatus(chat, status) {
+        await this.sock.sendPresenceUpdate(WAStatus_1.WAStatus[status] || 'available', chat.id);
+    }
+    async createChat(chat) {
+        await this.sock.groupCreate(chat.name || '', [this.id]);
+    }
+    async leaveChat(chat) {
+        if (!(0, baileys_1.isJidGroup)(chat.id))
+            return;
+        if ((await this.getChat(chat)) == null)
+            return;
+        await this.sock.groupLeave(chat.id);
+        await this.removeChat(chat);
+    }
+    async joinChat(code) {
+        await this.sock.groupAcceptInvite(code.replace('https://chat.whatsapp.com/', ''));
+    }
+    async getChatInvite(chat) {
+        if (!(0, baileys_1.isJidGroup)(chat.id))
+            return '';
+        // TODO: Return undefined if user is not admin
+        const admins = await this.getChatAdmins(chat);
+        if (admins.length && !admins.includes(this.id))
+            return '';
+        return (await this.sock.groupInviteCode(chat.id)) || '';
+    }
+    async revokeChatInvite(chat) {
+        if (!(0, baileys_1.isJidGroup)(chat.id))
+            return '';
+        const admins = await this.getChatAdmins(chat);
+        if (admins.length && !admins.includes(this.id))
+            return '';
+        return (await this.sock.groupRevokeInvite(chat.id)) || '';
+    }
+    async rejectCall(call) {
+        await this.sock.rejectCall(call.id, call.chat.id);
+    }
+    async getUserName(user) {
+        var _a;
+        return ((_a = (await this.getUser(user))) === null || _a === void 0 ? void 0 : _a.name) || '';
+    }
+    async setUserName(user, name) {
+        if (user.id != this.id)
+            return;
+        await this.setBotName(name);
+    }
+    async getUserDescription(user) {
+        // O método fetchStatus não existe na API pública do Baileys
+        // return (await this.sock.fetchStatus(String(user.id)))[0]?.status || '';
+        throw new Error('getUserDescription não implementado: fetchStatus não disponível na API do Baileys');
+    }
+    async setUserDescription(user, description) {
+        if (user.id != this.id)
+            return;
+        await this.setBotDescription(description);
+    }
+    async getUserProfile(user, lowQuality) {
+        const uri = await this.getUserProfileUrl(user, lowQuality);
+        return await (0, Generic_1.getImageURL)(uri);
+    }
+    async getUserProfileUrl(user, lowQuality) {
+        try {
+            return ((await this.sock.profilePictureUrl(user.id, lowQuality ? 'preview' : 'image')) || '');
+        }
+        catch (_a) {
+            return '';
+        }
+    }
+    async setUserProfile(user, image) {
+        if (user.id != this.id)
+            return;
+        await this.setBotProfile(image);
+    }
+    async getUser(user) {
+        const userData = await this.auth.get(`users-${user.id}`);
+        if (!userData)
+            return null;
+        return User_1.default.fromJSON(userData);
+    }
+    async getUsers() {
+        return (await this.auth.listAll('users-')).map((id) => id.replace('users-', ''));
+    }
+    async updateUser(user) {
+        const userData = await this.getUser(new User_1.default(user.id));
+        if (userData != null) {
+            user = Object.keys(user).reduce((data, key) => {
+                if (user[key] == undefined || user[key] == null)
+                    return data;
+                if ((0, Generic_1.verifyIsEquals)(user[key], userData[key]))
+                    return data;
+                return { ...data, [key]: user[key] };
+            }, { id: user.id });
+            if (Object.keys(user).length < 2)
+                return;
+        }
+        const newUser = User_1.default.fromJSON({ ...(userData || {}), ...user });
+        newUser.phoneNumber = newUser.phoneNumber || (0, ID_1.getPhoneNumber)(user.id);
+        await this.auth.set(`users-${user.id}`, newUser.toJSON());
+    }
+    async setUsers(users) {
+        await Promise.all(users.map(async (user) => await this.updateUser(user)));
+    }
+    async removeUser(user) {
+        await this.auth.remove(`users-${user.id}`);
+    }
+    async blockUser(user) {
+        if (user.id == this.id)
+            return;
+        await this.sock.updateBlockStatus(user.id, 'block');
+    }
+    async unblockUser(user) {
+        if (user.id == this.id)
+            return;
+        await this.sock.updateBlockStatus(user.id, 'unblock');
+    }
+    //! ******************************** BOT ********************************
+    async getBotName() {
+        return await this.getUserName(new User_1.default(this.id));
+    }
+    async setBotName(name) {
+        await this.sock.updateProfileName(name);
+    }
+    async getBotDescription() {
+        return await this.getUserDescription(new User_1.default(this.id));
+    }
+    async setBotDescription(description) {
+        await this.sock.updateProfileStatus(description);
+    }
+    async getBotProfile(lowQuality) {
+        return await this.getUserProfile(new User_1.default(this.id), lowQuality);
+    }
+    async getBotProfileUrl(lowQuality) {
+        return (await this.getUserProfileUrl(new User_1.default(this.id), lowQuality)) || '';
+    }
+    async setBotProfile(image) {
+        await this.sock.updateProfilePicture(this.id, image);
+    }
+    //! ******************************* MESSAGE *******************************
+    async readMessage(message) {
+        const key = {
+            remoteJid: message.chat.id,
+            id: message.id || '',
+            fromMe: message.fromMe || message.user.id == this.id,
+            participant: (0, baileys_1.isJidGroup)(message.chat.id)
+                ? message.user.id || this.id || undefined
+                : undefined,
+            toJSON: () => key,
+        };
+        const chat = await this.getChat(message.chat);
+        if ((chat === null || chat === void 0 ? void 0 : chat.type) == ChatType_1.default.Group) {
+            await this.sock.readMessages([key]);
+        }
+        else {
+            await this.sock.readMessages([key]);
+        }
+    }
+    // Adiciona um método utilitário para cache de mensagens
+    addMessageCache(id) {
+        if (!this.messagesCached.includes(id)) {
+            this.messagesCached.push(id);
+        }
+    }
+    // ================= APP STATE UPDATES =================
+    /** Arquiva ou desarquiva um chat */
+    async archiveChat(chat, archive = true, lastMessages) {
+        const chatId = typeof chat === 'string' ? chat : chat.id;
+        await this.sock.chatModify({ archive, lastMessages }, chatId);
+    }
+    /** Silencia ou dessilencia um chat */
+    async muteChat(chat, mute, lastMessages) {
+        const chatId = typeof chat === 'string' ? chat : chat.id;
+        await this.sock.chatModify({ mute, lastMessages }, chatId);
+    }
+    /** Marca um chat como lido */
+    async markChatRead(chat, read = true, lastMessages) {
+        const chatId = typeof chat === 'string' ? chat : chat.id;
+        await this.sock.chatModify({ markRead: read, lastMessages }, chatId);
+    }
+    /** Define o modo de mensagens temporárias em um chat */
+    async setDisappearingMessages(chat, duration) {
+        const chatId = typeof chat === 'string' ? chat : chat.id;
+        await this.sock.sendMessage(chatId, { disappearingMessagesInChat: duration });
+    }
+    // ================= BUSINESS FEATURES =================
+    /** Busca o perfil de negócio de um contato */
+    async fetchBusinessProfile(jid) {
+        return await this.sock.getBusinessProfile(jid);
+    }
+    // O método fetchBusinessProducts foi removido pois não existe na API pública do Baileys.
+    // Se precisar de recursos de catálogo, utilize a API oficial do WhatsApp Business.
+    // ================= PRIVACIDADE =================
+    async fetchBlocklist() {
+        return await this.sock.fetchBlocklist();
+    }
+    async fetchPrivacySettings(force = false) {
+        return await this.sock.fetchPrivacySettings(force);
+    }
+    async updateOnlinePrivacy(option) {
+        await this.sock.updateOnlinePrivacy(option);
+    }
+    async updateLastSeenPrivacy(option) {
+        await this.sock.updateLastSeenPrivacy(option);
+    }
+    async updateProfilePicturePrivacy(option) {
+        await this.sock.updateProfilePicturePrivacy(option);
+    }
+    async updateStatusPrivacy(option) {
+        await this.sock.updateStatusPrivacy(option);
+    }
+    async updateGroupsAddPrivacy(option) {
+        await this.sock.updateGroupsAddPrivacy(option);
+    }
+    async updateReadReceiptsPrivacy(option) {
+        await this.sock.updateReadReceiptsPrivacy(option);
+    }
+    /**
+     * Adiciona uma reação a uma mensagem
+     */
+    async addReaction(message) {
+        var _a;
+        if (!message.id || !((_a = message.chat) === null || _a === void 0 ? void 0 : _a.id) || !message.reaction)
+            return;
+        await this.sock.sendMessage(message.chat.id, {
+            react: {
+                text: message.reaction,
+                key: {
+                    id: message.id,
+                    remoteJid: message.chat.id,
+                    fromMe: message.fromMe || message.user.id === this.id,
+                    participant: (0, baileys_1.isJidGroup)(message.chat.id)
+                        ? message.user.id || this.id || undefined
+                        : undefined,
+                },
+            },
+        });
+    }
+    /** Remove uma reação de uma mensagem */
+    async removeReaction(message) {
+        var _a;
+        if (!message.id || !((_a = message.chat) === null || _a === void 0 ? void 0 : _a.id))
+            return;
+        await this.sock.sendMessage(message.chat.id, {
+            react: {
+                text: '',
+                key: {
+                    id: message.id,
+                    remoteJid: message.chat.id,
+                    fromMe: message.fromMe || message.user.id === this.id,
+                    participant: (0, baileys_1.isJidGroup)(message.chat.id)
+                        ? message.user.id || this.id || undefined
+                        : undefined,
+                },
+            },
+        });
+    }
+    /** Edita o texto de uma mensagem enviada */
+    async editMessage(message) {
+        var _a;
+        if (!message.id || !((_a = message.chat) === null || _a === void 0 ? void 0 : _a.id))
+            return;
+        await this.sock.sendMessage(message.chat.id, {
+            edit: {
+                remoteJid: message.chat.id,
+                id: message.id,
+                fromMe: message.fromMe || message.user.id === this.id,
+                participant: (0, baileys_1.isJidGroup)(message.chat.id)
+                    ? message.user.id || this.id || undefined
+                    : undefined,
+            },
+            text: message.text,
+        });
+    }
+    /** Envia uma mensagem */
+    async send(message) {
+        var _a;
+        try {
+            const waMsg = (await new ConvertToWAMessage_1.default(this, message).refactory()).waMessage;
+            const sent = await this.sock.sendMessage(message.chat.id, waMsg);
+            if (sent && sent.key && sent.key.id)
+                message.id = sent.key.id;
+            return message;
+        }
+        catch (error) {
+            // Log detalhado para diagnóstico
+            console.error('[WhatsAppBot.send] Erro ao enviar mensagem', {
+                chatId: (_a = message === null || message === void 0 ? void 0 : message.chat) === null || _a === void 0 ? void 0 : _a.id,
+                messageObj: message,
+                error
+            });
+            throw error;
+        }
+    }
+    /** Remove uma mensagem (marca como removida para todos) */
+    async removeMessage(message) {
+        var _a;
+        if (!message.id || !((_a = message.chat) === null || _a === void 0 ? void 0 : _a.id))
+            return;
+        await this.sock.sendMessage(message.chat.id, {
+            delete: {
+                remoteJid: message.chat.id,
+                id: message.id,
+                fromMe: message.fromMe || message.user.id === this.id,
+                participant: (0, baileys_1.isJidGroup)(message.chat.id)
+                    ? message.user.id || this.id || undefined
+                    : undefined,
+            },
+        });
+    }
+    /** Deleta uma mensagem (remove do histórico) */
+    async deleteMessage(message) {
+        var _a;
+        if (!message.id || !((_a = message.chat) === null || _a === void 0 ? void 0 : _a.id))
+            return;
+        await this.sock.sendMessage(message.chat.id, {
+            delete: {
+                remoteJid: message.chat.id,
+                id: message.id,
+                fromMe: message.fromMe || message.user.id === this.id,
+                participant: (0, baileys_1.isJidGroup)(message.chat.id)
+                    ? message.user.id || this.id || undefined
+                    : undefined,
+            },
+        });
+    }
+    /** Baixa a stream de mídia de uma mensagem */
+    async downloadStreamMessage(media) {
+        // media é um MediaMessage, que herda de Message
+        const msg = await this.store.loadMessage(media.chat.id, media.id);
+        if (!msg)
+            return Buffer.from("");
+        // downloadMediaMessage espera (msg, type, options?)
+        return Buffer.from(await (0, baileys_1.downloadMediaMessage)(msg, "buffer", {
+        // opções extras se necessário
+        }));
+    }
+}
+exports.default = WhatsAppBot;
+//# sourceMappingURL=WhatsAppBot.js.map