@wabot-dev/framework 0.1.0-beta.2 → 0.1.0-beta.21

package/dist/src/index.d.ts

@@ -1,16 +1,14 @@
 import InjectionToken from 'tsyringe/dist/typings/providers/injection-token';
 import DependencyContainer, { PreResolutionInterceptorCallback, PostResolutionInterceptorCallback } from 'tsyringe/dist/typings/types/dependency-container';
 import InterceptionOptions from 'tsyringe/dist/typings/types/interceptor-options';
-import { Express } from 'express';
-export { Express } from 'express';
-import { Server } from 'socket.io';
-export { Server as SocketIo } from 'socket.io';
+import { Server } from 'http';
+import { Express, Request, Response } from 'express';
+import { Server as Server$1 } from 'socket.io';
+import { Pool } from 'pg';
+import { Socket } from 'socket.io-client';
 import * as tsyringe from 'tsyringe';
 import { DependencyContainer as DependencyContainer$1 } from 'tsyringe';
 export { DependencyContainer } from 'tsyringe';
-import { Pool } from 'pg';
-import { Database } from 'sqlite';
-import sqlite3 from 'sqlite3';
 
 interface IMindsetFunctionConfig {
     description: string;
@@ -28,33 +26,58 @@ interface IMindsetFunctionDecoration {
     decorationConfig: any;
 }
 
-interface IPersistent {
+type IPrimitive = null | number | string | boolean | undefined;
+type IStorableData = {
+    [key: string]: IPrimitive | IPrimitive[] | IStorableData | IStorableData[];
+};
+declare class Storable<D extends IStorableData> {
+    protected data: D;
+    constructor(data: D);
+}
+
+interface IEntityData extends IStorableData {
     id?: string;
     createdAt?: number | null;
     discardedAt?: number | null;
 }
-declare class Persistent<D extends IPersistent = IPersistent> {
-    protected data: D;
-    constructor(data: D);
+declare class Entity<D extends IEntityData> extends Storable<D> {
+    get id(): string;
+    /**
+     * @deprecated use id
+     */
     getId(): string;
+    get createdAt(): Date;
+    /**
+     * @deprecated use createdAt
+     */
     getCreatedAt(): Date;
-    update(newData: D): void;
+    update(newData: Omit<D, 'id' | 'createdAt' | 'discardedAt'>): void;
     wasCreated(): boolean;
     validate(): void;
     discard(): void;
 }
+/**
+ * @deprecated Should use IEntityData
+ */
+interface IPersistentData extends IEntityData {
+}
+/**
+ * @deprecated Should use Entity
+ */
+declare class Persistent<D extends IPersistentData> extends Entity<D> {
+}
 
 type IChatType = 'PRIVATE' | 'GROUP';
-interface IChatConnection {
+interface IChatConnection extends IStorableData {
     chatType: IChatType;
     channelName: string;
     id: string;
 }
-interface IChatData extends IPersistent {
+interface IChatData extends IEntityData {
     type: IChatType;
     connections: IChatConnection[];
 }
-declare class Chat extends Persistent<IChatData> {
+declare class Chat extends Entity<IChatData> {
     constructor(data: IChatData);
     isPrivate(): boolean;
     isGroup(): boolean;
@@ -64,24 +87,24 @@ declare class Chat extends Persistent<IChatData> {
     validate(): void;
 }
 
-interface IChatDocument {
+interface IChatDocument extends IStorableData {
 }
 
-interface IChatImage {
+interface IChatImage extends IStorableData {
 }
 
-interface IUserConnection {
+interface IUserConnection extends IStorableData {
     channelName: string;
     id: string;
 }
-interface IUserData extends IPersistent {
+interface IUserData extends IEntityData {
     shortName: string;
     connections: IUserConnection[];
     keyValueData: {
         [key: string]: string;
     };
 }
-declare class User extends Persistent<IUserData> {
+declare class User extends Entity<IUserData> {
     constructor(data: IUserData);
     hasConnection(connection: IUserConnection): boolean;
     getValue(key: string): string;
@@ -89,7 +112,7 @@ declare class User extends Persistent<IUserData> {
     addConnection(connection: IUserConnection): void;
 }
 
-interface IChatMessage {
+interface IChatMessage extends IStorableData {
     text?: string;
     documents?: IChatDocument[];
     images?: IChatImage[];
@@ -120,12 +143,9 @@ type ISystemFunctionCallItem = {
     type: 'FUNCTION_CALL';
     content: IChatFunctionCall;
 };
-type IChatItemData = {
-    id?: string;
-    createdAt?: number;
-} & (ISystemMessageItem | IReceivedMessageItem | ISystemFunctionCallItem);
+type IChatItemData = IEntityData & (ISystemMessageItem | IReceivedMessageItem | ISystemFunctionCallItem);
 type IChatItemType = IChatItemData['type'];
-declare class ChatItem extends Persistent<IChatItemData> {
+declare class ChatItem extends Entity<IChatItemData> {
     getType(): "BOT_MESSAGE" | "CONNECTION_MESSAGE" | "FUNCTION_CALL";
     getContent(): IChatMessage | IConnectionChatMessage | IChatFunctionCall;
     getData(): IChatItemData;
@@ -174,11 +194,6 @@ declare class MessageContext implements IMessageContext {
     constructor(message: IConnectionChatMessage, chat: Chat, user: User | null);
 }
 
-interface IReversibleMapper<T1, T2> {
-    map(input: T1): T2;
-    rev(input: T2): T1;
-}
-
 type IConstructor<T> = new (...args: any[]) => T;
 
 interface IMindsetIdentity {
@@ -228,8 +243,6 @@ interface IMindsetModuleDecoration {
     decorationConfig: any;
 }
 
-declare function isOptional(): PropertyDecorator;
-
 interface IParamConfig {
     name?: string;
     optional?: boolean;
@@ -369,19 +382,29 @@ declare class ChatBot implements IChatBot {
     protected processLoop(callback: (message: IChatMessage) => void): Promise<void>;
 }
 
+declare class DeepSeekChatBotAdapter extends ChatBotAdapter {
+    private deepSeek;
+    private model;
+    constructor(mindset: MindsetOperator);
+    validateEnvVariables(envVariables: (string | undefined)[]): void;
+    generateNextChatItem(chatItems: ChatItem[]): Promise<ChatItem>;
+    private mapChatItems;
+}
+
 declare class OpenaiChatBotAdapter extends ChatBotAdapter {
     private openai;
     private model;
+    private logger;
     constructor(mindset: MindsetOperator);
     generateNextChatItem(chatItems: ChatItem[]): Promise<ChatItem>;
     private mapChatItems;
 }
 
-declare class DeepSeekChatBotAdapter extends ChatBotAdapter {
-    private deepSeek;
+declare class ClaudeChatBotAdapter extends ChatBotAdapter {
+    private anthropic;
     private model;
+    private logger;
     constructor(mindset: MindsetOperator);
-    validateEnvVariables(envVariables: (string | undefined)[]): void;
     generateNextChatItem(chatItems: ChatItem[]): Promise<ChatItem>;
     private mapChatItems;
 }
@@ -437,10 +460,6 @@ declare class ControllerMetadataStore {
     } | null;
 }
 
-declare const ExpressApp: unique symbol;
-
-declare const SocketIoApp: unique symbol;
-
 declare class CmdChannel implements IChatChannel {
     private chatResolver;
     private userResolver;
@@ -451,6 +470,63 @@ declare class CmdChannel implements IChatChannel {
     connect(): void;
 }
 
+declare class HttpServerProvider {
+    server: Server | null;
+    private listening;
+    private logger;
+    getHttpServer(): Server;
+    listen(): void;
+}
+
+declare class ExpressProvider {
+    private httpServerProvider;
+    private expressApp;
+    private logger;
+    constructor(httpServerProvider: HttpServerProvider);
+    getExpress(): Express;
+    listen(): void;
+    private createExpress;
+}
+
+interface ISocketChannelConfig {
+    channel: string;
+}
+
+declare class SocketChannelConfig implements ISocketChannelConfig {
+    channel: string;
+    constructor(channel: string);
+}
+
+declare function socket(config: SocketChannelConfig): (target: object, propertyKey: string | symbol) => void;
+
+declare class SocketServerProvider {
+    private httpServerProvider;
+    private socketServer;
+    private logger;
+    constructor(httpServerProvider: HttpServerProvider);
+    getSocketServer(): Server$1;
+    listen(): void;
+    private createSocketServer;
+}
+
+interface ISocketChannelReceivedMessage {
+    chatId: string;
+    userId: string;
+    senderName: string;
+    text: string;
+}
+declare class SocketChannel implements IChatChannel {
+    private config;
+    private socketServerProvider;
+    private chatResolver;
+    private userResolver;
+    private callBack;
+    private server;
+    constructor(config: SocketChannelConfig, socketServerProvider: SocketServerProvider, chatResolver: ChatResolver, userResolver: UserResolver);
+    listen(callback: (message: IReceivedMessage) => void): void;
+    connect(): void;
+}
+
 interface ITelegramChannelConfig {
     botToken: string;
 }
@@ -482,9 +558,64 @@ declare class WhatsappChannelConfig implements IWhatsappChannelConfig {
 
 declare function whatsapp(config: IWhatsappChannelConfig): (target: object, propertyKey: string | symbol) => void;
 
+interface IWhatsAppBusinessNumber extends IStorableData {
+    id: string;
+    number: string;
+}
+interface IWhatsAppBusinessAccount extends IStorableData {
+    id: string;
+}
+interface IWhatsAppData extends IEntityData {
+    slug: string;
+    verifyToken: string;
+    appSecret: string;
+    accessToken: string;
+    businessAccount: IWhatsAppBusinessAccount;
+    businessNumbers: IWhatsAppBusinessNumber[];
+}
+declare class WhatsApp extends Entity<IWhatsAppData> {
+    getVerifyToken(): string;
+    getSlug(): string;
+    getBusinessAccount(): IWhatsAppBusinessAccount;
+    getAppSecret(): string;
+    getBusinessNumbers(): IWhatsAppBusinessNumber[];
+    getAccessToken(): string;
+    hasBusinessNumber(number: string): boolean;
+    getBussinessNumber(number: string): IWhatsAppBusinessNumber | null;
+}
+
+interface IWhatsAppRepository {
+    findBySlug(slug: string): Promise<WhatsApp | null>;
+    findByBusinessNumber(number: string): Promise<WhatsApp | null>;
+}
+
+type IEnvType = 'development' | 'staging' | 'testing' | 'production';
+declare class Env {
+    private envType;
+    constructor();
+    isDevelopment(): boolean;
+    isProduction(): boolean;
+    isTesting(): boolean;
+    requireString(varName: string, options?: {
+        default?: string;
+    }): string;
+    requireNumber(varName: string, options?: {
+        default?: number;
+    }): number;
+}
+
+declare class EnvWhatsAppRepository implements IWhatsAppRepository {
+    private env;
+    constructor(env: Env);
+    findBySlug(slug: string): Promise<WhatsApp | null>;
+    findByBusinessNumber(number: string): Promise<WhatsApp | null>;
+    private getFromEnvVars;
+}
+
 type IWhatsAppTemplateParameter = {
     type: 'text';
     text: string;
+    parameter_name?: string;
 } | {
     type: 'currency';
     currency: {
@@ -504,12 +635,30 @@ interface IWhatsAppTemplateMessage {
     parameters: IWhatsAppTemplateParameter[];
 }
 
-type IWhatsAppMessageListener = (message: IConnectionChatMessage) => Promise<void>;
-interface IWhatsAppConnection {
-    listenMessage(businessNumber: string, listener: IWhatsAppMessageListener): void;
-    sendWhatsApp(businessNumber: string, to: string, message: IChatMessage): Promise<void>;
-    sendWhatsAppTemplate(businessNumber: string, to: string, templateMessage: IWhatsAppTemplateMessage): Promise<void>;
-    connect(): void;
+interface IWhatsAppTemplateResponse {
+    data: IWhatsAppTemplate[];
+    paging: IWhatsAppApiPaging;
+}
+interface IWhatsAppTemplate {
+    name: string;
+    parameter_format: 'POSITIONAL' | 'OTHER';
+    components: IWhatsAppTemplateComponent[];
+    language: string;
+    status: string;
+    category: string;
+    id: string;
+}
+interface IWhatsAppTemplateComponent {
+    type: 'HEADER' | 'BODY' | 'FOOTER';
+    format?: 'TEXT';
+    text?: string;
+}
+interface IWhatsAppApiPaging {
+    cursors: IWhatsAppApiCursors;
+}
+interface IWhatsAppApiCursors {
+    before: string;
+    after: string;
 }
 
 interface IWhatsAppWebhookPayload {
@@ -564,12 +713,70 @@ interface IAudioMessage extends IBaseMessage {
     };
 }
 
-type IWabotEnvType = 'development' | 'staging' | 'testing' | 'production';
-declare class WabotEnv {
-    private envType;
-    constructor();
-    isDevelopment(): boolean;
-    isProduction(): boolean;
+interface ICrudRepository<T> {
+    find(id: string): Promise<T | null>;
+    findOrThrow(id: string): Promise<T>;
+    findAll(id: string): Promise<T[]>;
+    create(item: T): Promise<void>;
+    update(item: T): Promise<void>;
+    discard(item: T): Promise<void>;
+}
+
+type IPgRepositoryConfig<P extends Entity<IEntityData>> = {
+    schema?: string;
+    table: string;
+    constructor: IConstructor<P>;
+    add?: {
+        columns: {
+            [column: string]: {
+                type: string;
+                value: (item: P) => boolean | number | string | null | Date;
+            };
+        };
+    };
+};
+
+declare class PgRepositoryBase<P extends Entity<IEntityData>> {
+    protected pool: Pool;
+    protected config: IPgRepositoryConfig<any>;
+    private tableIsCreated;
+    protected schema: string;
+    protected table: string;
+    protected columnsList: string[];
+    protected columnsAndTypes: string;
+    protected columns: string;
+    protected vars: string;
+    protected updates: string;
+    addColumns: {
+        [columns: string]: {
+            type: string;
+            value: (item: P) => number | boolean | string | null | Date;
+        };
+    };
+    constructor(pool: Pool, config: IPgRepositoryConfig<any>);
+    protected values(item: P): (string | number | boolean | Date | null)[];
+    protected exec(sql: string, values: any[]): Promise<void>;
+    protected query(sql: string, values: any[]): Promise<any[]>;
+    protected connect(): Promise<Pool>;
+    protected ensureTable(): Promise<void>;
+    protected ensureColumns(): Promise<void>;
+}
+
+declare class PgCrudRepository<P extends Entity<IEntityData>> extends PgRepositoryBase<P> implements ICrudRepository<P> {
+    protected readonly config: IPgRepositoryConfig<P>;
+    constructor(pool: Pool, config: IPgRepositoryConfig<P>);
+    find(id: string): Promise<P | null>;
+    findOrThrow(id: string): Promise<P>;
+    findAll(): Promise<P[]>;
+    create(item: P): Promise<void>;
+    update(item: P): Promise<void>;
+    discard(item: P): Promise<void>;
+}
+
+declare class PgWhatsAppRepository extends PgCrudRepository<WhatsApp> implements IWhatsAppRepository {
+    constructor(pool: Pool);
+    findBySlug(slug: string): Promise<WhatsApp | null>;
+    findByBusinessNumber(number: string): Promise<WhatsApp | null>;
 }
 
 declare class Logger {
@@ -584,123 +791,129 @@ declare class Logger {
     private log;
 }
 
-declare abstract class WhatsAppConnection implements IWhatsAppConnection {
+type IWhatsAppMessageListener = (message: IConnectionChatMessage) => Promise<void>;
+interface IListenWhatsAppMessageRequest {
+    to: string;
+    listener: IWhatsAppMessageListener;
+}
+declare abstract class WhatsAppReceiver {
     protected logger: Logger;
     private listeners;
     constructor(logger: Logger);
-    abstract sendWhatsApp(businessNumber: string, to: string, chatMessage: IChatMessage): Promise<void>;
-    abstract connect(): void;
-    abstract sendWhatsAppTemplate(businessNumber: string, to: string, templateMessage: IWhatsAppTemplateMessage): Promise<void>;
-    listenMessage(businessNumber: string, listener: IWhatsAppMessageListener): void;
+    abstract connect(): Promise<void>;
+    listenMessage(request: IListenWhatsAppMessageRequest): void;
     protected handlePayload(payload: IWhatsAppWebhookPayload): Promise<void>;
     private emmitMessage;
 }
 
-declare class WhatsAppDevConnection extends WhatsAppConnection implements IWhatsAppConnection {
-    private devProxy;
-    private devProxySocket;
-    private devToken?;
-    private connected;
-    constructor();
-    sendWhatsApp(businessNumber: string, to: string, chatMessage: IChatMessage): Promise<void>;
-    sendWhatsAppTemplate(businessNumber: string, to: string, templateMessage: IWhatsAppTemplateMessage): Promise<void>;
-    connect(): void;
-}
-
-declare class WhatsAppProdConnection implements IWhatsAppConnection {
-    private express;
-    constructor(express: Express);
-    listenMessage(businessNumber: string, listener: IWhatsAppMessageListener): void;
-    sendWhatsApp(businessNumber: string, to: string, replyMessage: IChatMessage): Promise<void>;
-    sendWhatsAppTemplate(businessNumber: string, to: string, templateMessage: IWhatsAppTemplateMessage): Promise<void>;
-    connect(): void;
-}
-
-declare class WhatsAppChannel implements IChatChannel {
-    private config;
-    private chatResolver;
-    private userResolver;
-    private wabotEnv;
-    private logger;
-    private whatsAppConection;
-    constructor(config: WhatsappChannelConfig, chatResolver: ChatResolver, userResolver: UserResolver, wabotEnv: WabotEnv, devConnection: WhatsAppDevConnection, prodConnection: WhatsAppProdConnection);
-    listen(callback: (message: IReceivedMessage) => void): void;
-    connect(): void;
+declare class WhatsAppRepository implements IWhatsAppRepository {
+    findBySlug(slug: string): Promise<WhatsApp | null>;
+    findByBusinessNumber(number: string): Promise<WhatsApp | null>;
 }
 
-declare const devWhatsAppListentEvent: {
-    readonly DEV_WATSAPP_WEBHOOK: "dev-whatsapp-webhook";
-};
-declare const devWhatsappEmitEvent: {
-    readonly DEV_CONNECTION: "dev-connection";
-    readonly DEV_SEND_WHATSAPP: "dev-send-whatsapp";
-    readonly DEV_SEND_WHATSAPP_TEMPLATE: "dev-send-whatsapp-template";
-};
-interface IDevConnectionRequest {
-    token: string;
-}
-interface IDevSendWhatsappRequest {
+interface ISendWhatsAppRequest {
     from: string;
     to: string;
     message: IChatMessage;
 }
-interface IDevSendWhatsappTemplateRequest {
+interface ISendWhatsAppTemplateRequest {
     from: string;
     to: string;
-    message: IWhatsAppTemplateMessage;
+    templateMessage: IWhatsAppTemplateMessage;
+    senderName: string;
 }
-
-declare class WhatsAppSender {
-    private wabotEnv;
-    private whatsAppConection;
-    constructor(wabotEnv: WabotEnv, devConnection: WhatsAppDevConnection, prodConnection: WhatsAppProdConnection);
-    send(businessNumber: string, to: string, message: IChatMessage): Promise<void>;
-    sendTemplate(businessNumber: string, to: string, templateMessage: IWhatsAppTemplateMessage): Promise<void>;
+interface IGetWhatsAppTemplateRequest {
+    from: string;
+    templateName: string;
+    languageCode: string;
 }
-
-interface ISocketChannelConfig {
-    channel: string;
+interface IWhatsAppSenderOptions {
+    writeChatMemory?: boolean;
 }
-
-declare class SocketChannelConfig implements ISocketChannelConfig {
-    channel: string;
-    constructor(channel: string);
+declare class WhatsAppSender {
+    protected logger: Logger;
+    protected chatRepository: ChatRepository;
+    protected chatResolver: ChatResolver;
+    protected whatsAppRepository: WhatsAppRepository;
+    constructor(logger: Logger, chatRepository: ChatRepository, chatResolver: ChatResolver, whatsAppRepository: WhatsAppRepository);
+    protected handleSendRequest(request: ISendWhatsAppRequest): Promise<void>;
+    protected handleSendTemplateRequest(request: ISendWhatsAppTemplateRequest): Promise<void>;
+    protected handleGetWhatsAppTemplate(request: IGetWhatsAppTemplateRequest): Promise<IWhatsAppTemplate | null>;
+    sendWhatsApp(request: ISendWhatsAppRequest, options?: IWhatsAppSenderOptions): Promise<void>;
+    sendWhatsAppTemplate(request: ISendWhatsAppTemplateRequest, options?: IWhatsAppSenderOptions): Promise<void>;
+    getWhatsAppTemplate(request: IGetWhatsAppTemplateRequest): Promise<IWhatsAppTemplate | null>;
+    protected resolveTemplateToChatMessage(request: ISendWhatsAppTemplateRequest): Promise<IChatMessage>;
+    protected writePrivateChatMemory(message: IChatMessage, to: string): Promise<void>;
+    private replaceTemplateParameters;
 }
 
-declare function socket(config: SocketChannelConfig): (target: object, propertyKey: string | symbol) => void;
-
-declare class SocketChannel implements IChatChannel {
+declare class WhatsAppChannel implements IChatChannel {
     private config;
-    private server;
     private chatResolver;
     private userResolver;
-    private callBack;
-    constructor(config: SocketChannelConfig, server: Server, chatResolver: ChatResolver, userResolver: UserResolver);
+    private sender;
+    private receiver;
+    private logger;
+    constructor(config: WhatsappChannelConfig, chatResolver: ChatResolver, userResolver: UserResolver, sender: WhatsAppSender, receiver: WhatsAppReceiver);
     listen(callback: (message: IReceivedMessage) => void): void;
     connect(): void;
 }
 
-declare function prepareChatContainer(container: DependencyContainer$1, context: IMessageContext, mindsetCtor?: IConstructor<IMindset>): Promise<DependencyContainer$1>;
+declare class WabotDevConnection {
+    private devProxy;
+    private devProxySocket;
+    private devToken;
+    private logger;
+    static isTokenAvailable(): boolean;
+    constructor();
+    getSocket(): Promise<Socket>;
+}
 
-interface IrunChannelProps {
-    channel: IConstructor<IChatChannel>;
-    channelConfig?: object;
-    mindset: IConstructor<IMindset>;
-    chatRepository: IConstructor<IChatRepository>;
-    chatBotAdapter: IConstructor<IChatBotAdapter>;
+declare class WhatsAppReceiverByDevConnection extends WhatsAppReceiver {
+    private wabotDevConnection;
+    constructor(wabotDevConnection: WabotDevConnection);
+    connect(): Promise<void>;
 }
-declare function runChannel(props: IrunChannelProps): void;
 
-interface IServerProvider<T, ST extends T> {
-    replace: IConstructor<T>;
-    with: IConstructor<ST>;
-    singleton?: true;
+declare class WhatsAppReceiverByWebHook extends WhatsAppReceiver {
+    private expressProvider;
+    private whatsAppRepository;
+    private expressApp;
+    private webhookPath;
+    constructor(expressProvider: ExpressProvider, whatsAppRepository: WhatsAppRepository);
+    connect(): Promise<void>;
 }
-interface IServerConfig {
-    controllers: IConstructor<any>[];
-    providers?: IServerProvider<unknown, unknown>[];
+
+declare class WhatsAppSenderByCloudApi extends WhatsAppSender {
+    constructor(chatRepository: ChatRepository, chatResolver: ChatResolver, whatsAppRepository: WhatsAppRepository);
+    handleSendRequest(request: ISendWhatsAppRequest): Promise<void>;
+    handleSendTemplateRequest(request: ISendWhatsAppTemplateRequest): Promise<void>;
+    handleGetWhatsAppTemplate(request: IGetWhatsAppTemplateRequest): Promise<IWhatsAppTemplate | null>;
+}
+
+declare class WhatsAppSenderByDevConnection extends WhatsAppSender {
+    private wabotDevConnection;
+    constructor(wabotDevConnection: WabotDevConnection, chatRepository: ChatRepository, chatResolver: ChatResolver, whatsAppRepository: WhatsAppRepository);
+    handleSendRequest(request: ISendWhatsAppRequest): Promise<void>;
+    handleSendTemplateRequest(request: ISendWhatsAppTemplateRequest): Promise<void>;
+    handleGetWhatsAppTemplate(request: IGetWhatsAppTemplateRequest): Promise<IWhatsAppTemplate | null>;
+}
+
+interface ICustomErrorData {
+    message: string;
+    humanMessage?: string;
+    code?: string;
+    httpCode?: number;
+    cause?: Error;
+    info?: any;
+}
+declare class CustomError extends Error {
+    humanMessage?: string;
+    code?: string;
+    httpCode?: number;
+    info?: any;
+    constructor(data: ICustomErrorData);
 }
-declare function runServer(config: IServerConfig): void;
 
 declare class SendOneTimePasswordRequest {
     fromEmail: string;
@@ -756,92 +969,14 @@ declare class RegisterUserModule {
     registerUserWithEmail(request: RegisterUserWithEmailRequest): Promise<string>;
 }
 
-interface ICrudRepository<T> {
-    find(id: string): Promise<T | null>;
-    findAll(id: string): Promise<T[]>;
-    create(item: T): Promise<void>;
-    update(item: T): Promise<void>;
-    discard(item: T): Promise<void>;
+interface IHtmlModuleOptions {
+    url: string;
+    title: string;
 }
-
-type IPgRepositoryConfig<P extends Persistent> = {
-    schema?: string;
-    table: string;
-    constructor: IConstructor<P>;
-    add?: {
-        columns: {
-            [column: string]: {
-                type: string;
-                value: (item: P) => boolean | number | string | null | Date;
-            };
-        };
-    };
+declare function HtmlModule(options: IHtmlModuleOptions): {
+    new (): {};
 };
 
-declare class PgRepositoryBase<P extends Persistent> {
-    protected pool: Pool;
-    protected config: IPgRepositoryConfig<any>;
-    private tableIsCreated;
-    schema: string;
-    table: string;
-    columnsList: string[];
-    columnsAndTypes: string;
-    columns: string;
-    vars: string;
-    updates: string;
-    addColumns: {
-        [columns: string]: {
-            type: string;
-            value: (item: P) => number | boolean | string | null | Date;
-        };
-    };
-    constructor(pool: Pool, config: IPgRepositoryConfig<any>);
-    values(item: P): (string | number | boolean | Date | null)[];
-    protected exec(sql: string, values: any[]): Promise<void>;
-    protected query(sql: string, values: any[]): Promise<any[]>;
-    protected connect(): Promise<Pool>;
-    protected ensureTable(): Promise<void>;
-    protected ensureColumns(): Promise<void>;
-}
-
-declare class PgCrudRepository<P extends Persistent> extends PgRepositoryBase<P> implements ICrudRepository<P> {
-    protected readonly config: IPgRepositoryConfig<P>;
-    constructor(pool: Pool, config: IPgRepositoryConfig<P>);
-    find(id: string): Promise<P | null>;
-    findAll(): Promise<P[]>;
-    create(item: P): Promise<void>;
-    update(item: P): Promise<void>;
-    discard(item: P): Promise<void>;
-}
-
-interface ISqliteRecord {
-    id: string;
-    data: string;
-}
-
-declare class SqliteCrudRepository<P extends Persistent> implements ICrudRepository<P> {
-    private table;
-    private dbPath;
-    private mapper;
-    private tableCreated;
-    constructor(table: string, dbPath: string, mapper: IReversibleMapper<P, string>);
-    find(id: string): Promise<P | null>;
-    findAll(): Promise<P[]>;
-    create(item: P): Promise<void>;
-    update(item: P): Promise<void>;
-    discard(item: P): Promise<void>;
-    protected getDb(): Promise<Database<sqlite3.Database, sqlite3.Statement>>;
-    protected createTable(db: Database<sqlite3.Database, sqlite3.Statement>): Promise<void>;
-}
-
-declare class SqlitePersistentMapper<P extends Persistent> implements IReversibleMapper<P, string> {
-    private ctor;
-    constructor(ctor: IConstructor<P>);
-    map(input: P): string;
-    rev(input: string): P;
-}
-declare function sqliteMapperFor<P extends Persistent>(ctor: IConstructor<P>): SqlitePersistentMapper<P>;
-
 declare class PgUserRepository extends PgCrudRepository<User> implements IUserRepository {
     constructor(pool: Pool);
     findByConnection(query: IUserConnection): Promise<User | null>;
@@ -854,12 +989,6 @@ declare class RamUserRepository implements IUserRepository {
     update(chat: User): Promise<void>;
 }
 
-declare class SqliteUserRepository extends SqliteCrudRepository<User> implements IUserRepository {
-    constructor();
-    findByConnection(query: IUserConnection): Promise<User | null>;
-    static getDbPath(): string;
-}
-
 declare class PgChatRepository extends PgCrudRepository<Chat> implements IChatRepository {
     constructor(pool: Pool);
     findByConnection(query: IChatConnection): Promise<Chat | null>;
@@ -872,19 +1001,6 @@ declare class PgChatMemory extends PgCrudRepository<ChatItem> implements IChatMe
     findLastItems(count: number): Promise<ChatItem[]>;
 }
 
-declare class SqliteChatMemory extends SqliteCrudRepository<ChatItem> implements IChatMemory {
-    constructor(chatId: string);
-    findLastItems(count: number): Promise<ChatItem[]>;
-    static getDbPath(chatId: string): string;
-}
-
-declare class SqliteChatRepository extends SqliteCrudRepository<Chat> implements IChatRepository {
-    constructor();
-    findByConnection(query: IChatConnection): Promise<Chat | null>;
-    findMemory(chatId: string): Promise<IChatMemory | null>;
-    static getDbPath(): string;
-}
-
 declare class RamChatMemory implements IChatMemory {
     private memory;
     findLastItems(count: number): Promise<ChatItem[]>;
@@ -901,4 +1017,187 @@ declare class RamChatRepository implements IChatRepository {
     private getMemory;
 }
 
-export { AuthenticationModule, Chat, ChatBot, ChatBotAdapter, ChatBotMetadataStore, ChatItem, ChatMemory, ChatRepository, ChatResolver, CmdChannel, Container, ControllerMetadataStore, DeepSeekChatBotAdapter, EmailService, ExpressApp, type IChannelMetadata, type IChatBot, type IChatBotAdapter, type IChatBotMetadata, type IChatChannel, type IChatConnection, type IChatControllerMetadata, type IChatData, type IChatFunctionCall, type IChatItemData, type IChatItemType, type IChatMemory, type IChatMessage, type IChatRepository, type IChatType, type IConnectionChatMessage, type IConstructor, type ICrudRepository, type IDevConnectionRequest, type IDevSendWhatsappRequest, type IDevSendWhatsappTemplateRequest, type IEmailService, type IMessageContext, type IMessageMetadata, type IMindset, type IMindsetDecoration, type IMindsetFunctionConfig, type IMindsetFunctionDecoration, type IMindsetFunctionMetadata, type IMindsetFunctionParamMetadata, type IMindsetIdentity, type IMindsetMetadata, type IMindsetModuleConfig, type IMindsetModuleDecoration, type IMindsetModuleMetadata, type IOtpService, type IParamConfig, type IParamDecoration, type IPersistent, type IPgRepositoryConfig, type IReceivedMessage, type IReceivedMessageItem, type IReversibleMapper, type ISendEmailRequest, type IServerConfig, type IServerProvider, type ISqliteRecord, type ISystemFunctionCallItem, type ISystemMessageItem, type ITelegramChannelConfig, type IUserConnection, type IUserData, type IUserRepository, type IWabotEnvType, type IWhatsAppConnection, type IWhatsAppContact, type IWhatsAppMessage, type IWhatsAppMessageListener, type IWhatsAppTemplateMessage, type IWhatsAppTemplateParameter, type IWhatsAppWebhookPayload, type IWhatsappChannelConfig, type IchatControllerConfig, type IrunChannelProps, Logger, MINDSET_DECORATION_MINDSET, MINDSET_FUNCTION_DECORATION_FUNCTION, MINDSET_MODULE_DECORATION_MODULE, MessageContext, Mindset, MindsetMetadataStore, MindsetOperator, OpenaiChatBotAdapter, OtpService, PARAM_DECORATION_IS_OPTIONAL, PARAM_DECORATION_PARAM, Persistent, PgChatMemory, PgChatRepository, PgCrudRepository, PgRepositoryBase, PgUserRepository, RamChatMemory, RamChatRepository, RamUserRepository, RegisterUserModule, RegisterUserWithEmailRequest, SendOneTimePasswordRequest, SocketChannel, SocketChannelConfig, SocketIoApp, SqliteChatMemory, SqliteChatRepository, SqliteCrudRepository, SqlitePersistentMapper, SqliteUserRepository, TelegramChannel, TelegramChannelConfig, User, UserRepository, UserResolver, ValidateOneTimePasswordRequest, WabotEnv, WhatsAppChannel, WhatsAppConnection, WhatsAppDevConnection, WhatsAppProdConnection, WhatsAppSender, WhatsappChannelConfig, chatBot, chatController, cmd, container, devWhatsAppListentEvent, devWhatsappEmitEvent, inject, injectable, isOptional, mindset, mindsetFunction, mindsetModule, param, prepareChatContainer, runChannel, runServer, singleton, socket, sqliteMapperFor, telegram, whatsapp };
+interface IGetConfig {
+    path?: string;
+}
+
+declare function get(config?: IGetConfig): (target: object, propertyKey: string | symbol) => void;
+
+interface IMiddleware {
+    handle(req: Request, res: Response, container: DependencyContainer$1): Promise<void>;
+}
+
+declare function middleware(middlewareConstructor: IConstructor<IMiddleware>): (target: object, propertyKey: string | symbol) => void;
+
+interface IPostConfig {
+    path?: string;
+}
+
+declare function post(config?: string | IPostConfig): (target: object, propertyKey: string | symbol) => void;
+
+interface IRestControllerConfig {
+    path: string;
+}
+
+declare function restController(config: string | IRestControllerConfig): (target: IConstructor<any>) => void;
+
+interface IEndPointMetadata {
+    method: 'get' | 'post';
+    path?: string;
+    controllerConstructor: IConstructor<any>;
+    functionName: string;
+    paramsTypes: any[];
+}
+
+interface IMiddlewareMetadata {
+    controllerConstructor: IConstructor<any>;
+    functionName: string;
+    middlewareConstructor: IConstructor<IMiddleware>;
+}
+
+interface IRestControllerMetadata {
+    controllerConstructor: IConstructor<any>;
+    path: string;
+}
+
+declare class RestControllerMetadataStore {
+    private endPoints;
+    private middlewares;
+    private restControllers;
+    saveControllerMetadata(controllerMetadata: IRestControllerMetadata): void;
+    saveEndPointMetadata(endPointMetadata: IEndPointMetadata): void;
+    saveMiddlewareMetadata(middlewareMetadata: IMiddlewareMetadata): void;
+    getControllerEndPointsInfo(controllerConstructor: IConstructor<any>): {
+        middlewares: IMiddlewareMetadata[];
+        controller: IRestControllerMetadata;
+        method: "get" | "post";
+        path?: string;
+        controllerConstructor: IConstructor<any>;
+        functionName: string;
+        paramsTypes: any[];
+    }[];
+}
+
+declare function runRestControllers(controllers: IConstructor<any>[]): void;
+
+declare function prepareChatContainer(container: DependencyContainer$1, context: IMessageContext, mindsetCtor?: IConstructor<IMindset>): Promise<DependencyContainer$1>;
+
+interface IrunChannelProps {
+    channel: IConstructor<IChatChannel>;
+    channelConfig?: object;
+    mindset: IConstructor<IMindset>;
+    chatRepository: IConstructor<IChatRepository>;
+    chatBotAdapter: IConstructor<IChatBotAdapter>;
+}
+declare function runChannel(props: IrunChannelProps): void;
+
+interface IServerProvider<T, ST extends T> {
+    replace: IConstructor<T>;
+    with: IConstructor<ST>;
+    singleton?: true;
+}
+interface IServerConfig {
+    controllers: IConstructor<any>[];
+    providers?: IServerProvider<unknown, unknown>[];
+}
+declare function runServer(config: IServerConfig): void;
+
+declare function isBoolean(): (target: object, propertyKey: string | symbol) => void;
+
+declare function isDate(): (target: object, propertyKey: string | symbol) => void;
+
+declare function isModel(model: IConstructor<any>): (target: object, propertyKey: string | symbol) => void;
+
+declare function isNotEmpty(): (target: object, propertyKey: string | symbol) => void;
+
+declare function isNumber(): (target: object, propertyKey: string | symbol) => void;
+
+declare function isOptional(): (target: object, propertyKey: string | symbol) => void;
+
+declare function isPresent(): (target: object, propertyKey: string | symbol) => void;
+
+declare function isString(): (target: object, propertyKey: string | symbol) => void;
+
+declare function max(limit: any): (target: object, propertyKey: string | symbol) => void;
+
+declare function min(limit: any): (target: object, propertyKey: string | symbol) => void;
+
+interface IValidationError {
+    description: string;
+}
+interface IModelValidationError extends IValidationError {
+    properties: {
+        [key: string]: string[];
+    };
+}
+type IValidationResult<V> = {
+    value: V;
+    error?: undefined;
+} | {
+    value?: undefined;
+    error: IValidationError;
+};
+type IModelValidationResult<V> = {
+    value: V;
+    error?: undefined;
+} | {
+    value?: undefined;
+    error: IModelValidationError;
+};
+type IValidator = (value: any, options: any) => IValidationResult<any>;
+interface IPropertyValidatorInfo {
+    propertyName: string;
+    validator: IValidator;
+    validatorOptions?: any;
+}
+type IModelValidatorsInfo<V> = {
+    modelConstructor: IConstructor<V>;
+    properties: {
+        [prop: string]: {
+            isOptional?: boolean;
+            validators?: IPropertyValidatorInfo[];
+        } | undefined;
+    };
+};
+
+interface IValidatorMetadata {
+    modelConstructor: IConstructor<any>;
+    propertyName: string;
+    validator: IValidator;
+    validatorOptions?: any;
+}
+
+declare class ValidationMetadataStore {
+    private validators;
+    saveValidatorMetadata(validatorMetadata: IValidatorMetadata): void;
+    getModelValidatorsInfo<V>(modelConstructor: IConstructor<V>): IModelValidatorsInfo<V>;
+    private getConstructorPropertiesValidatorsInfo;
+}
+
+declare function validateIsBoolean(value: any): IValidationResult<boolean>;
+
+declare function validateIsDate(value: any): IValidationResult<Date>;
+
+declare function validateIsNotEmpty(value: any): IValidationResult<any>;
+
+declare function validateIsNumber(value: any): IValidationResult<number>;
+
+declare function validateIsString(value: any): IValidationResult<string>;
+
+interface IValidateMaxOptions {
+    limit: any;
+}
+declare function validateMax(value: any, options: IValidateMaxOptions): IValidationResult<any>;
+
+interface IValidateMinOptions {
+    limit: any;
+}
+declare function validateMin(value: any, options: IValidateMinOptions): IValidationResult<any>;
+
+declare function validateIsPresent(value: any): IValidationResult<any>;
+
+declare function validateModel<V>(value: any, info: IModelValidatorsInfo<V>): IModelValidationResult<V>;
+
+declare function validate<V>(value: any, modelConstructor: IConstructor<V>): IModelValidationResult<V>;
+
+export { AuthenticationModule, Chat, ChatBot, ChatBotAdapter, ChatBotMetadataStore, ChatItem, ChatMemory, ChatRepository, ChatResolver, ClaudeChatBotAdapter, CmdChannel, Container, ControllerMetadataStore, CustomError, DeepSeekChatBotAdapter, EmailService, Entity, Env, EnvWhatsAppRepository, ExpressProvider, HtmlModule, HttpServerProvider, type IChannelMetadata, type IChatBot, type IChatBotAdapter, type IChatBotMetadata, type IChatChannel, type IChatConnection, type IChatControllerMetadata, type IChatData, type IChatFunctionCall, type IChatItemData, type IChatItemType, type IChatMemory, type IChatMessage, type IChatRepository, type IChatType, type IConnectionChatMessage, type IConstructor, type ICrudRepository, type ICustomErrorData, type IEmailService, type IEndPointMetadata, type IEntityData, type IEnvType, type IGetConfig, type IGetWhatsAppTemplateRequest, type IHtmlModuleOptions, type IListenWhatsAppMessageRequest, type IMessageContext, type IMessageMetadata, type IMiddleware, type IMiddlewareMetadata, type IMindset, type IMindsetDecoration, type IMindsetFunctionConfig, type IMindsetFunctionDecoration, type IMindsetFunctionMetadata, type IMindsetFunctionParamMetadata, type IMindsetIdentity, type IMindsetMetadata, type IMindsetModuleConfig, type IMindsetModuleDecoration, type IMindsetModuleMetadata, type IModelValidationError, type IModelValidationResult, type IModelValidatorsInfo, type IOtpService, type IParamConfig, type IParamDecoration, type IPersistentData, type IPgRepositoryConfig, type IPostConfig, type IPrimitive, type IPropertyValidatorInfo, type IReceivedMessage, type IReceivedMessageItem, type IRestControllerConfig, type IRestControllerMetadata, type ISendEmailRequest, type ISendWhatsAppRequest, type ISendWhatsAppTemplateRequest, type IServerConfig, type IServerProvider, type ISocketChannelConfig, type ISocketChannelReceivedMessage, type IStorableData, type ISystemFunctionCallItem, type ISystemMessageItem, type ITelegramChannelConfig, type IUserConnection, type IUserData, type IUserRepository, type IValidateMaxOptions, type IValidateMinOptions, type IValidationError, type IValidationResult, type IValidator, type IValidatorMetadata, type IWhatsAppBusinessAccount, type IWhatsAppBusinessNumber, type IWhatsAppContact, type IWhatsAppData, type IWhatsAppMessage, type IWhatsAppMessageListener, type IWhatsAppRepository, type IWhatsAppSenderOptions, type IWhatsAppTemplate, type IWhatsAppTemplateComponent, type IWhatsAppTemplateMessage, type IWhatsAppTemplateParameter, type IWhatsAppTemplateResponse, type IWhatsAppWebhookPayload, type IWhatsappChannelConfig, type IchatControllerConfig, type IrunChannelProps, Logger, MINDSET_DECORATION_MINDSET, MINDSET_FUNCTION_DECORATION_FUNCTION, MINDSET_MODULE_DECORATION_MODULE, MessageContext, Mindset, MindsetMetadataStore, MindsetOperator, OpenaiChatBotAdapter, OtpService, PARAM_DECORATION_IS_OPTIONAL, PARAM_DECORATION_PARAM, Persistent, PgChatMemory, PgChatRepository, PgCrudRepository, PgRepositoryBase, PgUserRepository, PgWhatsAppRepository, RamChatMemory, RamChatRepository, RamUserRepository, RegisterUserModule, RegisterUserWithEmailRequest, RestControllerMetadataStore, SendOneTimePasswordRequest, SocketChannel, SocketChannelConfig, SocketServerProvider, Storable, TelegramChannel, TelegramChannelConfig, User, UserRepository, UserResolver, ValidateOneTimePasswordRequest, ValidationMetadataStore, WhatsApp, WhatsAppChannel, WhatsAppReceiver, WhatsAppReceiverByDevConnection, WhatsAppReceiverByWebHook, WhatsAppRepository, WhatsAppSender, WhatsAppSenderByCloudApi, WhatsAppSenderByDevConnection, WhatsappChannelConfig, chatBot, chatController, cmd, container, get, inject, injectable, isBoolean, isDate, isModel, isNotEmpty, isNumber, isOptional, isPresent, isString, max, middleware, min, mindset, mindsetFunction, mindsetModule, param, post, prepareChatContainer, restController, runChannel, runRestControllers, runServer, singleton, socket, telegram, validate, validateIsBoolean, validateIsDate, validateIsNotEmpty, validateIsNumber, validateIsPresent, validateIsString, validateMax, validateMin, validateModel, whatsapp };