@wabot-dev/framework 0.0.16 → 0.0.50

package/dist/src/index.d.ts

@@ -1,15 +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 { Server } from 'http';
 import { Express } from 'express';
-export { Express } from 'express';
+import { Server as Server$1 } from 'socket.io';
+import { Socket } from 'socket.io-client';
+import { Pool } from 'pg';
 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';
-export { Server as SocketIo } from 'socket.io';
 
 interface IMindsetFunctionConfig {
     description: string;
@@ -27,12 +26,12 @@ interface IMindsetFunctionDecoration {
     decorationConfig: any;
 }
 
-interface IPersistent {
+interface IPersistentData {
     id?: string;
     createdAt?: number | null;
     discardedAt?: number | null;
 }
-declare class Persistent<D extends IPersistent = IPersistent> {
+declare class Persistent<D extends IPersistentData = IPersistentData> {
     protected data: D;
     constructor(data: D);
     getId(): string;
@@ -49,7 +48,7 @@ interface IChatConnection {
     channelName: string;
     id: string;
 }
-interface IChatData extends IPersistent {
+interface IChatData extends IPersistentData {
     type: IChatType;
     connections: IChatConnection[];
 }
@@ -73,7 +72,7 @@ interface IUserConnection {
     channelName: string;
     id: string;
 }
-interface IUserData extends IPersistent {
+interface IUserData extends IPersistentData {
     shortName: string;
     connections: IUserConnection[];
     keyValueData: {
@@ -227,10 +226,9 @@ interface IMindsetModuleDecoration {
     decorationConfig: any;
 }
 
-declare function isOptional(): PropertyDecorator;
-
 interface IParamConfig {
     name?: string;
+    optional?: boolean;
     description: string;
 }
 
@@ -367,9 +365,19 @@ 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;
@@ -426,10 +434,6 @@ declare class ControllerMetadataStore {
     } | null;
 }
 
-declare const ExpressApp: unique symbol;
-
-declare const SocketIoApp: unique symbol;
-
 declare class CmdChannel implements IChatChannel {
     private chatResolver;
     private userResolver;
@@ -440,6 +444,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;
 }
@@ -471,6 +532,29 @@ declare class WhatsappChannelConfig implements IWhatsappChannelConfig {
 
 declare function whatsapp(config: IWhatsappChannelConfig): (target: object, propertyKey: string | symbol) => void;
 
+type IWhatsAppTemplateParameter = {
+    type: 'text';
+    text: string;
+    parameter_name?: string;
+} | {
+    type: 'currency';
+    currency: {
+        fallback_value: string;
+        code: string;
+        amount_1000: number;
+    };
+} | {
+    type: 'date_time';
+    date_time: {
+        fallback_value: string;
+    };
+};
+interface IWhatsAppTemplateMessage {
+    templateName: string;
+    languageCode: string;
+    parameters: IWhatsAppTemplateParameter[];
+}
+
 interface IWhatsAppWebhookPayload {
     object: 'whatsapp_business_account';
     entry: IEntry[];
@@ -523,19 +607,30 @@ interface IAudioMessage extends IBaseMessage {
     };
 }
 
-type IWabotEnvType = 'development' | 'staging' | 'testing' | 'production';
-declare class WabotEnv {
-    private envType;
-    constructor();
-    isDevelopment(): boolean;
-    isProduction(): boolean;
+interface IWhatsAppBusinessNumber {
+    id: string;
+    number: string;
 }
-
-type IWhatsAppMessageListener = (message: IConnectionChatMessage) => Promise<void>;
-interface IWhatsAppConnection {
-    listenMessage(businessNumber: string, listener: IWhatsAppMessageListener): void;
-    sendWhatsApp(businessNumber: string, to: string, replyMessage: IChatMessage): Promise<void>;
-    connect(): void;
+interface IWhatsAppBusinessAccount {
+    id: string;
+}
+interface IWhatsAppData extends IPersistentData {
+    slug: string;
+    verifyToken: string;
+    appSecret: string;
+    accessToken: string;
+    businessAccount: IWhatsAppBusinessAccount;
+    businessNumbers: IWhatsAppBusinessNumber[];
+}
+declare class WhatsApp extends Persistent<IWhatsAppData> {
+    getVerifyToken(): string;
+    getSlug(): string;
+    getBusinessAccount(): IWhatsAppBusinessAccount;
+    getAppSecret(): string;
+    getBusinessNumbers(): IWhatsAppBusinessNumber[];
+    getAccessToken(): string;
+    hasBusinessNumber(number: string): boolean;
+    getBussinessNumber(number: string): IWhatsAppBusinessNumber | null;
 }
 
 declare class Logger {
@@ -550,61 +645,213 @@ 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;
-    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>;
-    connect(): void;
+interface IWhatsAppRepository {
+    findBySlug(slug: string): Promise<WhatsApp | null>;
+    findByBusinessNumber(number: string): Promise<WhatsApp | null>;
 }
 
-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>;
-    connect(): void;
+declare class WhatsAppRepository implements IWhatsAppRepository {
+    findBySlug(slug: string): Promise<WhatsApp | null>;
+    findByBusinessNumber(number: string): Promise<WhatsApp | null>;
+}
+
+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 ISendWhatsAppRequest {
+    from: string;
+    to: string;
+    message: IChatMessage;
+}
+interface ISendWhatsAppTemplateRequest {
+    from: string;
+    to: string;
+    templateMessage: IWhatsAppTemplateMessage;
+    senderName: string;
+}
+interface IGetWhatsAppTemplateRequest {
+    from: string;
+    templateName: string;
+    languageCode: string;
+}
+interface IWhatsAppSenderOptions {
+    writeChatMemory?: boolean;
+}
+declare abstract class WhatsAppSender {
+    protected logger: Logger;
+    protected chatRepository: ChatRepository;
+    protected chatResolver: ChatResolver;
+    protected whatsAppRepository: WhatsAppRepository;
+    constructor(logger: Logger, chatRepository: ChatRepository, chatResolver: ChatResolver, whatsAppRepository: WhatsAppRepository);
+    protected abstract handleSendRequest(request: ISendWhatsAppRequest): Promise<void>;
+    protected abstract handleSendTemplateRequest(request: ISendWhatsAppTemplateRequest): Promise<void>;
+    protected abstract 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 class WhatsAppChannel implements IChatChannel {
     private config;
     private chatResolver;
     private userResolver;
-    private wabotEnv;
+    private sender;
+    private receiver;
     private logger;
-    private whatsAppConection;
-    constructor(config: WhatsappChannelConfig, chatResolver: ChatResolver, userResolver: UserResolver, wabotEnv: WabotEnv, devConnection: WhatsAppDevConnection, prodConnection: WhatsAppProdConnection);
+    constructor(config: WhatsappChannelConfig, chatResolver: ChatResolver, userResolver: UserResolver, sender: WhatsAppSender, receiver: WhatsAppReceiver);
     listen(callback: (message: IReceivedMessage) => void): void;
     connect(): void;
 }
 
-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";
+declare class WabotDevConnection {
+    private devProxy;
+    private devProxySocket;
+    private devToken;
+    private logger;
+    static isTokenAvailable(): boolean;
+    constructor();
+    getSocket(): Promise<Socket>;
+}
+
+declare class WhatsAppReceiverByDevConnection extends WhatsAppReceiver {
+    private wabotDevConnection;
+    constructor(wabotDevConnection: WabotDevConnection);
+    connect(): Promise<void>;
+}
+
+declare class WhatsAppReceiverByWebHook extends WhatsAppReceiver {
+    private expressProvider;
+    private whatsAppRepository;
+    private expressApp;
+    private webhookPath;
+    constructor(expressProvider: ExpressProvider, whatsAppRepository: WhatsAppRepository);
+    connect(): Promise<void>;
+}
+
+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>;
+}
+
+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>;
+}
+
+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>;
+}
+
+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;
+            };
+        };
+    };
 };
-interface IDevConnectionRequest {
-    token: string;
+
+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>;
 }
-interface IDevSendWhatsappRequest {
-    from: string;
-    to: string;
-    message: IChatMessage;
+
+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>;
+}
+
+declare class PgWhatsAppRepository extends PgCrudRepository<WhatsApp> implements IWhatsAppRepository {
+    constructor(pool: Pool);
+    findBySlug(slug: string): Promise<WhatsApp | null>;
+    findByBusinessNumber(number: string): Promise<WhatsApp | null>;
+}
+
+type IWabotEnvType = 'development' | 'staging' | 'testing' | 'production';
+declare class WabotEnv {
+    private envType;
+    constructor();
+    isDevelopment(): boolean;
+    isProduction(): boolean;
+    requireString(varName: string): string;
+}
+
+declare class EnvWhatsAppRepository implements IWhatsAppRepository {
+    private env;
+    constructor(env: WabotEnv);
+    findBySlug(slug: string): Promise<WhatsApp | null>;
+    findByBusinessNumber(number: string): Promise<WhatsApp | null>;
+    private getFromEnvVars;
 }
 
 declare function prepareChatContainer(container: DependencyContainer$1, context: IMessageContext, mindsetCtor?: IConstructor<IMindset>): Promise<DependencyContainer$1>;
@@ -683,92 +930,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>;
@@ -781,12 +950,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>;
@@ -799,19 +962,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[]>;
@@ -828,4 +978,145 @@ declare class RamChatRepository implements IChatRepository {
     private getMemory;
 }
 
-export { AuthenticationModule, Chat, ChatBot, ChatBotAdapter, ChatBotMetadataStore, ChatItem, ChatMemory, ChatRepository, ChatResolver, CmdChannel, Container, ControllerMetadataStore, 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 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 IWhatsAppContact, type IWhatsAppMessage, 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, SocketIoApp, SqliteChatMemory, SqliteChatRepository, SqliteCrudRepository, SqlitePersistentMapper, SqliteUserRepository, TelegramChannel, TelegramChannelConfig, User, UserRepository, UserResolver, ValidateOneTimePasswordRequest, WabotEnv, WhatsAppChannel, WhatsappChannelConfig, chatBot, chatController, cmd, container, devWhatsAppListentEvent, devWhatsappEmitEvent, inject, injectable, isOptional, mindset, mindsetFunction, mindsetModule, param, prepareChatContainer, runChannel, runServer, singleton, sqliteMapperFor, telegram, whatsapp };
+interface IGetConfig {
+    path?: string;
+}
+
+declare function get(config?: IGetConfig): (target: object, propertyKey: string | symbol) => void;
+
+interface IPostConfig {
+    path?: string;
+}
+
+declare function post(config?: IPostConfig): (target: object, propertyKey: string | symbol) => void;
+
+interface IRestControllerConfig {
+    path: string;
+}
+
+declare function restController(config: IRestControllerConfig): (target: IConstructor<any>) => void;
+
+interface IEndPointMetadata {
+    method: 'get' | 'post';
+    path?: string;
+    controllerConstructor: IConstructor<any>;
+    functionName: string;
+    paramsTypes: any[];
+}
+
+interface IRestControllerMetadata {
+    controllerConstructor: IConstructor<any>;
+    path: string;
+}
+
+declare class RestControllerMetadataStore {
+    private endPoints;
+    private restControllers;
+    saveControllerMetadata(controllerMetadata: IRestControllerMetadata): void;
+    saveEndPointMetadata(endPointMetadata: IEndPointMetadata): void;
+    getControllerEndPointsInfo(controllerConstructor: IConstructor<any>): {
+        controller: IRestControllerMetadata;
+        method: "get" | "post";
+        path?: string;
+        controllerConstructor: IConstructor<any>;
+        functionName: string;
+        paramsTypes: any[];
+    }[];
+}
+
+declare function runRestControllers(controllers: IConstructor<any>[], container: DependencyContainer$1): void;
+
+declare function isBoolean(): (target: object, propertyKey: string | symbol) => void;
+
+declare function isDate(): (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;
+
+declare function validable<A>(): (target: IConstructor<A>) => void;
+
+interface IValidationError {
+    description: string;
+}
+interface IModelValidationError {
+    model: IValidationError[];
+    properties: {
+        name: string;
+        errors: IValidationError[];
+    }[];
+}
+interface IValidationResult<V> {
+    value?: V;
+    error?: IValidationError;
+}
+interface IModelValidationResult<V> {
+    value?: V;
+    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>;
+}
+
+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 validateModel2<V>(value: any, modelConstructor: IConstructor<V>): IModelValidationResult<V>;
+
+export { AuthenticationModule, Chat, ChatBot, ChatBotAdapter, ChatBotMetadataStore, ChatItem, ChatMemory, ChatRepository, ChatResolver, CmdChannel, Container, ControllerMetadataStore, DeepSeekChatBotAdapter, EmailService, 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 IEmailService, type IEndPointMetadata, type IGetConfig, type IGetWhatsAppTemplateRequest, type IHtmlModuleOptions, type IListenWhatsAppMessageRequest, 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 IModelValidationError, type IModelValidationResult, type IModelValidatorsInfo, type IOtpService, type IParamConfig, type IParamDecoration, type IPersistentData, type IPgRepositoryConfig, type IPostConfig, type IPropertyValidatorInfo, type IReceivedMessage, type IReceivedMessageItem, type IRestControllerConfig, type IRestControllerMetadata, type IReversibleMapper, type ISendEmailRequest, type ISendWhatsAppRequest, type ISendWhatsAppTemplateRequest, type IServerConfig, type IServerProvider, type ISocketChannelConfig, type ISocketChannelReceivedMessage, 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 IWabotEnvType, type IWhatsAppBusinessAccount, type IWhatsAppBusinessNumber, type IWhatsAppContact, type IWhatsAppData, type IWhatsAppMessage, type IWhatsAppMessageListener, type IWhatsAppRepository, type IWhatsAppSenderOptions, 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, PgWhatsAppRepository, RamChatMemory, RamChatRepository, RamUserRepository, RegisterUserModule, RegisterUserWithEmailRequest, RestControllerMetadataStore, SendOneTimePasswordRequest, SocketChannel, SocketChannelConfig, SocketServerProvider, TelegramChannel, TelegramChannelConfig, User, UserRepository, UserResolver, ValidateOneTimePasswordRequest, ValidationMetadataStore, WabotEnv, WhatsApp, WhatsAppChannel, WhatsAppReceiver, WhatsAppReceiverByDevConnection, WhatsAppReceiverByWebHook, WhatsAppRepository, WhatsAppSender, WhatsAppSenderByCloudApi, WhatsAppSenderByDevConnection, WhatsappChannelConfig, chatBot, chatController, cmd, container, get, inject, injectable, isBoolean, isDate, isNotEmpty, isNumber, isOptional, isPresent, isString, max, min, mindset, mindsetFunction, mindsetModule, param, post, prepareChatContainer, restController, runChannel, runRestControllers, runServer, singleton, socket, telegram, validable, validateIsBoolean, validateIsDate, validateIsNotEmpty, validateIsNumber, validateIsPresent, validateIsString, validateMax, validateMin, validateModel, validateModel2, whatsapp };