@gamastudio/sendwave-provider 0.0.2-dev

package/build/provider/core.js

@@ -0,0 +1,169 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SendWaveCore = void 0;
+const node_events_1 = require("node:events");
+const parserMsg_1 = require("../utils/parserMsg");
+const home_1 = require("../constants/html/home");
+const connect_1 = require("../constants/html/connect");
+const error_1 = require("../constants/html/error");
+class SendWaveCore extends node_events_1.EventEmitter {
+    constructor(port, queue, globalVendorArgs) {
+        super();
+        this.codeQR = "";
+        this.indexHome = (_, res) => {
+            res.setHeader("Content-Type", "text/html");
+            res.end(home_1.htmlHome);
+        };
+        this.indexConnect = (_, res) => {
+            const html = (0, connect_1.htmlConnect)(this.codeQR);
+            res.setHeader("Content-Type", "text/html");
+            res.end(html);
+        };
+        this.indexError = (_, res) => {
+            res.setHeader("Content-Type", "text/html");
+            res.end((0, error_1.htmlError)("Failed to connect to Instance"));
+        };
+        this.handlerLocalMedia = (_, res) => {
+            res.end("Media handler not implemented yet");
+        };
+        this.emitQR = (qr) => {
+            this.codeQR = qr;
+        };
+        this.incomingMsg = (req, res) => {
+            var _a;
+            try {
+                const { body } = req;
+                if (!["messages.upsert", "send_message"].includes(body.event)) {
+                    return res.end("Message queued");
+                }
+                const data = (0, parserMsg_1.parseIncomingMsg)(body);
+                if (!data)
+                    return res.end("Message queued");
+                this.flowMessage(data);
+                if (!(data === null || data === void 0 ? void 0 : data.fromMe)) {
+                    // Emit message event for queue flow system integration
+                    this.emit("user-message", data);
+                    if ((_a = this.globalVendorArgs.message) === null || _a === void 0 ? void 0 : _a.mergeMessage) {
+                        this.bufferMessage(data);
+                    }
+                    else {
+                        this.messageQueue.enqueue(() => this.processMessage(data));
+                    }
+                }
+                return res.end("Message queued");
+            }
+            catch (e) {
+                console.error("[IncomingMsg Error]:", e);
+                res.statusCode = 500;
+                return res.end("Internal Server Error");
+            }
+        };
+        this.messageBuffers = {};
+        this.port = port;
+        this.messageQueue = queue;
+        this.globalVendorArgs = globalVendorArgs;
+    }
+    processMessage(message) {
+        return new Promise((resolve, reject) => {
+            try {
+                this.emit("message", message);
+                resolve();
+            }
+            catch (error) {
+                reject(error);
+            }
+        });
+    }
+    bufferMessage(data) {
+        var _a;
+        const user = data.from;
+        const now = Date.now();
+        if (!this.messageBuffers[user]) {
+            this.messageBuffers[user] = {
+                messages: [],
+                messageTimeout: null,
+                maxWaitTimeout: null,
+                lastData: null,
+                lastMessageTime: now,
+                messageCount: 0,
+            };
+        }
+        const buffer = this.messageBuffers[user];
+        buffer.messages.push(data.body);
+        buffer.lastData = data;
+        buffer.messageCount++;
+        // Calculate time between messages
+        const timeBetweenMessages = now - buffer.lastMessageTime;
+        buffer.lastMessageTime = now;
+        // Clear existing timeout
+        if (buffer.messageTimeout) {
+            clearTimeout(buffer.messageTimeout);
+            buffer.messageTimeout = null;
+        }
+        // Set max wait timeout only on first message
+        if (buffer.messages.length === 1) {
+            const maxWaitTime = ((_a = this.globalVendorArgs.message) === null || _a === void 0 ? void 0 : _a.maxWaitTime) || 30;
+            buffer.maxWaitTimeout = setTimeout(() => {
+                this.processBufferedMessages(user);
+            }, maxWaitTime * 1000);
+        }
+        // Smart timeout calculation
+        let timeout = this.calculateSmartTimeout(data.body, timeBetweenMessages, buffer.messageCount);
+        buffer.messageTimeout = setTimeout(() => {
+            this.processBufferedMessages(user);
+        }, timeout);
+    }
+    calculateSmartTimeout(messageText, timeBetweenMessages, messageCount) {
+        var _a, _b, _c, _d;
+        const baseTimeout = (((_a = this.globalVendorArgs.message) === null || _a === void 0 ? void 0 : _a.timeMergeMessage) || 3) * 1000;
+        const shortThreshold = ((_b = this.globalVendorArgs.message) === null || _b === void 0 ? void 0 : _b.shortMessageThreshold) || 10;
+        const adaptiveTimer = (_d = (_c = this.globalVendorArgs.message) === null || _c === void 0 ? void 0 : _c.adaptiveTimer) !== null && _d !== void 0 ? _d : true;
+        let timeout = baseTimeout;
+        // If message is very short, assume more are coming
+        if (messageText.length < shortThreshold) {
+            timeout = Math.max(1000, timeout * 0.5); // Reduce timeout by 50%
+        }
+        // If adaptive timer is enabled
+        if (adaptiveTimer) {
+            // If messages are coming very fast (< 2 seconds), extend timeout
+            if (timeBetweenMessages < 2000 && messageCount > 1) {
+                timeout = Math.max(timeout, 4000); // At least 4 seconds
+            }
+            // If it's the first few messages, be more aggressive
+            if (messageCount <= 2) {
+                timeout = Math.max(2000, timeout * 0.7); // Reduce by 30%
+            }
+        }
+        return timeout;
+    }
+    processBufferedMessages(user) {
+        const buffer = this.messageBuffers[user];
+        if (!buffer || buffer.messages.length === 0)
+            return;
+        // Clear all timeouts
+        if (buffer.messageTimeout)
+            clearTimeout(buffer.messageTimeout);
+        if (buffer.maxWaitTimeout)
+            clearTimeout(buffer.maxWaitTimeout);
+        const fullMessage = buffer.messages.join(" ");
+        // Process the merged message
+        this.messageQueue.enqueue(() => this.processMessage({
+            ...buffer.lastData,
+            body: fullMessage,
+        }));
+        // Clean up buffer
+        delete this.messageBuffers[user];
+    }
+    flowMessage(message) {
+        return new Promise((resolve, reject) => {
+            try {
+                this.emit("flow-message", message);
+                resolve();
+            }
+            catch (error) {
+                reject(error);
+            }
+        });
+    }
+}
+exports.SendWaveCore = SendWaveCore;

package/build/provider/index.d.ts

@@ -0,0 +1 @@
+export * from './provider';

package/build/provider/index.js

@@ -0,0 +1,17 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./provider"), exports);

package/build/provider/provider.d.ts

@@ -0,0 +1,85 @@
+import { ProviderClass } from "@builderbot/bot";
+import Queue from "queue-promise";
+import { SendWaveCore } from "./core";
+import { BotContext, BotCtxMiddlewareOptions } from "@builderbot/bot/dist/types";
+import { GlobalVendorArgs } from "../core/interface/types";
+import { SenderMessage } from "./sender";
+import { ParsedMessage } from "../core/interface";
+export declare class SendWaveProvider extends ProviderClass<SendWaveCore> {
+    queue: Queue;
+    vendor: SendWaveCore;
+    private sendwaveApi?;
+    state: Boolean;
+    instanceConnected: Boolean;
+    sender: SenderMessage;
+    globalVendorArgs: GlobalVendorArgs;
+    constructor(args: Partial<GlobalVendorArgs>);
+    protected initVendor(): Promise<any>;
+    protected beforeHttpServerInit: () => Promise<void>;
+    protected getApiQrConnect: () => Promise<void>;
+    protected afterHttpServerInit(): Promise<void>;
+    saveFile(_: any, options?: {
+        path: string;
+    }): Promise<string>;
+    createInstance(): void;
+    busEvents: () => ({
+        event: string;
+        func: (payload: BotContext) => void;
+    } | {
+        event: string;
+        func: (payload: ParsedMessage) => void;
+    })[];
+    listenOnEvents(vendor: SendWaveCore): Promise<void>;
+    sendFlow(data: {
+        event: string;
+        name: string;
+        from: string;
+    }): void;
+    initAll: (port: number, opts?: Pick<BotCtxMiddlewareOptions, "blacklist">) => void;
+    sendMessage(from: string, text: any, options?: any): Promise<any>;
+    sendText(...args: Parameters<SenderMessage["sendText"]>): Promise<import("axios").AxiosResponse<any, any, {}> | undefined>;
+    sendList(...args: Parameters<SenderMessage["sendList"]>): Promise<import("axios").AxiosResponse<any, any, {}> | undefined>;
+    sendImage(...args: Parameters<SenderMessage["sendImage"]>): Promise<import("axios").AxiosResponse<any, any, {}> | undefined>;
+    sendVideo(...args: Parameters<SenderMessage["sendVideo"]>): Promise<import("axios").AxiosResponse<any, any, {}> | undefined>;
+    sendAudio(...args: Parameters<SenderMessage["sendAudio"]>): Promise<import("axios").AxiosResponse<any, any, {}> | undefined>;
+    sendFile(...args: Parameters<SenderMessage["sendFile"]>): Promise<import("axios").AxiosResponse<any, any, {}> | undefined>;
+    sendPresence(...args: Parameters<SenderMessage["sendPresence"]>): Promise<import("axios").AxiosResponse<any, any, {}> | undefined>;
+    sendVoice(...args: Parameters<SenderMessage["sendVoice"]>): Promise<import("axios").AxiosResponse<any, any, {}> | undefined>;
+    sendButton(...args: Parameters<SenderMessage["sendButton"]>): Promise<import("axios").AxiosResponse<any, any, {}> | undefined>;
+    /**
+     * Reset user timeout for queue flow system
+     */
+    resetUserTimeout(from: string, name?: string): {
+        isActive: boolean;
+        from: string;
+        name: string | undefined;
+    } | undefined;
+    /**
+     * Clear user timeout manually
+     */
+    clearUserTimeout(from: string): void;
+    /**
+     * Force clear all user data from queue flow
+     */
+    forceClearUser(from: string): void;
+    /**
+     * Check if user is ignored by queue flow system
+     */
+    isUserIgnored(from: string): boolean;
+    /**
+     * Get queue flow statistics
+     */
+    getQueueFlowStats(): {
+        activeTimeouts: number;
+        ignoredUsers: number;
+        config: Required<import("../utils/queueFlow").QueueFlowConfig>;
+    };
+    /**
+     * Listen to queue flow events
+     */
+    onQueueFlowEvent(event: string, callback: (data: any) => void): void;
+    /**
+     * Remove queue flow event listeners
+     */
+    offQueueFlowEvent(event: string, callback?: (data: any) => void): void;
+}

package/build/provider/provider.js

@@ -0,0 +1,375 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SendWaveProvider = void 0;
+const bot_1 = require("@builderbot/bot");
+const queue_promise_1 = __importDefault(require("queue-promise"));
+const core_1 = require("./core");
+const axios_1 = __importDefault(require("axios"));
+const https_1 = require("https");
+const sender_1 = require("./sender");
+const detectorMedia_1 = require("../utils/detectorMedia");
+const queueFlow_1 = require("../utils/queueFlow");
+const body_parser_1 = __importDefault(require("body-parser"));
+const cors_1 = __importDefault(require("cors"));
+const sirv_1 = __importDefault(require("sirv"));
+const assets = (0, sirv_1.default)("public/assets", { dev: true });
+class SendWaveProvider extends bot_1.ProviderClass {
+    constructor(args) {
+        var _a;
+        super();
+        this.queue = new queue_promise_1.default();
+        this.state = false;
+        this.instanceConnected = false;
+        this.globalVendorArgs = {
+            name: "bot",
+            url: "https://sendwave-api.gamastudio.co",
+            port: 3000,
+            apiKey: "",
+            delay: 0,
+            linkPreview: true,
+            message: {
+                mergeMessage: false,
+                timeMergeMessage: 3,
+            },
+            queueFlow: {
+                enabled: false,
+                warningTimeout: 30 * 60 * 1000, // 30 minutes
+                endTimeout: 2 * 60 * 1000, // 2 minutes
+                warningMessage: "⏳ Parece que has estado inactivo. ¿Sigues ahí?",
+            },
+        };
+        this.beforeHttpServerInit = async () => {
+            this.server = this.server
+                .use(body_parser_1.default.json())
+                .use((req, _, next) => {
+                req["globalVendorArgs"] = this.globalVendorArgs;
+                return next();
+            })
+                .use((0, cors_1.default)({ origin: "*", methods: "GET,POST" }))
+                .use("/assets", assets)
+                .get("/", async (req, res) => {
+                if (this.state && this.instanceConnected) {
+                    await this.afterHttpServerInit();
+                    return this.vendor.indexHome(req, res);
+                }
+                else if (!this.state && this.instanceConnected) {
+                    await this.afterHttpServerInit();
+                    this.getApiQrConnect();
+                    return this.vendor.indexConnect(req, res);
+                }
+                else {
+                }
+                return this.vendor.indexError(req, res);
+            })
+                .post("/webhook", this.vendor.incomingMsg);
+        };
+        this.getApiQrConnect = async () => {
+            var _a;
+            try {
+                const { data } = await ((_a = this.sendwaveApi) === null || _a === void 0 ? void 0 : _a.get(`/instance/connect/${this.globalVendorArgs.name}`));
+                this.vendor.emitQR(data === null || data === void 0 ? void 0 : data.base64);
+            }
+            catch (error) {
+                console.log(error === null || error === void 0 ? void 0 : error.response.data);
+                return;
+            }
+        };
+        this.busEvents = () => [
+            {
+                event: "auth_failure",
+                func: (payload) => this.emit("auth_failure", payload),
+            },
+            {
+                event: "notice",
+                func: ({ instructions, title }) => this.emit("notice", { instructions, title }),
+            },
+            {
+                event: "ready",
+                func: () => this.emit("ready", true),
+            },
+            {
+                event: "message",
+                func: (payload) => {
+                    var _a;
+                    // Auto-reset timeout for queue flow when user sends a message (AUTOMATIC)
+                    if (((_a = this.globalVendorArgs.queueFlow) === null || _a === void 0 ? void 0 : _a.enabled) && !payload.from.includes("@")) {
+                        this.resetUserTimeout(payload.from, payload.name);
+                    }
+                    this.emit("message", payload);
+                },
+            },
+            {
+                event: "flow-message",
+                func: (payload) => {
+                    this.emit("flow-message", payload);
+                },
+            },
+            {
+                event: "host",
+                func: (payload) => {
+                    this.emit("host", payload);
+                },
+            },
+        ];
+        this.initAll = (port, opts) => {
+            this.globalVendorArgs.port = port;
+            const methods = {
+                sendMessage: this.sendMessage,
+                sendList: this.sendList,
+                sendText: this.sendText,
+                sendImage: this.sendImage,
+                sendVideo: this.sendVideo,
+                sendAudio: this.sendAudio,
+                sendFile: this.sendFile,
+                sendVoice: this.sendVoice,
+                sendPresence: this.sendPresence,
+                sendButton: this.sendButton,
+                provider: this,
+                blacklist: opts === null || opts === void 0 ? void 0 : opts.blacklist,
+                dispatch: (customEvent, payload) => {
+                    this.emit("message", {
+                        ...payload,
+                        body: bot_1.utils.setEvent(customEvent),
+                        name: payload.name,
+                        from: bot_1.utils.removePlus(payload.from),
+                    });
+                },
+            };
+            this.initVendor()
+                .then((v) => this.listenOnEvents(v))
+                .then(() => {
+                this.beforeHttpServerInit();
+                this.start(methods, (routes) => {
+                    this.emit("notice", {
+                        title: "🛜  HTTP Server ON ",
+                        instructions: routes,
+                    });
+                    this.afterHttpServerInit();
+                });
+            });
+            return;
+        };
+        const cleanArgs = Object.fromEntries(Object.entries(args).filter(([_, v]) => v !== undefined));
+        this.globalVendorArgs = { ...this.globalVendorArgs, ...cleanArgs };
+        this.queue = new queue_promise_1.default({
+            concurrent: 50,
+            interval: 100,
+            start: true,
+        });
+        // Initialize queue flow system if enabled
+        if ((_a = this.globalVendorArgs.queueFlow) === null || _a === void 0 ? void 0 : _a.enabled) {
+            queueFlow_1.queueFlow.updateConfig({
+                warningTimeout: this.globalVendorArgs.queueFlow.warningTimeout,
+                endTimeout: this.globalVendorArgs.queueFlow.endTimeout,
+                warningMessage: this.globalVendorArgs.queueFlow.warningMessage,
+            });
+        }
+        this.createInstance();
+        this.on("ready", (isReady) => {
+            console.log("Instance connection status:", isReady ? "Connected to server" : "Disconnected from server");
+            // Puedes emitir eventos a websockets aquí, notificar a frontends, etc.
+        });
+        this.sender = new sender_1.SenderMessage(this.globalVendorArgs);
+    }
+    initVendor() {
+        const vendor = new core_1.SendWaveCore(this.globalVendorArgs.port, this.queue, this.globalVendorArgs);
+        this.vendor = vendor;
+        return Promise.resolve(this.vendor);
+    }
+    async afterHttpServerInit() {
+        var _a, _b, _c;
+        try {
+            await ((_a = this.sendwaveApi) === null || _a === void 0 ? void 0 : _a.get(`/instance/connectionState/${this.globalVendorArgs.name}`).then((res) => {
+                var _a;
+                const data = res.data;
+                if (((_a = data === null || data === void 0 ? void 0 : data.instance) === null || _a === void 0 ? void 0 : _a.state) === "open") {
+                    this.instanceConnected = true;
+                    this.state = true;
+                    this.emit("ready", true);
+                }
+                else {
+                    this.instanceConnected = true;
+                    this.emit("ready", false);
+                    this.getApiQrConnect();
+                    this.state = false;
+                }
+            }));
+        }
+        catch (error) {
+            this.instanceConnected = false;
+            this.emit("auth_failure", {
+                instructions: `Error al autenticar: ${(_c = (_b = error === null || error === void 0 ? void 0 : error.response) === null || _b === void 0 ? void 0 : _b.data) === null || _c === void 0 ? void 0 : _c.error}`,
+            });
+        }
+    }
+    saveFile(_, options) {
+        return new Promise((resolve, reject) => {
+            try {
+                const { path } = options || { path: "" };
+                resolve(path);
+            }
+            catch (e) {
+                reject(e);
+            }
+        });
+    }
+    createInstance() {
+        var _a;
+        const url = typeof ((_a = this.globalVendorArgs) === null || _a === void 0 ? void 0 : _a.url) === "string" &&
+            this.globalVendorArgs.url.trim()
+            ? this.globalVendorArgs.url.trim()
+            : "https://sendwave-api.gamastudio.co";
+        this.sendwaveApi = axios_1.default.create({
+            baseURL: url,
+            httpsAgent: new https_1.Agent({ rejectUnauthorized: false }),
+            headers: {
+                "Content-Type": "application/json",
+                apikey: this.globalVendorArgs.apiKey,
+            },
+        });
+    }
+    async listenOnEvents(vendor) {
+        const listEvents = this.busEvents();
+        for (const { event, func } of listEvents) {
+            vendor.on(event, func);
+        }
+    }
+    sendFlow(data) {
+        this.emit("message", {
+            body: bot_1.utils.setEvent(data.event),
+            name: data.name,
+            from: data.from,
+        });
+    }
+    async sendMessage(from, text, options) {
+        options = { ...options["options"] };
+        let mss = { from, text, options };
+        if (options.media) {
+            const { media, mediaType, fileName } = await detectorMedia_1.detectorMedia.processMedia(options.media);
+            switch (mediaType) {
+                case "image":
+                    return await this.sender.sendImage({
+                        ...mss,
+                        url: media,
+                        text: text,
+                    });
+                case "video":
+                    return await this.sender.sendVideo({
+                        ...mss,
+                        url: media,
+                        text: text,
+                    });
+                case "audio":
+                    return await this.sender.sendVoice({ ...mss, url: media });
+                case "document":
+                    return await this.sender.sendFile({
+                        ...mss,
+                        url: media,
+                        fileName,
+                        text: text,
+                    });
+                default:
+                    return await this.sender.sendText(mss);
+            }
+        }
+        else {
+            return await this.sender.sendText(mss);
+        }
+    }
+    // Métodos de conveniencia para mantener la API limpia
+    sendText(...args) {
+        return this.sender.sendText(...args);
+    }
+    sendList(...args) {
+        return this.sender.sendList(...args);
+    }
+    sendImage(...args) {
+        return this.sender.sendImage(...args);
+    }
+    sendVideo(...args) {
+        return this.sender.sendVideo(...args);
+    }
+    sendAudio(...args) {
+        return this.sender.sendAudio(...args);
+    }
+    sendFile(...args) {
+        return this.sender.sendFile(...args);
+    }
+    sendPresence(...args) {
+        return this.sender.sendPresence(...args);
+    }
+    sendVoice(...args) {
+        return this.sender.sendVoice(...args);
+    }
+    sendButton(...args) {
+        return this.sender.sendButton(...args);
+    }
+    // Queue Flow Management Methods
+    /**
+     * Reset user timeout for queue flow system
+     */
+    resetUserTimeout(from, name) {
+        var _a;
+        if (!((_a = this.globalVendorArgs.queueFlow) === null || _a === void 0 ? void 0 : _a.enabled))
+            return;
+        return queueFlow_1.queueFlow.resetUserTimeout({
+            provider: this,
+            from,
+            name,
+        });
+    }
+    /**
+     * Clear user timeout manually
+     */
+    clearUserTimeout(from) {
+        var _a;
+        if (!((_a = this.globalVendorArgs.queueFlow) === null || _a === void 0 ? void 0 : _a.enabled))
+            return;
+        queueFlow_1.queueFlow.clearUserTimeout(from);
+    }
+    /**
+     * Force clear all user data from queue flow
+     */
+    forceClearUser(from) {
+        var _a;
+        if (!((_a = this.globalVendorArgs.queueFlow) === null || _a === void 0 ? void 0 : _a.enabled))
+            return;
+        queueFlow_1.queueFlow.forceClearUser(from);
+    }
+    /**
+     * Check if user is ignored by queue flow system
+     */
+    isUserIgnored(from) {
+        var _a;
+        if (!((_a = this.globalVendorArgs.queueFlow) === null || _a === void 0 ? void 0 : _a.enabled))
+            return false;
+        return queueFlow_1.queueFlow.isUserIgnored(from);
+    }
+    /**
+     * Get queue flow statistics
+     */
+    getQueueFlowStats() {
+        return queueFlow_1.queueFlow.getUserStats();
+    }
+    /**
+     * Listen to queue flow events
+     */
+    onQueueFlowEvent(event, callback) {
+        queueFlow_1.queueFlow.on(event, callback);
+    }
+    /**
+     * Remove queue flow event listeners
+     */
+    offQueueFlowEvent(event, callback) {
+        if (callback) {
+            queueFlow_1.queueFlow.off(event, callback);
+        }
+        else {
+            queueFlow_1.queueFlow.removeAllListeners(event);
+        }
+    }
+}
+exports.SendWaveProvider = SendWaveProvider;

package/build/provider/sender.d.ts

@@ -0,0 +1,16 @@
+import { GlobalVendorArgs, ProviderInterface, SendButton, SendList, SendMedia, SendMessage, SendPresence } from "../core/interface";
+export declare class SenderMessage implements ProviderInterface {
+    private sendwaveApi?;
+    private globalVendorArgs?;
+    constructor(args: Partial<GlobalVendorArgs>);
+    sendPresence(data: SendPresence): Promise<import("axios").AxiosResponse<any, any, {}> | undefined>;
+    sendText(data: SendMessage): Promise<import("axios").AxiosResponse<any, any, {}> | undefined>;
+    sendList(data: SendList): Promise<import("axios").AxiosResponse<any, any, {}> | undefined>;
+    sendMedia(data: SendMedia): Promise<import("axios").AxiosResponse<any, any, {}> | undefined>;
+    sendFile(data: SendMedia): Promise<import("axios").AxiosResponse<any, any, {}> | undefined>;
+    sendImage(data: SendMedia): Promise<import("axios").AxiosResponse<any, any, {}> | undefined>;
+    sendAudio(data: SendMedia): Promise<import("axios").AxiosResponse<any, any, {}> | undefined>;
+    sendVideo(data: SendMedia): Promise<import("axios").AxiosResponse<any, any, {}> | undefined>;
+    sendVoice(data: SendMedia): Promise<import("axios").AxiosResponse<any, any, {}> | undefined>;
+    sendButton(data: SendButton): Promise<import("axios").AxiosResponse<any, any, {}> | undefined>;
+}