@wabot-dev/framework 0.1.0-beta.4 → 0.1.0-beta.41

package/dist/src/index.d.ts

@@ -1,183 +1,367 @@
+import * as tsyringe from 'tsyringe';
+import { DependencyContainer as DependencyContainer$1 } from 'tsyringe';
+export { DependencyContainer } from 'tsyringe';
 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';
+import { Express, Request, Response } from 'express';
 import { Server as Server$1 } from 'socket.io';
-import { Socket } from 'socket.io-client';
+import * as big_js from 'big.js';
 import { Pool } from 'pg';
-import * as tsyringe from 'tsyringe';
-import { DependencyContainer as DependencyContainer$1 } from 'tsyringe';
-export { DependencyContainer } from 'tsyringe';
+import { Socket } from 'socket.io-client';
+import { Algorithm } from 'jsonwebtoken';
 
-interface IMindsetFunctionConfig {
-    description: string;
+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);
 }
 
-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;
+declare class Auth<D extends IStorableData> {
+    private authInfo;
+    require(): D;
+    assign(authInfo: D): void;
 }
 
-interface IPersistentData {
+interface IEntityData extends IStorableData {
     id?: string;
     createdAt?: number | null;
     discardedAt?: number | null;
 }
-declare class Persistent<D extends IPersistentData = IPersistentData> {
-    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 {
-    chatType: IChatType;
-    channelName: string;
-    id: string;
+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;
+}
+
+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);
 }
-interface IChatData extends IPersistentData {
-    type: IChatType;
-    connections: IChatConnection[];
+
+type IConstructor<T> = new (...args: any[]) => T;
+
+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 class Chat extends Persistent<IChatData> {
-    constructor(data: IChatData);
-    isPrivate(): boolean;
-    isGroup(): boolean;
-    hasConnection(connection: IChatConnection): boolean;
-    private validatePrivateChat;
-    private validateGroupChat;
-    validate(): 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 const scoped: typeof tsyringe.scoped;
+declare const Lifecycle: typeof tsyringe.Lifecycle;
+
+declare class Logger {
+    private debuggers;
+    constructor(name: string);
+    trace(...args: any[]): void;
+    debug(...args: any[]): void;
+    info(...args: any[]): void;
+    warn(...args: any[]): void;
+    error(...args: any[]): void;
+    fatal(...args: any[]): void;
+    private log;
 }
 
-interface IChatDocument {
+declare class Mapper {
+    map<T>(data: any, ctor: IConstructor<T>): T;
 }
 
-interface IChatImage {
+declare class Random {
+    static slug(name: string, options: {
+        randomLength: number;
+    }): string;
+    static string(length: number): string;
+    static numberCode(length: number): string;
 }
 
-interface IUserConnection {
-    channelName: string;
-    id: string;
+interface ICrudRepository<T> {
+    find(id: string): Promise<T | null>;
+    findOrThrow(id: string): Promise<T>;
+    findByIds(ids: string[]): Promise<T[]>;
+    findAll(id: string): Promise<T[]>;
+    create(item: T): Promise<void>;
+    update(item: T): Promise<void>;
+    discard(item: T): Promise<void>;
+}
+
+declare function isModel(model: IConstructor<any>): (target: object, propertyKey: string | symbol) => void;
+
+declare function isOptional(): (target: object, propertyKey: string | symbol) => void;
+
+interface IValidationError {
+    description: string;
 }
-interface IUserData extends IPersistentData {
-    shortName: string;
-    connections: IUserConnection[];
-    keyValueData: {
-        [key: string]: string;
+interface IModelValidationError extends IValidationError {
+    properties: {
+        [key: string]: string[];
     };
 }
-declare class User extends Persistent<IUserData> {
-    constructor(data: IUserData);
-    hasConnection(connection: IUserConnection): boolean;
-    getValue(key: string): string;
-    setValue(key: string, value: string): void;
-    addConnection(connection: IUserConnection): void;
+interface IArrayValidationError extends IValidationError {
+    items: (IValidationError[] | null)[];
 }
+type IValidationResult<V> = {
+    value: V;
+    error?: undefined;
+} | {
+    value?: undefined;
+    error: IValidationError;
+};
+type IModelValidationResult<V> = {
+    value: V;
+    error?: undefined;
+} | {
+    value?: undefined;
+    error: IModelValidationError;
+};
+type IArrayValidationResult<V> = {
+    value: V[];
+    error?: undefined;
+} | {
+    value?: undefined;
+    error: IArrayValidationError;
+};
+type IValidator<V = any, O = any> = (value: V, options: O) => IValidationResult<V>;
+interface IPropertyValidatorInfo {
+    propertyName: string;
+    validator: IValidator;
+    validatorOptions?: any;
+}
+type IModelValidatorsInfo<V> = {
+    modelConstructor: IConstructor<V>;
+    properties: {
+        [prop: string]: {
+            isOptional?: boolean;
+            validators?: IPropertyValidatorInfo[];
+        } | undefined;
+    };
+};
 
-interface IChatMessage {
-    text?: string;
-    documents?: IChatDocument[];
-    images?: IChatImage[];
-    senderName: string;
+interface IValidateArrayOptions {
+    minLength?: number;
+    maxLength?: number;
 }
-interface IConnectionChatMessage extends IChatMessage {
-    chatConnection: IChatConnection;
-    userConnection: IUserConnection;
-    userId?: string;
+interface IValidateArrayOptionsWithItemsValidators extends IValidateArrayOptions {
+    itemsValidator?: {
+        validator: IValidator;
+        options: any;
+    }[];
 }
+declare function validateArray(value: any, options?: IValidateArrayOptionsWithItemsValidators): IArrayValidationResult<any>;
 
-interface IChatFunctionCall {
-    id: string;
-    name: string;
-    arguments?: string;
-    result: string;
+declare function isArray(options?: IValidateArrayOptions): (target: object, propertyKey: string | symbol) => void;
+
+interface IValidatorMetadata {
+    modelConstructor: IConstructor<any>;
+    propertyName: string;
+    validator: IValidator;
+    validatorOptions?: any;
 }
 
-type ISystemMessageItem = {
-    type: 'BOT_MESSAGE';
-    content: IChatMessage;
-};
-type IReceivedMessageItem = {
-    type: 'CONNECTION_MESSAGE';
-    content: IConnectionChatMessage;
-};
-type ISystemFunctionCallItem = {
-    type: 'FUNCTION_CALL';
-    content: IChatFunctionCall;
-};
-type IChatItemData = {
-    id?: string;
-    createdAt?: number;
-} & (ISystemMessageItem | IReceivedMessageItem | ISystemFunctionCallItem);
-type IChatItemType = IChatItemData['type'];
-declare class ChatItem extends Persistent<IChatItemData> {
-    getType(): "BOT_MESSAGE" | "CONNECTION_MESSAGE" | "FUNCTION_CALL";
-    getContent(): IChatMessage | IConnectionChatMessage | IChatFunctionCall;
-    getData(): IChatItemData;
+declare class ValidationMetadataStore {
+    private validators;
+    saveValidatorMetadata(validatorMetadata: IValidatorMetadata): void;
+    getModelValidatorsInfo<V>(modelConstructor: IConstructor<V>): IModelValidatorsInfo<V>;
+    private getConstructorPropertiesValidatorsInfo;
 }
 
-interface IChatMemory {
-    findLastItems(count: number): Promise<ChatItem[]>;
-    create(item: ChatItem): Promise<void>;
+declare function validateModel<V>(value: any, info: IModelValidatorsInfo<V>): IModelValidationResult<V>;
+
+declare function validate<V>(value: any, modelConstructor: IConstructor<V>): IModelValidationResult<V>;
+
+declare function modelInfo<V>(modelConstructor: IConstructor<V>): IModelValidatorsInfo<V>;
+
+interface ICommandConfig {
+    name?: string;
 }
-declare class ChatMemory implements IChatMemory {
-    findLastItems(count: number): Promise<ChatItem[]>;
-    create(item: ChatItem): Promise<void>;
+declare function command(config?: ICommandConfig): (target: IConstructor<any>) => void;
+
+declare class Command<T extends IStorableData> extends Storable<T> {
+    getData(): T;
 }
 
-interface IChatRepository {
-    create(chat: Chat): Promise<void>;
-    findByConnection(query: IChatConnection): Promise<Chat | null>;
-    findMemory(chatId: string): Promise<IChatMemory | null>;
+interface ICommandHandler<C extends Command<any>> {
+    handle(command: C): void | Promise<void>;
 }
-declare class ChatRepository implements IChatRepository {
-    create(chat: Chat): Promise<void>;
-    findByConnection(query: IChatConnection): Promise<Chat | null>;
-    findMemory(chatId: string): Promise<IChatMemory | null>;
+
+interface ICommandHandlerConfig<C extends Command<any>> {
+    command: IConstructor<C>;
+}
+declare function commandHandler<C extends Command<any>>(config: ICommandHandlerConfig<C>): (target: IConstructor<ICommandHandler<C>>) => void;
+
+declare class CommandMetadataStore {
+    private handlersMap;
+    private handlersInverseMap;
+    private commandsMap;
+    private commandsInverseMap;
+    registerCommand(command: IConstructor<Command<any>>, commandName: string): void;
+    registerHandler(command: IConstructor<Command<any>>, handlerConstructor: IConstructor<ICommandHandler<any>>): void;
+    getHandlerForCommandName(commandName: string): IConstructor<ICommandHandler<any>> | null;
+    getCommandNameForHandler(handlerConstructor: IConstructor<ICommandHandler<any>>): string | null;
+    getCommandName(command: IConstructor<Command<any>>): string | null;
+    getCommandForCommandName(commandName: string): IConstructor<Command<any>> | null;
 }
 
-interface IUserRepository {
-    create(chat: User): Promise<void>;
-    update(chat: User): Promise<void>;
-    findByConnection(query: IUserConnection): Promise<User | null>;
+interface IJobData extends IEntityData {
+    commandName: string;
+    commandData: any;
+    startedAt?: number;
+    successAt?: number;
+    failedAt?: number;
+    error?: {
+        message: string;
+        stack?: string;
+        info?: any;
+    };
 }
-declare class UserRepository implements IUserRepository {
-    create(chat: User): Promise<void>;
-    update(chat: User): Promise<void>;
-    findByConnection(query: IUserConnection): Promise<User | null>;
+declare class Job extends Entity<IJobData> {
+    get commandName(): string;
+    setAsStarted(): void;
+    setAsSuccess(): void;
+    setAsFailed(error: Error): void;
 }
 
-interface IMessageContext {
-    message: IConnectionChatMessage;
-    chat: Chat;
-    user: User | null;
+interface IJobRepository extends ICrudRepository<Job> {
 }
-declare class MessageContext implements IMessageContext {
-    message: IConnectionChatMessage;
-    chat: Chat;
-    user: User | null;
-    constructor(message: IConnectionChatMessage, chat: Chat, user: User | null);
+
+declare class JobRepository implements IJobRepository {
+    find(id: string): Promise<Job | null>;
+    findOrThrow(id: string): Promise<Job>;
+    findByIds(ids: string[]): Promise<Job[]>;
+    findAll(id: string): Promise<Job[]>;
+    create(item: Job): Promise<void>;
+    update(item: Job): Promise<void>;
+    discard(item: Job): Promise<void>;
 }
 
-interface IReversibleMapper<T1, T2> {
-    map(input: T1): T2;
-    rev(input: T2): T1;
+interface IJobEvent extends IStorableData {
+    jobId: string;
+    type: 'created';
+}
+type IJobEventListener = (event: IJobEvent) => void | Promise<void>;
+declare class JobsEventsHub {
+    private jobsEventsListener;
+    notifyJobCreated(job: Job): void;
+    listenJobsEvents(listener: IJobEventListener): void;
 }
 
-type IConstructor<T> = new (...args: any[]) => T;
+declare class Async {
+    private jobRepository;
+    private handlerContainer;
+    private jobsEventsHub;
+    constructor(jobRepository: JobRepository, handlerContainer: CommandMetadataStore, jobsEventsHub: JobsEventsHub);
+    run<T extends IStorableData>(command: Command<T>): Promise<Job>;
+}
+
+declare class JobRunner {
+    private jobRepository;
+    private handlerContainer;
+    constructor(jobRepository: JobRepository, handlerContainer: CommandMetadataStore);
+    run(job: Job): Promise<void>;
+}
+
+declare function runAsyncCommandHandlers(handlers: IConstructor<ICommandHandler<any>>[]): void;
+
+interface IChatConnection extends IStorableData {
+    channelName: string;
+    id: string;
+}
+
+type IChatType = 'PRIVATE' | 'GROUP';
+
+interface IChatData extends IEntityData {
+    type: IChatType;
+    connections: IChatConnection[];
+}
+declare class Chat extends Entity<IChatData> {
+    constructor(data: IChatData);
+    isPrivate(): boolean;
+    isGroup(): boolean;
+    hasConnection(connection: IChatConnection): boolean;
+    private validatePrivateChat;
+    private validateGroupChat;
+    validate(): void;
+}
+
+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;
+}
 
 interface IMindsetIdentity {
     name: string;
@@ -226,8 +410,6 @@ interface IMindsetModuleDecoration {
     decorationConfig: any;
 }
 
-declare function isOptional(): PropertyDecorator;
-
 interface IParamConfig {
     name?: string;
     optional?: boolean;
@@ -285,26 +467,17 @@ declare class MindsetMetadataStore {
     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;
+interface IMindsetToolParameter {
+    type: string;
+    name: string;
+    description: string;
+}
+interface IMindsetTool {
+    language: string;
+    name: string;
+    description: string;
+    parameters: IMindsetToolParameter[];
 }
-
-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;
@@ -314,45 +487,82 @@ declare class MindsetOperator implements IMindset {
     identity(): Promise<IMindsetIdentity>;
     skills(): Promise<string>;
     limits(): Promise<string>;
+    systemPrompt(): Promise<string>;
+    tools(): IMindsetTool[];
+    protected tool(fn: IMindsetFunctionMetadata, module: IMindsetModuleMetadata): IMindsetTool;
+    protected toolParameter(param: IMindsetFunctionParamMetadata): IMindsetToolParameter;
     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 IChatMessage extends IStorableData {
+    senderId?: string;
+    senderName?: string;
+    text?: string;
+}
 
-interface IChatBotMetadata {
-    constructor: IConstructor<any>;
-    mindsetConstructor: IConstructor<IMindset>;
-    injectionToken: string;
+interface IFunctionCall extends IStorableData {
+    id: string;
+    name: string;
+    arguments?: string;
+    result?: string;
 }
 
-declare class ChatBotMetadataStore {
-    private chatBots;
-    saveChatBotMetadata(chatBot: IChatBotMetadata): void;
-    getChatBotsMetadata(): IChatBotMetadata[];
+declare const chatItemTypeOptions: readonly ["botMessage", "humanMessage", "functionCall"];
+type IBotMessageItem = {
+    type: 'botMessage';
+    botMessage: IChatMessage;
+};
+type IHumanMessageItem = {
+    type: 'humanMessage';
+    humanMessage: IChatMessage;
+};
+type IFunctionCallItem = {
+    type: 'functionCall';
+    functionCall: IFunctionCall;
+};
+type IChatItem = IBotMessageItem | IHumanMessageItem | IFunctionCallItem;
+type IChatItemType = (typeof chatItemTypeOptions)[number];
+
+interface ILanguageModelUsage {
+    inputTokens: number;
+    outputTokens: number;
+}
+
+interface IChatAdapterNextItemReq {
+    model: string;
+    systemPrompt: string;
+    tools: IMindsetTool[];
+    prevItems: IChatItem[];
+}
+interface IChatAdapterNextItemRes {
+    chatItem: IChatItem;
+    usage: ILanguageModelUsage;
+}
+interface IChatAdapter {
+    nextItem(req: IChatAdapterNextItemReq): Promise<IChatAdapterNextItemRes>;
 }
 
-interface IChatBotAdapter {
-    generateNextChatItem(chatItems: ChatItem[]): Promise<ChatItem>;
+declare class ChatAdapter implements IChatAdapter {
+    nextItem(req: IChatAdapterNextItemReq): Promise<IChatAdapterNextItemRes>;
+}
+
+type IChatItemData = IEntityData & IChatItem;
+declare class ChatItem extends Entity<IChatItemData> {
+    get type(): "botMessage" | "humanMessage" | "functionCall";
+    get botMessage(): IChatMessage;
+    get functionCall(): IFunctionCall;
+    setFunctionResult(result: string): void;
+    getData(): IChatItemData;
+}
+
+interface IChatMemory {
+    findLastItems(count: number): Promise<ChatItem[]>;
+    create(item: ChatItem): Promise<void>;
 }
-declare class ChatBotAdapter implements IChatBotAdapter {
-    protected mindset: MindsetOperator;
-    constructor(mindset: MindsetOperator);
-    generateNextChatItem(chatItems: ChatItem[]): Promise<ChatItem>;
-    protected systemPrompt(): Promise<string>;
-    protected buildBotMessageItem(text: string): Promise<ChatItem>;
-    protected buildFunctionCallItem(id: string, functionName: string, functionArguments: string): Promise<ChatItem>;
+
+declare class ChatMemory implements IChatMemory {
+    findLastItems(count: number): Promise<ChatItem[]>;
+    create(item: ChatItem): Promise<void>;
 }
 
 interface IChatBot {
@@ -362,50 +572,36 @@ interface IChatBot {
 declare class ChatBot implements IChatBot {
     private memory;
     private adapter;
-    constructor(memory: ChatMemory, adapter: ChatBotAdapter);
-    sendMessage(message: IConnectionChatMessage, callback: (message: IChatMessage) => void): Promise<void>;
+    private mindset;
+    constructor(memory: ChatMemory, adapter: ChatAdapter, mindset: MindsetOperator);
+    sendMessage(message: IChatMessage, callback: (message: IChatMessage) => void): Promise<void>;
     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;
+interface IChatRepository {
+    create(chat: Chat): Promise<void>;
+    findByConnection(query: IChatConnection): Promise<Chat | null>;
+    findMemory(chatId: string): Promise<IChatMemory | null>;
 }
 
-declare class OpenaiChatBotAdapter extends ChatBotAdapter {
-    private openai;
-    private model;
-    constructor(mindset: MindsetOperator);
-    generateNextChatItem(chatItems: ChatItem[]): Promise<ChatItem>;
-    private mapChatItems;
+declare class ChatRepository implements IChatRepository {
+    create(chat: Chat): Promise<void>;
+    findByConnection(query: IChatConnection): Promise<Chat | null>;
+    findMemory(chatId: string): Promise<IChatMemory | null>;
 }
 
-declare function cmd(): (target: object, propertyKey: string | symbol) => void;
-
-declare class ChatResolver {
-    private chatRepository;
-    constructor(chatRepository: ChatRepository);
-    resolve(connection: IChatConnection): Promise<Chat>;
-    private resolveGroupChat;
-    private resolvePrivateChat;
-}
+declare function chatBot(mindset: IConstructor<IMindset>): (target: object, propertyKey: string | symbol | undefined, parameterIndex: number) => void;
 
-interface IReceivedMessage extends IMessageContext {
-    reply: (message: IChatMessage) => void;
-}
-interface IChatChannel {
-    listen(callback: (message: IReceivedMessage) => void): void;
-    connect(): void;
+interface IChatBotMetadata {
+    constructor: IConstructor<any>;
+    mindsetConstructor: IConstructor<IMindset>;
+    injectionToken: string;
 }
 
-declare class UserResolver {
-    private userRepository;
-    constructor(userRepository: UserRepository);
-    resolve(connection: IUserConnection): Promise<User | null>;
+declare class ChatBotMetadataStore {
+    private chatBots;
+    saveChatBotMetadata(chatBot: IChatBotMetadata): void;
+    getChatBotsMetadata(): IChatBotMetadata[];
 }
 
 interface IchatControllerConfig {
@@ -417,6 +613,20 @@ interface IChatControllerMetadata {
     controllerConstructor: Function;
 }
 
+interface IReceivedMessage {
+    message: IChatMessage;
+    reply: (message: IChatMessage) => void;
+}
+
+interface IChannelMessage extends IReceivedMessage {
+    chatConnection: IChatConnection;
+}
+
+interface IChatChannel {
+    listen(callback: (received: IChannelMessage) => void): void;
+    connect(): void;
+}
+
 interface IChannelMetadata {
     controllerConstructor: IConstructor<any>;
     functionName: string;
@@ -435,34 +645,280 @@ declare class ControllerMetadataStore {
     } | null;
 }
 
+declare class ChatResolver {
+    private chatRepository;
+    constructor(chatRepository: ChatRepository);
+    resolve(connection: IChatConnection): Promise<Chat>;
+    private resolveGroupChat;
+    private resolvePrivateChat;
+}
+
+interface IMessageContext extends IReceivedMessage {
+    chat: Chat;
+}
+
+declare function runChatControllers(controllers: IConstructor<any>[]): 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 IEndPointConfig {
+    path?: string;
+    disableJsonParser?: boolean;
+    disableUrlEncodedParser?: boolean;
+}
+
+declare function get(config?: string | IEndPointConfig): (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;
+
+declare function post(config?: string | IEndPointConfig): (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';
+    config?: IEndPointConfig;
+    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";
+        config?: IEndPointConfig;
+        controllerConstructor: IConstructor<any>;
+        functionName: string;
+        paramsTypes: any[];
+    }[];
+}
+
+declare function runRestControllers(controllers: IConstructor<any>[]): void;
+
+declare const EXPRESS_REQ = "EXPRESS_REQ";
+declare const EXPRESS_RES = "EXPRESS_RES";
+
+declare class SocketServerProvider {
+    private httpServerProvider;
+    private socketServer;
+    private logger;
+    constructor(httpServerProvider: HttpServerProvider);
+    getSocketServer(): Server$1;
+    listen(): void;
+    private createSocketServer;
+}
+
+interface IMoneyData extends IStorableData {
+    amount: string;
+    currency: string;
+}
+declare class Money extends Storable<IMoneyData> {
+    getData(): {
+        [key: string]: IPrimitive | IStorableData | IPrimitive[] | IStorableData[];
+        amount: string;
+        currency: string;
+    };
+    get amount(): big_js.Big;
+    get currency(): string;
+    plus(money: Money): Money;
+    minus(money: Money): Money;
+    times(value: bigint | string): Money;
+    div(value: bigint | string): Money;
+    negative(): Money;
+    isGretterThan(money: Money): boolean;
+    protected validateEqualCurrencies(left: string, right: string): void;
+    static zero(currency: string): Money;
+}
+
+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>;
+    findByIds(ids: string[]): Promise<P[]>;
+    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 PgJobRepository extends PgCrudRepository<Job> implements IJobRepository {
+    constructor(pool: Pool);
+}
+
+declare class AnthropicChatAdapter implements IChatAdapter {
+    private env;
+    private anthropic;
+    private logger;
+    constructor(env: Env);
+    nextItem(req: IChatAdapterNextItemReq): Promise<IChatAdapterNextItemRes>;
+    private mapChatItems;
+    private mapHumanMessage;
+    private mapBotMessage;
+    private mapFunctionCall;
+    private mapTool;
+    private mapResponse;
+}
+
+declare class DeepSeekChatAdapter implements IChatAdapter {
+    private deepSeek;
+    private logger;
+    constructor();
+    nextItem(req: IChatAdapterNextItemReq): Promise<IChatAdapterNextItemRes>;
+    private mapChatItems;
+    private mapHumanMessage;
+    private mapBotMessage;
+    private mapFunctionCall;
+    private mapTool;
+    private mapResponse;
+}
+
+declare class GoogleChatAdapter implements IChatAdapter {
+    private env;
+    private genai;
+    private logger;
+    constructor(env: Env);
+    nextItem(req: IChatAdapterNextItemReq): Promise<IChatAdapterNextItemRes>;
+    private buildContents;
+    private validateMessageContent;
+    private mapFunctionCall;
+    private mapTool;
+    private mapResponse;
+    private validateResponse;
+}
+
+declare class OpenaiChatAdapter implements IChatAdapter {
+    private openai;
+    private logger;
+    nextItem(req: IChatAdapterNextItemReq): Promise<IChatAdapterNextItemRes>;
+    private mapChatItems;
+    private mapConectionMessage;
+    private mapBotMessage;
+    private mapFunctionCall;
+    private mapTool;
+    private mapResponse;
+}
+
+declare class PgChatRepository extends PgCrudRepository<Chat> implements IChatRepository {
+    constructor(pool: Pool);
+    findByConnection(query: IChatConnection): Promise<Chat | null>;
+    findMemory(chatId: string): Promise<IChatMemory | null>;
+}
+
+declare class PgChatMemory extends PgCrudRepository<ChatItem> implements IChatMemory {
+    private chatId;
+    constructor(pool: Pool, chatId: string);
+    findLastItems(count: number): Promise<ChatItem[]>;
+}
+
+declare class RamChatMemory implements IChatMemory {
+    private memory;
+    findLastItems(count: number): Promise<ChatItem[]>;
+    create(item: ChatItem): Promise<void>;
+    clearMemory(): Promise<void>;
+}
+
+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;
+}
+
+declare function cmd(): (target: object, propertyKey: string | symbol) => void;
+
 declare class CmdChannel implements IChatChannel {
-    private chatResolver;
-    private userResolver;
     private rl;
     private callBack;
-    constructor(chatResolver: ChatResolver, userResolver: UserResolver);
-    listen(callback: (message: IReceivedMessage) => void): void;
+    listen(callback: (message: IChannelMessage) => void): void;
     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;
 }
@@ -474,16 +930,6 @@ declare class SocketChannelConfig implements ISocketChannelConfig {
 
 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;
@@ -493,12 +939,10 @@ interface ISocketChannelReceivedMessage {
 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;
+    constructor(config: SocketChannelConfig, socketServerProvider: SocketServerProvider);
+    listen(callback: (message: IChannelMessage) => void): void;
     connect(): void;
 }
 
@@ -514,11 +958,9 @@ declare function telegram(config: ITelegramChannelConfig): (target: object, prop
 
 declare class TelegramChannel implements IChatChannel {
     private config;
-    private chatResolver;
-    private userResolver;
     private bot;
-    constructor(config: TelegramChannelConfig, chatResolver: ChatResolver, userResolver: UserResolver);
-    listen(callback: (message: IReceivedMessage) => void): void;
+    constructor(config: TelegramChannelConfig);
+    listen(callback: (message: IChannelMessage) => void): void;
     connect(): void;
 }
 
@@ -533,9 +975,49 @@ 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>;
+}
+
+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: {
@@ -555,6 +1037,32 @@ interface IWhatsAppTemplateMessage {
     parameters: IWhatsAppTemplateParameter[];
 }
 
+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 {
     object: 'whatsapp_business_account';
     entry: IEntry[];
@@ -607,45 +1115,13 @@ interface IAudioMessage extends IBaseMessage {
     };
 }
 
-interface IWhatsAppBusinessNumber {
-    id: string;
-    number: string;
-}
-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 {
-    private debuggers;
-    constructor(name: string);
-    trace(...args: any[]): void;
-    debug(...args: any[]): void;
-    info(...args: any[]): void;
-    warn(...args: any[]): void;
-    error(...args: any[]): void;
-    fatal(...args: any[]): void;
-    private log;
+declare class PgWhatsAppRepository extends PgCrudRepository<WhatsApp> implements IWhatsAppRepository {
+    constructor(pool: Pool);
+    findBySlug(slug: string): Promise<WhatsApp | null>;
+    findByBusinessNumber(number: string): Promise<WhatsApp | null>;
 }
 
-type IWhatsAppMessageListener = (message: IConnectionChatMessage) => Promise<void>;
+type IWhatsAppMessageListener = (message: Omit<IChannelMessage, 'reply'>) => Promise<void>;
 interface IListenWhatsAppMessageRequest {
     to: string;
     listener: IWhatsAppMessageListener;
@@ -660,31 +1136,11 @@ declare abstract class WhatsAppReceiver {
     private emmitMessage;
 }
 
-interface IWhatsAppRepository {
-    findBySlug(slug: string): Promise<WhatsApp | null>;
-    findByBusinessNumber(number: string): Promise<WhatsApp | null>;
-}
-
 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;
@@ -704,31 +1160,30 @@ interface IGetWhatsAppTemplateRequest {
 interface IWhatsAppSenderOptions {
     writeChatMemory?: boolean;
 }
-declare abstract class WhatsAppSender {
+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 abstract handleSendRequest(request: ISendWhatsAppRequest): Promise<void>;
-    protected abstract handleSendTemplateRequest(request: ISendWhatsAppTemplateRequest): Promise<void>;
-    protected abstract handleGetWhatsAppTemplate(request: IGetWhatsAppTemplateRequest): Promise<IWhatsAppTemplate | null>;
+    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 class WhatsAppChannel implements IChatChannel {
     private config;
-    private chatResolver;
-    private userResolver;
     private sender;
     private receiver;
     private logger;
-    constructor(config: WhatsappChannelConfig, chatResolver: ChatResolver, userResolver: UserResolver, sender: WhatsAppSender, receiver: WhatsAppReceiver);
-    listen(callback: (message: IReceivedMessage) => void): void;
+    constructor(config: WhatsappChannelConfig, sender: WhatsAppSender, receiver: WhatsAppReceiver);
+    listen(callback: (message: IChannelMessage) => void): void;
     connect(): void;
 }
 
@@ -757,216 +1212,126 @@ declare class WhatsAppReceiverByWebHook extends WhatsAppReceiver {
     connect(): Promise<void>;
 }
 
-declare class WhatsAppSenderByDevConnection extends WhatsAppSender {
-    private wabotDevConnection;
-    constructor(wabotDevConnection: WabotDevConnection, chatRepository: ChatRepository, chatResolver: ChatResolver, whatsAppRepository: WhatsAppRepository);
+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 WhatsAppSenderByCloudApi extends WhatsAppSender {
-    constructor(chatRepository: ChatRepository, chatResolver: ChatResolver, whatsAppRepository: WhatsAppRepository);
+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 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 function jwtGuard(): (target: object, propertyKey: string | symbol) => 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>;
+declare class JwtTokenDto {
+    token?: string;
+    expiration?: Date;
 }
 
-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 JwtAccessAndRefreshTokenDto {
+    access?: JwtTokenDto;
+    refresh?: JwtTokenDto;
 }
 
-type IWabotEnvType = 'development' | 'staging' | 'testing' | 'production';
-declare class WabotEnv {
-    private envType;
-    constructor();
-    isDevelopment(): boolean;
-    isProduction(): boolean;
-    requireString(varName: string): string;
+declare class JwtConfig {
+    secretOrPublicKey: string;
+    secretOrPrivateKey: string;
+    algorithm: Algorithm;
+    accessExpirationSeconds: number;
+    refreshExpirationSeconds: number;
+    constructor(env: Env);
 }
 
-declare class EnvWhatsAppRepository implements IWhatsAppRepository {
-    private env;
-    constructor(env: WabotEnv);
-    findBySlug(slug: string): Promise<WhatsApp | null>;
-    findByBusinessNumber(number: string): Promise<WhatsApp | null>;
-    private getFromEnvVars;
+interface IJwtRefreshTokenData<A extends IStorableData> extends IEntityData {
+    authInfo: A;
 }
-
-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 class JwtRefreshToken<A extends IStorableData> extends Entity<IJwtRefreshTokenData<A>> {
+    get authInfo(): A;
 }
-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 class JwtSigner {
+    private config;
+    private mapper;
+    constructor(config: JwtConfig, mapper: Mapper);
+    signAccessToken<D extends IStorableData>(info: D | JwtRefreshToken<any>): Promise<JwtTokenDto>;
+    signRefreshToken(refreshToken: JwtRefreshToken<any>): Promise<JwtTokenDto>;
+    signAccessAndRefreshToken(refreshToken: JwtRefreshToken<any>): Promise<JwtAccessAndRefreshTokenDto>;
 }
-declare function runServer(config: IServerConfig): void;
 
-declare class SendOneTimePasswordRequest {
-    fromEmail: string;
-    toEmail: string;
+declare class JwtRefreshTokenRepository<D extends IStorableData> extends PgCrudRepository<JwtRefreshToken<D>> {
+    constructor(pool: Pool);
 }
 
-declare class ValidateOneTimePasswordRequest {
-    userEmail: string;
-    otp: string;
+declare class Jwt {
+    private auth;
+    private jwtSigner;
+    private jwtRefreshTokenRepository;
+    constructor(auth: Auth<any>, jwtSigner: JwtSigner, jwtRefreshTokenRepository: JwtRefreshTokenRepository<any>);
+    createToken(): Promise<JwtAccessAndRefreshTokenDto>;
 }
 
-interface ISendEmailRequest {
-    from: string;
-    to: string;
-    subject: string;
-    html: string;
-}
-interface IEmailService {
-    sendEmail(request: ISendEmailRequest): Promise<void>;
-}
-declare class EmailService implements IEmailService {
-    sendEmail(request: ISendEmailRequest): Promise<void>;
+declare class JwtGuardMiddleware implements IMiddleware {
+    private config;
+    private auth;
+    constructor(config: JwtConfig, auth: Auth<any>);
+    handle(req: Request, res: Response, container: DependencyContainer$1): Promise<void>;
 }
 
-interface IOtpService {
-    generate(): Promise<string>;
-}
-declare class OtpService implements IOtpService {
-    generate(): Promise<string>;
-}
+declare function isBoolean(): (target: object, propertyKey: string | symbol) => void;
 
-declare class AuthenticationModule {
-    private userRepository;
-    private emailService;
-    private otpService;
-    private context;
-    constructor(userRepository: UserRepository, emailService: EmailService, otpService: OtpService, context: MessageContext);
-    sendOneTimePassword(request: SendOneTimePasswordRequest): Promise<string>;
-    validateOneTimePassword(request: ValidateOneTimePasswordRequest): Promise<string>;
-    protected generateOtpEmailHtml(otp: string, user: User): Promise<string>;
-    protected generateOtpEmailSubject(): Promise<string>;
-}
+declare function validateIsBoolean(value: any): IValidationResult<boolean>;
 
-declare class RegisterUserWithEmailRequest {
-    email: string;
-    shortName: string;
-}
+declare function isDate(): (target: object, propertyKey: string | symbol) => void;
 
-declare class RegisterUserModule {
-    private userRepository;
-    private context;
-    constructor(userRepository: UserRepository, context: MessageContext);
-    registerUserWithEmail(request: RegisterUserWithEmailRequest): Promise<string>;
-}
+declare function validateIsDate(value: any): IValidationResult<Date>;
 
-declare class PgUserRepository extends PgCrudRepository<User> implements IUserRepository {
-    constructor(pool: Pool);
-    findByConnection(query: IUserConnection): Promise<User | null>;
-}
+declare function isNotEmpty(): (target: object, propertyKey: string | symbol) => void;
 
-declare class RamUserRepository implements IUserRepository {
-    private items;
-    create(chat: User): Promise<void>;
-    findByConnection(query: IUserConnection): Promise<User | null>;
-    update(chat: User): Promise<void>;
-}
+declare function validateIsNotEmpty(value: any): IValidationResult<any>;
 
-declare class PgChatRepository extends PgCrudRepository<Chat> implements IChatRepository {
-    constructor(pool: Pool);
-    findByConnection(query: IChatConnection): Promise<Chat | null>;
-    findMemory(chatId: string): Promise<IChatMemory | null>;
-}
+declare function isNumber(): (target: object, propertyKey: string | symbol) => void;
 
-declare class PgChatMemory extends PgCrudRepository<ChatItem> implements IChatMemory {
-    private chatId;
-    constructor(pool: Pool, chatId: string);
-    findLastItems(count: number): Promise<ChatItem[]>;
+declare function validateIsNumber(value: any): IValidationResult<number>;
+
+declare function isPresent(): (target: object, propertyKey: string | symbol) => void;
+
+declare function validateIsPresent(value: any): IValidationResult<any>;
+
+declare function isString(): (target: object, propertyKey: string | symbol) => void;
+
+declare function validateIsString(value: any): IValidationResult<string>;
+
+declare function min(limit: any): (target: object, propertyKey: string | symbol) => void;
+
+interface IValidateMinOptions {
+    limit: any;
 }
+declare function validateMin(value: any, options: IValidateMinOptions): IValidationResult<any>;
 
-declare class RamChatMemory implements IChatMemory {
-    private memory;
-    findLastItems(count: number): Promise<ChatItem[]>;
-    create(item: ChatItem): Promise<void>;
-    clearMemory(): Promise<void>;
+declare function max(limit: any): (target: object, propertyKey: string | symbol) => void;
+
+interface IValidateMaxOptions {
+    limit: any;
 }
+declare function validateMax(value: any, options: IValidateMaxOptions): IValidationResult<any>;
 
-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;
+declare class MoneyDto {
+    amount: string;
+    currency: string;
 }
 
-export { AuthenticationModule, Chat, ChatBot, ChatBotAdapter, ChatBotMetadataStore, ChatItem, ChatMemory, ChatRepository, ChatResolver, CmdChannel, Container, ControllerMetadataStore, DeepSeekChatBotAdapter, EmailService, EnvWhatsAppRepository, ExpressProvider, 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 IGetWhatsAppTemplateRequest, 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 IOtpService, type IParamConfig, type IParamDecoration, type IPersistentData, type IPgRepositoryConfig, type IReceivedMessage, type IReceivedMessageItem, 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 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, SendOneTimePasswordRequest, SocketChannel, SocketChannelConfig, SocketServerProvider, TelegramChannel, TelegramChannelConfig, User, UserRepository, UserResolver, ValidateOneTimePasswordRequest, WabotEnv, WhatsApp, WhatsAppChannel, WhatsAppReceiver, WhatsAppReceiverByDevConnection, WhatsAppReceiverByWebHook, WhatsAppRepository, WhatsAppSender, WhatsAppSenderByCloudApi, WhatsAppSenderByDevConnection, WhatsappChannelConfig, chatBot, chatController, cmd, container, inject, injectable, isOptional, mindset, mindsetFunction, mindsetModule, param, prepareChatContainer, runChannel, runServer, singleton, socket, telegram, whatsapp };
+export { AnthropicChatAdapter, Async, Auth, Chat, ChatAdapter, ChatBot, ChatBotMetadataStore, ChatItem, ChatMemory, ChatRepository, ChatResolver, CmdChannel, Command, CommandMetadataStore, Container, ControllerMetadataStore, CustomError, DeepSeekChatAdapter, EXPRESS_REQ, EXPRESS_RES, Entity, Env, EnvWhatsAppRepository, ExpressProvider, GoogleChatAdapter, HtmlModule, HttpServerProvider, type IArrayValidationError, type IArrayValidationResult, type IBotMessageItem, type IChannelMessage, type IChannelMetadata, type IChatAdapter, type IChatAdapterNextItemReq, type IChatAdapterNextItemRes, type IChatBot, type IChatBotMetadata, type IChatChannel, type IChatConnection, type IChatControllerMetadata, type IChatData, type IChatItem, type IChatItemData, type IChatItemType, type IChatMemory, type IChatMessage, type IChatRepository, type IChatType, type ICommandConfig, type ICommandHandler, type ICommandHandlerConfig, type IConstructor, type ICrudRepository, type ICustomErrorData, type IEndPointConfig, type IEndPointMetadata, type IEntityData, type IEnvType, type IFunctionCall, type IFunctionCallItem, type IGetWhatsAppTemplateRequest, type IHtmlModuleOptions, type IHumanMessageItem, type IJobData, type IJobEvent, type IJobEventListener, type IJobRepository, type IJwtRefreshTokenData, type ILanguageModelUsage, 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 IMindsetTool, type IMindsetToolParameter, type IModelValidationError, type IModelValidationResult, type IModelValidatorsInfo, type IMoneyData, type IParamConfig, type IParamDecoration, type IPersistentData, type IPgRepositoryConfig, type IPrimitive, type IPropertyValidatorInfo, type IReceivedMessage, type IRestControllerConfig, type IRestControllerMetadata, type ISendWhatsAppRequest, type ISendWhatsAppTemplateRequest, type ISocketChannelConfig, type ISocketChannelReceivedMessage, type IStorableData, type ITelegramChannelConfig, type IValidateArrayOptions, type IValidateArrayOptionsWithItemsValidators, 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, Job, JobRepository, JobRunner, JobsEventsHub, Jwt, JwtAccessAndRefreshTokenDto, JwtConfig, JwtGuardMiddleware, JwtRefreshToken, JwtRefreshTokenRepository, JwtSigner, JwtTokenDto, Lifecycle, Logger, MINDSET_DECORATION_MINDSET, MINDSET_FUNCTION_DECORATION_FUNCTION, MINDSET_MODULE_DECORATION_MODULE, Mapper, Mindset, MindsetMetadataStore, MindsetOperator, Money, MoneyDto, OpenaiChatAdapter, PARAM_DECORATION_IS_OPTIONAL, PARAM_DECORATION_PARAM, Persistent, PgChatMemory, PgChatRepository, PgCrudRepository, PgJobRepository, PgRepositoryBase, PgWhatsAppRepository, RamChatMemory, RamChatRepository, Random, RestControllerMetadataStore, SocketChannel, SocketChannelConfig, SocketServerProvider, Storable, TelegramChannel, TelegramChannelConfig, ValidationMetadataStore, WhatsApp, WhatsAppChannel, WhatsAppReceiver, WhatsAppReceiverByDevConnection, WhatsAppReceiverByWebHook, WhatsAppRepository, WhatsAppSender, WhatsAppSenderByCloudApi, WhatsAppSenderByDevConnection, WhatsappChannelConfig, chatBot, chatController, chatItemTypeOptions, cmd, command, commandHandler, container, get, inject, injectable, isArray, isBoolean, isDate, isModel, isNotEmpty, isNumber, isOptional, isPresent, isString, jwtGuard, max, middleware, min, mindset, mindsetFunction, mindsetModule, modelInfo, param, post, restController, runAsyncCommandHandlers, runChatControllers, runRestControllers, scoped, singleton, socket, telegram, validate, validateArray, validateIsBoolean, validateIsDate, validateIsNotEmpty, validateIsNumber, validateIsPresent, validateIsString, validateMax, validateMin, validateModel, whatsapp };