chz-telegram-bot 0.0.1

package/helpers/noop.ts

@@ -0,0 +1,13 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+class Noop {
+    static async true<T1>(arg1: T1) {
+        return true;
+    }
+    static async false<T1>(arg1: T1) {
+        return false;
+    }
+    static async call<T1, T2>(arg1: T1, arg2: T2): Promise<void>;
+    static async call<T1>(arg1: T1) {}
+}
+
+export default Noop;

package/helpers/randomInt.ts

@@ -0,0 +1,7 @@
+export default function randomInteger(x1: number, x2: number): number {
+    const range = x2 - x1 + 1;
+
+    const random = Math.floor(Math.random() * range);
+
+    return random + x1;
+}

package/helpers/reverseMap.ts

@@ -0,0 +1,3 @@
+export function reverseMap<K, V>(map: Map<K, V>): Map<V, K> {
+    return new Map(Array.from(map, ([key, value]) => [value, key]));
+}

package/helpers/timeConvertions.ts

@@ -0,0 +1,13 @@
+import { Hours, Milliseconds, Seconds } from '../types/timeValues';
+
+export function secondsToMilliseconds(value: Seconds): Milliseconds {
+    return (value * 1000) as Milliseconds;
+}
+
+export function hoursToMilliseconds(value: Hours): Milliseconds {
+    return (value * 60 * 60 * 1000) as Milliseconds;
+}
+
+export function hoursToSeconds(value: Hours): Seconds {
+    return (value * 60 * 60) as Seconds;
+}

package/helpers/toArray.ts

@@ -0,0 +1,3 @@
+export default function toArray<TType>(value: TType | TType[]) {
+    return Array.isArray(value) ? value : [value];
+}

package/index.ts

@@ -0,0 +1,47 @@
+import { readFile } from 'fs/promises';
+import BotInstance from './entities/bot.js';
+import taskScheduler from './services/taskScheduler.js';
+import { setTimeout } from 'timers/promises';
+import { Seconds } from './types/timeValues.js';
+import { secondsToMilliseconds } from './helpers/timeConvertions.js';
+import storage from './services/storage.js';
+import logger from './services/logger.js';
+import CommandAction from './entities/actions/commandAction.js';
+import IActionState from './types/actionState.js';
+import ScheduledAction from './entities/actions/scheduledAction.js';
+
+const bots: BotInstance[] = [];
+
+function log(text: string) {
+    logger.logWithTraceId('ALL BOTS', 'System:Bot', 'System', text);
+}
+
+async function startBot(
+    name: string,
+    tokenFile: string,
+    commands: CommandAction<IActionState>[],
+    scheduled: ScheduledAction[],
+    chats: Map<string, number>
+) {
+    const token = await readFile(tokenFile, 'utf8');
+    const bot = new BotInstance(name, token, commands, scheduled, chats);
+    bots.push(bot);
+
+    return bot;
+}
+
+async function stopBots(reason: string) {
+    log(`Recieved termination code: ${reason}`);
+    taskScheduler.stopAll();
+    log('Acquiring storage semaphore...');
+    await storage.semaphoreInstance.acquire();
+
+    log('Stopping bots...');
+    for (const bot of bots) {
+        bot.stop(reason);
+    }
+
+    process.exit(0);
+}
+
+export { startBot, stopBots };

package/package.json

@@ -0,0 +1,30 @@
+{
+    "name": "chz-telegram-bot",
+    "version": "0.0.1",
+    "type": "module",
+    "dependencies": {
+        "async-sema": "^3.1.1",
+        "markdown-escape": "^2.0.0",
+        "moment": "^2.29.4",
+        "telegraf": "^4.16.3"
+    },
+    "main": "dist/index.js",
+    "types": "dist/index.d.ts",
+    "devDependencies": {
+        "@eslint/js": "^9.10.0",
+        "@types/markdown-escape": "^1.1.3",
+        "@types/node": "^22.5.5",
+        "eslint": "^9.10.0",
+        "typescript": "^5.6.2",
+        "typescript-eslint": "^8.5.0"
+    },
+    "scripts": {
+        "build": "tsc",
+        "lint": "npx eslint && tsc --noEmit"
+    },
+    "overrides": {
+        "telegraf": {
+            "node-fetch": "3.3.2"
+        }
+    }
+}

package/services/logger.ts

@@ -0,0 +1,30 @@
+class Logger {
+    logWithTraceId(
+        botName: string,
+        traceId: string | number,
+        chatName: string,
+        text: string
+    ) {
+        console.log(JSON.stringify({ botName, traceId, chatName, text }));
+    }
+
+    errorWithTraceId<TData>(
+        botName: string,
+        traceId: string | number,
+        chatName: string,
+        errorObj: string | Error,
+        extraData?: TData | undefined
+    ) {
+        console.error(
+            JSON.stringify({
+                botName,
+                traceId,
+                chatName,
+                errorObj,
+                extraData
+            })
+        );
+    }
+}
+
+export default new Logger();

package/services/storage.ts

@@ -0,0 +1,111 @@
+import { existsSync } from 'fs';
+import { dirname } from 'path';
+import TransactionResult from '../entities/transactionResult';
+import { mkdir, readFile, writeFile } from 'fs/promises';
+import ActionStateBase from '../entities/states/actionStateBase';
+import IActionState from '../types/actionState';
+import IActionWithState from '../types/actionWithState';
+import { Sema as Semaphore } from 'async-sema';
+
+class Storage {
+    static semaphore = new Semaphore(1);
+    cache: Map<string, Record<number, ActionStateBase>>;
+
+    get semaphoreInstance() {
+        return Storage.semaphore;
+    }
+
+    constructor() {
+        this.cache = new Map<string, Record<number, ActionStateBase>>();
+    }
+
+    private async lock<TType>(action: () => Promise<TType>) {
+        await this.semaphoreInstance.acquire();
+
+        try {
+            return await action();
+        } finally {
+            this.semaphoreInstance.release();
+        }
+    }
+
+    private async loadInternal(key: string) {
+        if (!this.cache.has(key)) {
+            const targetPath = this.buidPathFromKey(key);
+            if (!existsSync(targetPath)) {
+                return {};
+            }
+
+            const fileContent = await readFile(targetPath, 'utf8');
+
+            if (fileContent) {
+                const data = JSON.parse(fileContent);
+
+                this.cache.set(key, data);
+            }
+        }
+
+        return this.cache.get(key) ?? {};
+    }
+
+    private async save(data: Record<number, ActionStateBase>, key: string) {
+        this.cache.delete(key);
+
+        const targetPath = this.buidPathFromKey(key);
+        const folderName = dirname(targetPath);
+
+        if (!existsSync(folderName)) {
+            await mkdir(folderName, { recursive: true });
+        }
+
+        await writeFile(targetPath, JSON.stringify(data), { flag: 'w+' });
+    }
+
+    private buidPathFromKey(key: string) {
+        return 'storage/' + key.replaceAll(':', '/') + '.json';
+    }
+
+    async load(key: string) {
+        return await this.lock(async () => {
+            return this.loadInternal(key);
+        });
+    }
+
+    async saveMetadata(actions: IActionWithState[], botName: string) {
+        return await this.lock(async () => {
+            const targetPath = this.buidPathFromKey(`Metadata-${botName}`);
+
+            await writeFile(targetPath, JSON.stringify(actions), {
+                flag: 'w+'
+            });
+        });
+    }
+
+    async getActionState<TActionState extends IActionState>(
+        entity: IActionWithState,
+        chatId: number
+    ) {
+        return await this.lock(async () => {
+            const data = await this.loadInternal(entity.key);
+
+            return (data[chatId] as TActionState) ?? entity.stateConstructor();
+        });
+    }
+
+    async commitTransactionForAction(
+        action: IActionWithState,
+        chatId: number,
+        transactionResult: TransactionResult
+    ) {
+        await this.lock(async () => {
+            const data = await this.loadInternal(action.key);
+
+            if (transactionResult.shouldUpdate) {
+                data[chatId] = transactionResult.data;
+                await this.save(data, action.key);
+            }
+        });
+    }
+}
+
+export default new Storage();

package/services/taskScheduler.ts

@@ -0,0 +1,66 @@
+import TaskRecord from '../entities/taskRecord';
+import { secondsToMilliseconds } from '../helpers/timeConvertions';
+import { Milliseconds, Seconds } from '../types/timeValues';
+import logger from './logger';
+
+class TaskScheduler {
+    activeTasks: TaskRecord[] = [];
+
+    stopAll() {
+        this.activeTasks.forEach((task) => {
+            clearInterval(task.taskId);
+        });
+    }
+
+    createTask(
+        name: string,
+        action: () => void,
+        interval: Milliseconds,
+        executeRightAway: boolean,
+        ownerName: string
+    ) {
+        executeRightAway = executeRightAway ?? false;
+        const taskId = setInterval(action, interval);
+        const task = new TaskRecord(name, taskId, interval);
+
+        if (executeRightAway) {
+            setTimeout(action, secondsToMilliseconds(1 as Seconds));
+        }
+
+        logger.logWithTraceId(
+            ownerName,
+            `System:TaskScheduler-${ownerName}-${name}`,
+            'System',
+            `Created task [${taskId}]${name}, that will run every ${interval}ms.`
+        );
+
+        this.activeTasks.push(task);
+    }
+
+    createOnetimeTask(
+        name: string,
+        action: () => void,
+        delay: Milliseconds,
+        ownerName: string
+    ) {
+        const actionWrapper = () => {
+            logger.logWithTraceId(
+                ownerName,
+                `System:TaskScheduler-${ownerName}-${name}`,
+                'System',
+                `Executing delayed oneshot [${taskId}]${name}`
+            );
+            action();
+        };
+        const taskId = setTimeout(actionWrapper, delay);
+
+        logger.logWithTraceId(
+            ownerName,
+            `System:TaskScheduler-${ownerName}-${name}`,
+            'System',
+            `Created oneshot task [${taskId}]${name}, that will run in ${delay}ms.`
+        );
+    }
+}
+
+export default new TaskScheduler();

package/services/telegramApi.ts

@@ -0,0 +1,172 @@
+import MessageContext from '../entities/context/messageContext';
+import ChatContext from '../entities/context/chatContext';
+import ImageMessage from '../entities/responses/imageMessage';
+import TextMessage from '../entities/responses/textMessage';
+import VideoMessage from '../entities/responses/videoMessage';
+import taskScheduler from './taskScheduler';
+import logger from './logger';
+import { Telegraf } from 'telegraf';
+import IReplyMessage from '../types/replyMessage';
+import IncomingMessage from '../entities/incomingMessage';
+import { Milliseconds } from '../types/timeValues';
+import Reaction from '../entities/responses/reaction';
+import { InputFile } from 'telegraf/types';
+import { reverseMap } from '../helpers/reverseMap';
+
+export default class TelegramApiService {
+    botName: string;
+    telegraf: Telegraf;
+    chats: Map<number, string>;
+    messageQueue: Array<IReplyMessage<unknown> | Reaction> = [];
+
+    constructor(
+        botName: string,
+        telegraf: Telegraf,
+        chats: Map<string, number>
+    ) {
+        this.telegraf = telegraf;
+        this.botName = botName;
+        this.chats = reverseMap(chats);
+
+        taskScheduler.createTask(
+            'MessageSending',
+            () => {
+                this.dequeueResponse();
+            },
+            100 as Milliseconds,
+            false,
+            this.botName
+        );
+    }
+
+    private async dequeueResponse() {
+        const message = this.messageQueue.pop();
+
+        if (!message) return;
+
+        try {
+            await this.processResponse(message);
+        } catch (error) {
+            logger.errorWithTraceId(
+                this.botName,
+                message.traceId,
+                this.chats.get(message.chatId)!,
+                error as string | Error,
+                message
+            );
+        }
+    }
+
+    private async processResponse<TType>(
+        response: IReplyMessage<TType> | Reaction
+    ) {
+        if ('emoji' in response) {
+            this.telegraf.telegram.setMessageReaction(
+                response.chatId,
+                response.messageId,
+                [
+                    {
+                        type: 'emoji',
+                        emoji: response.emoji
+                    }
+                ],
+                true
+            );
+
+            return;
+        }
+
+        switch (response.constructor) {
+            case TextMessage:
+                await this.telegraf.telegram.sendMessage(
+                    response.chatId,
+                    response.content as string,
+                    {
+                        reply_to_message_id: response.replyId,
+                        parse_mode: 'MarkdownV2',
+                        disable_web_page_preview: true
+                        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                    } as any
+                );
+                break;
+            case ImageMessage:
+                await this.telegraf.telegram.sendPhoto(
+                    response.chatId,
+                    response.content as InputFile,
+                    response.replyId
+                        ? // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                          ({ reply_to_message_id: response.replyId } as any)
+                        : undefined
+                );
+                break;
+            case VideoMessage:
+                await this.telegraf.telegram.sendVideo(
+                    response.chatId,
+                    response.content as InputFile,
+                    response.replyId
+                        ? // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                          ({ reply_to_message_id: response.replyId } as any)
+                        : undefined
+                );
+                break;
+            default:
+                logger.errorWithTraceId(
+                    this.botName,
+                    response.traceId,
+                    this.chats.get(response.chatId)!,
+                    `Unknown message type: ${response.constructor}`,
+                    response
+                );
+                break;
+        }
+    }
+
+    private enqueueResponse<TType>(response: IReplyMessage<TType>) {
+        this.messageQueue.push(response);
+    }
+
+    private enqueueReaction(reaction: Reaction) {
+        this.messageQueue.push(reaction);
+    }
+
+    private getInteractions() {
+        return {
+            react: (reaction) => this.enqueueReaction(reaction),
+            respond: (response) => this.enqueueResponse(response)
+        } as IBotApiInteractions;
+    }
+
+    createContextForMessage(incomingMessage: IncomingMessage) {
+        const firstName = incomingMessage.from?.first_name ?? 'Unknown user';
+        const lastName = incomingMessage.from?.last_name
+            ? ` ${incomingMessage.from?.last_name}`
+            : '';
+
+        return new MessageContext(
+            this.botName,
+            this.getInteractions(),
+            incomingMessage.chat.id,
+            incomingMessage.chatName,
+            incomingMessage.message_id,
+            incomingMessage.text,
+            incomingMessage.from?.id,
+            incomingMessage.traceId,
+            firstName + lastName
+        );
+    }
+
+    createContextForChat(chatId: number, scheduledName: string) {
+        return new ChatContext(
+            this.botName,
+            this.getInteractions(),
+            chatId,
+            this.chats.get(chatId)!,
+            `Scheduled:${scheduledName}:${chatId}`
+        );
+    }
+}
+
+export interface IBotApiInteractions {
+    respond: <TType>(response: IReplyMessage<TType>) => void;
+    react: (reaction: Reaction) => void;
+}

package/tsconfig.json

@@ -0,0 +1,110 @@
+{
+  "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": "es2020",                                  /* Set the JavaScript language version for emitted JavaScript and include compatible library declarations. */
+    "lib": ["es2021", "DOM", "ES6" ,"DOM.Iterable", "ScriptHost"],                                        /* 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": "./",                                  /* 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. */
+    // "noUncheckedSideEffectImports": true,             /* Check side effect 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. */
+    // "noEmit": true,                                   /* Disable emitting files from a compilation. */
+    // "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": "./dist",                                  /* Specify an output folder for all emitted files. */
+    // "removeComments": true,                           /* Disable emitting comments. */
+    // "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. */
+    // "strictBuiltinIteratorReturn": true,              /* Built-in iterators are instantiated with a 'TReturn' type of 'undefined' instead of 'any'. */
+    // "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. */
+  }
+}

package/types/actionState.ts

@@ -0,0 +1,3 @@
+export default interface IActionState {
+    lastExecutedDate: number;
+}

package/types/actionWithState.ts

@@ -0,0 +1,6 @@
+import IActionState from './actionState';
+
+export default interface IActionWithState {
+    key: string;
+    stateConstructor: () => IActionState;
+}

package/types/cachedValueAccessor.ts

@@ -0,0 +1 @@
+export type CachedValueAccessor = <TResult>(key: string) => Promise<TResult>;

package/types/commandCondition.ts

@@ -0,0 +1,6 @@
+import MessageContext from '../entities/context/messageContext';
+import IActionState from './actionState';
+
+export type CommandCondition<TActionState extends IActionState> = (
+    ctx: MessageContext<TActionState>
+) => Promise<boolean>;

package/types/daysOfTheWeek.ts

@@ -0,0 +1,9 @@
+export enum Day {
+    Sunday = 0,
+    Monday = 1,
+    Tuesday = 2,
+    Wednesday = 3,
+    Thursday = 4,
+    Friday = 5,
+    Saturday = 6
+}