@wabot-dev/framework 0.0.2 → 0.0.4

package/dist/src/index.d.ts

@@ -1,10 +1,445 @@
-export * from './ai';
-export * from './channels';
-export * from './chatbot';
-export * from './context';
-export * from './controller';
-export * from './injection';
-export * from './message';
-export * from './mindset';
-export * from './server';
-export * from './shared';
+import * as tsyringe from 'tsyringe';
+import { DependencyContainer, InjectionToken } from 'tsyringe';
+export { DependencyContainer } from 'tsyringe';
+import { InterceptionOptions } from 'tsyringe/dist/typings/types';
+import { PreResolutionInterceptorCallback, PostResolutionInterceptorCallback } from 'tsyringe/dist/typings/types/dependency-container';
+
+interface IChatDocument {
+}
+
+interface IChatImage {
+}
+
+interface IChatSender {
+    shortName: string;
+    senderId?: string;
+}
+
+interface IChatMessage {
+    sender: IChatSender;
+    text?: string;
+    documents?: IChatDocument[];
+    images?: IChatImage[];
+}
+
+interface IChatFunctionCall {
+    foreignId: string;
+    name: string;
+    arguments?: string;
+    result: string;
+}
+
+type ISystemMessageItem = {
+    type: 'BOT_MESSAGE';
+    content: IChatMessage;
+};
+type IUserMessageItem = {
+    type: 'USER_MESSAGE';
+    content: IChatMessage;
+};
+type ISystemFunctionCallItem = {
+    type: 'FUNCTION_CALL';
+    content: IChatFunctionCall;
+};
+type IChatItem = {
+    id: string;
+    createdAt: Date;
+} & (ISystemMessageItem | IUserMessageItem | ISystemFunctionCallItem);
+type IChatItemType = IChatItem['type'];
+
+interface IChatMemory {
+    findLastItems(count: number): Promise<IChatItem[]>;
+    saveItem(item: IChatItem): Promise<void>;
+}
+declare class ChatMemory implements IChatMemory {
+    findLastItems(count: number): Promise<IChatItem[]>;
+    saveItem(item: IChatItem): Promise<void>;
+}
+
+declare class RamChatMemory implements IChatMemory {
+    private memory;
+    findLastItems(count: number): Promise<IChatItem[]>;
+    saveItem(item: IChatItem): Promise<void>;
+    clearMemory(): Promise<void>;
+}
+
+type IChatType = 'PRIVATE' | 'GROUP';
+interface IChatConnection {
+    channelType: string;
+    chatId: string;
+}
+interface IChatData {
+    id?: string;
+    createdAt?: Date;
+    type: IChatType;
+    connections: IChatConnection[];
+}
+declare class Chat {
+    private data;
+    constructor(data: IChatData);
+    isPrivate(): boolean;
+    isGroup(): boolean;
+    hasConnection(connection: IChatConnection): boolean;
+    private validatePrivateChat;
+    private validateGroupChat;
+    getId(): string;
+    wasCreated(): boolean;
+    validate(): void;
+}
+
+interface IChatRepository {
+    create(chat: Chat): Promise<void>;
+    findByConnection(query: IChatConnection): Promise<Chat | null>;
+    findMemory(chatId: string): Promise<IChatMemory | null>;
+}
+declare class ChatRepository implements IChatRepository {
+    create(chat: Chat): Promise<void>;
+    findByConnection(query: IChatConnection): Promise<Chat | null>;
+    findMemory(chatId: string): Promise<IChatMemory | null>;
+}
+
+declare class RamChatRepository implements IChatRepository {
+    private items;
+    private memories;
+    create(chat: Chat): Promise<void>;
+    findByConnection(query: IChatConnection): Promise<Chat | null>;
+    findMemory(chatId: string): Promise<IChatMemory | null>;
+    private getMemory;
+}
+
+interface IMindsetFunctionConfig {
+    description: string;
+}
+
+declare function mindsetFunction(config: IMindsetFunctionConfig): (target: object, propertyKey: string | symbol) => void;
+
+declare const MINDSET_FUNCTION_DECORATION_FUNCTION = "mindsetFunction";
+
+interface IMindsetFunctionDecoration {
+    decorationName: string;
+    functionName: string;
+    constructor: Function;
+    paramsTypes: Function[];
+    decorationConfig: any;
+}
+
+type IConstructor<T> = new (...args: any[]) => T;
+
+interface IMindsetIdentity {
+    name: string;
+    language: string;
+    age?: number;
+    personality?: string;
+    emotions?: string;
+}
+interface IMindset {
+    identity(): Promise<IMindsetIdentity>;
+    skills(): Promise<string>;
+    limits(): Promise<string>;
+}
+declare class Mindset implements IMindset {
+    identity(): Promise<IMindsetIdentity>;
+    skills(): Promise<string>;
+    limits(): Promise<string>;
+}
+
+interface IMindsetConfig {
+    modules?: IConstructor<any>[];
+}
+
+declare function mindset(config?: IMindsetConfig): (target: IConstructor<IMindset>) => void;
+
+declare const MINDSET_DECORATION_MINDSET = "mindset";
+
+interface IMindsetDecoration {
+    decorationName: string;
+    constructor: Function;
+    decorationConfig: IMindsetConfig;
+}
+
+interface IMindsetModuleConfig {
+    description: string;
+}
+
+declare function mindsetModule<A>(config: IMindsetModuleConfig): (target: IConstructor<A>) => void;
+
+declare const MINDSET_MODULE_DECORATION_MODULE = "mindsetModule";
+
+interface IMindsetModuleDecoration {
+    decorationName: string;
+    constructor: Function;
+    decorationConfig: any;
+}
+
+declare function isOptional(): PropertyDecorator;
+
+interface IParamConfig {
+    name?: string;
+    description: string;
+}
+
+declare function param(config: IParamConfig): PropertyDecorator;
+
+interface IParamDecoration {
+    decorationName: string;
+    paramType: any;
+    paramName: string;
+    constructor: Function;
+    decorationConfig: any;
+}
+
+interface IMindsetFunctionParamMetadata {
+    config: IParamConfig;
+    name: string;
+    type: Function;
+}
+interface IMindsetFunctionMetadata {
+    moduleConstructor: Function;
+    requestConstructor?: Function;
+    name: string;
+    config: IMindsetFunctionConfig;
+    params: IMindsetFunctionParamMetadata[];
+}
+interface IMindsetModuleMetadata {
+    constructor: Function;
+    config: IMindsetModuleConfig;
+    functions: IMindsetFunctionMetadata[];
+}
+interface IMindsetMetadata {
+    constructor: IConstructor<IMindset>;
+    config: IMindsetConfig;
+    modules: IMindsetModuleMetadata[];
+}
+
+declare class MindsetMetadataStore {
+    private readonly paramsDecorations;
+    private readonly functionsDecorations;
+    private readonly modulesDecorations;
+    private readonly mindsetsDecorations;
+    saveParamDecoration(paramDecoration: IParamDecoration): void;
+    saveFunctionDecoration(functionDecoration: IMindsetFunctionDecoration): void;
+    saveModuleDecoration(moduleDecoration: IMindsetModuleDecoration): void;
+    saveMindsetDecoration(mindsetDecoration: IMindsetDecoration): void;
+    getRequestParamsMetadata(requestConstructor: Function): IMindsetFunctionParamMetadata[];
+    getFunctionsMetadata(moduleConstructor: Function): IMindsetFunctionMetadata[];
+    getModuleMetadata(moduleConstructor: Function): IMindsetModuleMetadata;
+    getMindsetMetadata(ctor: Function): IMindsetMetadata;
+}
+
+declare class Container implements DependencyContainer {
+    register(token: unknown, provider: unknown, options?: unknown): DependencyContainer;
+    registerSingleton(from: unknown, to?: unknown): DependencyContainer;
+    registerType<T>(from: InjectionToken<T>, to: InjectionToken<T>): DependencyContainer;
+    registerInstance<T>(token: InjectionToken<T>, instance: T): DependencyContainer;
+    resolve<T>(token: InjectionToken<T>): T;
+    resolveAll<T>(token: InjectionToken<T>): T[];
+    isRegistered<T>(token: InjectionToken<T>, recursive?: boolean): boolean;
+    reset(): void;
+    clearInstances(): void;
+    createChildContainer(): DependencyContainer;
+    beforeResolution<T>(token: InjectionToken<T>, callback: PreResolutionInterceptorCallback<T>, options?: InterceptionOptions): void;
+    afterResolution<T>(token: InjectionToken<T>, callback: PostResolutionInterceptorCallback<T>, options?: InterceptionOptions): void;
+    dispose(): Promise<void> | void;
+}
+
+declare const injectable: typeof tsyringe.injectable;
+declare const container: tsyringe.DependencyContainer;
+declare const singleton: typeof tsyringe.singleton;
+declare const inject: typeof tsyringe.inject;
+
+declare class MindsetOperator implements IMindset {
+    private mindset;
+    private container;
+    private metadata;
+    constructor(mindset: Mindset, container: Container, metadataStore: MindsetMetadataStore);
+    identity(): Promise<IMindsetIdentity>;
+    skills(): Promise<string>;
+    limits(): Promise<string>;
+    callFunction(name: string, params: string): Promise<string>;
+    allFunctionsDescriptors(): Promise<{
+        readonly type: "function";
+        readonly name: string;
+        readonly description: string;
+        readonly parameters: {
+            readonly type: "object";
+            readonly properties: {};
+            readonly required: string[];
+        };
+    }[]>;
+    private functionDescriptor;
+    private toolParam;
+}
+
+declare function chatBot(mindset: IConstructor<IMindset>): (target: object, propertyKey: string | symbol | undefined, parameterIndex: number) => void;
+
+interface IChatBotMetadata {
+    constructor: IConstructor<any>;
+    mindsetConstructor: IConstructor<IMindset>;
+    injectionToken: string;
+}
+
+declare class ChatBotMetadataStore {
+    private chatBots;
+    saveChatBotMetadata(chatBot: IChatBotMetadata): void;
+    getChatBotsMetadata(): IChatBotMetadata[];
+}
+
+interface IChatBotAdapter {
+    generateNextChatItem(chatItems: IChatItem[]): Promise<IChatItem>;
+}
+declare class ChatBotAdapter implements IChatBotAdapter {
+    protected mindset: MindsetOperator;
+    constructor(mindset: MindsetOperator);
+    generateNextChatItem(chatItems: IChatItem[]): Promise<IChatItem>;
+    protected systemPrompt(): Promise<string>;
+    protected buildBotMessageItem(text: string): Promise<{
+        id: string;
+        createdAt: Date;
+    } & ISystemMessageItem>;
+    protected buildFunctionCallItem(foreignId: string, functionName: string, functionArguments: string): Promise<{
+        readonly id: string;
+        readonly createdAt: Date;
+        readonly type: "FUNCTION_CALL";
+        readonly content: {
+            readonly foreignId: string;
+            readonly name: string;
+            readonly arguments: string;
+            readonly result: string;
+        };
+    }>;
+}
+
+interface IChatBot {
+    sendMessage(message: IChatMessage, callback: (message: IChatMessage) => void): void | Promise<void>;
+}
+
+declare class ChatBot implements IChatBot {
+    private memory;
+    private adapter;
+    constructor(memory: ChatMemory, adapter: ChatBotAdapter);
+    sendMessage(message: IChatMessage, callback: (message: IChatMessage) => void): Promise<void>;
+    protected processLoop(callback: (message: IChatMessage) => void): Promise<void>;
+}
+
+declare class OpenaiChatBotAdapter extends ChatBotAdapter {
+    private openai;
+    private model;
+    constructor(mindset: MindsetOperator);
+    generateNextChatItem(chatItems: IChatItem[]): Promise<IChatItem>;
+    private mapChatItems;
+}
+
+interface IChatContext {
+    chatId: string;
+    message: IChatMessage;
+    reply: (message: IChatMessage) => void;
+}
+interface IUserContext {
+    userId: string;
+}
+interface IContext {
+    user?: IUserContext;
+    chat: IChatContext;
+}
+declare class Context implements IContext {
+    chat: IChatContext;
+    user?: IUserContext | undefined;
+    constructor(chat: IChatContext, user?: IUserContext | undefined);
+}
+
+interface IMessageOrigin {
+    chatId: string;
+    chatType: IChatType;
+    channelType: Function;
+}
+interface IMessageContext extends IChatContext {
+    origin: IMessageOrigin;
+}
+
+declare class ChatResolver {
+    private chatRepository;
+    constructor(chatRepository: ChatRepository);
+    resolve(origin: IMessageOrigin): Promise<Chat>;
+    private resolveGroupChat;
+    private resolvePrivateChat;
+}
+
+interface IChatChannel {
+    listen(callback: (message: IMessageContext) => void): void;
+    connect(): void;
+}
+
+interface IchatControllerConfig {
+}
+
+declare function chatController(config?: IchatControllerConfig): (target: IConstructor<any>) => void;
+
+interface IChatControllerMetadata {
+    controllerConstructor: Function;
+}
+
+interface IChannelMetadata {
+    controllerConstructor: IConstructor<any>;
+    functionName: string;
+    channelConstructor: IConstructor<IChatChannel>;
+    channelConfig: object;
+}
+
+declare class ControllerMetadataStore {
+    private channels;
+    private chatControllers;
+    saveChannelMetadata(channelMetadata: IChannelMetadata): void;
+    saveChatControllerMetadata(controllerMetadata: IChatControllerMetadata): void;
+    getChatControllerMetadata(controllerConstructor: Function): {
+        config: IChatControllerMetadata;
+        channels: IChannelMetadata[];
+    } | null;
+}
+
+declare class CmdChannel implements IChatChannel {
+    private chatResolver;
+    private rl;
+    private callBack;
+    constructor(chatResolver: ChatResolver);
+    listen(callback: (message: IMessageContext) => void): void;
+    connect(): void;
+}
+
+interface ITelegramChannelConfig {
+    botToken: string;
+}
+declare class TelegramChannelConfig implements ITelegramChannelConfig {
+    botToken: string;
+    constructor(botToken: string);
+}
+
+declare function telegram(config: ITelegramChannelConfig): (target: object, propertyKey: string | symbol) => void;
+
+declare class TelegramChannel implements IChatChannel {
+    private config;
+    private chatResolver;
+    private bot;
+    constructor(config: TelegramChannelConfig, chatResolver: ChatResolver);
+    listen(callback: (message: IMessageContext) => void): void;
+    connect(): void;
+}
+
+declare function prepareChatContainer(container: DependencyContainer, context: IContext, mindsetCtor?: IConstructor<IMindset>): Promise<DependencyContainer>;
+
+interface IrunChannelProps {
+    channel: IConstructor<IChatChannel>;
+    channelConfig?: object;
+    mindset: IConstructor<IMindset>;
+    chatRepository: IConstructor<IChatRepository>;
+    chatBotAdapter: IConstructor<IChatBotAdapter>;
+}
+declare function runChannel(props: IrunChannelProps): void;
+
+interface IServerConfig {
+    controllers: IConstructor<any>[];
+    chatRepository?: IConstructor<IChatRepository>;
+    chatBotAdapter?: IConstructor<IChatBotAdapter>;
+}
+declare function runServer(config: IServerConfig): void;
+
+export { Chat, ChatBot, ChatBotAdapter, ChatBotMetadataStore, ChatMemory, ChatRepository, ChatResolver, CmdChannel, Container, Context, ControllerMetadataStore, type IChannelMetadata, type IChatBot, type IChatBotAdapter, type IChatBotMetadata, type IChatChannel, type IChatConnection, type IChatContext, type IChatControllerMetadata, type IChatData, type IChatDocument, type IChatFunctionCall, type IChatImage, type IChatItem, type IChatItemType, type IChatMemory, type IChatMessage, type IChatRepository, type IChatSender, type IChatType, type IConstructor, type IContext, type IMessageContext, type IMessageOrigin, type IMindset, type IMindsetDecoration, type IMindsetFunctionConfig, type IMindsetFunctionDecoration, type IMindsetFunctionMetadata, type IMindsetFunctionParamMetadata, type IMindsetIdentity, type IMindsetMetadata, type IMindsetModuleConfig, type IMindsetModuleDecoration, type IMindsetModuleMetadata, type IParamDecoration, type IServerConfig, type ISystemFunctionCallItem, type ISystemMessageItem, type ITelegramChannelConfig, type IUserContext, type IUserMessageItem, type IchatControllerConfig, type IrunChannelProps, MINDSET_DECORATION_MINDSET, MINDSET_FUNCTION_DECORATION_FUNCTION, MINDSET_MODULE_DECORATION_MODULE, Mindset, MindsetMetadataStore, MindsetOperator, OpenaiChatBotAdapter, RamChatMemory, RamChatRepository, TelegramChannel, TelegramChannelConfig, chatBot, chatController, container, inject, injectable, isOptional, mindset, mindsetFunction, mindsetModule, param, prepareChatContainer, runChannel, runServer, singleton, telegram };

package/dist/src/mindset/metadata/mindsets/@mindset.js

@@ -9,7 +9,7 @@ function mindset(config) {
         store.saveMindsetDecoration({
             decorationName: MINDSET_DECORATION_MINDSET,
             constructor: target,
-            decorationConfig: config,
+            decorationConfig: config ?? {},
         });
         injectable()(target);
     };

package/dist/src/server/runChannel.js

@@ -1,4 +1,4 @@
-import dotenv from '../_virtual/main.js';
+import dotenv from 'dotenv';
 import '../chatbot/chat/repository/ram/RamChatRepository.js';
 import { ChatRepository } from '../chatbot/chat/repository/IChatRepository.js';
 import { container } from '../injection/index.js';

package/dist/src/server/runServer.js

@@ -1,4 +1,4 @@
-import dotenv from '../_virtual/main.js';
+import dotenv from 'dotenv';
 import { RamChatRepository } from '../chatbot/chat/repository/ram/RamChatRepository.js';
 import { ChatRepository } from '../chatbot/chat/repository/IChatRepository.js';
 import { container } from '../injection/index.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wabot-dev/framework",
-  "version": "0.0.2",
+  "version": "0.0.4",
   "description": "Framework for IA Chat Bots",
   "type": "module",
   "main": "dist/src/index.js",
@@ -10,8 +10,7 @@
     "dist/src"
   ],
   "scripts": {
-    "build": "rollup --config rollup.config.ts --configPlugin typescript && tsc --declaration --emitDeclarationOnly --declarationDir dist",
-    "publish": "npm publish --access public",
+    "build": "rollup --config rollup.config.ts --configPlugin typescript && tsup --dts-only --format esm --out-dir dist/src src/index.ts",
     "test:units": "node --import @yucacodes/ts/src/custom-import.mjs  --test './src/**/*.unit.test.ts'",
     "test:integration": "node --import @yucacodes/ts/src/custom-import.mjs  --test './src/**/*.integration.test.ts'",
     "fmt": "prettier --write .",
@@ -28,9 +27,9 @@
     "@rollup/plugin-typescript": "12.1.2",
     "@types/node": "22.14.1",
     "@yucacodes/ts": "^0.0.4",
-    "dotenv": "^16.5.0",
     "prettier": "^3.5.3",
     "rollup": "4.39.0",
+    "tsup": "^8.4.0",
     "typescript": "5.8.3"
   },
   "peerDependencies": {
@@ -42,6 +41,7 @@
     "reflect-metadata": "^0.2.2",
     "tslib": "^2.8.1",
     "tsyringe": "^4.9.1",
-    "uuid": "^11.1.0"
+    "uuid": "^11.1.0",
+    "dotenv": "^16.5.0"
   }
 }

package/dist/src/_virtual/_commonjsHelpers.js

@@ -1,5 +0,0 @@
-function getDefaultExportFromCjs (x) {
-	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
-}
-
-export { getDefaultExportFromCjs };

package/dist/src/_virtual/main.js

@@ -1,7 +0,0 @@
-import { getDefaultExportFromCjs } from './_commonjsHelpers.js';
-import { __require as requireMain } from '../node_modules/dotenv/lib/main.js';
-
-var mainExports = requireMain();
-var dotenv = /*@__PURE__*/getDefaultExportFromCjs(mainExports);
-
-export { dotenv as default };

package/dist/src/_virtual/main2.js

@@ -1,3 +0,0 @@
-var main = {exports: {}};
-
-export { main as __module };

package/dist/src/ai/index.d.ts

@@ -1 +0,0 @@
-export * from './openia';

package/dist/src/ai/openia/OpenaiChatBotAdapter.d.ts

@@ -1,9 +0,0 @@
-import { ChatBotAdapter, IChatItem } from '@/chatbot';
-import { MindsetOperator } from '@/mindset';
-export declare class OpenaiChatBotAdapter extends ChatBotAdapter {
-    private openai;
-    private model;
-    constructor(mindset: MindsetOperator);
-    generateNextChatItem(chatItems: IChatItem[]): Promise<IChatItem>;
-    private mapChatItems;
-}

package/dist/src/ai/openia/index.d.ts

@@ -1 +0,0 @@
-export * from './OpenaiChatBotAdapter';

package/dist/src/channels/cmd/CmdChannel.d.ts

@@ -1,9 +0,0 @@
-import { ChatResolver, IChatChannel, IMessageContext } from '@/controller';
-export declare class CmdChannel implements IChatChannel {
-    private chatResolver;
-    private rl;
-    private callBack;
-    constructor(chatResolver: ChatResolver);
-    listen(callback: (message: IMessageContext) => void): void;
-    connect(): void;
-}

package/dist/src/channels/cmd/index.d.ts

@@ -1 +0,0 @@
-export * from './CmdChannel';

package/dist/src/channels/index.d.ts

@@ -1,2 +0,0 @@
-export * from './cmd';
-export * from './telegram';

package/dist/src/channels/telegram/@telegram.d.ts

@@ -1,2 +0,0 @@
-import { ITelegramChannelConfig } from './TelegramChannelConfig';
-export declare function telegram(config: ITelegramChannelConfig): (target: object, propertyKey: string | symbol) => void;

package/dist/src/channels/telegram/TelegramChannel.d.ts

@@ -1,12 +0,0 @@
-import { IChatChannel } from '../../controller/channel/IChatChannel';
-import { ChatResolver } from '../../controller/channel/ChatResolver';
-import { IMessageContext } from '../../controller/channel/IMessageContext';
-import { TelegramChannelConfig } from './TelegramChannelConfig';
-export declare class TelegramChannel implements IChatChannel {
-    private config;
-    private chatResolver;
-    private bot;
-    constructor(config: TelegramChannelConfig, chatResolver: ChatResolver);
-    listen(callback: (message: IMessageContext) => void): void;
-    connect(): void;
-}

package/dist/src/channels/telegram/TelegramChannelConfig.d.ts

@@ -1,7 +0,0 @@
-export interface ITelegramChannelConfig {
-    botToken: string;
-}
-export declare class TelegramChannelConfig implements ITelegramChannelConfig {
-    botToken: string;
-    constructor(botToken: string);
-}

package/dist/src/channels/telegram/index.d.ts

@@ -1,3 +0,0 @@
-export * from './@telegram';
-export * from './TelegramChannelConfig';
-export * from './TelegramChannel';

package/dist/src/chatbot/ChatBot.d.ts

@@ -1,11 +0,0 @@
-import { IChatMessage } from '@/message';
-import { ChatBotAdapter } from './ChatBotAdapter';
-import { IChatBot } from './IChatBot';
-import { ChatMemory } from './chat';
-export declare class ChatBot implements IChatBot {
-    private memory;
-    private adapter;
-    constructor(memory: ChatMemory, adapter: ChatBotAdapter);
-    sendMessage(message: IChatMessage, callback: (message: IChatMessage) => void): Promise<void>;
-    protected processLoop(callback: (message: IChatMessage) => void): Promise<void>;
-}

package/dist/src/chatbot/ChatBotAdapter.d.ts

@@ -1,26 +0,0 @@
-import { MindsetOperator } from '@/mindset/MindsetOperator';
-import { IChatItem } from './chat/IChatItem';
-export interface IChatBotAdapter {
-    generateNextChatItem(chatItems: IChatItem[]): Promise<IChatItem>;
-}
-export declare class ChatBotAdapter implements IChatBotAdapter {
-    protected mindset: MindsetOperator;
-    constructor(mindset: MindsetOperator);
-    generateNextChatItem(chatItems: IChatItem[]): Promise<IChatItem>;
-    protected systemPrompt(): Promise<string>;
-    protected buildBotMessageItem(text: string): Promise<{
-        id: string;
-        createdAt: Date;
-    } & import("./chat").ISystemMessageItem>;
-    protected buildFunctionCallItem(foreignId: string, functionName: string, functionArguments: string): Promise<{
-        readonly id: string;
-        readonly createdAt: Date;
-        readonly type: "FUNCTION_CALL";
-        readonly content: {
-            readonly foreignId: string;
-            readonly name: string;
-            readonly arguments: string;
-            readonly result: string;
-        };
-    }>;
-}

package/dist/src/chatbot/IChatBot.d.ts

@@ -1,4 +0,0 @@
-import { IChatMessage } from '@/message';
-export interface IChatBot {
-    sendMessage(message: IChatMessage, callback: (message: IChatMessage) => void): void | Promise<void>;
-}

package/dist/src/chatbot/chat/Chat.d.ts

@@ -1,23 +0,0 @@
-export type IChatType = 'PRIVATE' | 'GROUP';
-export interface IChatConnection {
-    channelType: string;
-    chatId: string;
-}
-export interface IChatData {
-    id?: string;
-    createdAt?: Date;
-    type: IChatType;
-    connections: IChatConnection[];
-}
-export declare class Chat {
-    private data;
-    constructor(data: IChatData);
-    isPrivate(): boolean;
-    isGroup(): boolean;
-    hasConnection(connection: IChatConnection): boolean;
-    private validatePrivateChat;
-    private validateGroupChat;
-    getId(): string;
-    wasCreated(): boolean;
-    validate(): void;
-}