chz-telegram-bot 0.5.4 → 0.6.8

package/dist/services/jsonFileStorage.js

@@ -0,0 +1,133 @@
+import { existsSync, mkdirSync } from 'fs';
+import { readFile, writeFile } from 'fs/promises';
+import { Sema as Semaphore } from 'async-sema';
+import { getOrSetIfNotExists } from '../helpers/mapUtils';
+import { BotEventType } from '../types/events';
+function buildPath(storagePath, botName, actionKey) {
+    return `${storagePath}/${botName}/${actionKey.replaceAll(':', '/')}.json`;
+}
+export class JsonFileStorage {
+    eventEmitter;
+    filePaths = new Map();
+    locks = new Map();
+    cache;
+    storagePath;
+    botName;
+    constructor(botName, actions, eventEmitter, path) {
+        this.eventEmitter = eventEmitter;
+        this.cache = new Map();
+        this.botName = botName;
+        this.storagePath = path ?? 'storage';
+        if (!existsSync(`${this.storagePath}/${this.botName}/`)) {
+            mkdirSync(`${this.storagePath}/${this.botName}/`, {
+                recursive: true
+            });
+        }
+        for (const action of actions) {
+            this.locks.set(action.key, new Semaphore(1));
+            this.filePaths.set(action.key, buildPath(this.storagePath, this.botName, action.key));
+        }
+    }
+    backfillEmptyActionStates(action, data) {
+        for (const [stringKey, value] of Object.entries(data)) {
+            if (value)
+                continue;
+            data[Number.parseInt(stringKey)] = action.stateConstructor();
+        }
+        return true;
+    }
+    async lock(key, action) {
+        const lock = getOrSetIfNotExists(this.locks, key, new Semaphore(1));
+        this.eventEmitter.emit(BotEventType.storageLockAcquiring, key);
+        await lock.acquire();
+        this.eventEmitter.emit(BotEventType.storageLockAcquired, key);
+        try {
+            return await action();
+        }
+        finally {
+            lock.release();
+            this.eventEmitter.emit(BotEventType.storageLockReleased, key);
+        }
+    }
+    tryGetFromCache(key) {
+        return this.cache.get(key);
+    }
+    async loadFromFile(key) {
+        const targetPath = getOrSetIfNotExists(this.filePaths, key, buildPath(this.storagePath, this.botName, key));
+        const fileContent = await readFile(targetPath, {
+            encoding: 'utf-8',
+            flag: 'a+'
+        });
+        if (fileContent) {
+            const data = JSON.parse(fileContent);
+            this.cache.set(key, data);
+        }
+        return (this.cache.get(key) ?? {});
+    }
+    async updateCacheAndSaveToFile(data, key) {
+        this.eventEmitter.emit(BotEventType.storageStateSaving, {
+            data,
+            key
+        });
+        this.cache.set(key, data);
+        const targetPath = getOrSetIfNotExists(this.filePaths, key, buildPath(this.storagePath, this.botName, key));
+        await writeFile(targetPath, JSON.stringify(data), { flag: 'w+' });
+        this.eventEmitter.emit(BotEventType.storageStateSaved, {
+            data,
+            key
+        });
+    }
+    async load(key) {
+        return (this.tryGetFromCache(key) ??
+            (await this.lock(key, async () => {
+                return await this.loadFromFile(key);
+            })));
+    }
+    async saveMetadata(actions) {
+        const targetPath = `${this.storagePath}/${this.botName}/Metadata-${this.botName}.json`;
+        await writeFile(targetPath, JSON.stringify(actions), {
+            flag: 'w+'
+        });
+    }
+    async getActionState(action, chatId) {
+        this.eventEmitter.emit(BotEventType.storageStateLoading, {
+            action,
+            chatId
+        });
+        const value = this.tryGetFromCache(action.key) ??
+            (await this.lock(action.key, async () => {
+                return await this.loadFromFile(action.key);
+            }));
+        const result = Object.assign(action.stateConstructor(), value[chatId]);
+        this.eventEmitter.emit(BotEventType.storageStateLoaded, {
+            action,
+            chatId,
+            state: result
+        });
+        return result;
+    }
+    async saveActionExecutionResult(action, chatId, state) {
+        await this.lock(action.key, async () => {
+            const data = this.tryGetFromCache(action.key) ??
+                (await this.loadFromFile(action.key));
+            data[chatId] = state;
+            if (this.backfillEmptyActionStates(action, data))
+                await this.updateCacheAndSaveToFile(data, action.key);
+        });
+    }
+    async close() {
+        for (const lock of this.locks.values()) {
+            await lock.acquire();
+        }
+    }
+    async updateStateFor(action, chatId, update) {
+        await this.lock(action.key, async () => {
+            const data = this.tryGetFromCache(action.key) ??
+                (await this.loadFromFile(action.key));
+            const state = Object.assign(action.stateConstructor(), data[chatId]);
+            await update(state);
+            if (this.backfillEmptyActionStates(action, data))
+                await this.updateCacheAndSaveToFile(data, action.key);
+        });
+    }
+}

package/dist/services/nodeTimeoutScheduler.d.ts

@@ -0,0 +1,13 @@
+import { TaskRecord } from '../entities/taskRecord';
+import { TypedEventEmitter } from '../types/events';
+import { IScheduler } from '../types/scheduler';
+import { Milliseconds } from '../types/timeValues';
+export declare class NodeTimeoutScheduler implements IScheduler {
+    readonly eventEmitter: TypedEventEmitter;
+    readonly activeTasks: TaskRecord[];
+    constructor(eventEmitter: TypedEventEmitter);
+    stopAll(): void;
+    createTask(name: string, action: () => unknown, interval: Milliseconds, executeRightAway: boolean, ownerName: string): void;
+    createOnetimeTask(name: string, action: () => unknown, delay: Milliseconds, ownerName: string): void;
+}
+//# sourceMappingURL=nodeTimeoutScheduler.d.ts.map

package/dist/services/nodeTimeoutScheduler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"nodeTimeoutScheduler.d.ts","sourceRoot":"","sources":["../../services/nodeTimeoutScheduler.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,wBAAwB,CAAC;AACpD,OAAO,EAAgB,iBAAiB,EAAE,MAAM,iBAAiB,CAAC;AAClE,OAAO,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAChD,OAAO,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAEnD,qBAAa,oBAAqB,YAAW,UAAU;IAGvC,QAAQ,CAAC,YAAY,EAAE,iBAAiB;IAFpD,QAAQ,CAAC,WAAW,EAAE,UAAU,EAAE,CAAM;gBAEnB,YAAY,EAAE,iBAAiB;IAEpD,OAAO;IAMP,UAAU,CACN,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,MAAM,OAAO,EACrB,QAAQ,EAAE,YAAY,EACtB,gBAAgB,EAAE,OAAO,EACzB,SAAS,EAAE,MAAM;IAyBrB,iBAAiB,CACb,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,MAAM,OAAO,EACrB,KAAK,EAAE,YAAY,EACnB,SAAS,EAAE,MAAM;CAkBxB"}

package/dist/services/nodeTimeoutScheduler.js

@@ -0,0 +1,50 @@
+import { TaskRecord } from '../entities/taskRecord';
+import { BotEventType } from '../types/events';
+export class NodeTimeoutScheduler {
+    eventEmitter;
+    activeTasks = [];
+    constructor(eventEmitter) {
+        this.eventEmitter = eventEmitter;
+    }
+    stopAll() {
+        for (const task of this.activeTasks) {
+            clearInterval(task.taskId);
+        }
+    }
+    createTask(name, action, interval, executeRightAway, ownerName) {
+        const taskId = setInterval(() => {
+            action();
+            this.eventEmitter.emit(BotEventType.taskRun, {
+                name,
+                ownerName,
+                interval
+            });
+        }, interval);
+        const task = new TaskRecord(name, taskId, interval);
+        if (executeRightAway) {
+            setImmediate(action);
+        }
+        this.eventEmitter.emit(BotEventType.taskCreated, {
+            name,
+            ownerName,
+            interval
+        });
+        this.activeTasks.push(task);
+    }
+    createOnetimeTask(name, action, delay, ownerName) {
+        const actionWrapper = () => {
+            this.eventEmitter.emit(BotEventType.taskRun, {
+                name,
+                ownerName,
+                delay
+            });
+            action();
+        };
+        setTimeout(actionWrapper, delay);
+        this.eventEmitter.emit(BotEventType.taskCreated, {
+            name,
+            ownerName,
+            delay
+        });
+    }
+}

package/dist/services/responseProcessingQueue.d.ts

@@ -0,0 +1,12 @@
+export type QueueItem = {
+    priority: number;
+    callback: () => Promise<void>;
+};
+export declare class ResponseProcessingQueue {
+    rateLimiter: () => Promise<void>;
+    items: QueueItem[];
+    isFlushing: boolean;
+    enqueue(item: QueueItem): void;
+    flushReadyItems(): Promise<void>;
+}
+//# sourceMappingURL=responseProcessingQueue.d.ts.map

package/dist/services/responseProcessingQueue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"responseProcessingQueue.d.ts","sourceRoot":"","sources":["../../services/responseProcessingQueue.ts"],"names":[],"mappings":"AAGA,MAAM,MAAM,SAAS,GAAG;IACpB,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;CACjC,CAAC;AAQF,qBAAa,uBAAuB;IAChC,WAAW,sBAAwD;IACnE,KAAK,EAAE,SAAS,EAAE,CAAM;IACxB,UAAU,UAAS;IAEnB,OAAO,CAAC,IAAI,EAAE,SAAS;IAmBjB,eAAe;CAkBxB"}

package/dist/services/responseProcessingQueue.js

@@ -0,0 +1,37 @@
+import { RateLimit } from 'async-sema';
+function notEmpty(arr) {
+    return arr.length > 0;
+}
+const TELEGRAM_RATELIMIT_DELAY = 35;
+export class ResponseProcessingQueue {
+    rateLimiter = RateLimit(1, { timeUnit: TELEGRAM_RATELIMIT_DELAY });
+    items = [];
+    isFlushing = false;
+    enqueue(item) {
+        if (this.items.length === 0 ||
+            item.priority >= this.items[this.items.length - 1].priority) {
+            this.items.push(item);
+            return;
+        }
+        let insertIndex = this.items.length;
+        while (insertIndex > 0 &&
+            this.items[insertIndex - 1].priority > item.priority) {
+            insertIndex--;
+        }
+        this.items.splice(insertIndex, 0, item);
+    }
+    async flushReadyItems() {
+        if (this.isFlushing)
+            return;
+        this.isFlushing = true;
+        while (notEmpty(this.items)) {
+            if (Date.now() >= this.items[0].priority) {
+                await this.rateLimiter();
+                const [item] = this.items;
+                this.items.shift();
+                await item.callback();
+            }
+        }
+        this.isFlushing = false;
+    }
+}

package/dist/services/telegramApi.d.ts

@@ -0,0 +1,23 @@
+import { IStorageClient } from '../types/storage';
+import { BotResponse } from '../types/response';
+import { IReplyCapture } from '../types/capture';
+import { ChatInfo } from '../dtos/chatInfo';
+import { TelegramApiClient } from '../types/externalAliases';
+import { TypedEventEmitter } from '../types/events';
+export declare const TELEGRAM_ERROR_QUOTE_INVALID = "QUOTE_TEXT_INVALID";
+export declare class TelegramApiService {
+    private readonly queue;
+    private readonly telegram;
+    private readonly storage;
+    private readonly eventEmitter;
+    private readonly captureRegistrationCallback;
+    private readonly botName;
+    private readonly methodMap;
+    constructor(botName: string, telegram: TelegramApiClient, storage: IStorageClient, eventEmitter: TypedEventEmitter, captureRegistrationCallback: (capture: IReplyCapture, parentMessageId: number, chatInfo: ChatInfo) => void);
+    enqueueBatchedResponses(responses: BotResponse[]): void;
+    flushResponses(): void;
+    private pinIfShould;
+    private processResponse;
+    private sendApiRequest;
+}
+//# sourceMappingURL=telegramApi.d.ts.map

package/dist/services/telegramApi.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"telegramApi.d.ts","sourceRoot":"","sources":["../../services/telegramApi.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAClD,OAAO,EACH,WAAW,EAGd,MAAM,mBAAmB,CAAC;AAE3B,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAIjD,OAAO,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAC;AAC5C,OAAO,EAAE,iBAAiB,EAAmB,MAAM,0BAA0B,CAAC;AAC9E,OAAO,EAAgB,iBAAiB,EAAE,MAAM,iBAAiB,CAAC;AAElE,eAAO,MAAM,4BAA4B,uBAAuB,CAAC;AAEjE,qBAAa,kBAAkB;IAC3B,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAiC;IACvD,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAoB;IAC7C,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAiB;IACzC,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAoB;IACjD,OAAO,CAAC,QAAQ,CAAC,2BAA2B,CAKlC;IAEV,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAS;IAEjC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAYxB;gBAGE,OAAO,EAAE,MAAM,EACf,QAAQ,EAAE,iBAAiB,EAC3B,OAAO,EAAE,cAAc,EACvB,YAAY,EAAE,iBAAiB,EAC/B,2BAA2B,EAAE,CACzB,OAAO,EAAE,aAAa,EACtB,eAAe,EAAE,MAAM,EACvB,QAAQ,EAAE,QAAQ,KACjB,IAAI;IASb,uBAAuB,CAAC,SAAS,EAAE,WAAW,EAAE;IAoDhD,cAAc;YAIA,WAAW;YA6BX,eAAe;YAqBf,cAAc;CAkG/B"}

package/dist/services/telegramApi.js

@@ -0,0 +1,163 @@
+import { ResponseProcessingQueue } from './responseProcessingQueue';
+import { BotEventType } from '../types/events';
+export const TELEGRAM_ERROR_QUOTE_INVALID = 'QUOTE_TEXT_INVALID';
+export class TelegramApiService {
+    queue = new ResponseProcessingQueue();
+    telegram;
+    storage;
+    eventEmitter;
+    captureRegistrationCallback;
+    botName;
+    methodMap = {
+        inlineQuery: 'answerInlineQuery',
+        text: 'sendMessage',
+        react: 'setMessageReaction',
+        unpin: 'unpinChatMessage',
+        pin: 'pinChatMessage',
+        image: 'sendPhoto',
+        video: 'sendVideo',
+        delay: null
+    };
+    constructor(botName, telegram, storage, eventEmitter, captureRegistrationCallback) {
+        this.telegram = telegram;
+        this.botName = botName;
+        this.storage = storage;
+        this.eventEmitter = eventEmitter;
+        this.captureRegistrationCallback = captureRegistrationCallback;
+    }
+    enqueueBatchedResponses(responses) {
+        let offset = 0;
+        for (const response of responses) {
+            if (response.kind == 'delay') {
+                offset += response.delay;
+                continue;
+            }
+            const queueItem = {
+                callback: async () => {
+                    try {
+                        await this.processResponse(response);
+                    }
+                    catch (error) {
+                        if ('message' in error) {
+                            const telegramResponse = error;
+                            if (telegramResponse.message.includes(TELEGRAM_ERROR_QUOTE_INVALID)) {
+                                this.eventEmitter.emit(BotEventType.error, {
+                                    error: new Error('Quote error recieved, retrying without quote')
+                                });
+                                try {
+                                    await this.processResponse(response, true);
+                                }
+                                catch (error) {
+                                    this.eventEmitter.emit(BotEventType.error, {
+                                        error: error
+                                    });
+                                }
+                                return;
+                            }
+                        }
+                        this.eventEmitter.emit(BotEventType.error, {
+                            error: error
+                        });
+                    }
+                },
+                priority: response.createdAt + offset
+            };
+            this.queue.enqueue(queueItem);
+        }
+    }
+    flushResponses() {
+        void this.queue.flushReadyItems();
+    }
+    async pinIfShould(response, message) {
+        if (response.shouldPin) {
+            this.eventEmitter.emit(BotEventType.apiRequestSending, {
+                response: null,
+                telegramMethod: this.methodMap['pin']
+            });
+            await this.telegram.pinChatMessage(response.chatInfo.id, message.message_id, { disable_notification: true });
+            this.eventEmitter.emit(BotEventType.apiRequestSent, {
+                response: null,
+                telegramMethod: this.methodMap['pin']
+            });
+            await this.storage.updateStateFor(response.action, response.chatInfo.id, (state) => {
+                state.pinnedMessages.push(message.message_id);
+            });
+        }
+    }
+    async processResponse(response, ignoreQuote = false) {
+        const sentMessage = await this.sendApiRequest(response, ignoreQuote);
+        this.eventEmitter.emit(BotEventType.apiRequestSent, {
+            response,
+            telegramMethod: this.methodMap[response.kind]
+        });
+        if (sentMessage && 'content' in response) {
+            await this.pinIfShould(response, sentMessage);
+            for (const capture of response.captures) {
+                this.captureRegistrationCallback(capture, sentMessage.message_id, response.chatInfo, response.traceId);
+            }
+        }
+    }
+    async sendApiRequest(response, ignoreQuote) {
+        this.eventEmitter.emit(BotEventType.apiRequestSending, {
+            response,
+            telegramMethod: this.methodMap[response.kind]
+        });
+        switch (response.kind) {
+            case 'text':
+                return await this.telegram.sendMessage(response.chatInfo.id, response.content, {
+                    reply_parameters: response.replyInfo
+                        ? {
+                            message_id: response.replyInfo.id,
+                            quote: ignoreQuote
+                                ? undefined
+                                : response.replyInfo.quote
+                        }
+                        : undefined,
+                    parse_mode: 'MarkdownV2',
+                    link_preview_options: {
+                        is_disabled: response.disableWebPreview
+                    },
+                    reply_markup: response.keyboard
+                        ? {
+                            inline_keyboard: response.keyboard
+                        }
+                        : undefined
+                });
+            case 'image':
+                return await this.telegram.sendPhoto(response.chatInfo.id, response.content, 
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+                response.replyInfo?.id
+                    ? {
+                        reply_to_message_id: response.replyInfo.id // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                    }
+                    : undefined);
+            case 'video':
+                return await this.telegram.sendVideo(response.chatInfo.id, response.content, 
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+                response.replyInfo?.id
+                    ? {
+                        reply_to_message_id: response.replyInfo.id // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                    }
+                    : undefined);
+            case 'react':
+                await this.telegram.setMessageReaction(response.chatInfo.id, response.messageId, [
+                    {
+                        type: 'emoji',
+                        emoji: response.emoji
+                    }
+                ]);
+                return null;
+            case 'unpin':
+                await this.telegram.unpinChatMessage(response.chatInfo.id, response.messageId);
+                await this.storage.updateStateFor(response.action, response.chatInfo.id, (state) => {
+                    state.pinnedMessages = state.pinnedMessages.filter((x) => x != response.messageId);
+                });
+                return null;
+            case 'inlineQuery':
+                await this.telegram.answerInlineQuery(response.queryId, response.queryResults, { cache_time: 0 });
+                return null;
+            case 'delay':
+                return null;
+        }
+    }
+}

package/dist/types/action.d.ts

@@ -0,0 +1,14 @@
+import { BaseContextInternal } from '../entities/context/baseContext';
+import { IActionState } from './actionState';
+import { BotResponse } from './response';
+export type ActionKey = string & {
+    __brand: 'actionKey';
+};
+export interface IActionWithState<TActionState extends IActionState> extends IAction {
+    readonly stateConstructor: () => TActionState;
+}
+export interface IAction {
+    readonly key: ActionKey;
+    exec(ctx: BaseContextInternal<IAction>): Promise<BotResponse[]>;
+}
+//# sourceMappingURL=action.d.ts.map

package/dist/types/action.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"action.d.ts","sourceRoot":"","sources":["../../types/action.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAE,MAAM,iCAAiC,CAAC;AACtE,OAAO,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAC7C,OAAO,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAEzC,MAAM,MAAM,SAAS,GAAG,MAAM,GAAG;IAAE,OAAO,EAAE,WAAW,CAAA;CAAE,CAAC;AAE1D,MAAM,WAAW,gBAAgB,CAAC,YAAY,SAAS,YAAY,CAC/D,SAAQ,OAAO;IACf,QAAQ,CAAC,gBAAgB,EAAE,MAAM,YAAY,CAAC;CACjD;AAED,MAAM,WAAW,OAAO;IACpB,QAAQ,CAAC,GAAG,EAAE,SAAS,CAAC;IACxB,IAAI,CAAC,GAAG,EAAE,mBAAmB,CAAC,OAAO,CAAC,GAAG,OAAO,CAAC,WAAW,EAAE,CAAC,CAAC;CACnE"}

package/dist/types/action.js

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

package/dist/types/actionState.d.ts

@@ -0,0 +1,5 @@
+export interface IActionState {
+    lastExecutedDate: number;
+    pinnedMessages: number[];
+}
+//# sourceMappingURL=actionState.d.ts.map

package/dist/types/actionState.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"actionState.d.ts","sourceRoot":"","sources":["../../types/actionState.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,YAAY;IACzB,gBAAgB,EAAE,MAAM,CAAC;IACzB,cAAc,EAAE,MAAM,EAAE,CAAC;CAC5B"}

package/dist/types/actionState.js

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

package/dist/types/cachedValueAccessor.d.ts

@@ -0,0 +1,2 @@
+export type CachedValueAccessor = <TResult>(key: string) => Promise<TResult>;
+//# sourceMappingURL=cachedValueAccessor.d.ts.map

package/dist/types/cachedValueAccessor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cachedValueAccessor.d.ts","sourceRoot":"","sources":["../../types/cachedValueAccessor.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,mBAAmB,GAAG,CAAC,OAAO,EAAE,GAAG,EAAE,MAAM,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC"}

package/dist/types/cachedValueAccessor.js

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

package/dist/types/capture.d.ts

@@ -0,0 +1,24 @@
+import { ReplyContext, ReplyContextInternal } from '../entities/context/replyContext';
+import { IActionState } from './actionState';
+import { CommandTrigger } from './commandTrigger';
+import { IAction } from './action';
+export interface ICaptureController {
+    captureReplies: <TParentActionState extends IActionState>(
+    /**
+     * Defines action trigger.
+     * If `string` or `string[]` is provided, will be triggered only on exact message match.
+     * If `RegExp` or `RegExp[]` is provided, will be triggered on successful match.
+     */
+    trigger: CommandTrigger[], 
+    /** Callback that will be called on trigger */
+    handler: (replyContext: ReplyContext<TParentActionState>) => Promise<void>, 
+    /** Abort controller to abort capturing manually */
+    abortController?: AbortController) => void;
+}
+export interface IReplyCapture {
+    trigger: CommandTrigger[];
+    handler: (replyContext: ReplyContextInternal<IActionState>) => Promise<void>;
+    abortController: AbortController;
+    action: IAction;
+}
+//# sourceMappingURL=capture.d.ts.map

package/dist/types/capture.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"capture.d.ts","sourceRoot":"","sources":["../../types/capture.ts"],"names":[],"mappings":"AAAA,OAAO,EACH,YAAY,EACZ,oBAAoB,EACvB,MAAM,kCAAkC,CAAC;AAC1C,OAAO,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAC7C,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAClD,OAAO,EAAE,OAAO,EAAE,MAAM,UAAU,CAAC;AAEnC,MAAM,WAAW,kBAAkB;IAC/B,cAAc,EAAE,CAAC,kBAAkB,SAAS,YAAY;IACpD;;;;OAIG;IACH,OAAO,EAAE,cAAc,EAAE;IACzB,8CAA8C;IAC9C,OAAO,EAAE,CACL,YAAY,EAAE,YAAY,CAAC,kBAAkB,CAAC,KAC7C,OAAO,CAAC,IAAI,CAAC;IAClB,mDAAmD;IACnD,eAAe,CAAC,EAAE,eAAe,KAChC,IAAI,CAAC;CACb;AAED,MAAM,WAAW,aAAa;IAC1B,OAAO,EAAE,cAAc,EAAE,CAAC;IAC1B,OAAO,EAAE,CACL,YAAY,EAAE,oBAAoB,CAAC,YAAY,CAAC,KAC/C,OAAO,CAAC,IAAI,CAAC,CAAC;IACnB,eAAe,EAAE,eAAe,CAAC;IACjC,MAAM,EAAE,OAAO,CAAC;CACnB"}

package/dist/types/capture.js

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

package/dist/types/commandCondition.d.ts

@@ -0,0 +1,8 @@
+import { MessageContext } from '../entities/context/messageContext';
+import { IActionState } from './actionState';
+export type CommandCondition<TActionState extends IActionState> = (
+/** Context of action executed in chat, in response to a message. */
+ctx: MessageContext<TActionState>, 
+/** State of an action being executed. */
+state: TActionState) => boolean;
+//# sourceMappingURL=commandCondition.d.ts.map

package/dist/types/commandCondition.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"commandCondition.d.ts","sourceRoot":"","sources":["../../types/commandCondition.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,oCAAoC,CAAC;AACpE,OAAO,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAE7C,MAAM,MAAM,gBAAgB,CAAC,YAAY,SAAS,YAAY,IAAI;AAC9D,oEAAoE;AACpE,GAAG,EAAE,cAAc,CAAC,YAAY,CAAC;AACjC,yCAAyC;AACzC,KAAK,EAAE,YAAY,KAClB,OAAO,CAAC"}

package/dist/types/commandCondition.js

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

package/dist/types/commandTrigger.d.ts

@@ -0,0 +1,2 @@
+export type CommandTrigger = string | RegExp;
+//# sourceMappingURL=commandTrigger.d.ts.map

package/dist/types/commandTrigger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"commandTrigger.d.ts","sourceRoot":"","sources":["../../types/commandTrigger.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,cAAc,GAAG,MAAM,GAAG,MAAM,CAAC"}

package/dist/types/commandTrigger.js

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