@wabot-dev/framework 0.1.0-beta.6 → 0.1.0-beta.61

package/dist/src/index.d.ts

@@ -1,183 +1,434 @@
+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 { Server as Server$1 } from 'socket.io';
-import { Socket } from 'socket.io-client';
+import { Express, Request, Response } from 'express';
+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 { Server as Server$1, Socket } from 'socket.io';
+import { Algorithm } from 'jsonwebtoken';
+import { Socket as Socket$1 } from 'socket.io-client';
 
-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;
 }
-
-type IChatType = 'PRIVATE' | 'GROUP';
-interface IChatConnection {
-    chatType: IChatType;
-    channelName: string;
-    id: string;
+/**
+ * @deprecated Should use IEntityData
+ */
+interface IPersistentData extends IEntityData {
 }
-interface IChatData extends IPersistentData {
-    type: IChatType;
-    connections: IChatConnection[];
+/**
+ * @deprecated Should use Entity
+ */
+declare class Persistent<D extends IPersistentData> extends Entity<D> {
 }
-declare class Chat extends Persistent<IChatData> {
-    constructor(data: IChatData);
-    isPrivate(): boolean;
-    isGroup(): boolean;
-    hasConnection(connection: IChatConnection): boolean;
-    private validatePrivateChat;
-    private validateGroupChat;
-    validate(): void;
+
+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 IChatDocument {
+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;
 }
 
-interface IChatImage {
+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 IUserConnection {
-    channelName: string;
-    id: string;
+declare class Mapper {
+    map<T>(data: any, ctor: IConstructor<T>): T;
 }
-interface IUserData extends IPersistentData {
-    shortName: string;
-    connections: IUserConnection[];
-    keyValueData: {
-        [key: string]: string;
-    };
+
+interface PasswordHashOptions {
+    password: string;
+    saltLength?: number;
+    keyLength?: number;
 }
-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;
+declare class Password {
+    static hash(options: PasswordHashOptions): string;
+    static isValid(req: {
+        password: string;
+        hash: string;
+    }): boolean;
+    static generate(length: number): string;
 }
 
-interface IChatMessage {
-    text?: string;
-    documents?: IChatDocument[];
-    images?: IChatImage[];
-    senderName: string;
-}
-interface IConnectionChatMessage extends IChatMessage {
-    chatConnection: IChatConnection;
-    userConnection: IUserConnection;
-    userId?: string;
+declare class Random {
+    static integer(options: {
+        min: number;
+        max: number;
+    }): number;
+    static slug(name: string, options: {
+        randomLength: number;
+    }): string;
+    static alphaNumeric(length: number): string;
+    static alphaNumericLowerCase(length: number): string;
+    static numberCode(length: number): string;
 }
 
-interface IChatFunctionCall {
-    id: string;
-    name: string;
-    arguments?: string;
-    result: 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>;
+    delete(item: T): Promise<void>;
 }
 
-type ISystemMessageItem = {
-    type: 'BOT_MESSAGE';
-    content: IChatMessage;
+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 IModelValidationError extends IValidationError {
+    properties: {
+        [key: string]: string[];
+    };
+}
+interface IArrayValidationError extends IValidationError {
+    items: (IValidationError[] | null)[];
+}
+type IValidationResult<V> = {
+    value: V;
+    error?: undefined;
+} | {
+    value?: undefined;
+    error: IValidationError;
 };
-type IReceivedMessageItem = {
-    type: 'CONNECTION_MESSAGE';
-    content: IConnectionChatMessage;
+type IModelValidationResult<V> = {
+    value: V;
+    error?: undefined;
+} | {
+    value?: undefined;
+    error: IModelValidationError;
 };
-type ISystemFunctionCallItem = {
-    type: 'FUNCTION_CALL';
-    content: IChatFunctionCall;
+type IArrayValidationResult<V> = {
+    value: V[];
+    error?: undefined;
+} | {
+    value?: undefined;
+    error: IArrayValidationError;
 };
-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;
+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 IValidateArrayOptions {
+    minLength?: number;
+    maxLength?: number;
+}
+interface IValidateArrayOptionsWithItemsValidators extends IValidateArrayOptions {
+    itemsValidator?: {
+        validator: IValidator;
+        options: any;
+    }[];
 }
+declare function validateArray(value: any, options?: IValidateArrayOptionsWithItemsValidators): IArrayValidationResult<any>;
 
-interface IChatMemory {
-    findLastItems(count: number): Promise<ChatItem[]>;
-    create(item: ChatItem): Promise<void>;
+declare function isArray(options?: IValidateArrayOptions): (target: object, propertyKey: string | symbol) => void;
+
+interface IValidatorMetadata {
+    modelConstructor: IConstructor<any>;
+    propertyName: string;
+    validator: IValidator;
+    validatorOptions?: any;
 }
-declare class ChatMemory implements IChatMemory {
-    findLastItems(count: number): Promise<ChatItem[]>;
-    create(item: ChatItem): Promise<void>;
+
+declare class ValidationMetadataStore {
+    private validators;
+    saveValidatorMetadata(validatorMetadata: IValidatorMetadata): void;
+    getModelValidatorsInfo<V>(modelConstructor: IConstructor<V>): IModelValidatorsInfo<V>;
+    private getConstructorPropertiesValidatorsInfo;
 }
 
-interface IChatRepository {
-    create(chat: Chat): Promise<void>;
-    findByConnection(query: IChatConnection): Promise<Chat | null>;
-    findMemory(chatId: string): Promise<IChatMemory | null>;
+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>;
+
+declare function isBoolean(): (target: object, propertyKey: string | symbol) => void;
+
+declare function validateIsBoolean(value: any): IValidationResult<boolean>;
+
+declare function isDate(): (target: object, propertyKey: string | symbol) => void;
+
+declare function validateIsDate(value: any): IValidationResult<Date>;
+
+interface IValidateIsInOptions {
+    values: (number | string | boolean | null)[];
 }
-declare class ChatRepository implements IChatRepository {
-    create(chat: Chat): Promise<void>;
-    findByConnection(query: IChatConnection): Promise<Chat | null>;
-    findMemory(chatId: string): Promise<IChatMemory | null>;
+declare function validateIsIn(value: any, options: IValidateIsInOptions): IValidationResult<any>;
+
+declare function isIn(values: IValidateIsInOptions['values']): (target: object, propertyKey: string | symbol) => void;
+
+declare function isNotEmpty(): (target: object, propertyKey: string | symbol) => void;
+
+declare function validateIsNotEmpty(value: any): IValidationResult<any>;
+
+declare function isNumber(): (target: object, propertyKey: string | symbol) => void;
+
+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 max(limit: any): (target: object, propertyKey: string | symbol) => void;
+
+interface IValidateMaxOptions {
+    limit: any;
 }
+declare function validateMax(value: any, options: IValidateMaxOptions): IValidationResult<any>;
 
-interface IUserRepository {
-    create(chat: User): Promise<void>;
-    update(chat: User): Promise<void>;
-    findByConnection(query: IUserConnection): Promise<User | null>;
+declare function min(limit: any): (target: object, propertyKey: string | symbol) => void;
+
+interface IValidateMinOptions {
+    limit: any;
 }
-declare class UserRepository implements IUserRepository {
-    create(chat: User): Promise<void>;
-    update(chat: User): Promise<void>;
-    findByConnection(query: IUserConnection): Promise<User | null>;
+declare function validateMin(value: any, options: IValidateMinOptions): IValidationResult<any>;
+
+interface ICommandConfig {
+    name?: string;
 }
+declare function command(config?: ICommandConfig): (target: IConstructor<any>) => void;
 
-interface IMessageContext {
-    message: IConnectionChatMessage;
-    chat: Chat;
-    user: User | null;
+declare class Command<T extends IStorableData> extends Storable<T> {
+    getData(): T;
 }
-declare class MessageContext implements IMessageContext {
-    message: IConnectionChatMessage;
-    chat: Chat;
-    user: User | null;
-    constructor(message: IConnectionChatMessage, chat: Chat, user: User | null);
+
+interface ICommandHandler<C extends Command<any>> {
+    handle(command: C): void | Promise<void>;
 }
 
-interface IReversibleMapper<T1, T2> {
-    map(input: T1): T2;
-    rev(input: T2): T1;
+interface ICommandHandlerConfig<C extends Command<any>> {
+    command: IConstructor<C>;
 }
+declare function commandHandler<C extends Command<any>>(config: ICommandHandlerConfig<C>): (target: IConstructor<ICommandHandler<C>>) => void;
 
-type IConstructor<T> = new (...args: any[]) => T;
+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 IJobData extends IEntityData {
+    commandName: string;
+    commandData: any;
+    startedAt?: number;
+    successAt?: number;
+    failedAt?: number;
+    retryAt?: number;
+    error?: {
+        message: string;
+        stack?: string;
+        info?: any;
+    };
+}
+declare class Job extends Entity<IJobData> {
+    get commandName(): string;
+    hasFinished(): boolean;
+    setAsStarted(): void;
+    setAsSuccess(): void;
+    setAsFailed(error: Error): void;
+}
+
+interface IJobRepository extends ICrudRepository<Job> {
+}
+
+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>;
+    delete(item: Job): Promise<void>;
+}
+
+interface IJobEvent extends IStorableData {
+    jobId: string;
+    type: 'created';
+}
+type IJobEventListener = (event: IJobEvent) => void | Promise<void>;
+declare class JobsEventsHub {
+    private logger;
+    private jobsEventsListener;
+    notifyJobCreated(job: Job): void;
+    listenJobsEvents(listener: IJobEventListener): void;
+}
+
+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;
+    private logger;
+    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;
@@ -186,15 +437,21 @@ interface IMindsetIdentity {
     personality?: string;
     emotions?: string;
 }
+interface IMindsetLlm {
+    provider?: string;
+    model: string;
+}
 interface IMindset {
     identity(): Promise<IMindsetIdentity>;
     skills(): Promise<string>;
     limits(): Promise<string>;
+    llms(): Promise<IMindsetLlm[]>;
 }
 declare class Mindset implements IMindset {
     identity(): Promise<IMindsetIdentity>;
     skills(): Promise<string>;
     limits(): Promise<string>;
+    llms(): Promise<IMindsetLlm[]>;
 }
 
 interface IMindsetConfig {
@@ -226,8 +483,6 @@ interface IMindsetModuleDecoration {
     decorationConfig: any;
 }
 
-declare function isOptional(): PropertyDecorator;
-
 interface IParamConfig {
     name?: string;
     optional?: boolean;
@@ -285,26 +540,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,99 +560,124 @@ declare class MindsetOperator implements IMindset {
     identity(): Promise<IMindsetIdentity>;
     skills(): Promise<string>;
     limits(): Promise<string>;
+    llms(): Promise<IMindsetLlm[]>;
+    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 IChatBotAdapter {
-    generateNextChatItem(chatItems: ChatItem[]): Promise<ChatItem>;
+interface IChatAdapterNextItemReq {
+    model: string;
+    systemPrompt: string;
+    tools: IMindsetTool[];
+    prevItems: IChatItem[];
 }
-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>;
+interface IChatAdapterNextItemRes {
+    chatItem: IChatItem;
+    usage: ILanguageModelUsage;
 }
-
-interface IChatBot {
-    sendMessage(message: IChatMessage, callback: (message: IChatMessage) => void): void | Promise<void>;
+interface IChatAdapter {
+    nextItem(req: IChatAdapterNextItemReq): Promise<IChatAdapterNextItemRes>;
 }
 
-declare class ChatBot implements IChatBot {
-    private memory;
-    private adapter;
-    constructor(memory: ChatMemory, adapter: ChatBotAdapter);
-    sendMessage(message: IConnectionChatMessage, callback: (message: IChatMessage) => void): Promise<void>;
-    protected processLoop(callback: (message: IChatMessage) => void): Promise<void>;
+declare class ChatAdapter implements IChatAdapter {
+    nextItem(req: IChatAdapterNextItemReq & {
+        provider?: string;
+    }): Promise<IChatAdapterNextItemRes>;
 }
 
-declare class DeepSeekChatBotAdapter extends ChatBotAdapter {
-    private deepSeek;
-    private model;
-    constructor(mindset: MindsetOperator);
-    validateEnvVariables(envVariables: (string | undefined)[]): void;
-    generateNextChatItem(chatItems: ChatItem[]): Promise<ChatItem>;
-    private mapChatItems;
+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;
 }
 
-declare class OpenaiChatBotAdapter extends ChatBotAdapter {
-    private openai;
-    private model;
-    private logger;
-    constructor(mindset: MindsetOperator);
-    generateNextChatItem(chatItems: ChatItem[]): Promise<ChatItem>;
-    private mapChatItems;
+interface IChatMemory {
+    findLastItems(count: number): Promise<ChatItem[]>;
+    create(item: ChatItem): Promise<void>;
 }
 
-declare function cmd(): (target: object, propertyKey: string | symbol) => void;
+declare class ChatMemory implements IChatMemory {
+    findLastItems(count: number): Promise<ChatItem[]>;
+    create(item: ChatItem): Promise<void>;
+}
 
-declare class ChatResolver {
-    private chatRepository;
-    constructor(chatRepository: ChatRepository);
-    resolve(connection: IChatConnection): Promise<Chat>;
-    private resolveGroupChat;
-    private resolvePrivateChat;
+interface IChatBot {
+    sendMessage(message: IChatMessage, callback: (message: IChatMessage) => void): void | Promise<void>;
 }
 
-interface IReceivedMessage extends IMessageContext {
-    reply: (message: IChatMessage) => void;
+declare class ChatBot implements IChatBot {
+    private memory;
+    private adapter;
+    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>;
 }
-interface IChatChannel {
-    listen(callback: (message: IReceivedMessage) => void): void;
-    connect(): void;
+
+interface IChatRepository {
+    create(chat: Chat): Promise<void>;
+    findByConnection(query: IChatConnection): Promise<Chat | null>;
+    findMemory(chatId: string): Promise<IChatMemory | null>;
+}
+
+declare class ChatRepository implements IChatRepository {
+    create(chat: Chat): Promise<void>;
+    findByConnection(query: IChatConnection): Promise<Chat | null>;
+    findMemory(chatId: string): Promise<IChatMemory | null>;
+}
+
+declare function chatBot(mindset: IConstructor<IMindset>): (target: object, propertyKey: string | symbol | undefined, parameterIndex: number) => void;
+
+interface IChatBotMetadata {
+    constructor: IConstructor<any>;
+    mindsetConstructor: IConstructor<IMindset>;
+    injectionToken: string;
 }
 
-declare class 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 {
@@ -418,6 +689,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;
@@ -436,16 +721,20 @@ declare class ControllerMetadataStore {
     } | null;
 }
 
-declare class CmdChannel implements IChatChannel {
-    private chatResolver;
-    private userResolver;
-    private rl;
-    private callBack;
-    constructor(chatResolver: ChatResolver, userResolver: UserResolver);
-    listen(callback: (message: IReceivedMessage) => void): void;
-    connect(): void;
+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;
@@ -464,16 +753,152 @@ declare class ExpressProvider {
     private createExpress;
 }
 
-interface ISocketChannelConfig {
-    channel: string;
+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;
 }
 
-declare class SocketChannelConfig implements ISocketChannelConfig {
-    channel: string;
-    constructor(channel: string);
+declare class MoneyDto {
+    amount: string;
+    currency: string;
 }
 
-declare function socket(config: SocketChannelConfig): (target: object, propertyKey: string | symbol) => void;
+type IPgRepositoryConfig<P extends Entity<IEntityData>> = {
+    schema?: string;
+    table: string;
+    constructor: IConstructor<P>;
+    add?: {
+        columns: {
+            [column: string]: {
+                type: string;
+                value: (item: P) => boolean | number | string | null | Date;
+            };
+        };
+    };
+};
+
+declare class PgRepositoryBase<P extends Entity<IEntityData>> {
+    protected pool: Pool;
+    protected config: IPgRepositoryConfig<any>;
+    private tableIsCreated;
+    protected schema: string;
+    protected table: string;
+    protected columnsList: string[];
+    protected columnsAndTypes: string;
+    protected columns: string;
+    protected vars: string;
+    protected updates: string;
+    addColumns: {
+        [columns: string]: {
+            type: string;
+            value: (item: P) => number | boolean | string | null | Date;
+        };
+    };
+    constructor(pool: Pool, config: IPgRepositoryConfig<any>);
+    protected values(item: P): (string | number | boolean | Date | null)[];
+    protected exec(sql: string, values: any[]): Promise<void>;
+    protected query(sql: string, values: any[]): Promise<P[]>;
+    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>;
+    delete(item: P): Promise<void>;
+}
+
+interface IEndPointConfig {
+    path?: string;
+    disableJsonParser?: boolean;
+    disableUrlEncodedParser?: boolean;
+}
+
+declare function onGet(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 onPost(config?: string | IEndPointConfig): (target: object, propertyKey: string | symbol) => void;
+
+declare function onPut(config?: string | IEndPointConfig): (target: object, propertyKey: string | symbol) => void;
+
+declare function onDelete(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' | 'put' | 'delete';
+    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" | "put" | "delete";
+        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;
@@ -485,138 +910,422 @@ declare class SocketServerProvider {
     private createSocketServer;
 }
 
-interface ISocketChannelReceivedMessage {
-    chatId: string;
-    userId: string;
-    senderName: string;
-    text: string;
+interface IConnectionMiddleware {
+    handle(socket: Socket, container: DependencyContainer$1): Promise<void>;
 }
-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;
+
+declare function connectionMiddleware(middlewareConstructor: IConstructor<IConnectionMiddleware>): (target: object, propertyKey: string | symbol) => void;
+
+interface ISocketConnectionConfig {
+    namespace: string;
 }
 
-interface ITelegramChannelConfig {
-    botToken: string;
+declare function socketConnection(config?: string | ISocketConnectionConfig): (target: object, propertyKey: string | symbol) => void;
+
+interface ISocketControllerConfig {
+    namespace: string;
 }
-declare class TelegramChannelConfig implements ITelegramChannelConfig {
-    botToken: string;
-    constructor(botToken: string);
+
+declare function socketController(config?: string | ISocketControllerConfig): (target: IConstructor<any>) => void;
+
+interface ISocketEventConfig {
+    namespace?: string;
+    event: string;
 }
 
-declare function telegram(config: ITelegramChannelConfig): (target: object, propertyKey: string | symbol) => void;
+declare function socketEvent(config: string | ISocketEventConfig): (target: object, propertyKey: string | symbol) => void;
 
-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;
-    connect(): void;
+interface IConnectionMiddlewareMetadata {
+    controllerConstructor: IConstructor<any>;
+    functionName: string;
+    middlewareConstructor: IConstructor<IConnectionMiddleware>;
 }
 
-interface IWhatsappChannelConfig {
-    number: string;
-    proxy?: string;
+interface ISocketConnectionMetadata {
+    config?: ISocketConnectionConfig;
+    controllerConstructor: IConstructor<any>;
+    functionName: string;
+    paramsTypes: any[];
 }
-declare class WhatsappChannelConfig implements IWhatsappChannelConfig {
-    number: string;
-    constructor(number: string);
+
+interface ISocketControllerMetadata {
+    controllerConstructor: IConstructor<any>;
+    config?: ISocketControllerConfig;
 }
 
-declare function whatsapp(config: IWhatsappChannelConfig): (target: object, propertyKey: string | symbol) => void;
+interface ISocketEventMetadata {
+    config: ISocketEventConfig;
+    controllerConstructor: IConstructor<any>;
+    functionName: string;
+    paramsTypes: any[];
+}
+
+declare class SocketControllerMetadataStore {
+    private socketControllers;
+    private socketConnections;
+    private socketEvents;
+    private connectionMiddlewares;
+    saveControllerMetadata(controllerMetadata: ISocketControllerMetadata): void;
+    saveSocketConnectionMetadata(socketConnectionMetadata: ISocketConnectionMetadata): void;
+    saveSocketEventMetadata(socketEventMetadata: ISocketEventMetadata): void;
+    saveConnectionMiddlewareMetadata(middlewareMetadata: IConnectionMiddlewareMetadata): void;
+    getControllerSockerConnectionsInfo(controllerConstructor: IConstructor<any>): {
+        events: ISocketEventMetadata[];
+        connectionMiddlewares: IConnectionMiddlewareMetadata[];
+        controller: ISocketControllerMetadata;
+        config?: ISocketConnectionConfig;
+        controllerConstructor: IConstructor<any>;
+        functionName: string;
+        paramsTypes: any[];
+    }[];
+}
+
+declare function runSocketControllers(controllers: IConstructor<any>[]): void;
+
+declare class PgJobRepository extends PgCrudRepository<Job> implements IJobRepository {
+    constructor(pool: Pool);
+}
 
-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;
+declare function apiKeyConnectionGuard(): (target: object, propertyKey: string | symbol) => void;
+
+declare function apiKeyGuard(): (target: object, propertyKey: string | symbol) => void;
+
+interface IApiKeyData<A extends IStorableData> extends IEntityData {
+    passwordHash?: string;
+    authInfo: A;
+    name: string;
+}
+declare class ApiKey<A extends IStorableData> extends Entity<IApiKeyData<A>> {
+    get authInfo(): A;
+    setAuthInfo(authInfo: A): void;
+    generatePassword(): string;
+    isValidPassword(password: string): boolean;
+    validatePassword(password: string): void;
+    static inflate(secret: string): {
+        id: string;
+        pass: string;
     };
-};
-interface IWhatsAppTemplateMessage {
-    templateName: string;
-    languageCode: string;
-    parameters: IWhatsAppTemplateParameter[];
+    static deflate(data: {
+        id: string;
+        pass: string;
+    }): string;
 }
 
-interface IWhatsAppWebhookPayload {
-    object: 'whatsapp_business_account';
-    entry: IEntry[];
+interface IApiKeyRepository<A extends IStorableData> {
+    find(id: string): Promise<ApiKey<A> | null>;
+    findOrThrow(id: string): Promise<ApiKey<A>>;
+    create(item: ApiKey<A>): Promise<void>;
+    generate(req: IGenerateApiKeyReq<A>): Promise<IGenerateApiKeyRes>;
+    findAuthInfo(secret: string): Promise<A>;
+}
+interface IGenerateApiKeyReq<A extends IStorableData> extends IStorableData {
+    name: string;
+    authInfo: A;
 }
-interface IEntry {
+interface IGenerateApiKeyRes {
     id: string;
-    changes: IChange[];
+    secret: string;
 }
-type IChange = IMessagesChange;
-interface IMessagesChange {
-    value: IMessagesChangeValue;
-    field: 'messages';
+
+declare class ApiKeyRepository<A extends IStorableData> implements IApiKeyRepository<A> {
+    findAuthInfo(secret: string): Promise<A>;
+    find(id: string): Promise<ApiKey<A> | null>;
+    findOrThrow(id: string): Promise<ApiKey<A>>;
+    create(item: ApiKey<A>): Promise<void>;
+    generate(req: IGenerateApiKeyReq<A>): Promise<IGenerateApiKeyRes>;
+    static generate(repository: ApiKeyRepository<any>, req: IGenerateApiKeyReq<any>): Promise<{
+        id: string;
+        secret: string;
+    }>;
+    static findAuthInfo<A extends IStorableData>(repository: ApiKeyRepository<A>, secret: string): Promise<A>;
 }
-interface IMessagesChangeValue {
-    messaging_product: 'whatsapp';
-    metadata: IMessageMetadata;
-    contacts?: IWhatsAppContact[];
-    messages?: IWhatsAppMessage[];
+
+declare class ApiKeyConnectionGuardMiddleware implements IConnectionMiddleware {
+    private apiKeyRepository;
+    private auth;
+    constructor(apiKeyRepository: ApiKeyRepository<any>, auth: Auth<any>);
+    handle(socket: Socket, container: DependencyContainer$1): Promise<void>;
 }
-interface IMessageMetadata {
-    display_phone_number: string;
-    phone_number_id: string;
+
+declare class ApiKeyGuardMiddleware implements IMiddleware {
+    private apiKeyRepository;
+    private auth;
+    constructor(apiKeyRepository: ApiKeyRepository<any>, auth: Auth<any>);
+    handle(req: Request, res: Response, container: DependencyContainer$1): Promise<void>;
 }
-interface IWhatsAppContact {
-    profile: {
-        name: string;
+
+declare class PgApiKeyRepository<A extends IStorableData> extends PgCrudRepository<ApiKey<A>> implements IApiKeyRepository<A> {
+    constructor(pool: Pool);
+    findAuthInfo(secret: string): Promise<A>;
+    generate(req: IGenerateApiKeyReq<A>): Promise<IGenerateApiKeyRes>;
+}
+
+declare class RemoteApiKeyRepository<A extends IStorableData> implements IApiKeyRepository<A> {
+    private fetcher;
+    private cacheSeconds;
+    private cache;
+    constructor(fetcher: (id: string) => Promise<ApiKey<A> | null>, cacheSeconds: number);
+    find(id: string): Promise<ApiKey<A> | null>;
+    findOrThrow(id: string): Promise<ApiKey<A>>;
+    findAuthInfo(secret: string): Promise<A>;
+    create(item: ApiKey<A>): Promise<void>;
+    generate(req: IGenerateApiKeyReq<A>): Promise<IGenerateApiKeyRes>;
+}
+
+declare function jwtConnectionGuard(): (target: object, propertyKey: string | symbol) => void;
+
+declare function jwtGuard(): (target: object, propertyKey: string | symbol) => void;
+
+interface IJwtRefreshTokenData<A extends IStorableData> extends IEntityData {
+    authInfo: A;
+    passwordHash?: string;
+    expirationTime: number;
+}
+declare class JwtRefreshToken<A extends IStorableData> extends Entity<IJwtRefreshTokenData<A>> {
+    get authInfo(): A;
+    get expirationTime(): Date;
+    generatePassword(): string;
+    isValidPassword(password: string): boolean;
+    validatePassword(password: string): void;
+    static inflate(secret: string): {
+        id: string;
+        pass: string;
     };
-    wa_id: string;
+    static deflate(data: {
+        id: string;
+        pass: string;
+    }): string;
+}
+
+interface IJwtRefreshTokenRepository<D extends IStorableData> extends ICrudRepository<JwtRefreshToken<D>> {
+}
+
+declare class JwtTokenDto {
+    token?: string;
+    expiration?: Date;
+}
+
+declare class JwtAccessAndRefreshTokenDto {
+    access?: JwtTokenDto;
+    refresh?: JwtTokenDto;
+}
+
+declare class JwtConfig {
+    secretOrPublicKey: string;
+    secretOrPrivateKey: string;
+    algorithm: Algorithm;
+    accessExpirationSeconds: number;
+    refreshExpirationSeconds: number;
+    constructor(env: Env);
+}
+
+declare class JwtSigner {
+    private config;
+    private mapper;
+    constructor(config: JwtConfig, mapper: Mapper);
+    signAccessToken<D extends IStorableData>(info: D | JwtRefreshToken<any>): Promise<JwtTokenDto>;
+}
+
+declare class JwtRefreshTokenRepository<D extends IStorableData> implements IJwtRefreshTokenRepository<D> {
+    find(id: string): Promise<JwtRefreshToken<D> | null>;
+    findOrThrow(id: string): Promise<JwtRefreshToken<D>>;
+    findByIds(ids: string[]): Promise<JwtRefreshToken<D>[]>;
+    findAll(id: string): Promise<JwtRefreshToken<D>[]>;
+    create(item: JwtRefreshToken<D>): Promise<void>;
+    update(item: JwtRefreshToken<D>): Promise<void>;
+    delete(item: JwtRefreshToken<D>): Promise<void>;
+}
+
+declare class Jwt {
+    private auth;
+    private jwtSigner;
+    private jwtRefreshTokenRepository;
+    private config;
+    constructor(auth: Auth<any>, jwtSigner: JwtSigner, jwtRefreshTokenRepository: JwtRefreshTokenRepository<any>, config: JwtConfig);
+    createToken(): Promise<JwtAccessAndRefreshTokenDto>;
+    refreshToken(refreshSecret: string): Promise<JwtTokenDto>;
+}
+
+declare class JwtConnectionGuardMiddleware implements IConnectionMiddleware {
+    private config;
+    private auth;
+    constructor(config: JwtConfig, auth: Auth<any>);
+    handle(socket: Socket, container: DependencyContainer$1): 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>;
+}
+
+declare class PgJwtRefreshTokenRepository<D extends IStorableData> extends PgCrudRepository<JwtRefreshToken<D>> implements IJwtRefreshTokenRepository<D> {
+    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 openai;
+    private logger;
+    constructor(env: Env);
+    nextItem(req: IChatAdapterNextItemReq): Promise<IChatAdapterNextItemRes>;
+    private mapChatItems;
+    private mapHumanMessage;
+    private mapBotMessage;
+    private mapFunctionCall;
+    private mapTool;
+    private mapResponse;
+}
+
+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 class WabotChatAdapter implements IChatAdapter {
+    private apiKey;
+    private baseUrl;
+    private logger;
+    constructor(env: Env);
+    nextItem(req: IChatAdapterNextItemReq): Promise<IChatAdapterNextItemRes>;
+}
+
+declare function cmd(): (target: object, propertyKey: string | symbol) => void;
+
+declare class CmdChannel implements IChatChannel {
+    private rl;
+    private callBack;
+    listen(callback: (message: IChannelMessage) => void): void;
+    connect(): void;
+}
+
+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;
+
+interface ISocketChannelReceivedMessage {
+    chatId: string;
+    userId: string;
+    senderName: string;
+    text: string;
+}
+declare class SocketChannel implements IChatChannel {
+    private config;
+    private socketServerProvider;
+    private callBack;
+    private server;
+    constructor(config: SocketChannelConfig, socketServerProvider: SocketServerProvider);
+    listen(callback: (message: IChannelMessage) => void): void;
+    connect(): void;
+}
+
+interface ITelegramChannelConfig {
+    botToken: string;
 }
-type IWhatsAppMessage = ITextMessage | IAudioMessage;
-interface IBaseMessage {
-    from: string;
-    id: string;
-    timestamp: string;
-    type: string;
+declare class TelegramChannelConfig implements ITelegramChannelConfig {
+    botToken: string;
+    constructor(botToken: string);
 }
-interface ITextMessage extends IBaseMessage {
-    type: 'text';
-    text: {
-        body: string;
-    };
+
+declare function telegram(config: ITelegramChannelConfig): (target: object, propertyKey: string | symbol) => void;
+
+declare class TelegramChannel implements IChatChannel {
+    private config;
+    private bot;
+    constructor(config: TelegramChannelConfig);
+    listen(callback: (message: IChannelMessage) => void): void;
+    connect(): void;
 }
-interface IAudioMessage extends IBaseMessage {
-    type: 'audio';
-    audio: {
-        mime_type: string;
-        sha256: string;
-        id: string;
-        voice: boolean;
-    };
+
+interface IWhatsappChannelConfig {
+    number: string;
+    proxy?: string;
+}
+declare class WhatsappChannelConfig implements IWhatsappChannelConfig {
+    number: string;
+    constructor(number: string);
 }
 
-interface IWhatsAppBusinessNumber {
+declare function whatsApp(config: string | IWhatsappChannelConfig): (target: object, propertyKey: string | symbol) => void;
+
+interface IWhatsAppBusinessNumber extends IStorableData {
     id: string;
     number: string;
 }
-interface IWhatsAppBusinessAccount {
+interface IWhatsAppBusinessAccount extends IStorableData {
     id: string;
 }
-interface IWhatsAppData extends IPersistentData {
+interface IWhatsAppData extends IEntityData {
     slug: string;
     verifyToken: string;
     appSecret: string;
@@ -624,7 +1333,7 @@ interface IWhatsAppData extends IPersistentData {
     businessAccount: IWhatsAppBusinessAccount;
     businessNumbers: IWhatsAppBusinessNumber[];
 }
-declare class WhatsApp extends Persistent<IWhatsAppData> {
+declare class WhatsApp extends Entity<IWhatsAppData> {
     getVerifyToken(): string;
     getSlug(): string;
     getBusinessAccount(): IWhatsAppBusinessAccount;
@@ -635,57 +1344,88 @@ declare class WhatsApp extends Persistent<IWhatsAppData> {
     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;
+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;
+}
+
+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;
 }
-declare abstract class WhatsAppReceiver {
-    protected logger: Logger;
-    private listeners;
-    constructor(logger: Logger);
-    abstract connect(): Promise<void>;
+declare class WhatsAppReceiver {
+    connect(): Promise<void>;
     listenMessage(request: IListenWhatsAppMessageRequest): void;
-    protected handlePayload(payload: IWhatsAppWebhookPayload): Promise<void>;
-    private emmitMessage;
 }
 
-interface IWhatsAppRepository {
-    findBySlug(slug: string): Promise<WhatsApp | null>;
-    findByBusinessNumber(number: string): Promise<WhatsApp | null>;
+type IWhatsAppCloudTemplateParameter = {
+    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 IWhatsAppCloudTemplateMessage {
+    templateName: string;
+    languageCode: string;
+    parameters: IWhatsAppCloudTemplateParameter[];
 }
 
-declare class WhatsAppRepository implements IWhatsAppRepository {
-    findBySlug(slug: string): Promise<WhatsApp | null>;
-    findByBusinessNumber(number: string): Promise<WhatsApp | null>;
+interface IWhatsAppCloudTemplateResponse {
+    data: IWhatsAppCloudTemplate[];
+    paging: IWhatsAppCloudApiPaging;
 }
-
-interface IWhatsAppTemplate {
+interface IWhatsAppCloudTemplate {
     name: string;
     parameter_format: 'POSITIONAL' | 'OTHER';
-    components: IWhatsAppTemplateComponent[];
+    components: IWhatsAppCloudTemplateComponent[];
     language: string;
     status: string;
     category: string;
     id: string;
 }
-interface IWhatsAppTemplateComponent {
+interface IWhatsAppCloudTemplateComponent {
     type: 'HEADER' | 'BODY' | 'FOOTER';
     format?: 'TEXT';
     text?: string;
 }
+interface IWhatsAppCloudApiPaging {
+    cursors: IWhatsAppCloudApiCursors;
+}
+interface IWhatsAppCloudApiCursors {
+    before: string;
+    after: string;
+}
+
+declare class WhatsAppRepository implements IWhatsAppRepository {
+    findBySlug(slug: string): Promise<WhatsApp | null>;
+    findByBusinessNumber(number: string): Promise<WhatsApp | null>;
+}
 
 interface ISendWhatsAppRequest {
     from: string;
@@ -695,7 +1435,7 @@ interface ISendWhatsAppRequest {
 interface ISendWhatsAppTemplateRequest {
     from: string;
     to: string;
-    templateMessage: IWhatsAppTemplateMessage;
+    templateMessage: IWhatsAppCloudTemplateMessage;
     senderName: string;
 }
 interface IGetWhatsAppTemplateRequest {
@@ -706,270 +1446,164 @@ interface IGetWhatsAppTemplateRequest {
 interface IWhatsAppSenderOptions {
     writeChatMemory?: boolean;
 }
-declare abstract class WhatsAppSender {
-    protected logger: Logger;
+declare class WhatsAppSender {
     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>;
+    constructor(chatRepository: ChatRepository, chatResolver: ChatResolver, whatsAppRepository: WhatsAppRepository);
     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 getWhatsAppTemplate(request: IGetWhatsAppTemplateRequest): Promise<IWhatsAppCloudTemplate | null>;
+    protected mapTemplateToChatMessage(request: ISendWhatsAppTemplateRequest): Promise<IChatMessage>;
     protected writePrivateChatMemory(message: IChatMessage, to: string): Promise<void>;
-    private replaceTemplateParameters;
+    protected replaceTemplateParameters(template: string, data: IWhatsAppCloudTemplateParameter[]): string;
 }
 
 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;
 }
 
-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>;
+interface IWhatsAppCloudWebhookPayload {
+    object: 'whatsapp_business_account';
+    entry: IWhatsAppCloudEntry[];
 }
-
-declare class WhatsAppReceiverByWebHook extends WhatsAppReceiver {
-    private expressProvider;
-    private whatsAppRepository;
-    private expressApp;
-    private webhookPath;
-    constructor(expressProvider: ExpressProvider, whatsAppRepository: WhatsAppRepository);
-    connect(): Promise<void>;
+interface IWhatsAppCloudEntry {
+    id: string;
+    changes: IWhatsAppCloudChange[];
 }
-
-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>;
+type IWhatsAppCloudChange = IWhatsAppCloudMessagesChange;
+interface IWhatsAppCloudMessagesChange {
+    value: IWhatsAppCloudMessagesChangeValue;
+    field: 'messages';
 }
-
-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 IWhatsAppCloudMessagesChangeValue {
+    messaging_product: 'whatsapp';
+    metadata: IWhatsAppCloudMessageMetadata;
+    contacts?: IWhatsAppCloudContact[];
+    messages?: IWhatsAppCloudMessage[];
 }
-
-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 IWhatsAppCloudMessageMetadata {
+    display_phone_number: string;
+    phone_number_id: 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 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;
-        };
+interface IWhatsAppCloudContact {
+    profile: {
+        name: string;
     };
-    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>;
-}
-
-declare class PgWhatsAppRepository extends PgCrudRepository<WhatsApp> implements IWhatsAppRepository {
-    constructor(pool: Pool);
-    findBySlug(slug: string): Promise<WhatsApp | null>;
-    findByBusinessNumber(number: string): Promise<WhatsApp | null>;
+    wa_id: string;
 }
-
-type IWabotEnvType = 'development' | 'staging' | 'testing' | 'production';
-declare class WabotEnv {
-    private envType;
-    constructor();
-    isDevelopment(): boolean;
-    isProduction(): boolean;
-    requireString(varName: string): string;
+type IWhatsAppCloudMessage = IWhatsAppCloudTextMessage | IWhatsAppCloudAudioMessage;
+interface IWhatsAppCloudBaseMessage {
+    from: string;
+    id: string;
+    timestamp: string;
+    type: 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;
+interface IWhatsAppCloudTextMessage extends IWhatsAppCloudBaseMessage {
+    type: 'text';
+    text: {
+        body: string;
+    };
 }
-
-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>;
+interface IWhatsAppCloudAudioMessage extends IWhatsAppCloudBaseMessage {
+    type: 'audio';
+    audio: {
+        mime_type: string;
+        sha256: string;
+        id: string;
+        voice: boolean;
+    };
 }
-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 WhatsAppReceiverByCloudApi extends WhatsAppReceiver {
+    private expressProvider;
+    private whatsAppRepository;
+    private listeners;
+    private expressApp;
+    private logger;
+    private webhookPath;
+    constructor(expressProvider: ExpressProvider, whatsAppRepository: WhatsAppRepository);
+    connect(): Promise<void>;
+    listenMessage(request: IListenWhatsAppMessageRequest): void;
+    protected handlePayload(payload: IWhatsAppCloudWebhookPayload): Promise<void>;
+    private emmitMessage;
 }
-declare function runServer(config: IServerConfig): void;
 
-declare class SendOneTimePasswordRequest {
-    fromEmail: string;
-    toEmail: string;
+declare class WhatsAppSenderByCloudApi extends WhatsAppSender {
+    private logger;
+    constructor(chatRepository: ChatRepository, chatResolver: ChatResolver, whatsAppRepository: WhatsAppRepository);
+    sendWhatsApp(request: ISendWhatsAppRequest, options?: IWhatsAppSenderOptions): Promise<void>;
+    sendWhatsAppTemplate(request: ISendWhatsAppTemplateRequest, options?: IWhatsAppSenderOptions): Promise<void>;
+    protected getWhatsAppTemplate(request: IGetWhatsAppTemplateRequest): Promise<IWhatsAppCloudTemplate | null>;
 }
 
-declare class ValidateOneTimePasswordRequest {
-    userEmail: string;
-    otp: string;
+interface IWhatsAppProxyMessageContent {
+    text: string;
 }
 
-interface ISendEmailRequest {
+interface IWhatsAppProxyMessage {
     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>;
-}
-
-interface IOtpService {
-    generate(): Promise<string>;
-}
-declare class OtpService implements IOtpService {
-    generate(): Promise<string>;
-}
-
-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>;
+    senderName?: string;
+    content: IWhatsAppProxyMessageContent;
 }
 
-declare class RegisterUserWithEmailRequest {
-    email: string;
-    shortName: string;
+declare const WHATSAPP_PROXY_SEND_MESSAGE_EVENT: "sendMessage";
+interface IWhatsAppProxySendMessageEventReq {
+    event: typeof WHATSAPP_PROXY_SEND_MESSAGE_EVENT;
+    data: IWhatsAppProxyMessage;
 }
-
-declare class RegisterUserModule {
-    private userRepository;
-    private context;
-    constructor(userRepository: UserRepository, context: MessageContext);
-    registerUserWithEmail(request: RegisterUserWithEmailRequest): Promise<string>;
+declare const WHATSAPP_PROXY_LISTEN_MESSAGE_EVENT: "listenMessage";
+interface IWhatsAppProxyListenMessageEventReq {
+    event: typeof WHATSAPP_PROXY_LISTEN_MESSAGE_EVENT;
+    data: IWhatsAppProxyListenMessageEventData;
 }
-
-declare class PgUserRepository extends PgCrudRepository<User> implements IUserRepository {
-    constructor(pool: Pool);
-    findByConnection(query: IUserConnection): Promise<User | null>;
+interface IWhatsAppProxyListenMessageEventData {
+    from?: string[];
+    to: string[];
 }
-
-declare class RamUserRepository implements IUserRepository {
-    private items;
-    create(chat: User): Promise<void>;
-    findByConnection(query: IUserConnection): Promise<User | null>;
-    update(chat: User): Promise<void>;
+declare const WHATSAPP_MESSAGE_EVENT: "message";
+interface IWhatsAppProxyMessageEventReq {
+    event: typeof WHATSAPP_MESSAGE_EVENT;
+    data: IWhatsAppProxyMessage;
 }
 
-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 WhatsAppWabotProxyConnection {
+    private baseUrl;
+    private socket;
+    private apiKey;
+    private logger;
+    constructor(env: Env);
+    getSocket(): Promise<Socket$1>;
 }
 
-declare class PgChatMemory extends PgCrudRepository<ChatItem> implements IChatMemory {
-    private chatId;
-    constructor(pool: Pool, chatId: string);
-    findLastItems(count: number): Promise<ChatItem[]>;
+declare class WhatsAppReceiverByWabotProxy extends WhatsAppReceiver {
+    private connection;
+    private loger;
+    constructor(connection: WhatsAppWabotProxyConnection);
+    connect(): Promise<void>;
+    listenMessage(request: IListenWhatsAppMessageRequest): void;
 }
 
-declare class RamChatMemory implements IChatMemory {
-    private memory;
-    findLastItems(count: number): Promise<ChatItem[]>;
-    create(item: ChatItem): Promise<void>;
-    clearMemory(): Promise<void>;
+declare class WhatsAppSenderByWabotProxy extends WhatsAppSender {
+    private wabotDevConnection;
+    private logger;
+    constructor(wabotDevConnection: WhatsAppWabotProxyConnection, chatRepository: ChatRepository, chatResolver: ChatResolver, whatsAppRepository: WhatsAppRepository);
+    sendWhatsApp(request: ISendWhatsAppRequest, options?: IWhatsAppSenderOptions): 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;
+interface IHtmlModuleOptions {
+    url: string;
+    title: string;
 }
+declare function HtmlModule(options: IHtmlModuleOptions): {
+    new (): {};
+};
 
-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, ApiKey, ApiKeyConnectionGuardMiddleware, ApiKeyGuardMiddleware, ApiKeyRepository, 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 IApiKeyData, type IApiKeyRepository, 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 IConnectionMiddleware, type IConnectionMiddlewareMetadata, type IConstructor, type ICrudRepository, type ICustomErrorData, type IEndPointConfig, type IEndPointMetadata, type IEntityData, type IEnvType, type IFunctionCall, type IFunctionCallItem, type IGenerateApiKeyReq, type IGenerateApiKeyRes, type IGetWhatsAppTemplateRequest, type IHtmlModuleOptions, type IHumanMessageItem, type IJobData, type IJobEvent, type IJobEventListener, type IJobRepository, type IJwtRefreshTokenData, type IJwtRefreshTokenRepository, type ILanguageModelUsage, type IListenWhatsAppMessageRequest, type IMessageContext, type IMiddleware, type IMiddlewareMetadata, type IMindset, type IMindsetDecoration, type IMindsetFunctionConfig, type IMindsetFunctionDecoration, type IMindsetFunctionMetadata, type IMindsetFunctionParamMetadata, type IMindsetIdentity, type IMindsetLlm, 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 ISocketConnectionConfig, type ISocketConnectionMetadata, type ISocketControllerConfig, type ISocketControllerMetadata, type ISocketEventConfig, type ISocketEventMetadata, type IStorableData, type ITelegramChannelConfig, type IValidateArrayOptions, type IValidateArrayOptionsWithItemsValidators, type IValidateIsInOptions, type IValidateMaxOptions, type IValidateMinOptions, type IValidationError, type IValidationResult, type IValidator, type IValidatorMetadata, type IWhatsAppBusinessAccount, type IWhatsAppBusinessNumber, type IWhatsAppCloudContact, type IWhatsAppCloudMessage, type IWhatsAppCloudMessageMetadata, type IWhatsAppCloudTemplate, type IWhatsAppCloudTemplateComponent, type IWhatsAppCloudTemplateMessage, type IWhatsAppCloudTemplateParameter, type IWhatsAppCloudTemplateResponse, type IWhatsAppCloudWebhookPayload, type IWhatsAppData, type IWhatsAppMessageListener, type IWhatsAppProxyListenMessageEventData, type IWhatsAppProxyListenMessageEventReq, type IWhatsAppProxyMessage, type IWhatsAppProxyMessageContent, type IWhatsAppProxyMessageEventReq, type IWhatsAppProxySendMessageEventReq, type IWhatsAppRepository, type IWhatsAppSenderOptions, type IWhatsappChannelConfig, type IchatControllerConfig, Job, JobRepository, JobRunner, JobsEventsHub, Jwt, JwtAccessAndRefreshTokenDto, JwtConfig, JwtConnectionGuardMiddleware, 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, Password, type PasswordHashOptions, Persistent, PgApiKeyRepository, PgChatMemory, PgChatRepository, PgCrudRepository, PgJobRepository, PgJwtRefreshTokenRepository, PgRepositoryBase, PgWhatsAppRepository, RamChatMemory, RamChatRepository, Random, RemoteApiKeyRepository, RestControllerMetadataStore, SocketChannel, SocketChannelConfig, SocketControllerMetadataStore, SocketServerProvider, Storable, TelegramChannel, TelegramChannelConfig, ValidationMetadataStore, WHATSAPP_MESSAGE_EVENT, WHATSAPP_PROXY_LISTEN_MESSAGE_EVENT, WHATSAPP_PROXY_SEND_MESSAGE_EVENT, WabotChatAdapter, WhatsApp, WhatsAppChannel, WhatsAppReceiver, WhatsAppReceiverByCloudApi, WhatsAppReceiverByWabotProxy, WhatsAppRepository, WhatsAppSender, WhatsAppSenderByCloudApi, WhatsAppSenderByWabotProxy, WhatsAppWabotProxyConnection, WhatsappChannelConfig, apiKeyConnectionGuard, apiKeyGuard, chatBot, chatController, chatItemTypeOptions, cmd, command, commandHandler, connectionMiddleware, container, inject, injectable, isArray, isBoolean, isDate, isIn, isModel, isNotEmpty, isNumber, isOptional, isPresent, isString, jwtConnectionGuard, jwtGuard, max, middleware, min, mindset, mindsetFunction, mindsetModule, modelInfo, onDelete, onGet, onPost, onPut, param, restController, runAsyncCommandHandlers, runChatControllers, runRestControllers, runSocketControllers, scoped, singleton, socket, socketConnection, socketController, socketEvent, telegram, validate, validateArray, validateIsBoolean, validateIsDate, validateIsIn, validateIsNotEmpty, validateIsNumber, validateIsPresent, validateIsString, validateMax, validateMin, validateModel, whatsApp };