telegram-botbuilder 1.0.0

package/lib/bot-service.d.ts

@@ -0,0 +1,22 @@
+import TelegramBot from 'node-telegram-bot-api';
+import { Schema, Action } from './bot-struct';
+import EventEmitter from 'events';
+export interface ActionCallback {
+    chatid: number;
+}
+export declare class EasyBot {
+    private _bot;
+    private _schema;
+    ActionSystem: EventEmitter;
+    private _userdialogs;
+    constructor(schema: Schema, token: string, options?: TelegramBot.ConstructorOptions);
+    private _getDialog;
+    private _getButton;
+    private _activateButton;
+    ChangeDialog(chat: number, id: string): Promise<void>;
+    AttachDataWait(chat: number, descriptor: string): void;
+    Message(chat: number, content: string): Promise<TelegramBot.Message>;
+}
+export declare function ChangeDialog(id: string): Action;
+export declare function CallbackAction(descriptor: string): Action;
+export declare function WaitForData(descriptor: string): Action;

package/lib/bot-service.js

@@ -0,0 +1,250 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EasyBot = void 0;
+exports.ChangeDialog = ChangeDialog;
+exports.CallbackAction = CallbackAction;
+exports.WaitForData = WaitForData;
+var node_telegram_bot_api_1 = __importDefault(require("node-telegram-bot-api"));
+var events_1 = __importDefault(require("events"));
+var crypto_1 = require("crypto");
+var fs_1 = require("fs");
+var EasyBot = /** @class */ (function () {
+    function EasyBot(schema, token, options) {
+        var _this = this;
+        this._bot = new node_telegram_bot_api_1.default(token, options);
+        this._schema = schema;
+        this._schema.buttons = [];
+        for (var x = 0; x < this._schema.content.length; x++) {
+            for (var y = 0; y < this._schema.content[x].buttons.length; y++) {
+                for (var b = 0; b < this._schema.content[x].buttons[y].length; b++) {
+                    this._schema.content[x].buttons[y][b]._callback = (0, crypto_1.randomInt)(281474976710655).toFixed(0);
+                    this._schema.buttons.push(this._schema.content[x].buttons[y][b]);
+                }
+            }
+        }
+        this.ActionSystem = new events_1.default();
+        this._userdialogs = {};
+        this._bot.onText(/\/start/, function (msg) {
+            if (!_this._userdialogs[msg.chat.id])
+                _this._userdialogs[msg.chat.id] = { dialog: _this._schema.start, lastid: -1, waiter: { statewait: false, descriptor: '' } };
+            _this._bot.deleteMessage(msg.chat.id, msg.message_id).catch(function () { return undefined; });
+            _this.ChangeDialog(msg.chat.id, _this._schema.start);
+        });
+        this._bot.on('callback_query', function (query) {
+            if (!_this._userdialogs[query.message.chat.id])
+                _this._userdialogs[query.message.chat.id] = { dialog: _this._schema.start, lastid: -1, waiter: { statewait: false, descriptor: '' } };
+            _this._activateButton(query.message.chat.id, query.data);
+        });
+        this._bot.onText(/.+/g, function (msg) {
+            var chat = msg.chat.id;
+            if (_this._userdialogs[chat].waiter.statewait) {
+                _this._userdialogs[chat].waiter.statewait = false;
+                _this._bot.deleteMessage(chat, msg.message_id).catch(function () { return undefined; });
+                _this.ActionSystem.emit(_this._userdialogs[chat].waiter.descriptor, chat, msg.text);
+            }
+        });
+        this._bot.on('document', function (msg) {
+            if (!msg.document)
+                return;
+            var chat = msg.chat.id;
+            if (!_this._userdialogs[chat].waiter.statewait)
+                return;
+            _this._bot.downloadFile(msg.document.file_id, './').then(function (x) {
+                _this._userdialogs[chat].waiter.statewait = false;
+                _this._bot.deleteMessage(chat, msg.message_id).catch(function () { return undefined; });
+                var content = (0, fs_1.readFileSync)(x, 'utf8');
+                (0, fs_1.rmSync)(x);
+                _this.ActionSystem.emit(_this._userdialogs[chat].waiter.descriptor, chat, content);
+            });
+        });
+    }
+    EasyBot.prototype._getDialog = function (id) {
+        return this._schema.content.find(function (x) { return x.id === id; });
+    };
+    EasyBot.prototype._getButton = function (callback) {
+        return this._schema.buttons.find(function (x) { return x._callback === callback; });
+    };
+    EasyBot.prototype._activateButton = function (chat, btn) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _btn, _i, _a, act;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        if (typeof btn === 'string')
+                            _btn = this._getButton(btn);
+                        else
+                            _btn = btn;
+                        if (!Array.isArray(_btn === null || _btn === void 0 ? void 0 : _btn.action)) return [3 /*break*/, 5];
+                        _i = 0, _a = _btn === null || _btn === void 0 ? void 0 : _btn.action;
+                        _b.label = 1;
+                    case 1:
+                        if (!(_i < _a.length)) return [3 /*break*/, 4];
+                        act = _a[_i];
+                        return [4 /*yield*/, act(chat, this)];
+                    case 2:
+                        _b.sent();
+                        _b.label = 3;
+                    case 3:
+                        _i++;
+                        return [3 /*break*/, 1];
+                    case 4: return [3 /*break*/, 7];
+                    case 5:
+                        if (!(_btn === null || _btn === void 0 ? void 0 : _btn.action)) return [3 /*break*/, 7];
+                        return [4 /*yield*/, (_btn === null || _btn === void 0 ? void 0 : _btn.action)(chat, this)];
+                    case 6:
+                        _b.sent();
+                        _b.label = 7;
+                    case 7: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    EasyBot.prototype.ChangeDialog = function (chat, id) {
+        return __awaiter(this, void 0, void 0, function () {
+            var dialog, markup, b, _i, _a, btn, text_1, _b, text, _c, _d, msg;
+            return __generator(this, function (_e) {
+                switch (_e.label) {
+                    case 0:
+                        this._userdialogs[chat].dialog = id;
+                        if (this._userdialogs[chat].waiter.statewait) {
+                            this._userdialogs[chat].waiter.statewait = false;
+                            this.ActionSystem.emit("cancel_".concat(this._userdialogs[chat].waiter.descriptor), chat);
+                        }
+                        dialog = this._getDialog(id);
+                        markup = undefined;
+                        if (!((dialog === null || dialog === void 0 ? void 0 : dialog.buttons.length) > 0)) return [3 /*break*/, 8];
+                        markup = [];
+                        b = 0;
+                        _e.label = 1;
+                    case 1:
+                        if (!(b < (dialog === null || dialog === void 0 ? void 0 : dialog.buttons.length))) return [3 /*break*/, 8];
+                        markup[b] = [];
+                        _i = 0, _a = dialog === null || dialog === void 0 ? void 0 : dialog.buttons[b];
+                        _e.label = 2;
+                    case 2:
+                        if (!(_i < _a.length)) return [3 /*break*/, 7];
+                        btn = _a[_i];
+                        if (!(typeof btn.text === 'function')) return [3 /*break*/, 4];
+                        return [4 /*yield*/, btn.text(chat)];
+                    case 3:
+                        _b = _e.sent();
+                        return [3 /*break*/, 5];
+                    case 4:
+                        _b = btn.text;
+                        _e.label = 5;
+                    case 5:
+                        text_1 = _b;
+                        markup[b].push({ text: text_1, callback_data: btn._callback });
+                        _e.label = 6;
+                    case 6:
+                        _i++;
+                        return [3 /*break*/, 2];
+                    case 7:
+                        b++;
+                        return [3 /*break*/, 1];
+                    case 8:
+                        if (!(typeof (dialog === null || dialog === void 0 ? void 0 : dialog.text) === 'function')) return [3 /*break*/, 10];
+                        return [4 /*yield*/, (dialog === null || dialog === void 0 ? void 0 : dialog.text(chat))];
+                    case 9:
+                        _c = _e.sent();
+                        return [3 /*break*/, 11];
+                    case 10:
+                        _c = dialog === null || dialog === void 0 ? void 0 : dialog.text;
+                        _e.label = 11;
+                    case 11:
+                        text = _c;
+                        _e.label = 12;
+                    case 12:
+                        _e.trys.push([12, 14, , 16]);
+                        return [4 /*yield*/, this._bot.editMessageText(text || "404", { chat_id: chat, message_id: this._userdialogs[chat].lastid, reply_markup: { inline_keyboard: markup || [] } })];
+                    case 13:
+                        _e.sent();
+                        return [3 /*break*/, 16];
+                    case 14:
+                        _d = _e.sent();
+                        return [4 /*yield*/, this._bot.sendMessage(chat, text || "404", { reply_markup: { inline_keyboard: markup || [] } })];
+                    case 15:
+                        msg = _e.sent();
+                        this._userdialogs[chat].lastid = msg.message_id;
+                        return [3 /*break*/, 16];
+                    case 16: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    EasyBot.prototype.AttachDataWait = function (chat, descriptor) {
+        this._userdialogs[chat].waiter.descriptor = descriptor;
+        this._userdialogs[chat].waiter.statewait = true;
+    };
+    EasyBot.prototype.Message = function (chat, content) {
+        return this._bot.sendMessage(chat, content);
+    };
+    return EasyBot;
+}());
+exports.EasyBot = EasyBot;
+function ChangeDialog(id) {
+    var _this = this;
+    return function (chat, _bot) { return __awaiter(_this, void 0, void 0, function () { return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0: return [4 /*yield*/, _bot.ChangeDialog(chat, id)];
+            case 1:
+                _a.sent();
+                return [2 /*return*/];
+        }
+    }); }); };
+}
+function CallbackAction(descriptor) {
+    var _this = this;
+    return function (chat, _bot) { return __awaiter(_this, void 0, void 0, function () { return __generator(this, function (_a) {
+        _bot.ActionSystem.emit(descriptor, { chatid: chat });
+        return [2 /*return*/];
+    }); }); };
+}
+function WaitForData(descriptor) {
+    return function (chat, _bot) {
+        _bot.AttachDataWait(chat, descriptor);
+        return new Promise(function (r) {
+            _bot.ActionSystem.once(descriptor, r);
+            _bot.ActionSystem.once("cancel_".concat(descriptor), r);
+        });
+    };
+}

package/lib/bot-struct.d.ts

@@ -0,0 +1,25 @@
+import { EasyBot } from "./bot-service";
+export type Action = (chat: number, _bot: EasyBot) => Promise<void>;
+export interface Dialog {
+    id: string;
+    text: string | ((chat: number) => Promise<string>);
+    buttons: Button[][];
+}
+export interface BotDialog extends Dialog {
+    buttons: BotButton[][];
+}
+export interface Button {
+    text: string | ((chat: number) => Promise<string>);
+    action: Action[] | Action;
+}
+export interface BotButton extends Button {
+    _callback: string;
+}
+export interface Schema {
+    start: string;
+    content: Dialog[];
+}
+export interface BotSchema extends Schema {
+    content: BotDialog[];
+    buttons: BotButton[];
+}

package/lib/bot-struct.js

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

package/lib/index.js

@@ -0,0 +1 @@
+"use strict";

package/package.json

@@ -0,0 +1,20 @@
+{
+  "name": "telegram-botbuilder",
+  "version": "1.0.0",
+  "main": "index.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "description": "",
+  "dependencies": {
+    "node-telegram-bot-api": "^0.66.0",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.5.3"
+  },
+  "devDependencies": {
+    "@types/node-telegram-bot-api": "^0.64.7"
+  }
+}

package/src/bot-service.ts

@@ -0,0 +1,144 @@
+import TelegramBot, { InlineKeyboardButton }  from 'node-telegram-bot-api';
+import { Schema, Action, BotSchema, Button, BotButton } from './bot-struct';
+import EventEmitter from 'events';
+import { randomInt } from 'crypto';
+import { readFileSync, rmSync } from 'fs';
+
+
+interface UserDialog {
+  [key: number]: {dialog: string, lastid: number, waiter: { statewait: boolean, descriptor: string }};
+}
+
+export interface ActionCallback {
+  chatid: number;
+}
+
+export class EasyBot {
+  private _bot: TelegramBot;
+  private _schema: BotSchema;
+  public ActionSystem: EventEmitter;
+  private _userdialogs: UserDialog;
+
+  constructor (schema: Schema, token: string, options?: TelegramBot.ConstructorOptions) {
+    this._bot = new TelegramBot(token, options);
+    this._schema = schema as BotSchema;
+    this._schema.buttons = [];
+
+    for (let x = 0; x < this._schema.content.length; x++) {
+      for (let y = 0; y < this._schema.content[x].buttons.length; y++) {
+        for (let b = 0; b < this._schema.content[x].buttons[y].length; b++) {
+          this._schema.content[x].buttons[y][b]._callback = randomInt(281474976710655).toFixed(0);
+          this._schema.buttons.push(this._schema.content[x].buttons[y][b]);
+        }
+      }
+    }
+
+    this.ActionSystem = new EventEmitter();
+    this._userdialogs = {};
+
+    this._bot.onText(/\/start/, (msg) => {
+      if (!this._userdialogs[msg.chat.id]) this._userdialogs[msg.chat.id] = {dialog: this._schema.start, lastid: -1, waiter: { statewait: false, descriptor: '' }}
+      this._bot.deleteMessage(msg.chat.id, msg.message_id).catch(() => undefined);
+      this.ChangeDialog(msg.chat.id, this._schema.start);
+    });
+
+    this._bot.on('callback_query', (query) => {
+      if (!this._userdialogs[query.message!.chat.id]) this._userdialogs[query.message!.chat.id] = {dialog: this._schema.start, lastid: -1, waiter: { statewait: false, descriptor: '' }}
+      this._activateButton(query.message!.chat.id, query.data!)
+    });
+
+    this._bot.onText(/.+/g, (msg) => {
+      let chat = msg.chat.id;
+      if (this._userdialogs[chat].waiter.statewait) {
+        this._userdialogs[chat].waiter.statewait = false;
+        this._bot.deleteMessage(chat, msg.message_id).catch(() => undefined);
+        this.ActionSystem.emit(this._userdialogs[chat].waiter.descriptor, chat, msg.text);
+      }
+    })
+
+    this._bot.on('document', (msg) => {
+      if (!msg.document) return;
+      let chat = msg.chat.id;
+      if (!this._userdialogs[chat].waiter.statewait) return;
+      this._bot.downloadFile(msg.document.file_id, './').then((x) => {
+        this._userdialogs[chat].waiter.statewait = false;
+        this._bot.deleteMessage(chat, msg.message_id).catch(() => undefined);
+        let content = readFileSync(x, 'utf8');
+        rmSync(x);
+        this.ActionSystem.emit(this._userdialogs[chat].waiter.descriptor, chat, content);
+      })
+    })
+  }
+
+  private _getDialog(id: string) {
+    return this._schema.content.find(x => x.id === id);
+  }
+  private _getButton(callback: string) {
+    return this._schema.buttons.find(x => x._callback === callback);
+  }
+  private async _activateButton(chat: number, btn: string | BotButton) {
+    let _btn;
+    if (typeof btn === 'string') _btn = this._getButton(btn);
+    else _btn = btn;
+
+    if (Array.isArray(_btn?.action)) {
+      for (let act of (_btn?.action as Action[])) {
+        await act(chat, this);
+      }
+    } else if (_btn?.action as Action) {
+      await (_btn?.action as Action)(chat, this);
+    }
+  }
+
+  public async ChangeDialog(chat: number, id: string) {
+    this._userdialogs[chat].dialog = id;
+    if (this._userdialogs[chat].waiter.statewait) {
+      this._userdialogs[chat].waiter.statewait = false;
+      this.ActionSystem.emit(`cancel_${this._userdialogs[chat].waiter.descriptor}`, chat)
+    }
+
+    let dialog = this._getDialog(id);
+    let markup: InlineKeyboardButton[][] | undefined = undefined;
+    if (dialog?.buttons.length! > 0) {
+      markup = [];
+      for (let b = 0; b < dialog?.buttons.length!; b++) {
+        markup[b] = [];
+        for (let btn of dialog?.buttons[b]!) {
+          let text = typeof btn.text === 'function' ? await btn.text(chat) : btn.text;
+          markup[b].push({ text, callback_data: btn._callback});
+        }
+      }
+    }
+
+    let text = typeof dialog?.text === 'function' ? await dialog?.text(chat) : dialog?.text;
+    try {
+      await this._bot.editMessageText(text || "404", { chat_id: chat, message_id: this._userdialogs[chat].lastid, reply_markup: { inline_keyboard: markup || [] }})
+    } catch {
+      let msg = await this._bot.sendMessage(chat, text || "404", { reply_markup: { inline_keyboard: markup || [] }});
+      this._userdialogs[chat].lastid = msg.message_id;
+    }
+  }
+  public AttachDataWait(chat: number, descriptor: string) {
+    this._userdialogs[chat].waiter.descriptor = descriptor;
+    this._userdialogs[chat].waiter.statewait = true;
+  }
+  public Message(chat: number, content: string) {
+    return this._bot.sendMessage(chat, content);
+  }
+}
+
+export function ChangeDialog(id: string): Action {
+  return async (chat: number, _bot: EasyBot) => { await _bot.ChangeDialog(chat, id); };
+}
+export function CallbackAction(descriptor: string): Action {
+  return async (chat: number, _bot: EasyBot) => { _bot.ActionSystem.emit(descriptor, {chatid: chat}); };
+}
+export function WaitForData(descriptor: string): Action {
+  return (chat: number, _bot: EasyBot) => { 
+    _bot.AttachDataWait(chat, descriptor);
+    return new Promise(r => {
+      _bot.ActionSystem.once(descriptor, r);
+      _bot.ActionSystem.once(`cancel_${descriptor}`, r); 
+    });
+  };
+}

package/src/bot-struct.ts

@@ -0,0 +1,31 @@
+import { EasyBot } from "./bot-service";
+
+
+export type Action = (chat: number, _bot: EasyBot) => Promise<void>;
+
+export interface Dialog {
+  id: string;
+  text: string | ((chat: number) => Promise<string>);
+  buttons: Button[][]
+}
+export interface BotDialog extends Dialog {
+  buttons: BotButton[][]
+}
+
+export interface Button {
+  text: string | ((chat: number) => Promise<string>);
+  action: Action[] | Action;
+}
+export interface BotButton extends Button {
+  _callback: string;
+}
+
+export interface Schema {
+  start: string;
+  content: Dialog[];
+}
+
+export interface BotSchema extends Schema {
+  content: BotDialog[];
+  buttons: BotButton[];
+}

package/tsconfig.json

@@ -0,0 +1,108 @@
+{
+  "compilerOptions": {
+    /* Visit https://aka.ms/tsconfig to read more about this file */
+
+    /* Projects */
+    // "incremental": true,                              /* Save .tsbuildinfo files to allow for incremental compilation of projects. */
+    // "composite": true,                                /* Enable constraints that allow a TypeScript project to be used with project references. */
+    // "tsBuildInfoFile": "./.tsbuildinfo",              /* Specify the path to .tsbuildinfo incremental compilation file. */
+    // "disableSourceOfProjectReferenceRedirect": true,  /* Disable preferring source files instead of declaration files when referencing composite projects. */
+    // "disableSolutionSearching": true,                 /* Opt a project out of multi-project reference checking when editing. */
+    // "disableReferencedProjectLoad": true,             /* Reduce the number of projects loaded automatically by TypeScript. */
+
+    /* Language and Environment */
+    "target": "ES5",                                  /* Set the JavaScript language version for emitted JavaScript and include compatible library declarations. */
+    // "lib": [],                                        /* Specify a set of bundled library declaration files that describe the target runtime environment. */
+    // "jsx": "preserve",                                /* Specify what JSX code is generated. */
+    // "experimentalDecorators": true,                   /* Enable experimental support for legacy experimental decorators. */
+    // "emitDecoratorMetadata": true,                    /* Emit design-type metadata for decorated declarations in source files. */
+    // "jsxFactory": "",                                 /* Specify the JSX factory function used when targeting React JSX emit, e.g. 'React.createElement' or 'h'. */
+    // "jsxFragmentFactory": "",                         /* Specify the JSX Fragment reference used for fragments when targeting React JSX emit e.g. 'React.Fragment' or 'Fragment'. */
+    // "jsxImportSource": "",                            /* Specify module specifier used to import the JSX factory functions when using 'jsx: react-jsx*'. */
+    // "reactNamespace": "",                             /* Specify the object invoked for 'createElement'. This only applies when targeting 'react' JSX emit. */
+    // "noLib": true,                                    /* Disable including any library files, including the default lib.d.ts. */
+    // "useDefineForClassFields": true,                  /* Emit ECMAScript-standard-compliant class fields. */
+    // "moduleDetection": "auto",                        /* Control what method is used to detect module-format JS files. */
+
+    /* Modules */
+    "module": "commonjs",                                /* Specify what module code is generated. */
+    "rootDir": "./src/",                                  /* Specify the root folder within your source files. */
+    // "moduleResolution": "node10",                     /* Specify how TypeScript looks up a file from a given module specifier. */
+    // "baseUrl": "./",                                  /* Specify the base directory to resolve non-relative module names. */
+    // "paths": {},                                      /* Specify a set of entries that re-map imports to additional lookup locations. */
+    // "rootDirs": [],                                   /* Allow multiple folders to be treated as one when resolving modules. */
+    // "typeRoots": [],                                  /* Specify multiple folders that act like './node_modules/@types'. */
+    // "types": [],                                      /* Specify type package names to be included without being referenced in a source file. */
+    // "allowUmdGlobalAccess": true,                     /* Allow accessing UMD globals from modules. */
+    // "moduleSuffixes": [],                             /* List of file name suffixes to search when resolving a module. */
+    // "allowImportingTsExtensions": true,               /* Allow imports to include TypeScript file extensions. Requires '--moduleResolution bundler' and either '--noEmit' or '--emitDeclarationOnly' to be set. */
+    // "resolvePackageJsonExports": true,                /* Use the package.json 'exports' field when resolving package imports. */
+    // "resolvePackageJsonImports": true,                /* Use the package.json 'imports' field when resolving imports. */
+    // "customConditions": [],                           /* Conditions to set in addition to the resolver-specific defaults when resolving imports. */
+    // "resolveJsonModule": true,                        /* Enable importing .json files. */
+    // "allowArbitraryExtensions": true,                 /* Enable importing files with any extension, provided a declaration file is present. */
+    // "noResolve": true,                                /* Disallow 'import's, 'require's or '<reference>'s from expanding the number of files TypeScript should add to a project. */
+
+    /* JavaScript Support */
+    // "allowJs": true,                                  /* Allow JavaScript files to be a part of your program. Use the 'checkJS' option to get errors from these files. */
+    // "checkJs": true,                                  /* Enable error reporting in type-checked JavaScript files. */
+    // "maxNodeModuleJsDepth": 1,                        /* Specify the maximum folder depth used for checking JavaScript files from 'node_modules'. Only applicable with 'allowJs'. */
+
+    /* Emit */
+    "declaration": true,                              /* Generate .d.ts files from TypeScript and JavaScript files in your project. */
+    // "declarationMap": true,                           /* Create sourcemaps for d.ts files. */
+    // "emitDeclarationOnly": true,                      /* Only output d.ts files and not JavaScript files. */
+    // "sourceMap": true,                                /* Create source map files for emitted JavaScript files. */
+    // "inlineSourceMap": true,                          /* Include sourcemap files inside the emitted JavaScript. */
+    // "outFile": "./",                                  /* Specify a file that bundles all outputs into one JavaScript file. If 'declaration' is true, also designates a file that bundles all .d.ts output. */
+    "outDir": "./lib/",                                   /* Specify an output folder for all emitted files. */
+    // "removeComments": true,                           /* Disable emitting comments. */
+    // "noEmit": true,                                   /* Disable emitting files from a compilation. */
+    // "importHelpers": true,                            /* Allow importing helper functions from tslib once per project, instead of including them per-file. */
+    // "downlevelIteration": true,                       /* Emit more compliant, but verbose and less performant JavaScript for iteration. */
+    // "sourceRoot": "",                                 /* Specify the root path for debuggers to find the reference source code. */
+    // "mapRoot": "",                                    /* Specify the location where debugger should locate map files instead of generated locations. */
+    // "inlineSources": true,                            /* Include source code in the sourcemaps inside the emitted JavaScript. */
+    // "emitBOM": true,                                  /* Emit a UTF-8 Byte Order Mark (BOM) in the beginning of output files. */
+    // "newLine": "crlf",                                /* Set the newline character for emitting files. */
+    // "stripInternal": true,                            /* Disable emitting declarations that have '@internal' in their JSDoc comments. */
+    // "noEmitHelpers": true,                            /* Disable generating custom helper functions like '__extends' in compiled output. */
+    // "noEmitOnError": true,                            /* Disable emitting files if any type checking errors are reported. */
+    // "preserveConstEnums": true,                       /* Disable erasing 'const enum' declarations in generated code. */
+    // "declarationDir": "./",                           /* Specify the output directory for generated declaration files. */
+
+    /* Interop Constraints */
+    // "isolatedModules": true,                          /* Ensure that each file can be safely transpiled without relying on other imports. */
+    // "verbatimModuleSyntax": true,                     /* Do not transform or elide any imports or exports not marked as type-only, ensuring they are written in the output file's format based on the 'module' setting. */
+    // "isolatedDeclarations": true,                     /* Require sufficient annotation on exports so other tools can trivially generate declaration files. */
+    // "allowSyntheticDefaultImports": true,             /* Allow 'import x from y' when a module doesn't have a default export. */
+    "esModuleInterop": true,                             /* Emit additional JavaScript to ease support for importing CommonJS modules. This enables 'allowSyntheticDefaultImports' for type compatibility. */
+    // "preserveSymlinks": true,                         /* Disable resolving symlinks to their realpath. This correlates to the same flag in node. */
+    "forceConsistentCasingInFileNames": true,            /* Ensure that casing is correct in imports. */
+
+    /* Type Checking */
+    "strict": true,                                      /* Enable all strict type-checking options. */
+    // "noImplicitAny": true,                            /* Enable error reporting for expressions and declarations with an implied 'any' type. */
+    // "strictNullChecks": true,                         /* When type checking, take into account 'null' and 'undefined'. */
+    // "strictFunctionTypes": true,                      /* When assigning functions, check to ensure parameters and the return values are subtype-compatible. */
+    // "strictBindCallApply": true,                      /* Check that the arguments for 'bind', 'call', and 'apply' methods match the original function. */
+    // "strictPropertyInitialization": true,             /* Check for class properties that are declared but not set in the constructor. */
+    // "noImplicitThis": true,                           /* Enable error reporting when 'this' is given the type 'any'. */
+    // "useUnknownInCatchVariables": true,               /* Default catch clause variables as 'unknown' instead of 'any'. */
+    // "alwaysStrict": true,                             /* Ensure 'use strict' is always emitted. */
+    // "noUnusedLocals": true,                           /* Enable error reporting when local variables aren't read. */
+    // "noUnusedParameters": true,                       /* Raise an error when a function parameter isn't read. */
+    // "exactOptionalPropertyTypes": true,               /* Interpret optional property types as written, rather than adding 'undefined'. */
+    // "noImplicitReturns": true,                        /* Enable error reporting for codepaths that do not explicitly return in a function. */
+    // "noFallthroughCasesInSwitch": true,               /* Enable error reporting for fallthrough cases in switch statements. */
+    // "noUncheckedIndexedAccess": true,                 /* Add 'undefined' to a type when accessed using an index. */
+    // "noImplicitOverride": true,                       /* Ensure overriding members in derived classes are marked with an override modifier. */
+    // "noPropertyAccessFromIndexSignature": true,       /* Enforces using indexed accessors for keys declared using an indexed type. */
+    // "allowUnusedLabels": true,                        /* Disable error reporting for unused labels. */
+    // "allowUnreachableCode": true,                     /* Disable error reporting for unreachable code. */
+
+    /* Completeness */
+    // "skipDefaultLibCheck": true,                      /* Skip type checking .d.ts files that are included with TypeScript. */
+    "skipLibCheck": true                                 /* Skip type checking all .d.ts files. */
+  }
+}