@tgify/tgify 0.1.4 → 1.0.1

package/lib/tgify.js

@@ -0,0 +1,254 @@
+"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 });
+exports.Tgify = void 0;
+const crypto = __importStar(require("crypto"));
+const http = __importStar(require("http"));
+const https = __importStar(require("https"));
+const composer_1 = require("./composer");
+const compact_1 = require("./core/helpers/compact");
+const context_1 = __importDefault(require("./context"));
+const debug_1 = __importDefault(require("debug"));
+const webhook_1 = __importDefault(require("./core/network/webhook"));
+const polling_1 = require("./core/network/polling");
+const p_timeout_1 = __importDefault(require("p-timeout"));
+const telegram_1 = __importDefault(require("./telegram"));
+const url_1 = require("url");
+const safeCompare = require("safe-compare");
+const debug = (0, debug_1.default)('tgify:main');
+const DEFAULT_OPTIONS = {
+    telegram: {},
+    handlerTimeout: 90000, // 90s in ms
+    contextType: context_1.default,
+};
+function always(x) {
+    return () => x;
+}
+const anoop = always(Promise.resolve());
+const TOKEN_HEADER = 'x-telegram-bot-api-secret-token';
+class Tgify extends composer_1.Composer {
+    constructor(token, options) {
+        super();
+        this.context = {};
+        /** Assign to this to customise the webhook filter middleware.
+         * `{ path, secretToken }` will be bound to this rather than the Tgify instance.
+         * Remember to assign a regular function and not an arrow function so it's bindable.
+         */
+        this.webhookFilter = function (req) {
+            const debug = (0, debug_1.default)('telegraf:webhook');
+            if (req.method === 'POST') {
+                if (safeCompare(this.path, req.url)) {
+                    // no need to check if secret_token was not set
+                    if (!this.secretToken)
+                        return true;
+                    else {
+                        const token = req.headers[TOKEN_HEADER];
+                        if (safeCompare(this.secretToken, token))
+                            return true;
+                        else
+                            debug('Secret token does not match:', token, this.secretToken);
+                    }
+                }
+                else
+                    debug('Path does not match:', req.url, this.path);
+            }
+            else
+                debug('Unexpected request method, not POST. Received:', req.method);
+            return false;
+        };
+        this.handleError = (err, ctx) => {
+            // set exit code to emulate `warn-with-error-code` behavior of
+            // https://nodejs.org/api/cli.html#cli_unhandled_rejections_mode
+            // to prevent a clean exit despite an error being thrown
+            process.exitCode = 1;
+            console.error('Unhandled error while processing', ctx.update);
+            throw err;
+        };
+        // @ts-expect-error Trust me, TS
+        this.options = {
+            ...DEFAULT_OPTIONS,
+            ...(0, compact_1.compactOptions)(options),
+        };
+        this.telegram = new telegram_1.default(token, this.options.telegram);
+        debug('Created a `Tgify` instance');
+    }
+    get token() {
+        return this.telegram.token;
+    }
+    /** @deprecated use `ctx.telegram.webhookReply` */
+    set webhookReply(webhookReply) {
+        this.telegram.webhookReply = webhookReply;
+    }
+    /** @deprecated use `ctx.telegram.webhookReply` */
+    get webhookReply() {
+        return this.telegram.webhookReply;
+    }
+    /**
+     * _Override_ error handling
+     */
+    catch(handler) {
+        this.handleError = handler;
+        return this;
+    }
+    /**
+     * You must call `bot.telegram.setWebhook` for this to work.
+     * You should probably use {@link Tgify.createWebhook} instead.
+     */
+    webhookCallback(path = '/', opts = {}) {
+        const { secretToken } = opts;
+        return (0, webhook_1.default)(this.webhookFilter.bind({ hookPath: path, path, secretToken }), (update, res) => this.handleUpdate(update, res));
+    }
+    getDomainOpts(opts) {
+        const protocol = opts.local ? 'http:' : 'https:';
+        const path = opts.path || `/telegraf/${this.secretPathComponent()}`;
+        const domain = new url_1.URL(`${protocol}//${opts.domain}`).host;
+        const url = `${protocol}//${domain}${path}`;
+        return { domain, path, url };
+    }
+    /**
+     * Specify a url to receive incoming updates via webhook.
+     * Returns an Express-style middleware you can pass to app.use()
+     */
+    async createWebhook(opts) {
+        const { domain, path, local, ...extra } = opts;
+        const domainOpts = this.getDomainOpts({ local, domain, path });
+        await this.telegram.setWebhook(domainOpts.url, extra);
+        debug(`Webhook set to ${domainOpts.url}`);
+        return this.webhookCallback(domainOpts.path, {
+            secretToken: extra.secret_token,
+        });
+    }
+    startPolling(allowedUpdates = []) {
+        this.polling = new polling_1.Polling(this.telegram, allowedUpdates);
+        return this.polling.loop(async (update) => {
+            await this.handleUpdate(update);
+        });
+    }
+    startWebhook(path, tlsOptions, port, host, cb, secretToken) {
+        const webhookCb = this.webhookCallback(path, { secretToken });
+        const callback = typeof cb === 'function'
+            ? (req, res) => webhookCb(req, res, () => cb(req, res))
+            : webhookCb;
+        this.webhookServer =
+            tlsOptions != null
+                ? https.createServer(tlsOptions, callback)
+                : http.createServer(callback);
+        this.webhookServer.listen(port, host, () => {
+            debug('Webhook listening on port: %s', port);
+        });
+        return this;
+    }
+    secretPathComponent() {
+        return crypto
+            .createHash('sha3-256')
+            .update(this.token)
+            .update(process.version) // salt
+            .digest('hex');
+    }
+    /**
+     * @see https://github.com/telegraf/telegraf/discussions/1344#discussioncomment-335700
+     */
+    async launch(config = {}, 
+    /** @experimental */
+    onLaunch) {
+        var _a, _b;
+        const [cfg, onMe] = typeof config === 'function' ? [{}, config] : [config, onLaunch];
+        const drop_pending_updates = cfg.dropPendingUpdates;
+        const allowed_updates = cfg.allowedUpdates;
+        const webhook = cfg.webhook;
+        debug('Connecting to Telegram');
+        (_a = this.botInfo) !== null && _a !== void 0 ? _a : (this.botInfo = await this.telegram.getMe());
+        onMe === null || onMe === void 0 ? void 0 : onMe();
+        debug(`Launching @${this.botInfo.username}`);
+        if (webhook === undefined) {
+            await this.telegram.deleteWebhook({ drop_pending_updates });
+            debug('Bot started with long polling');
+            await this.startPolling(allowed_updates);
+            return;
+        }
+        const domainOpts = this.getDomainOpts({
+            local: webhook.local,
+            domain: webhook.domain,
+            path: (_b = webhook.path) !== null && _b !== void 0 ? _b : webhook.hookPath,
+        });
+        const { tlsOptions, port, host, cb, secretToken } = webhook;
+        this.startWebhook(domainOpts.path, tlsOptions, port, host, cb, secretToken);
+        await this.telegram.setWebhook(domainOpts.url, {
+            drop_pending_updates: drop_pending_updates,
+            allowed_updates: allowed_updates,
+            ip_address: webhook.ipAddress,
+            max_connections: webhook.maxConnections,
+            secret_token: webhook.secretToken,
+            certificate: webhook.certificate,
+        });
+        debug(`Bot started with webhook @ ${domainOpts.url}`);
+    }
+    stop(reason = 'unspecified') {
+        var _a, _b;
+        debug('Stopping bot... Reason:', reason);
+        // https://github.com/telegraf/telegraf/pull/1224#issuecomment-742693770
+        if (this.polling === undefined && this.webhookServer === undefined) {
+            throw new Error('Bot is not running!');
+        }
+        (_a = this.webhookServer) === null || _a === void 0 ? void 0 : _a.close();
+        (_b = this.polling) === null || _b === void 0 ? void 0 : _b.stop();
+    }
+    async handleUpdate(update, webhookResponse) {
+        var _a, _b;
+        (_a = this.botInfo) !== null && _a !== void 0 ? _a : (this.botInfo = (debug('Update %d is waiting for `botInfo` to be initialized', update.update_id),
+            await ((_b = this.botInfoCall) !== null && _b !== void 0 ? _b : (this.botInfoCall = this.telegram.getMe()))));
+        debug('Processing update', update.update_id);
+        const tg = new telegram_1.default(this.token, this.telegram.options, webhookResponse);
+        const TelegrafContext = this.options.contextType;
+        const ctx = new TelegrafContext(update, tg, this.botInfo);
+        Object.assign(ctx, this.context);
+        try {
+            await (0, p_timeout_1.default)(Promise.resolve(this.middleware()(ctx, anoop)), this.options.handlerTimeout);
+        }
+        catch (err) {
+            return await this.handleError(err, ctx);
+        }
+        finally {
+            if ((webhookResponse === null || webhookResponse === void 0 ? void 0 : webhookResponse.writableEnded) === false) {
+                webhookResponse.end();
+            }
+            debug('Finished processing update', update.update_id);
+        }
+    }
+}
+exports.Tgify = Tgify;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tgify/tgify",
-  "version": "0.1.4",
+  "version": "1.0.1",
   "description": "Modern Telegram Bot Framework",
   "license": "MIT",
   "author": "IATNAOD",
@@ -94,7 +94,7 @@
   },
   "types": "./typings/index.d.ts",
   "dependencies": {
-    "@telegraf/types": "^7.1.0",
+    "@tgify/types": "^9.2.4",
     "abort-controller": "^3.0.0",
     "debug": "^4.3.5",
     "mri": "^1.2.0",

package/src/button.ts

@@ -1,30 +1,32 @@
 import {
-  InlineKeyboardButton,
   KeyboardButton,
+  InlineKeyboardButton,
   KeyboardButtonRequestChat,
   KeyboardButtonRequestUsers,
 } from './core/types/typegram'
 
 type Hideable<B> = B & { hide: boolean }
 
+
 export function text(
   text: string,
-  hide = false
-): Hideable<KeyboardButton.CommonButton> {
-  return { text, hide }
+  hide = false,
+  extra?: Pick<KeyboardButton.Text, 'style' | 'icon_custom_emoji_id'>,
+): Hideable<KeyboardButton.Text> {
+  return { text, hide, ...extra }
 }
 
 export function contactRequest(
   text: string,
   hide = false
-): Hideable<KeyboardButton.RequestContactButton> {
+): Hideable<KeyboardButton.RequestContact> {
   return { text, request_contact: true, hide }
 }
 
 export function locationRequest(
   text: string,
   hide = false
-): Hideable<KeyboardButton.RequestLocationButton> {
+): Hideable<KeyboardButton.RequestLocation> {
   return { text, request_location: true, hide }
 }
 
@@ -32,7 +34,7 @@ export function pollRequest(
   text: string,
   type?: 'quiz' | 'regular',
   hide = false
-): Hideable<KeyboardButton.RequestPollButton> {
+): Hideable<KeyboardButton.RequestPoll> {
   return { text, request_poll: { type }, hide }
 }
 
@@ -42,7 +44,7 @@ export function userRequest(
   request_id: number,
   extra?: Omit<KeyboardButtonRequestUsers, 'request_id' | 'text'>,
   hide = false
-): Hideable<KeyboardButton.RequestUsersButton> {
+): Hideable<KeyboardButton.RequestUsers> {
   return {
     text,
     request_users: { request_id, ...extra },
@@ -59,7 +61,7 @@ export function botRequest(
     'request_id' | 'user_is_bot' | 'text'
   >,
   hide = false
-): Hideable<KeyboardButton.RequestUsersButton> {
+): Hideable<KeyboardButton.RequestUsers> {
   return {
     text,
     request_users: { request_id, user_is_bot: true, ...extra },
@@ -78,7 +80,7 @@ export function groupRequest(
   request_id: number,
   extra?: KeyboardButtonRequestGroup,
   hide = false
-): Hideable<KeyboardButton.RequestChatButton> {
+): Hideable<KeyboardButton.RequestChat> {
   return {
     text,
     request_chat: { request_id, chat_is_channel: false, ...extra },
@@ -97,7 +99,7 @@ export function channelRequest(
   request_id: number,
   extra?: KeyboardButtonRequestChannel,
   hide = false
-): Hideable<KeyboardButton.RequestChatButton> {
+): Hideable<KeyboardButton.RequestChat> {
   return {
     text,
     request_chat: { request_id, chat_is_channel: true, ...extra },
@@ -108,47 +110,53 @@ export function channelRequest(
 export function url(
   text: string,
   url: string,
-  hide = false
-): Hideable<InlineKeyboardButton.UrlButton> {
-  return { text, url, hide }
+  hide = false,
+  extra?: Pick<InlineKeyboardButton.Url, 'style' | 'icon_custom_emoji_id'>,
+): Hideable<InlineKeyboardButton.Url> {
+  return { text, url, hide, ...extra }
 }
 
 export function callback(
   text: string,
   data: string,
-  hide = false
-): Hideable<InlineKeyboardButton.CallbackButton> {
-  return { text, callback_data: data, hide }
+  hide = false,
+  extra?: Pick<InlineKeyboardButton.Callback, 'style' | 'icon_custom_emoji_id'>,
+): Hideable<InlineKeyboardButton.Callback> {
+  return { text, callback_data: data, hide, ...extra }
 }
 
 export function switchToChat(
   text: string,
   value: string,
-  hide = false
-): Hideable<InlineKeyboardButton.SwitchInlineButton> {
-  return { text, switch_inline_query: value, hide }
+  hide = false,
+  extra?: Pick<InlineKeyboardButton.SwitchInline, 'style' | 'icon_custom_emoji_id'>,
+): Hideable<InlineKeyboardButton.SwitchInline> {
+  return { text, switch_inline_query: value, hide, ...extra }
 }
 
 export function switchToCurrentChat(
   text: string,
   value: string,
-  hide = false
-): Hideable<InlineKeyboardButton.SwitchInlineCurrentChatButton> {
-  return { text, switch_inline_query_current_chat: value, hide }
+  hide = false,
+  extra?: Pick<InlineKeyboardButton.SwitchInlineCurrentChat, 'style' | 'icon_custom_emoji_id'>,
+): Hideable<InlineKeyboardButton.SwitchInlineCurrentChat> {
+  return { text, switch_inline_query_current_chat: value, hide, ...extra }
 }
 
 export function game(
   text: string,
-  hide = false
-): Hideable<InlineKeyboardButton.GameButton> {
-  return { text, callback_game: {}, hide }
+  hide = false,
+  extra?: Pick<InlineKeyboardButton.Game, 'style' | 'icon_custom_emoji_id'>,
+): Hideable<InlineKeyboardButton.Game> {
+  return { text, callback_game: {}, hide, ...extra }
 }
 
 export function pay(
   text: string,
-  hide = false
-): Hideable<InlineKeyboardButton.PayButton> {
-  return { text, pay: true, hide }
+  hide = false,
+  extra?: Pick<InlineKeyboardButton.Pay, 'style' | 'icon_custom_emoji_id'>,
+): Hideable<InlineKeyboardButton.Pay> {
+  return { text, pay: true, hide, ...extra }
 }
 
 export function login(
@@ -159,24 +167,28 @@ export function login(
     bot_username?: string
     request_write_access?: boolean
   } = {},
-  hide = false
-): Hideable<InlineKeyboardButton.LoginButton> {
+  hide = false,
+  extra?: Pick<InlineKeyboardButton.Login, 'style' | 'icon_custom_emoji_id'>,
+): Hideable<InlineKeyboardButton.Login> {
   return {
     text,
-    login_url: { ...opts, url },
     hide,
+    login_url: { ...opts, url },
+    ...extra
   }
 }
 
+// works as both InlineKeyboardButton and KeyboardButton
 export function webApp(
   text: string,
   url: string,
-  hide = false
-  // works as both InlineKeyboardButton and KeyboardButton
-): Hideable<InlineKeyboardButton.WebAppButton> {
+  hide = false,
+  extra?: Pick<InlineKeyboardButton.WebApp, 'style' | 'icon_custom_emoji_id'>,
+): Hideable<InlineKeyboardButton.WebApp> {
   return {
     text,
-    web_app: { url },
     hide,
+    web_app: { url },
+    ...extra
   }
 }

package/src/composer.ts

@@ -110,10 +110,10 @@ export class Composer<C extends Context> implements MiddlewareObj<C> {
     ...fns: NonemptyReadonlyArray<
       Middleware<
         Filter extends tt.MessageSubType
-          ? MatchedContext<C, Filter>
-          : Filter extends tt.UpdateType | Guard<C['update']>
-          ? FilteredContext<C, Filter>
-          : never
+        ? MatchedContext<C, Filter>
+        : Filter extends tt.UpdateType | Guard<C['update']>
+        ? FilteredContext<C, Filter>
+        : never
       >
     >
   ): this {
@@ -209,8 +209,8 @@ export class Composer<C extends Context> implements MiddlewareObj<C> {
 
   private entity<
     T extends 'message' | 'channel_post' | tt.MessageSubType =
-      | 'message'
-      | 'channel_post',
+    | 'message'
+    | 'channel_post',
   >(
     predicate:
       | MaybeArray<string>
@@ -497,12 +497,12 @@ export class Composer<C extends Context> implements MiddlewareObj<C> {
           // https://github.com/microsoft/TypeScript/pull/51502
           typeof filter !== 'string'
             ? // filter is a type guard
-              filter(update)
+            filter(update)
             : // check if filter is the update type
-              filter in update ||
-              // check if filter is the msg type
-              // TODO: remove in v5!
-              ('message' in update && filter in update.message)
+            filter in update ||
+            // check if filter is the msg type
+            // TODO: remove in v5!
+            ('message' in update && filter in update.message)
         ) {
           return true
         }
@@ -523,8 +523,8 @@ export class Composer<C extends Context> implements MiddlewareObj<C> {
   private static entity<
     C extends Context,
     T extends 'message' | 'channel_post' | tt.MessageSubType =
-      | 'message'
-      | 'channel_post',
+    | 'message'
+    | 'channel_post',
   >(
     predicate:
       | MaybeArray<string>

package/src/context.ts

@@ -245,9 +245,9 @@ export class Context<U extends Deunionize<tg.Update> = tg.Update> {
         // https://github.com/microsoft/TypeScript/pull/51502
         typeof filter !== 'string'
           ? // filter is a type guard
-            filter(this.update)
+          filter(this.update)
           : // check if filter is the update type
-            filter in this.update
+          filter in this.update
       )
         return true
 
@@ -856,7 +856,7 @@ export class Context<U extends Deunionize<tg.Update> = tg.Update> {
   /**
    * @see https://core.telegram.org/bots/api#sendpoll
    */
-  sendPoll(poll: string, options: readonly string[], extra?: tt.ExtraPoll) {
+  sendPoll(poll: string, options: readonly tg.InputPollOption[], extra?: tt.ExtraPoll) {
     this.assert(this.chat, 'sendPoll')
     return this.telegram.sendPoll(this.chat.id, poll, options, {
       message_thread_id: getThreadId(this),
@@ -874,7 +874,7 @@ export class Context<U extends Deunionize<tg.Update> = tg.Update> {
   /**
    * @see https://core.telegram.org/bots/api#sendpoll
    */
-  sendQuiz(quiz: string, options: readonly string[], extra?: tt.ExtraPoll) {
+  sendQuiz(quiz: string, options: readonly tg.InputPollOption[], extra?: tt.ExtraPoll) {
     this.assert(this.chat, 'sendQuiz')
     return this.telegram.sendQuiz(this.chat.id, quiz, options, {
       message_thread_id: getThreadId(this),
@@ -1518,8 +1518,8 @@ type UpdateTypes<U extends Deunionize<tg.Update>> = Extract<
 
 export type GetUpdateContent<U extends tg.Update> =
   U extends tg.Update.CallbackQueryUpdate
-    ? U['callback_query']['message']
-    : U[UpdateTypes<U>]
+  ? U['callback_query']['message']
+  : U[UpdateTypes<U>]
 
 type Getter<U extends Deunionize<tg.Update>, P extends string> = PropOr<
   GetUpdateContent<U>,
@@ -1575,22 +1575,22 @@ function getMessageFromAnySource<U extends tg.Update>(ctx: Context<U>) {
 type GetUserFromAnySource<U extends tg.Update> =
   // check if it's a message type with `from`
   GetMsg<U> extends { from: tg.User }
-    ? tg.User
-    : U extends  // these updates have `from`
-        | tg.Update.CallbackQueryUpdate
-        | tg.Update.InlineQueryUpdate
-        | tg.Update.ShippingQueryUpdate
-        | tg.Update.PreCheckoutQueryUpdate
-        | tg.Update.ChosenInlineResultUpdate
-        | tg.Update.ChatMemberUpdate
-        | tg.Update.MyChatMemberUpdate
-        | tg.Update.ChatJoinRequestUpdate
-        // these updates have `user`
-        | tg.Update.MessageReactionUpdate
-        | tg.Update.PollAnswerUpdate
-        | tg.Update.ChatBoostUpdate
-    ? tg.User
-    : undefined
+  ? tg.User
+  : U extends  // these updates have `from`
+  | tg.Update.CallbackQueryUpdate
+  | tg.Update.InlineQueryUpdate
+  | tg.Update.ShippingQueryUpdate
+  | tg.Update.PreCheckoutQueryUpdate
+  | tg.Update.ChosenInlineResultUpdate
+  | tg.Update.ChatMemberUpdate
+  | tg.Update.MyChatMemberUpdate
+  | tg.Update.ChatJoinRequestUpdate
+  // these updates have `user`
+  | tg.Update.MessageReactionUpdate
+  | tg.Update.PollAnswerUpdate
+  | tg.Update.ChatBoostUpdate
+  ? tg.User
+  : undefined
 
 function getUserFromAnySource<U extends tg.Update>(ctx: Context<U>) {
   if (ctx.callbackQuery) return ctx.callbackQuery.from

package/src/core/helpers/formatting.ts

@@ -1,5 +1,5 @@
 /* eslint-disable @typescript-eslint/no-unsafe-declaration-merging */
-import { MessageEntity, User } from '@telegraf/types'
+import { MessageEntity, User } from '@tgify/types'
 import { Any, zip } from './util'
 
 export type Nestable<Kind extends string> =
@@ -19,8 +19,7 @@ export interface FmtString<Brand extends string> {
 }
 
 export class FmtString<Brand extends string = string>
-  implements FmtString<Brand>
-{
+  implements FmtString<Brand> {
   constructor(
     public text: string,
     entities?: MessageEntity[]

package/src/core/types/typegram.ts

@@ -1,16 +1,16 @@
-import * as Typegram from '@telegraf/types'
+import * as Typegram from '@tgify/types'
 
 // internal type provisions
-export * from '@telegraf/types/api'
-export * from '@telegraf/types/inline'
-export * from '@telegraf/types/manage'
-export * from '@telegraf/types/markup'
-export * from '@telegraf/types/message'
-export * from '@telegraf/types/methods'
-export * from '@telegraf/types/passport'
-export * from '@telegraf/types/payment'
-export * from '@telegraf/types/settings'
-export * from '@telegraf/types/update'
+export * from '@tgify/types/api'
+export * from '@tgify/types/inline'
+export * from '@tgify/types/manage'
+export * from '@tgify/types/markup'
+export * from '@tgify/types/message'
+export * from '@tgify/types/methods'
+export * from '@tgify/types/passport'
+export * from '@tgify/types/payment'
+export * from '@tgify/types/settings'
+export * from '@tgify/types/update'
 
 // telegraf input file definition
 interface InputFileByPath {