@wabot-dev/framework 0.0.16 → 0.0.50

package/dist/src/_virtual/_commonjsHelpers.js

@@ -0,0 +1,5 @@
+function getDefaultExportFromCjs (x) {
+	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
+}
+
+export { getDefaultExportFromCjs };

package/dist/src/_virtual/cjs.js

@@ -0,0 +1,7 @@
+import { getDefaultExportFromCjs } from './_commonjsHelpers.js';
+import { __require as requireCjs } from '../node_modules/deepmerge/dist/cjs.js';
+
+var cjsExports = requireCjs();
+var merge = /*@__PURE__*/getDefaultExportFromCjs(cjsExports);
+
+export { merge as default };

package/dist/src/ai/deepseek/DeepSeekChatBotAdapter.js

@@ -0,0 +1,107 @@
+import { __decorate, __metadata } from 'tslib';
+import { injectable } from '../../injection/index.js';
+import { OpenAI } from 'openai';
+import 'uuid';
+import '../../chatbot/metadata/ChatBotMetadataStore.js';
+import '../../chatbot/ChatBot.js';
+import { ChatBotAdapter } from '../../chatbot/ChatBotAdapter.js';
+import 'reflect-metadata';
+import '../../mindset/metadata/MindsetMetadataStore.js';
+import { MindsetOperator } from '../../mindset/MindsetOperator.js';
+
+let DeepSeekChatBotAdapter = class DeepSeekChatBotAdapter extends ChatBotAdapter {
+    deepSeek;
+    model;
+    constructor(mindset) {
+        super(mindset);
+        const model = process.env.DEEPSEEK_CHAT_MODEL;
+        const apiKey = process.env.DEEPSEEK_API_KEY;
+        const baseURL = process.env.DEEPSEEK_BASE_URL;
+        this.validateEnvVariables([model, apiKey, baseURL]);
+        this.model = model || 'deepseek-chat';
+        this.deepSeek = new OpenAI({
+            apiKey: apiKey,
+            baseURL: baseURL,
+        });
+    }
+    validateEnvVariables(envVariables) {
+        envVariables.forEach((envVariable) => {
+            if (!envVariable) {
+                throw new Error('Missing environment variable');
+            }
+        });
+    }
+    async generateNextChatItem(chatItems) {
+        const systemPrompt = await this.systemPrompt();
+        const tools = (await this.mindset.allFunctionsDescriptors()).map((fn) => {
+            const parameters = { ...fn.parameters, additionalProperties: false, type: 'object' };
+            return {
+                type: 'function',
+                function: { name: fn.name, description: fn.description, parameters, strict: true },
+            };
+        });
+        const response = await this.deepSeek.chat.completions.create({
+            model: this.model,
+            messages: [{ role: 'system', content: systemPrompt }, ...this.mapChatItems(chatItems)],
+            tools: tools,
+            tool_choice: 'auto',
+        });
+        let newChatItem;
+        const { tool_calls: responseFunctionCall, content: responseText } = response.choices?.[0]?.message ?? {};
+        if (responseText) {
+            newChatItem = await this.buildBotMessageItem(responseText);
+        }
+        else if (responseFunctionCall && responseFunctionCall[0]?.type == 'function') {
+            newChatItem = await this.buildFunctionCallItem(responseFunctionCall[0].id, responseFunctionCall[0].function.name, responseFunctionCall[0].function.arguments);
+        }
+        else {
+            throw new Error('Not supported DeepSeek Response');
+        }
+        return newChatItem;
+    }
+    mapChatItems(chatItems) {
+        const deepSeekInput = [];
+        for (const item of chatItems) {
+            const itemData = item.getData();
+            if (itemData.type === 'CONNECTION_MESSAGE') {
+                if (!itemData.content.text) {
+                    throw new Error('System message content is empty');
+                }
+                deepSeekInput.push({ role: 'user', content: itemData.content.text });
+            }
+            else if (itemData.type === 'BOT_MESSAGE') {
+                if (!itemData.content.text) {
+                    throw new Error('System message content is empty');
+                }
+                deepSeekInput.push({ role: 'assistant', content: itemData.content.text });
+            }
+            if (itemData.type === 'FUNCTION_CALL') {
+                deepSeekInput.push({
+                    role: 'assistant',
+                    tool_calls: [
+                        {
+                            id: itemData.content.id,
+                            type: 'function',
+                            function: {
+                                name: itemData.content.name,
+                                arguments: JSON.stringify(itemData.content.arguments),
+                            },
+                        },
+                    ],
+                });
+                deepSeekInput.push({
+                    role: 'tool',
+                    tool_call_id: itemData.content.id,
+                    content: itemData.content.result,
+                });
+            }
+        }
+        return deepSeekInput;
+    }
+};
+DeepSeekChatBotAdapter = __decorate([
+    injectable(),
+    __metadata("design:paramtypes", [MindsetOperator])
+], DeepSeekChatBotAdapter);
+
+export { DeepSeekChatBotAdapter };

package/dist/src/ai/openia/OpenaiChatBotAdapter.js

@@ -1,19 +1,19 @@
 import { __decorate, __metadata } from 'tslib';
 import { injectable } from '../../injection/index.js';
 import { OpenAI } from 'openai';
-import 'reflect-metadata';
-import '../../mindset/metadata/MindsetMetadataStore.js';
-import '../../core/chat/repository/IChatRepository.js';
-import '../../core/user/IUserRepository.js';
-import { MindsetOperator } from '../../mindset/MindsetOperator.js';
 import 'uuid';
 import '../../chatbot/metadata/ChatBotMetadataStore.js';
 import '../../chatbot/ChatBot.js';
 import { ChatBotAdapter } from '../../chatbot/ChatBotAdapter.js';
+import 'reflect-metadata';
+import '../../mindset/metadata/MindsetMetadataStore.js';
+import { MindsetOperator } from '../../mindset/MindsetOperator.js';
+import { Logger } from '../../logger/Logger.js';
 
 let OpenaiChatBotAdapter = class OpenaiChatBotAdapter extends ChatBotAdapter {
     openai = new OpenAI();
     model;
+    logger = new Logger('wabot:openai-chat-bot-adapter');
     constructor(mindset) {
         super(mindset);
         const model = process.env.OPENAI_CHAT_MODEL;
@@ -28,11 +28,13 @@ let OpenaiChatBotAdapter = class OpenaiChatBotAdapter extends ChatBotAdapter {
             const parameters = { ...fn.parameters, additionalProperties: false, type: 'object' };
             return { ...fn, type: 'function', parameters, strict: true };
         });
-        const response = await this.openai.responses.create({
+        const request = {
             model: this.model,
             input: [{ role: 'system', content: systemPrompt }, ...this.mapChatItems(chatItems)],
             tools,
-        });
+        };
+        this.logger.debug(`Call Api with Request: ${JSON.stringify(request)}`);
+        const response = await this.openai.responses.create(request);
         let newChatItem;
         if (response.output_text) {
             newChatItem = await this.buildBotMessageItem(response.output_text);

package/dist/src/channels/cmd/@cmd.js

@@ -1,11 +1,7 @@
 import '../../controller/channel/ChatResolver.js';
 import '../../controller/channel/UserResolver.js';
 import { container } from '../../injection/index.js';
-import '../../core/chat/repository/IChatRepository.js';
-import '../../core/user/IUserRepository.js';
 import { ControllerMetadataStore } from '../../controller/metadata/ControllerMetadataStore.js';
-import 'express';
-import 'socket.io';
 import { CmdChannel } from './CmdChannel.js';
 
 function cmd() {

package/dist/src/channels/cmd/CmdChannel.js

@@ -2,11 +2,7 @@ import { __decorate, __metadata } from 'tslib';
 import { ChatResolver } from '../../controller/channel/ChatResolver.js';
 import { UserResolver } from '../../controller/channel/UserResolver.js';
 import { injectable } from '../../injection/index.js';
-import '../../core/chat/repository/IChatRepository.js';
-import '../../core/user/IUserRepository.js';
 import '../../controller/metadata/ControllerMetadataStore.js';
-import 'express';
-import 'socket.io';
 import * as readline from 'readline';
 
 var CmdChannel_1;

package/dist/src/channels/express/ExpressProvider.js

@@ -0,0 +1,46 @@
+import { __decorate, __metadata } from 'tslib';
+import { HttpServerProvider } from '../http/HttpServerProvider.js';
+import express from 'express';
+import { singleton } from 'tsyringe';
+import bodyParser from 'body-parser';
+import { Logger } from '../../logger/Logger.js';
+
+let ExpressProvider = class ExpressProvider {
+    httpServerProvider;
+    expressApp = null;
+    logger = new Logger('wabot:express');
+    constructor(httpServerProvider) {
+        this.httpServerProvider = httpServerProvider;
+    }
+    getExpress() {
+        if (!this.expressApp) {
+            this.expressApp = this.createExpress();
+        }
+        return this.expressApp;
+    }
+    listen() {
+        this.httpServerProvider.listen();
+    }
+    createExpress() {
+        const expressApp = express();
+        expressApp.use(bodyParser.json());
+        expressApp.use((req, res, next) => {
+            const start = process.hrtime();
+            res.on('finish', () => {
+                const [seconds, nanoseconds] = process.hrtime(start);
+                const ms = (seconds * 1000 + nanoseconds / 1e6).toFixed(2);
+                this.logger.trace(`${req.method} ${req.originalUrl} ${res.statusCode} - ${ms}ms`);
+            });
+            next();
+        });
+        const httpServer = this.httpServerProvider.getHttpServer();
+        httpServer.on('request', expressApp);
+        return expressApp;
+    }
+};
+ExpressProvider = __decorate([
+    singleton(),
+    __metadata("design:paramtypes", [HttpServerProvider])
+], ExpressProvider);
+
+export { ExpressProvider };

package/dist/src/channels/http/HttpServerProvider.js

@@ -0,0 +1,31 @@
+import { __decorate } from 'tslib';
+import { Logger } from '../../logger/Logger.js';
+import { Server } from 'http';
+import { singleton } from 'tsyringe';
+
+let HttpServerProvider = class HttpServerProvider {
+    server = null;
+    listening = false;
+    logger = new Logger('wabot:http');
+    getHttpServer() {
+        if (!this.server) {
+            this.server = new Server();
+        }
+        return this.server;
+    }
+    listen() {
+        if (!this.server || this.listening) {
+            return;
+        }
+        this.listening = true;
+        const PORT = process.env.PORT || 3000;
+        this.server.listen(PORT, () => {
+            this.logger.info(`server listenig on port ${PORT}`);
+        });
+    }
+};
+HttpServerProvider = __decorate([
+    singleton()
+], HttpServerProvider);
+
+export { HttpServerProvider };

package/dist/src/channels/socket/@socket.js

@@ -0,0 +1,20 @@
+import '../../controller/channel/ChatResolver.js';
+import '../../controller/channel/UserResolver.js';
+import { container } from '../../injection/index.js';
+import { ControllerMetadataStore } from '../../controller/metadata/ControllerMetadataStore.js';
+import { SocketChannel } from './SocketChannel.js';
+import { SocketChannelConfig } from './SocketChannelConfig.js';
+
+function socket(config) {
+    return function (target, propertyKey) {
+        const store = container.resolve(ControllerMetadataStore);
+        store.saveChannelMetadata({
+            channelConstructor: SocketChannel,
+            functionName: propertyKey.toString(),
+            controllerConstructor: target.constructor,
+            channelConfig: new SocketChannelConfig(config.channel),
+        });
+    };
+}
+
+export { socket };

package/dist/src/channels/socket/SocketChannel.js

@@ -0,0 +1,79 @@
+import { __decorate, __metadata } from 'tslib';
+import { SocketChannelConfig } from './SocketChannelConfig.js';
+import { injectable } from '../../injection/index.js';
+import { ChatResolver } from '../../controller/channel/ChatResolver.js';
+import { UserResolver } from '../../controller/channel/UserResolver.js';
+import '../../controller/metadata/ControllerMetadataStore.js';
+import { SocketServerProvider } from './SocketServerProvider.js';
+
+var SocketChannel_1;
+let SocketChannel = SocketChannel_1 = class SocketChannel {
+    config;
+    socketServerProvider;
+    chatResolver;
+    userResolver;
+    callBack = null;
+    server;
+    constructor(config, socketServerProvider, chatResolver, userResolver) {
+        this.config = config;
+        this.socketServerProvider = socketServerProvider;
+        this.chatResolver = chatResolver;
+        this.userResolver = userResolver;
+        this.server = this.socketServerProvider.getSocketServer();
+    }
+    listen(callback) {
+        this.callBack = callback;
+    }
+    connect() {
+        this.server.on('connection', (socket) => {
+            socket.on(this.config.channel, async (message) => {
+                const trimmedInput = message.text.trim();
+                if (!trimmedInput) {
+                    return;
+                }
+                if (!message.chatId || !message.userId || !message.senderName) {
+                    socket.emit(this.config.channel, {
+                        error: 'Invalid message format. chatId, userId, and senderName are required.',
+                    });
+                    return;
+                }
+                const chatConnection = {
+                    id: message.chatId,
+                    chatType: 'PRIVATE',
+                    channelName: SocketChannel_1.name,
+                };
+                const chat = await this.chatResolver.resolve(chatConnection);
+                const userConnection = {
+                    id: message.userId,
+                    channelName: SocketChannel_1.name,
+                };
+                const user = await this.userResolver.resolve(userConnection);
+                if (!this.callBack)
+                    return;
+                this.callBack({
+                    chat,
+                    user,
+                    message: {
+                        chatConnection,
+                        userConnection,
+                        text: trimmedInput,
+                        senderName: message.senderName,
+                    },
+                    reply: (message) => {
+                        socket.emit(this.config.channel, message);
+                    },
+                });
+            });
+        });
+        this.socketServerProvider.listen();
+    }
+};
+SocketChannel = SocketChannel_1 = __decorate([
+    injectable(),
+    __metadata("design:paramtypes", [SocketChannelConfig,
+        SocketServerProvider,
+        ChatResolver,
+        UserResolver])
+], SocketChannel);
+
+export { SocketChannel };

package/dist/src/channels/socket/SocketChannelConfig.js

@@ -0,0 +1,15 @@
+import { __decorate, __metadata } from 'tslib';
+import { injectable } from '../../injection/index.js';
+
+let SocketChannelConfig = class SocketChannelConfig {
+    channel;
+    constructor(channel) {
+        this.channel = channel;
+    }
+};
+SocketChannelConfig = __decorate([
+    injectable(),
+    __metadata("design:paramtypes", [String])
+], SocketChannelConfig);
+
+export { SocketChannelConfig };

package/dist/src/channels/socket/SocketServerProvider.js

@@ -0,0 +1,50 @@
+import { __decorate, __metadata } from 'tslib';
+import { Logger } from '../../logger/Logger.js';
+import { HttpServerProvider } from '../http/HttpServerProvider.js';
+import { Server } from 'socket.io';
+import { singleton } from 'tsyringe';
+
+let SocketServerProvider = class SocketServerProvider {
+    httpServerProvider;
+    socketServer = null;
+    logger = new Logger('wabot:socket');
+    constructor(httpServerProvider) {
+        this.httpServerProvider = httpServerProvider;
+    }
+    getSocketServer() {
+        if (!this.socketServer) {
+            this.socketServer = this.createSocketServer();
+        }
+        return this.socketServer;
+    }
+    listen() {
+        this.httpServerProvider.listen();
+    }
+    createSocketServer() {
+        const httpServer = this.httpServerProvider.getHttpServer();
+        const socketServer = new Server(httpServer, {
+            cors: {
+                origin: '*',
+            },
+        });
+        socketServer.on('connection', (socket) => {
+            this.logger.trace(`socket:${socket.id} connection`);
+            socket.onAny((event) => {
+                this.logger.trace(`socket:${socket.id} emmits ${event}`);
+            });
+            socket.on('disconnect', (reason) => {
+                this.logger.trace(`socket:${socket.id} disconnect with reason: ${reason}`);
+            });
+        });
+        httpServer.on('listening', () => {
+            this.logger.info(`socket server listening`);
+        });
+        return socketServer;
+    }
+};
+SocketServerProvider = __decorate([
+    singleton(),
+    __metadata("design:paramtypes", [HttpServerProvider])
+], SocketServerProvider);
+
+export { SocketServerProvider };

package/dist/src/channels/telegram/@telegram.js

@@ -1,11 +1,7 @@
 import { container } from '../../injection/index.js';
 import '../../controller/channel/ChatResolver.js';
 import '../../controller/channel/UserResolver.js';
-import '../../core/chat/repository/IChatRepository.js';
-import '../../core/user/IUserRepository.js';
 import { ControllerMetadataStore } from '../../controller/metadata/ControllerMetadataStore.js';
-import 'express';
-import 'socket.io';
 import { TelegramChannel } from './TelegramChannel.js';
 import { TelegramChannelConfig } from './TelegramChannelConfig.js';
 

package/dist/src/channels/telegram/TelegramChannel.js

@@ -2,11 +2,7 @@ import { __decorate, __metadata } from 'tslib';
 import { ChatResolver } from '../../controller/channel/ChatResolver.js';
 import { UserResolver } from '../../controller/channel/UserResolver.js';
 import { injectable } from '../../injection/index.js';
-import '../../core/chat/repository/IChatRepository.js';
-import '../../core/user/IUserRepository.js';
 import '../../controller/metadata/ControllerMetadataStore.js';
-import 'express';
-import 'socket.io';
 import { Bot } from 'grammy';
 import { TelegramChannelConfig } from './TelegramChannelConfig.js';
 

package/dist/src/channels/wabot/WabotDevConnection.js

@@ -0,0 +1,57 @@
+import { __decorate, __metadata } from 'tslib';
+import { singleton } from '../../injection/index.js';
+import { Logger } from '../../logger/Logger.js';
+import { io } from 'socket.io-client';
+import { devEmitEvent } from './WabotDevSocketContracts.js';
+
+var WabotDevConnection_1;
+let WabotDevConnection = WabotDevConnection_1 = class WabotDevConnection {
+    devProxy;
+    devProxySocket = null;
+    devToken;
+    logger = new Logger('wabot:dev-connection');
+    static isTokenAvailable() {
+        return !!process.env.WABOT_DEV_TOKEN;
+    }
+    constructor() {
+        if (!WabotDevConnection_1.isTokenAvailable()) {
+            throw new Error('WABOT_DEV_TOKEN is not set in environment variables');
+        }
+        this.devToken = process.env.WABOT_DEV_TOKEN;
+        this.devProxy = process.env.WABOT_DEV_PROXY ?? 'https://proxy.wabot.dev';
+    }
+    async getSocket() {
+        if (this.devProxySocket) {
+            return this.devProxySocket;
+        }
+        return new Promise((resolve, reject) => {
+            const devProxySocket = io(this.devProxy, { autoConnect: false });
+            devProxySocket.on('connect', async () => {
+                try {
+                    const req = {
+                        token: this.devToken,
+                    };
+                    this.logger.debug('dev connection request');
+                    const ack = await devProxySocket.emitWithAck(devEmitEvent.DEV_CONNECTION, req);
+                    if (ack != 'OK') {
+                        return reject(new Error('Dev connection failed'));
+                    }
+                    this.logger.debug('success dev connection');
+                    this.devProxySocket = devProxySocket;
+                    resolve(devProxySocket);
+                }
+                catch (err) {
+                    this.logger.error(err);
+                    reject(err);
+                }
+            });
+            devProxySocket.connect();
+        });
+    }
+};
+WabotDevConnection = WabotDevConnection_1 = __decorate([
+    singleton(),
+    __metadata("design:paramtypes", [])
+], WabotDevConnection);
+
+export { WabotDevConnection };

package/dist/src/channels/wabot/WabotDevSocketContracts.js

@@ -0,0 +1,10 @@
+const devListentEvent = {
+    DEV_WATSAPP_WEBHOOK: 'dev-whatsapp-webhook',
+};
+const devEmitEvent = {
+    DEV_CONNECTION: 'dev-connection',
+    DEV_SEND_WHATSAPP: 'dev-send-whatsapp',
+    DEV_SEND_WHATSAPP_TEMPLATE: 'dev-send-whatsapp-template',
+};
+
+export { devEmitEvent, devListentEvent };

package/dist/src/channels/whatsapp/@whatsapp.js

@@ -2,11 +2,7 @@ import { container } from '../../injection/index.js';
 import { WhatsappChannelConfig } from './WhatsAppChannelConfig.js';
 import '../../controller/channel/ChatResolver.js';
 import '../../controller/channel/UserResolver.js';
-import '../../core/chat/repository/IChatRepository.js';
-import '../../core/user/IUserRepository.js';
 import { ControllerMetadataStore } from '../../controller/metadata/ControllerMetadataStore.js';
-import 'express';
-import 'socket.io';
 import { WhatsAppChannel } from './WhatsAppChannel.js';
 
 function whatsapp(config) {

package/dist/src/channels/whatsapp/EnvWhatsAppRepository.js

@@ -0,0 +1,49 @@
+import { __decorate, __metadata } from 'tslib';
+import { singleton } from '../../injection/index.js';
+import { WhatsApp } from './WhatsApp.js';
+import { WabotEnv } from '../../env/WabotEnv.js';
+
+let EnvWhatsAppRepository = class EnvWhatsAppRepository {
+    env;
+    constructor(env) {
+        this.env = env;
+    }
+    async findBySlug(slug) {
+        const whatsApp = this.getFromEnvVars();
+        if (whatsApp.getSlug() !== slug) {
+            throw new Error(`Not found WhatsApp configuration in env variables for the required slug '${slug}'`);
+        }
+        return whatsApp;
+    }
+    async findByBusinessNumber(number) {
+        const whatsApp = this.getFromEnvVars();
+        if (!whatsApp.getBussinessNumber(number)) {
+            throw new Error(`Not found WhatsApp configuration in env variables for the required number '${number}'`);
+        }
+        return whatsApp;
+    }
+    getFromEnvVars() {
+        const whatsApp = new WhatsApp({
+            verifyToken: this.env.requireString('WHATSAPP_HOOK_TOKEN'),
+            slug: this.env.requireString('WHATSAPP_HOOK_SLUG'),
+            appSecret: this.env.requireString('WHATSAPP_APP_SECRET'),
+            businessAccount: {
+                id: this.env.requireString('WHATSAPP_ACCOUNT_ID'),
+            },
+            accessToken: this.env.requireString('WHATSAPP_ACCESS_TOKEN'),
+            businessNumbers: [
+                {
+                    id: this.env.requireString('WHATSAPP_BUSINESS_NUMBER_ID'),
+                    number: this.env.requireString('WHATSAPP_BUSINESS_NUMBER'),
+                },
+            ],
+        });
+        return whatsApp;
+    }
+};
+EnvWhatsAppRepository = __decorate([
+    singleton(),
+    __metadata("design:paramtypes", [WabotEnv])
+], EnvWhatsAppRepository);
+
+export { EnvWhatsAppRepository };

package/dist/src/channels/whatsapp/PgWhatsAppRepository.js

@@ -0,0 +1,41 @@
+import { __decorate, __metadata } from 'tslib';
+import { Pool } from 'pg';
+import { WhatsApp } from './WhatsApp.js';
+import { singleton } from '../../injection/index.js';
+import { PgCrudRepository } from '../../repository/pg/PgCrudRepository.js';
+
+let PgWhatsAppRepository = class PgWhatsAppRepository extends PgCrudRepository {
+    constructor(pool) {
+        super(pool, {
+            table: 'whatsapp',
+            constructor: WhatsApp,
+            schema: 'wabot',
+        });
+    }
+    async findBySlug(slug) {
+        const sql = `
+      SELECT ${this.columns}
+      FROM ${this.table}
+      WHERE data @> $1
+      LIMIT 1
+    `;
+        const items = await this.query(sql, [JSON.stringify({ slug })]);
+        return items.at(0) ?? null;
+    }
+    async findByBusinessNumber(number) {
+        const sql = `
+      SELECT ${this.columns}
+      FROM ${this.table}
+      WHERE data->'businessNumbers' @> $1
+      LIMIT 1
+    `;
+        const items = await this.query(sql, [JSON.stringify([{ number }])]);
+        return items.at(0) ?? null;
+    }
+};
+PgWhatsAppRepository = __decorate([
+    singleton(),
+    __metadata("design:paramtypes", [Pool])
+], PgWhatsAppRepository);
+
+export { PgWhatsAppRepository };

package/dist/src/channels/whatsapp/WhatsApp.js

@@ -0,0 +1,32 @@
+import '../../core/chat/repository/IChatRepository.js';
+import { Persistent } from '../../core/Persistent.js';
+import '../../core/user/IUserRepository.js';
+
+class WhatsApp extends Persistent {
+    getVerifyToken() {
+        return this.data.verifyToken;
+    }
+    getSlug() {
+        return this.data.slug;
+    }
+    getBusinessAccount() {
+        return this.data.businessAccount;
+    }
+    getAppSecret() {
+        return this.data.appSecret;
+    }
+    getBusinessNumbers() {
+        return this.data.businessNumbers;
+    }
+    getAccessToken() {
+        return this.data.accessToken;
+    }
+    hasBusinessNumber(number) {
+        return this.data.businessNumbers.some((x) => x.number === number);
+    }
+    getBussinessNumber(number) {
+        return this.data.businessNumbers.find((x) => x.number === number) ?? null;
+    }
+}
+
+export { WhatsApp };