telegram-badge 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Alexander Kireyev
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,134 @@
+# 🛡️ Telegram Group Badge Generator
+
+[![Build Status](https://github.com/chatman-media/telegram-badge/workflows/CI/badge.svg)](https://github.com/chatman-media/telegram-badge/actions)
+[![npm version](https://badge.fury.io/js/telegram-badge.svg)](https://badge.fury.io/js/telegram-badge)
+[![TypeScript](https://img.shields.io/badge/TypeScript-5.5-blue.svg)](https://www.typescriptlang.org/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+Этот проект генерирует SVG-бейдж с текущим количеством участников вашей Telegram-группы. Идеально подходит для отображения активности сообщества в README на GitHub или на сайте.
+
+## 🚀 Демо
+
+![Telegram Group Members](https://telegram-badge.vercel.app/api/telegram-badge)
+
+---
+
+## 📦 Стек
+
+- Node.js / Bun
+- Telegram Bot API
+- Vercel (Serverless API)
+
+---
+
+## 🛠 Установка
+
+1. Клонируйте репозиторий:
+
+```bash
+git clone https://github.com/chatman-media/telegram-badge.git
+cd telegram-badge
+```
+
+2. Установите зависимости:
+
+```bash
+npm install
+# или
+bun install
+```
+
+3. Создайте .env файл и добавьте:
+
+```bash
+BOT_TOKEN=your_telegram_bot_token
+CHAT_ID=@your_group_username_or_chat_id
+```
+
+Убедитесь, что бот добавлен в группу как админ.
+
+## 🧪 Локальный запуск
+
+```bash
+npm run dev
+# или
+bun dev
+```
+
+Открой в браузере: http://localhost:3000/api/telegram-badge
+
+## ☁️ Деплой на Vercel
+1.	Задеплойте репозиторий на vercel.com
+2.	В настройках проекта добавьте переменные окружения:
+	•	BOT_TOKEN
+	•	CHAT_ID
+
+## 🧩 Использование в GitHub README
+
+Добавьте следующую строку в ваш README.md:
+
+```markdown
+![Telegram Group Badge](https://telegram-badge.vercel.app/api/telegram-badge)
+```
+
+### 🎨 Параметры стилизации
+
+Вы можете настроить внешний вид бейджа с помощью следующих параметров:
+
+| Параметр | Описание | Значение по умолчанию |
+|----------|----------|------------------------|
+| `style` | Стиль бейджа | `flat` |
+| `label` | Текст метки | `Telegram` |
+| `color` | Цвет основной части бейджа | `2AABEE` (цвет Telegram) |
+| `labelColor` | Цвет метки бейджа | `555555` |
+
+#### Доступные стили:
+
+- `flat` - плоский стиль (по умолчанию)
+- `plastic` - объемный стиль
+- `flat-square` - плоский квадратный стиль
+- `for-the-badge` - широкий стиль с заглавными буквами
+- `social` - социальный стиль
+
+#### Примеры:
+
+Стандартный бейдж:
+```
+https://telegram-badge.vercel.app/api/telegram-badge
+```
+
+Бейдж с кастомной меткой:
+```
+https://telegram-badge.vercel.app/api/telegram-badge?label=Our%20Group
+```
+
+Бейдж с кастомным цветом:
+```
+https://telegram-badge.vercel.app/api/telegram-badge?color=FF0000
+```
+
+Бейдж с кастомным стилем:
+```
+https://telegram-badge.vercel.app/api/telegram-badge?style=for-the-badge
+```
+
+Полностью кастомизированный бейдж:
+```
+https://telegram-badge.vercel.app/api/telegram-badge?style=social&label=Join%20Us&color=FF5733&labelColor=333333
+```
+
+## 🧠 Возможности
+
+- 👥 Отображение количества участников в реальном времени
+- 🎨 Полная кастомизация внешнего вида бейджа
+- 🔒 Поддержка .env и переменных Vercel для безопасного хранения токенов
+- ⚡ Оптимизированное кэширование для быстрой загрузки
+- 🛡️ Обработка ошибок с информативными сообщениями
+- 🆓 Бесплатно на Vercel при обычной нагрузке
+- 📡 Можно расширить до отображения активности / количества сообщений
+
+⸻
+
+📜 Лицензия
+
+MIT

package/dist/api/telegram-badge.d.ts

@@ -0,0 +1,2 @@
+import { Request, Response } from '../types';
+export default function handler(req: Request, res: Response): Promise<void>;

package/dist/api/telegram-badge.js

@@ -0,0 +1,213 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = handler;
+const badge_maker_1 = require("badge-maker");
+const crypto = __importStar(require("crypto"));
+const logger = {
+    info: (message, data = {}) => {
+        console.log(`[INFO] ${message}`, data);
+    },
+    warn: (message, data = {}) => {
+        console.warn(`[WARN] ${message}`, data);
+    },
+    error: (message, error = null) => {
+        console.error(`[ERROR] ${message}`, error);
+    },
+    debug: (message, data = {}) => {
+        if (process.env.DEBUG) {
+            console.log(`[DEBUG] ${message}`, data);
+        }
+    }
+};
+const validateEnvironment = () => {
+    const token = process.env.BOT_TOKEN;
+    const chatId = process.env.CHAT_ID;
+    if (!token) {
+        throw new Error("Missing BOT_TOKEN environment variable");
+    }
+    if (!chatId) {
+        throw new Error("Missing CHAT_ID environment variable");
+    }
+    return { token, chatId };
+};
+const getMemberCount = async (token, chatId) => {
+    const apiUrl = `https://api.telegram.org/bot${token}/getChatMemberCount?chat_id=${encodeURIComponent(chatId)}`;
+    logger.debug('Fetching member count', { chatId });
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), 5000);
+    try {
+        const response = await fetch(apiUrl, {
+            signal: controller.signal,
+            headers: {
+                'Accept': 'application/json',
+                'User-Agent': 'TelegramBadgeGenerator/1.0'
+            }
+        });
+        clearTimeout(timeoutId);
+        if (!response.ok) {
+            throw new Error(`HTTP error: ${response.status} ${response.statusText}`);
+        }
+        const data = await response.json();
+        if (!data.ok) {
+            throw new Error(`Telegram API error: ${data.description}`);
+        }
+        logger.debug('Member count received', { count: data.result });
+        return data.result;
+    }
+    catch (error) {
+        if (error instanceof Error && error.name === 'AbortError') {
+            logger.error('Request timeout', error);
+            throw new Error('Request timeout: Telegram API took too long to respond');
+        }
+        logger.error('Error fetching member count', error);
+        throw error;
+    }
+};
+const validateStyleOptions = (options) => {
+    const validStyles = ['flat', 'plastic', 'flat-square', 'for-the-badge', 'social'];
+    let style = options.style || 'flat';
+    if (!validStyles.includes(style)) {
+        logger.warn(`Invalid style: ${style}, using default 'flat'`);
+        style = 'flat';
+    }
+    const label = options.label || 'Telegram';
+    const color = options.color || '2AABEE';
+    const labelColor = options.labelColor || '555555';
+    return { style, label, color, labelColor };
+};
+const createBadge = (members, options) => {
+    const { style, label, color, labelColor } = validateStyleOptions(options);
+    logger.debug('Creating badge', { style, label, color, labelColor });
+    const normalizedColor = color.replace(/^#/, '');
+    const normalizedLabelColor = labelColor.replace(/^#/, '');
+    const format = {
+        label,
+        message: `${members} members`,
+        color: `#${normalizedColor}`,
+        labelColor: `#${normalizedLabelColor}`,
+        style
+    };
+    return (0, badge_maker_1.makeBadge)(format);
+};
+const createErrorBadge = (errorMessage) => {
+    const format = {
+        label: 'Error',
+        message: errorMessage,
+        color: '#e05d44',
+        labelColor: '#555555',
+        style: 'flat'
+    };
+    return (0, badge_maker_1.makeBadge)(format);
+};
+const setCacheHeaders = (res, svg) => {
+    res.setHeader("Content-Type", "image/svg+xml");
+    res.setHeader("Cache-Control", "max-age=300, s-maxage=600, stale-while-revalidate=86400");
+    const etag = crypto
+        .createHash('md5')
+        .update(svg)
+        .digest('hex');
+    res.setHeader("ETag", `"${etag}"`);
+    const expiresDate = new Date();
+    expiresDate.setSeconds(expiresDate.getSeconds() + 300);
+    res.setHeader("Expires", expiresDate.toUTCString());
+    logger.debug('Cache headers set');
+};
+async function handler(req, res) {
+    logger.info('Received badge request', {
+        query: req.query,
+        userAgent: req.headers['user-agent'],
+        referer: req.headers['referer'] || 'unknown'
+    });
+    try {
+        const { token, chatId } = validateEnvironment();
+        logger.debug('Environment validated', { chatId });
+        const ifNoneMatch = req.headers['if-none-match'];
+        const requestEtag = `"${crypto
+            .createHash('md5')
+            .update(JSON.stringify({ token, chatId, query: req.query, time: Math.floor(Date.now() / 300000) }))
+            .digest('hex')}"`;
+        if (ifNoneMatch && ifNoneMatch === requestEtag) {
+            logger.info('Returning 304 Not Modified');
+            res.status(304).end();
+            return;
+        }
+        const members = await getMemberCount(token, chatId);
+        logger.info('Member count fetched', { members });
+        const badgeOptions = {
+            style: req.query.style,
+            label: req.query.label,
+            color: req.query.color,
+            labelColor: req.query.labelColor
+        };
+        const svg = createBadge(members, badgeOptions);
+        logger.debug('Badge created');
+        setCacheHeaders(res, svg);
+        res.status(200).send(svg);
+        logger.info('Badge sent successfully');
+    }
+    catch (err) {
+        logger.error('Error processing request', err);
+        let errorBadge;
+        let statusCode = 500;
+        if (err instanceof Error) {
+            if (err.message.includes("Missing BOT_TOKEN") || err.message.includes("Missing CHAT_ID")) {
+                errorBadge = createErrorBadge('Configuration Error');
+                logger.error(`Configuration error: ${err.message}`);
+            }
+            else if (err.message.includes("Telegram API error")) {
+                errorBadge = createErrorBadge('API Error');
+                logger.error(`Telegram API error: ${err.message}`);
+            }
+            else if (err.message.includes("Request timeout")) {
+                errorBadge = createErrorBadge('Timeout');
+                statusCode = 503;
+                logger.error(`Timeout error: ${err.message}`);
+            }
+            else {
+                errorBadge = createErrorBadge('Server Error');
+                logger.error(`Server error: ${err.message}`);
+            }
+        }
+        else {
+            errorBadge = createErrorBadge('Server Error');
+            logger.error('Unknown error occurred');
+        }
+        res.setHeader("Content-Type", "image/svg+xml");
+        res.setHeader("Cache-Control", "no-cache, no-store, must-revalidate");
+        res.status(statusCode).send(errorBadge);
+        logger.info(`Error badge sent with status ${statusCode}`);
+    }
+}

package/dist/tests/setup.js

@@ -0,0 +1,6 @@
+"use strict";
+// Setup file for Jest tests
+afterEach(() => {
+    jest.clearAllTimers();
+    jest.restoreAllMocks();
+});

package/dist/tests/telegram-badge.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/telegram-badge.test.js

@@ -0,0 +1,181 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const telegram_badge_1 = __importDefault(require("../api/telegram-badge"));
+const crypto = __importStar(require("crypto"));
+// Mock fetch globally
+global.fetch = jest.fn();
+// Mock console methods for clean test output
+console.log = jest.fn();
+console.error = jest.fn();
+console.warn = jest.fn();
+describe('Telegram Badge API', () => {
+    let req;
+    let res;
+    beforeEach(() => {
+        jest.clearAllMocks();
+        // Mock environment variables
+        process.env.BOT_TOKEN = 'test_token';
+        process.env.CHAT_ID = '@test_chat';
+        // Mock request and response objects
+        req = {
+            query: {},
+            headers: {}
+        };
+        res = {
+            status: jest.fn().mockReturnThis(),
+            send: jest.fn(),
+            setHeader: jest.fn(),
+            end: jest.fn()
+        };
+        // Mock successful Telegram API response
+        fetch.mockResolvedValue({
+            ok: true,
+            json: jest.fn().mockResolvedValue({
+                ok: true,
+                result: 100
+            })
+        });
+    });
+    test('должен возвращать SVG бейдж с количеством участников', async () => {
+        await (0, telegram_badge_1.default)(req, res);
+        // Check that fetch was called with correct parameters
+        expect(fetch).toHaveBeenCalledWith(expect.stringContaining('https://api.telegram.org/bottest_token/getChatMemberCount'), expect.any(Object));
+        // Check that headers were set
+        expect(res.setHeader).toHaveBeenCalledWith('Content-Type', 'image/svg+xml');
+        expect(res.setHeader).toHaveBeenCalledWith('Cache-Control', expect.any(String));
+        // Check that response was sent with status 200
+        expect(res.status).toHaveBeenCalledWith(200);
+        expect(res.send).toHaveBeenCalled();
+    });
+    test('должен обрабатывать отсутствие переменных окружения', async () => {
+        // Remove environment variables
+        delete process.env.BOT_TOKEN;
+        await (0, telegram_badge_1.default)(req, res);
+        // Check that error response was sent
+        expect(res.status).toHaveBeenCalledWith(500);
+        expect(res.send).toHaveBeenCalledWith(expect.any(String));
+    });
+    test('должен обрабатывать ошибки Telegram API', async () => {
+        // Mock Telegram API error
+        fetch.mockResolvedValue({
+            ok: true,
+            json: jest.fn().mockResolvedValue({
+                ok: false,
+                description: 'Test error'
+            })
+        });
+        await (0, telegram_badge_1.default)(req, res);
+        // Check that error response was sent
+        expect(res.status).toHaveBeenCalledWith(500);
+        expect(res.send).toHaveBeenCalledWith(expect.any(String));
+    });
+    test('должен обрабатывать сетевые ошибки', async () => {
+        // Mock network error
+        fetch.mockRejectedValue(new Error('Network error'));
+        await (0, telegram_badge_1.default)(req, res);
+        // Check that error response was sent
+        expect(res.status).toHaveBeenCalledWith(500);
+        expect(res.send).toHaveBeenCalledWith(expect.any(String));
+    });
+    test('должен применять параметры стилизации', async () => {
+        // Set styling parameters
+        req.query = {
+            style: 'flat-square',
+            label: 'Custom Label',
+            color: 'FF0000',
+            labelColor: '000000'
+        };
+        await (0, telegram_badge_1.default)(req, res);
+        // Check that response was sent with status 200
+        expect(res.status).toHaveBeenCalledWith(200);
+        expect(res.send).toHaveBeenCalled();
+    });
+    test('должен возвращать 304 Not Modified при совпадении ETag', async () => {
+        // Set If-None-Match header
+        const testEtag = '\"test-etag\"';
+        req.headers['if-none-match'] = testEtag;
+        // Mock the specific environment to create a predictable ETag
+        const originalEnv = process.env;
+        process.env = {
+            ...originalEnv,
+            BOT_TOKEN: 'test_token_for_etag',
+            CHAT_ID: '@test_chat_for_etag'
+        };
+        // We need to create the exact same hash that would be generated
+        const fixedTime = 1234567890000; // Fixed timestamp
+        jest.spyOn(Date, 'now').mockReturnValue(fixedTime);
+        // Create expected ETag based on our known values
+        const expectedHash = crypto
+            .createHash('md5')
+            .update(JSON.stringify({
+            token: 'test_token_for_etag',
+            chatId: '@test_chat_for_etag',
+            query: {},
+            time: Math.floor(fixedTime / 300000)
+        }))
+            .digest('hex');
+        req.headers['if-none-match'] = `"${expectedHash}"`;
+        await (0, telegram_badge_1.default)(req, res);
+        // Restore environment
+        process.env = originalEnv;
+        // Check that response was sent with status 304
+        expect(res.status).toHaveBeenCalledWith(304);
+        expect(res.end).toHaveBeenCalled();
+    });
+    test('должен обрабатывать таймауты запросов', async () => {
+        // Mock timeout error
+        const abortError = new Error('Request timeout');
+        abortError.name = 'AbortError';
+        fetch.mockRejectedValue(abortError);
+        await (0, telegram_badge_1.default)(req, res);
+        // Check that error response was sent with service unavailable status
+        expect(res.status).toHaveBeenCalledWith(503);
+        expect(res.send).toHaveBeenCalledWith(expect.any(String));
+    });
+    test('должен валидировать стили бейджа', async () => {
+        // Set invalid style
+        req.query = {
+            style: 'invalid-style'
+        };
+        await (0, telegram_badge_1.default)(req, res);
+        // Should still work with default style
+        expect(res.status).toHaveBeenCalledWith(200);
+        expect(res.send).toHaveBeenCalled();
+    });
+});

package/dist/types/index.d.ts

@@ -0,0 +1,49 @@
+export interface BadgeOptions {
+    style?: 'flat' | 'plastic' | 'flat-square' | 'for-the-badge' | 'social';
+    label?: string;
+    color?: string;
+    labelColor?: string;
+}
+export interface BadgeFormat {
+    label: string;
+    message: string;
+    color: string;
+    labelColor: string;
+    style: 'flat' | 'plastic' | 'flat-square' | 'for-the-badge' | 'social';
+}
+export interface TelegramApiResponse {
+    ok: boolean;
+    result?: number;
+    description?: string;
+}
+export interface Logger {
+    info: (message: string, data?: Record<string, any>) => void;
+    warn: (message: string, data?: Record<string, any>) => void;
+    error: (message: string, error?: any) => void;
+    debug: (message: string, data?: Record<string, any>) => void;
+}
+export interface RequestQuery {
+    style?: string;
+    label?: string;
+    color?: string;
+    labelColor?: string;
+}
+export interface RequestHeaders {
+    'if-none-match'?: string;
+    'user-agent'?: string;
+    referer?: string;
+}
+export interface Request {
+    query: RequestQuery;
+    headers: RequestHeaders;
+}
+export interface Response {
+    status: (code: number) => Response;
+    send: (data: string) => void;
+    end: () => void;
+    setHeader: (name: string, value: string) => void;
+}
+export interface Environment {
+    token: string;
+    chatId: string;
+}

package/dist/types/index.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "telegram-badge",
+  "version": "1.0.0",
+  "description": "Generate Telegram group member count badges for GitHub README",
+  "keywords": ["telegram", "badge", "svg", "group", "members", "api"],
+  "author": "Chatman Media",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/chatman-media/telegram-badge.git"
+  },
+  "homepage": "https://github.com/chatman-media/telegram-badge",
+  "bugs": {
+    "url": "https://github.com/chatman-media/telegram-badge/issues"
+  },
+  "type": "commonjs",
+  "main": "dist/api/telegram-badge.js",
+  "types": "dist/api/telegram-badge.d.ts",
+  "files": [
+    "dist",
+    "types",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "dev": "vercel dev",
+    "start": "vercel dev",
+    "test": "jest",
+    "build": "tsc",
+    "type-check": "tsc --noEmit",
+    "prepublishOnly": "npm run build && npm test",
+    "prepack": "npm run build"
+  },
+  "dependencies": {
+    "badge-maker": "^5.0.2"
+  },
+  "devDependencies": {
+    "@types/jest": "^29.5.12",
+    "@types/node": "^24.0.15",
+    "dotenv": "^17.2.0",
+    "jest": "^30.0.4",
+    "node-fetch": "^2.7.0",
+    "typescript": "^5.5.4",
+    "ts-jest": "^29.2.5",
+    "ts-node": "^10.9.2"
+  }
+}

package/types/index.ts

@@ -0,0 +1,57 @@
+export interface BadgeOptions {
+  style?: 'flat' | 'plastic' | 'flat-square' | 'for-the-badge' | 'social';
+  label?: string;
+  color?: string;
+  labelColor?: string;
+}
+
+export interface BadgeFormat {
+  label: string;
+  message: string;
+  color: string;
+  labelColor: string;
+  style: 'flat' | 'plastic' | 'flat-square' | 'for-the-badge' | 'social';
+}
+
+export interface TelegramApiResponse {
+  ok: boolean;
+  result?: number;
+  description?: string;
+}
+
+export interface Logger {
+  info: (message: string, data?: Record<string, any>) => void;
+  warn: (message: string, data?: Record<string, any>) => void;
+  error: (message: string, error?: any) => void;
+  debug: (message: string, data?: Record<string, any>) => void;
+}
+
+export interface RequestQuery {
+  style?: string;
+  label?: string;
+  color?: string;
+  labelColor?: string;
+}
+
+export interface RequestHeaders {
+  'if-none-match'?: string;
+  'user-agent'?: string;
+  referer?: string;
+}
+
+export interface Request {
+  query: RequestQuery;
+  headers: RequestHeaders;
+}
+
+export interface Response {
+  status: (code: number) => Response;
+  send: (data: string) => void;
+  end: () => void;
+  setHeader: (name: string, value: string) => void;
+}
+
+export interface Environment {
+  token: string;
+  chatId: string;
+}