trompot 1.6.1 → 1.6.2

package/lib/wa/WhatsAppBot.js

@@ -37,79 +37,141 @@ var __importDefault = (this && this.__importDefault) || function (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 MediaMessage_1 = __importDefault(require("../messages/MediaMessage"));
 const ConfigWAEvents_1 = __importDefault(require("./ConfigWAEvents"));
 const ID_1 = require("./ID");
+const Timeouts_1 = require("./constants/Timeouts");
+const ErrorCodes_1 = require("./constants/ErrorCodes");
+const ConfigValidator_1 = require("./utils/ConfigValidator");
+const MessageOperations_1 = require("./operations/MessageOperations");
+const ChatOperations_1 = require("./operations/ChatOperations");
+const UserOperations_1 = require("./operations/UserOperations");
+const GroupOperations_1 = require("./operations/GroupOperations");
+// Novos serviços e managers
+const LoggerService_1 = require("./services/LoggerService");
+const CacheService_1 = require("./services/CacheService");
+const ErrorHandler_1 = require("./services/ErrorHandler");
+const RetryService_1 = require("./services/RetryService");
+const LIDMappingService_1 = require("./services/LIDMappingService");
+const PendingMessageQueue_1 = require("./services/PendingMessageQueue");
+const LIDNormalizationService_1 = require("./services/LIDNormalizationService");
+const StateManager_1 = require("./core/StateManager");
+const ConnectionManager_1 = require("./core/ConnectionManager");
+const SessionManager_1 = require("./core/SessionManager");
+const EventManager_1 = require("./events/EventManager");
+const ConnectionEventHandler_1 = require("./events/ConnectionEventHandler");
+const MessageEventHandler_1 = require("./events/MessageEventHandler");
+const HistoryEventHandler_1 = require("./events/HistoryEventHandler");
+const ContactEventHandler_1 = require("./events/ContactEventHandler");
+const GroupEventHandler_1 = require("./events/GroupEventHandler");
+const ChatEventHandler_1 = require("./events/ChatEventHandler");
+const CallEventHandler_1 = require("./events/CallEventHandler");
+const LIDMappingEventHandler_1 = require("./events/LIDMappingEventHandler");
 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 {
+    // Tornar stateManager acessível para ConfigWAEvents (sem type casting)
+    getStateManager() {
+        return this.stateManager;
+    }
+    // Getters para compatibilidade (delegam para StateManager)
+    get id() {
+        return this.stateManager.id;
+    }
+    get status() {
+        return this.stateManager.status;
+    }
+    get phoneNumber() {
+        return this.stateManager.phoneNumber;
+    }
+    get name() {
+        return this.stateManager.name;
+    }
+    get profileUrl() {
+        return this.stateManager.profileUrl;
+    }
+    get lastConnectionUpdateDate() {
+        return this.stateManager.lastConnectionUpdateDate;
+    }
+    get lastDisconnectError() {
+        return this.stateManager.lastDisconnectError;
+    }
     constructor(config) {
-        var _a, _b;
         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 = async (creds) => {
-            // v7.0.0-rc.5: Salvar credenciais básicas
-            // LIDs e deviceIndex serão implementados quando estiverem disponíveis na API estável
-            await this.auth.set('creds', creds);
+            await this.sessionManager.saveCredentials(this.auth, creds);
         };
         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);
-        // Inicializa caches com TTLs apropriados (fallback numérico para 6.7.x)
-        const GROUP_META_TTL = (_a = baileys_1.DEFAULT_CACHE_TTLS === null || baileys_1.DEFAULT_CACHE_TTLS === void 0 ? void 0 : baileys_1.DEFAULT_CACHE_TTLS.CALL_OFFER) !== null && _a !== void 0 ? _a : 300; // 5min
-        const SIGNAL_KEY_TTL = (_b = baileys_1.DEFAULT_CACHE_TTLS === null || baileys_1.DEFAULT_CACHE_TTLS === void 0 ? void 0 : baileys_1.DEFAULT_CACHE_TTLS.USER_DEVICES) !== null && _b !== void 0 ? _b : 300; // 5min
-        this.groupMetadataCache = new node_cache_1.default({
-            stdTTL: GROUP_META_TTL,
-            useClones: false,
-        });
-        this.signalKeyCache = new node_cache_1.default({
-            stdTTL: SIGNAL_KEY_TTL,
-            useClones: false,
-        });
+        this.eventsIsStoped = false;
+        /**
+         * Cria e configura um novo socket (método centralizado)
+         * Usado tanto em connect() quanto após restartRequired
+         */
+        this.isCreatingSocket = false;
+        this.createSocketPromise = null;
+        // Valida e normaliza configuração
+        const validatedConfig = ConfigValidator_1.ConfigValidator.validateWithWarnings(config);
+        // Inicializa serviços
+        this.loggerService = new LoggerService_1.LoggerService(validatedConfig.logLevel || 'info');
+        this.cacheService = new CacheService_1.CacheService(this.loggerService);
+        this.errorHandler = new ErrorHandler_1.ErrorHandler(this.loggerService);
+        this.retryService = new RetryService_1.RetryService();
+        this.lidMappingService = new LIDMappingService_1.LIDMappingService(this.loggerService, this.cacheService);
+        this.lidNormalizationService = new LIDNormalizationService_1.LIDNormalizationService(this.loggerService, this.lidMappingService);
+        this.pendingMessageQueue = new PendingMessageQueue_1.PendingMessageQueue(this.loggerService);
+        this.stateManager = new StateManager_1.StateManager(this.loggerService);
+        this.sessionManager = new SessionManager_1.SessionManager(this.loggerService);
+        this.connectionManager = new ConnectionManager_1.ConnectionManager(this.stateManager, this.sessionManager, this.retryService, this.errorHandler, this.loggerService);
+        this.eventManager = new EventManager_1.EventManager(this.loggerService);
+        // Inicializa handlers
+        this.connectionEventHandler = new ConnectionEventHandler_1.ConnectionEventHandler(this, this.loggerService, this.stateManager, this.sessionManager);
+        this.messageEventHandler = new MessageEventHandler_1.MessageEventHandler(this, this.loggerService);
+        this.historyEventHandler = new HistoryEventHandler_1.HistoryEventHandler(this, this.loggerService);
+        this.contactEventHandler = new ContactEventHandler_1.ContactEventHandler(this, this.loggerService);
+        this.groupEventHandler = new GroupEventHandler_1.GroupEventHandler(this, this.loggerService);
+        this.chatEventHandler = new ChatEventHandler_1.ChatEventHandler(this, this.loggerService);
+        this.callEventHandler = new CallEventHandler_1.CallEventHandler(this, this.loggerService);
+        this.lidMappingEventHandler = new LIDMappingEventHandler_1.LIDMappingEventHandler(this, this.loggerService, this.lidMappingService, this.pendingMessageQueue);
+        // Inicializa operações especializadas
+        this.messageOperations = new MessageOperations_1.MessageOperations(this, this.errorHandler, this.pendingMessageQueue);
+        this.chatOperations = new ChatOperations_1.ChatOperations(this);
+        this.userOperations = new UserOperations_1.UserOperations(this);
+        this.groupOperations = new GroupOperations_1.GroupOperations(this);
+        // Configura caches usando CacheService
+        this.msgRetryCountercache = this.cacheService.getMessageRetryCache();
+        this.groupMetadataCache = this.cacheService.getGroupMetadataCache();
+        this.signalKeyCache = this.cacheService.getSignalKeyCache();
+        // Cria store
         const store = (0, makeInMemoryStore_1.default)({ logger: this.logger });
         this.store = store;
         const waBot = this;
+        // Configuração do socket (usa valores validados)
         this.config = {
             ...baileys_1.DEFAULT_CONNECTION_CONFIG,
             logger: this.logger,
-            qrTimeout: 60000,
-            defaultQueryTimeoutMs: 10000,
-            retryRequestDelayMs: 500,
+            qrTimeout: validatedConfig.qrTimeout,
+            defaultQueryTimeoutMs: validatedConfig.defaultQueryTimeoutMs,
+            retryRequestDelayMs: validatedConfig.retryRequestDelayMs,
             maxMsgRetryCount: 5,
-            readAllFailedMessages: false,
+            readAllFailedMessages: validatedConfig.readAllFailedMessages,
             msgRetryCounterCache: this.msgRetryCountercache,
-            autoRestartInterval: 1000 * 60 * 30, // 30 minutes (recommended)
-            useExperimentalServers: false,
-            autoSyncHistory: false,
-            autoLoadContactInfo: false,
-            autoLoadGroupInfo: false,
+            autoRestartInterval: validatedConfig.autoRestartInterval,
+            useExperimentalServers: validatedConfig.useExperimentalServers,
+            autoSyncHistory: validatedConfig.autoSyncHistory,
+            autoLoadContactInfo: validatedConfig.autoLoadContactInfo,
+            autoLoadGroupInfo: validatedConfig.autoLoadGroupInfo,
+            autoRejectCalls: validatedConfig.autoRejectCalls,
             shouldIgnoreJid: () => false,
             // v7.0.0-rc.5: Removido ACKs automáticos para evitar banimentos
             generateHighQualityLinkPreview: false,
@@ -138,213 +200,197 @@ class WhatsAppBot extends BotEvents_1.default {
                 return msg.message;
             },
             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
-                });
-                // Listener padrão Baileys: emite evento 'qr' para o client externo
-                this.sock.ev.on('connection.update', (update) => {
-                    if (update.qr) {
-                        this.emit('qr', update.qr);
-                    }
-                });
-                // Para exibir o QR code no terminal, utilize:
-                //
-                // client.on('qr', async (qr) => {
-                //   try {
-                //     const QRCode = (await import('qrcode')).default;
-                //     console.log(await QRCode.toString(qr, { type: 'terminal' }));
-                //   } catch (err) {
-                //     console.log('QRCode:', qr);
-                //   }
-                // });
-            }
-        }, 0);
+        // NOTA: Listeners de eventos Baileys são configurados em:
+        // - setupEventHandlers() - handlers especializados (MessageEventHandler, etc.)
+        // - ConfigWAEvents.configureAll() - configuração de eventos do Baileys
+        // Não adicionar listeners diretamente aqui para evitar vazamento de memória
     }
     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) {
-            // Fluxo normal com QR code
-            await this.internalConnect({ browser: baileys_1.Browsers.windows('Rompot') });
-            await this.awaitConnectionState('open');
+        // Valida sessão antes de criar socket (evita gerar QR code desnecessário)
+        const validation = await this.sessionManager.validateSession(this.auth);
+        if (!validation.isValid && validation.shouldGenerateQR) {
+            this.loggerService.warn(`⚠️ Sessão inválida: ${validation.reason}. QR code será gerado.`);
+        }
+        else if (validation.isValid) {
+            this.loggerService.info('✅ Sessão válida encontrada. Reconectando sem QR code.');
         }
         else {
-            // Fluxo de pairing code (sem QR)
-            // Segundo o README do Baileys: printQRInTerminal deve ser false
-            // IMPORTANTE: Criar socket SEM esperar por 'open' primeiro
-            await this.internalConnect({
-                browser: ['Chrome (linux)', 'Rompot', '22.5.0'],
-                printQRInTerminal: false, // Necessário para pairing code
-            }, false); // false = não esperar por 'open' ainda
-            // Verifica se já está registrado ANTES de esperar conexão
-            // O README do Baileys mostra que requestPairingCode deve ser chamado
-            // logo após criar o socket, antes de esperar por 'open'
-            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)) {
-                // Não espera por QR - chama requestPairingCode diretamente
-                // O número deve estar no formato: apenas números com código do país (sem +, (), -)
-                const code = await this.sock.requestPairingCode(this.auth.botPhoneNumber);
-                this.emit('code', code);
-            }
-            // Só agora espera pela conexão abrir
-            await this.awaitConnectionState('open');
+            this.loggerService.warn(`⚠️ Sessão pode estar inválida, mas QR code não será gerado automaticamente.`);
         }
+        // Cria e configura o socket (método centralizado)
+        await this.createSocket();
     }
-    async internalConnect(additionalOptions = {}, waitForOpen = true) {
-        return new Promise(async (resolve, reject) => {
+    async createSocket() {
+        // Previne race condition: se já estiver criando, retorna a Promise existente
+        if (this.isCreatingSocket && this.createSocketPromise) {
+            return this.createSocketPromise;
+        }
+        this.isCreatingSocket = true;
+        this.createSocketPromise = this._createSocketInternal().finally(() => {
+            this.isCreatingSocket = false;
+            this.createSocketPromise = null;
+        });
+        return this.createSocketPromise;
+    }
+    async _createSocketInternal() {
+        var _a, _b;
+        // Carrega credenciais
+        const { state, saveCreds } = await (0, Auth_1.getBaileysAuth)(this.auth);
+        this.saveCreds = saveCreds;
+        // Verifica se as credenciais são válidas antes de criar socket
+        // Se não forem válidas, o Baileys gerará QR code automaticamente
+        if (!state.creds || !state.creds.registered || !((_a = state.creds.me) === null || _a === void 0 ? void 0 : _a.id)) {
+            this.loggerService.warn('Credenciais inválidas detectadas. QR code será gerado pelo Baileys.');
+        }
+        else {
+            this.loggerService.debug('Credenciais válidas carregadas. Reconectando sem QR code.');
+        }
+        // Cria logger para o Baileys (filtra logs de sessão se logLevel for 'warn' ou superior)
+        // O Baileys usa este logger para logs internos, incluindo "Closing session"
+        const baileysLogger = this.config.logger || (0, pino_1.default)({
+            level: this.config.logLevel === 'info' ? 'warn' : this.config.logLevel || 'warn'
+        });
+        // Cria configuração do socket
+        const socketConfig = {
+            auth: {
+                creds: state.creds,
+                keys: (0, baileys_1.makeCacheableSignalKeyStore)(state.keys, baileysLogger),
+            },
+            browser: baileys_1.Browsers.windows('Rompot'),
+            logger: baileysLogger, // Passa logger explicitamente para o Baileys
+            ...this.config,
+        };
+        // Fecha socket anterior se existir
+        if (this.sock) {
             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),
-                        // v7.0.0-rc.5: Configuração básica de auth
-                        // LIDs serão implementados quando estiverem disponíveis na API estável
-                    },
-                    ...additionalOptions,
-                    ...this.config,
-                });
-                this.store.bind(this.sock.ev);
-                this.configEvents.configureAll();
-                this.sock.ev.on('creds.update', saveCreds);
-                resolve();
-                // Só espera por 'open' se solicitado (para pairing code, não esperamos ainda)
-                if (waitForOpen) {
-                    await this.awaitConnectionState('open');
-                }
+                // Remove todos os listeners ANTES de fechar para evitar vazamento
+                this.configEvents.cleanup(); // Limpa listeners do ConfigWAEvents
+                this.eventManager.cleanup(); // Limpa listeners do EventManager
+                this.sock.end(undefined);
             }
             catch (err) {
-                this.ev.emit('error', err);
-                reject(err);
+                // Ignora erros
             }
-        });
+        }
+        // Cria novo socket
+        this.sock = (0, baileys_1.default)(socketConfig);
+        // Armazena configuração no ConnectionManager
+        this.connectionManager.connectionConfig = socketConfig;
+        // Configura componentes
+        this.store.bind(this.sock.ev);
+        this.eventManager.setSocket(this.sock);
+        this.lidMappingService.setSocket(this.sock);
+        this.lidNormalizationService.setSocket(this.sock);
+        // Configura handlers (CRÍTICO: antes de qualquer evento)
+        this.configEvents.configureAll();
+        this.setupEventHandlers();
+        // Configura limpeza periódica da fila de mensagens pendentes (a cada 30 segundos)
+        if (this.pendingMessageQueue) {
+            setInterval(() => {
+                this.pendingMessageQueue.cleanup();
+            }, 30000);
+        }
+        // Configura creds.update
+        this.sock.ev.on('creds.update', saveCreds);
+        // Se já estiver conectado, emite evento
+        if ((_b = this.sock) === null || _b === void 0 ? void 0 : _b.ws.isOpen) {
+            this.emit('open', { isNewLogin: false });
+        }
+    }
+    /**
+     * Configura todos os handlers de eventos
+     */
+    setupEventHandlers() {
+        if (!this.sock)
+            return;
+        this.connectionEventHandler.setup(this.sock);
+        this.messageEventHandler.setup(this.sock);
+        this.historyEventHandler.setup(this.sock);
+        this.contactEventHandler.setup(this.sock);
+        this.groupEventHandler.setup(this.sock);
+        this.chatEventHandler.setup(this.sock);
+        this.callEventHandler.setup(this.sock);
+        this.lidMappingEventHandler.setup(this.sock);
     }
     /**
      * * 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;
-            });
+    async reconnect(stopEvents = false, showOpen, force = false) {
+        // 428 foi removido da lista de erros não reconectáveis
+        // É um erro temporário que permite reconexão
+        // Apenas 401/421 (token expirado) impedem reconexão
+        var _a;
+        // Se já estiver conectado, não precisa reconectar
+        if ((_a = this.sock) === null || _a === void 0 ? void 0 : _a.ws.isOpen) {
+            return;
+        }
+        // Se force=true (vindo de restartRequired após QR code), sempre reconecta
+        // Caso contrário, verifica se está aguardando QR code inicial
+        // IMPORTANTE: Não impede reconexão se for restartRequired (código 515)
+        // O restartRequired acontece após escanear QR code e precisa reconectar imediatamente
+        if (!force && this.sock && !this.sock.ws.isOpen) {
+            // Verifica se o último erro foi restartRequired (515) - se sim, permite reconexão
+            const isRestartRequired = this.lastDisconnectError === baileys_1.DisconnectReason.restartRequired;
+            if (!isRestartRequired) {
+                // Verifica se há QR code pendente - se sim, não reconecta
+                // Mas permite se for restartRequired
+                this.loggerService.warn('Aguardando autenticação (QR code). Não reconectando para evitar limpar sessão.');
+                return;
+            }
+            // Se for restartRequired, continua e reconecta (force será true implicitamente)
+            this.loggerService.info('RestartRequired detectado (após QR code). Reconectando...');
+            force = true; // Força reconexão para restartRequired
+        }
+        // Limpa socket anterior se existir (sem desconectar explicitamente)
+        if (this.sock) {
+            try {
+                this.sock.end(undefined);
+            }
+            catch (err) {
+                // Ignora erros ao fechar socket anterior
+            }
+        }
+        // Delay antes de reconectar (mas não para restartRequired - precisa ser imediato)
+        if (!force) {
+            await new Promise((resolve) => setTimeout(resolve, Timeouts_1.Timeouts.RECONNECT_DELAY));
         }
-        await this.stop();
-        // Delay antes de reconectar para evitar loops infinitos
-        // Especialmente importante para erros como 428 (Connection Terminated)
-        await new Promise((resolve) => setTimeout(resolve, 2000));
         this.emit('reconnecting', {});
-        await this.internalConnect();
+        // Reconecta usando o auth existente (CRÍTICO: não criar novo auth)
+        // Para restartRequired (force=true), reconecta imediatamente sem delay
+        // Usa createSocket() diretamente para manter o auth original
+        await this.createSocket();
     }
     /**
      * * Desliga a conexão com o servidor do WhatsApp
      * @param reason
      * @returns
      */
-    async stop(reason = 402) {
-        var _a;
+    async stop(reason = ErrorCodes_1.ErrorCodes.CONNECTION_CLOSED) {
         try {
-            this.status = BotStatus_1.BotStatus.Offline;
-            (_a = this.sock) === null || _a === void 0 ? void 0 : _a.end(reason);
+            this.stateManager.setStatus(BotStatus_1.BotStatus.Offline);
+            // Limpa event handlers (já remove listeners do socket)
+            this.configEvents.cleanup(); // Limpa listeners do ConfigWAEvents
+            this.eventManager.cleanup(); // Limpa listeners do EventManager
+            // Limpa connection listeners
+            this.connectionListeners = [];
+            // Limpa checkConnectionInterval
+            if (this.checkConnectionInterval) {
+                clearInterval(this.checkConnectionInterval);
+                this.checkConnectionInterval = null;
+            }
+            await this.connectionManager.disconnect(reason);
         }
         catch (err) {
+            this.errorHandler.handle(err, 'WhatsAppBot.stop');
             this.emit('error', err);
         }
     }
@@ -356,13 +402,41 @@ class WhatsAppBot extends BotEvents_1.default {
      * * Aguarda um status de conexão
      */
     async awaitConnectionState(connection) {
-        return new Promise((res) => {
-            this.connectionListeners.push((update) => {
+        return new Promise((res, rej) => {
+            var _a;
+            // Timeout usando constante
+            const timeout = setTimeout(() => {
+                // Remove listener do array para evitar vazamento
+                const index = this.connectionListeners.indexOf(listener);
+                if (index > -1) {
+                    this.connectionListeners.splice(index, 1);
+                }
+                rej(new Error(`Timeout ao aguardar conexão '${connection}'`));
+            }, Timeouts_1.Timeouts.CONNECTION_WAIT);
+            const listener = (update) => {
                 if (update.connection != connection)
                     return false;
+                clearTimeout(timeout);
+                // Remove listener do array após resolver
+                const index = this.connectionListeners.indexOf(listener);
+                if (index > -1) {
+                    this.connectionListeners.splice(index, 1);
+                }
                 res(update);
                 return true;
-            });
+            };
+            this.connectionListeners.push(listener);
+            // Se já estiver no estado desejado, resolve imediatamente
+            if (((_a = this.sock) === null || _a === void 0 ? void 0 : _a.ws.isOpen) && connection === 'open') {
+                clearTimeout(timeout);
+                // Remove listener do array
+                const index = this.connectionListeners.indexOf(listener);
+                if (index > -1) {
+                    this.connectionListeners.splice(index, 1);
+                }
+                res({ connection: 'open' });
+                return;
+            }
         });
     }
     /**
@@ -370,110 +444,14 @@ class WhatsAppBot extends BotEvents_1.default {
      * @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) { }
+        return this.chatOperations.readChat(chat, metadata, updateMetadata);
     }
     /**
      * * 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);
-        }
+        return this.userOperations.readUser(user, metadata);
     }
     /**
      * Obtem uma mensagem de enquete.
@@ -481,20 +459,14 @@ class WhatsAppBot extends BotEvents_1.default {
      * @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);
+        return this.messageOperations.getPollMessage(pollMessageId);
     }
     /**
      * 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());
+        return this.messageOperations.savePollMessage(pollMessage);
     }
     /**
      * * Trata atualizações de participantes
@@ -504,341 +476,154 @@ class WhatsAppBot extends BotEvents_1.default {
      * @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 });
+        return this.groupOperations.groupParticipantsUpdate(action, chatId, userId, fromId);
     }
     //! ********************************* CHAT *********************************
     async getChatName(chat) {
-        var _a;
-        return ((_a = (await this.getChat(chat))) === null || _a === void 0 ? void 0 : _a.name) || '';
+        return this.chatOperations.getChatName(chat);
     }
     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);
+        return this.chatOperations.setChatName(chat, name);
     }
     async getChatDescription(chat) {
-        var _a;
-        return ((_a = (await this.getChat(chat))) === null || _a === void 0 ? void 0 : _a.description) || '';
+        return this.chatOperations.getChatDescription(chat);
     }
     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);
+        return this.chatOperations.setChatDescription(chat, description);
     }
     async getChatProfile(chat, lowQuality) {
-        const uri = await this.getChatProfileUrl(chat, lowQuality);
-        return await (0, Generic_1.getImageURL)(uri);
+        return this.chatOperations.getChatProfile(chat, lowQuality);
     }
     async getChatProfileUrl(chat, lowQuality) {
-        try {
-            return ((await this.sock.profilePictureUrl(chat.id, lowQuality ? 'preview' : 'image')) || '');
-        }
-        catch (_a) {
-            return '';
-        }
+        return this.chatOperations.getChatProfileUrl(chat, lowQuality);
     }
     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);
+        return this.chatOperations.setChatProfile(chat, 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 });
+        return this.chatOperations.updateChat(chat);
     }
     async removeChat(chat) {
-        await this.auth.remove(`chats-${chat.id}`);
-        this.ev.emit('chat', { action: 'remove', chat });
+        return this.chatOperations.removeChat(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);
+        return this.chatOperations.getChat(chat);
     }
     async getChats() {
-        return (await this.auth.listAll('chats-')).map((id) => id.replace('chats-', ''));
+        return this.chatOperations.getChats();
     }
     async setChats(chats) {
-        await Promise.all(chats.map(async (chat) => await this.updateChat(chat)));
+        return this.chatOperations.setChats(chats);
     }
     async getChatUsers(chat) {
-        var _a;
-        return ((_a = (await this.getChat(chat))) === null || _a === void 0 ? void 0 : _a.users) || [];
+        return this.chatOperations.getChatUsers(chat);
     }
     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) || [];
+        return this.chatOperations.getChatAdmins(chat);
     }
     async getChatLeader(chat) {
-        var _a;
-        return ((_a = (await this.getChat(chat))) === null || _a === void 0 ? void 0 : _a.leader) || '';
+        return this.chatOperations.getChatLeader(chat);
     }
     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');
+        return this.groupOperations.addUserInChat(chat, user);
     }
     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');
+        return this.groupOperations.removeUserInChat(chat, user);
     }
     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');
+        return this.groupOperations.promoteUserInChat(chat, user);
     }
     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');
+        return this.groupOperations.demoteUserInChat(chat, user);
     }
     async changeChatStatus(chat, status) {
-        await this.sock.sendPresenceUpdate(WAStatus_1.WAStatus[status] || 'available', chat.id);
+        return this.chatOperations.changeChatStatus(chat, status);
     }
     async createChat(chat) {
-        await this.sock.groupCreate(chat.name || '', [this.id]);
+        return this.chatOperations.createChat(chat);
     }
     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);
+        return this.chatOperations.leaveChat(chat);
     }
     async joinChat(code) {
-        await this.sock.groupAcceptInvite(code.replace('https://chat.whatsapp.com/', ''));
+        return this.chatOperations.joinChat(code);
     }
     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)) || '';
+        return this.chatOperations.getChatInvite(chat);
     }
     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)) || '';
+        return this.chatOperations.revokeChatInvite(chat);
     }
     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) || '';
+        return this.userOperations.getUserName(user);
     }
     async setUserName(user, name) {
-        if (user.id != this.id)
-            return;
-        await this.setBotName(name);
+        return this.userOperations.setUserName(user, 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');
+        return this.userOperations.getUserDescription(user);
     }
     async setUserDescription(user, description) {
-        if (user.id != this.id)
-            return;
-        await this.setBotDescription(description);
+        return this.userOperations.setUserDescription(user, description);
     }
     async getUserProfile(user, lowQuality) {
-        const uri = await this.getUserProfileUrl(user, lowQuality);
-        return await (0, Generic_1.getImageURL)(uri);
+        return this.userOperations.getUserProfile(user, lowQuality);
     }
     async getUserProfileUrl(user, lowQuality) {
-        try {
-            return ((await this.sock.profilePictureUrl(user.id, lowQuality ? 'preview' : 'image')) || '');
-        }
-        catch (_a) {
-            return '';
-        }
+        return this.userOperations.getUserProfileUrl(user, lowQuality);
     }
     async setUserProfile(user, image) {
-        if (user.id != this.id)
-            return;
-        await this.setBotProfile(image);
+        return this.userOperations.setUserProfile(user, image);
     }
     async getUser(user) {
-        const userData = await this.auth.get(`users-${user.id}`);
-        if (!userData)
-            return null;
-        return User_1.default.fromJSON(userData);
+        return this.userOperations.getUser(user);
     }
     async getUsers() {
-        return (await this.auth.listAll('users-')).map((id) => id.replace('users-', ''));
+        return this.userOperations.getUsers();
     }
     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());
+        return this.userOperations.updateUser(user);
     }
     async setUsers(users) {
-        await Promise.all(users.map(async (user) => await this.updateUser(user)));
+        return this.userOperations.setUsers(users);
     }
     async removeUser(user) {
-        await this.auth.remove(`users-${user.id}`);
+        return this.userOperations.removeUser(user);
     }
     async blockUser(user) {
-        if (user.id == this.id)
-            return;
-        await this.sock.updateBlockStatus(user.id, 'block');
+        return this.userOperations.blockUser(user);
     }
     async unblockUser(user) {
-        if (user.id == this.id)
-            return;
-        await this.sock.updateBlockStatus(user.id, 'unblock');
+        return this.userOperations.unblockUser(user);
     }
     //! ******************************** BOT ********************************
     async getBotName() {
-        return await this.getUserName(new User_1.default(this.id));
+        return this.userOperations.getBotName();
     }
     async setBotName(name) {
-        await this.sock.updateProfileName(name);
+        return this.userOperations.setBotName(name);
     }
     async getBotDescription() {
-        return await this.getUserDescription(new User_1.default(this.id));
+        return this.userOperations.getBotDescription();
     }
     async setBotDescription(description) {
-        await this.sock.updateProfileStatus(description);
+        return this.userOperations.setBotDescription(description);
     }
     async getBotProfile(lowQuality) {
-        return await this.getUserProfile(new User_1.default(this.id), lowQuality);
+        return this.userOperations.getBotProfile(lowQuality);
     }
     async getBotProfileUrl(lowQuality) {
-        return (await this.getUserProfileUrl(new User_1.default(this.id), lowQuality)) || '';
+        return this.userOperations.getBotProfileUrl(lowQuality);
     }
     async setBotProfile(image) {
-        await this.sock.updateProfilePicture(this.id, image);
+        return this.userOperations.setBotProfile(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,
-        };
-        // v7.0.0: Removido ACKs automáticos para evitar banimentos
-        // O WhatsApp agora gerencia automaticamente o status de leitura
-        const chat = await this.getChat(message.chat);
-        // Apenas marcar como lido localmente, sem enviar ACK
-        if ((chat === null || chat === void 0 ? void 0 : chat.type) == ChatType_1.default.Group || (chat === null || chat === void 0 ? void 0 : chat.type) == ChatType_1.default.PV) {
-            // Marcar mensagem como lida apenas no cache local
-            this.addMessageCache(message.id || '');
-        }
+        return this.messageOperations.readMessage(message);
     }
     // Adiciona um método utilitário para cache de mensagens
     addMessageCache(id) {
@@ -849,23 +634,19 @@ class WhatsAppBot extends BotEvents_1.default {
     // ================= 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);
+        return this.chatOperations.archiveChat(chat, archive, lastMessages);
     }
     /** 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);
+        return this.chatOperations.muteChat(chat, mute, lastMessages);
     }
     /** 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);
+        return this.chatOperations.markChatRead(chat, read, lastMessages);
     }
     /** 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 });
+        return this.chatOperations.setDisappearingMessages(chat, duration);
     }
     // ================= BUSINESS FEATURES =================
     /** Busca o perfil de negócio de um contato */
@@ -903,121 +684,39 @@ class WhatsAppBot extends BotEvents_1.default {
      * 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,
-                },
-            },
-        });
+        return this.messageOperations.addReaction(message);
     }
     /** 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,
-                },
-            },
-        });
+        return this.messageOperations.removeReaction(message);
     }
     /** 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,
-        });
+        return this.messageOperations.editMessage(message);
     }
     /** 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;
-        }
+        return this.messageOperations.send(message);
     }
     /** 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,
-            },
-        });
+        return this.messageOperations.removeMessage(message);
     }
     /** 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,
-            },
-        });
+        return this.messageOperations.deleteMessage(message);
     }
     /** 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
-        }));
+        // A interface IBot espera Media, mas internamente precisamos de MediaMessage
+        // MediaMessage estende Message e tem chat e id necessários para carregar do store
+        // Na prática, sempre será passado MediaMessage, então fazemos type assertion
+        if (media instanceof MediaMessage_1.default) {
+            return this.messageOperations.downloadStreamMessage(media);
+        }
+        // Se não for MediaMessage, tenta usar como MediaMessage (compatibilidade)
+        // Isso permite que código que passa MediaMessage funcione
+        return this.messageOperations.downloadStreamMessage(media);
     }
 }
 exports.default = WhatsAppBot;