@wabot-dev/framework 0.1.0-beta.29 → 0.1.0-beta.30

package/dist/src/index.d.ts

@@ -1,32 +1,16 @@
+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 { Pool } from 'pg';
 import { Server } from 'http';
 import { Express, Request, Response } from 'express';
 import { Server as Server$1 } from 'socket.io';
+import { Pool } from 'pg';
 import { Socket } from 'socket.io-client';
-import * as tsyringe from 'tsyringe';
-import { DependencyContainer as DependencyContainer$1 } from 'tsyringe';
-export { DependencyContainer } from 'tsyringe';
 import { Algorithm } from 'jsonwebtoken';
 
-interface IMindsetFunctionConfig {
-    description: string;
-}
-
-declare function mindsetFunction(config: IMindsetFunctionConfig): (target: object, propertyKey: string | symbol) => void;
-
-declare const MINDSET_FUNCTION_DECORATION_FUNCTION = "mindsetFunction";
-
-interface IMindsetFunctionDecoration {
-    decorationName: string;
-    functionName: string;
-    constructor: Function;
-    paramsTypes: Function[];
-    decorationConfig: any;
-}
-
 type IPrimitive = null | number | string | boolean | undefined;
 type IStorableData = {
     [key: string]: IPrimitive | IPrimitive[] | IStorableData | IStorableData[];
@@ -68,73 +52,278 @@ interface IPersistentData extends IEntityData {
 declare class Persistent<D extends IPersistentData> extends Entity<D> {
 }
 
-interface IChatMessage {
-    text?: 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 IFunctionCall {
-    id: string;
-    name: string;
-    arguments?: string;
-    result?: string;
+
+interface ICustomErrorData {
+    message: string;
+    humanMessage?: string;
+    code?: string;
+    httpCode?: number;
+    cause?: Error;
+    info?: any;
 }
-declare const chatItemTypeOptions: readonly ["botMessage", "connectionMessage", "functionCall"];
-type IBotMessageItem = {
-    type: 'botMessage';
-    botMessage: IChatMessage;
+declare class CustomError extends Error {
+    humanMessage?: string;
+    code?: string;
+    httpCode?: number;
+    info?: any;
+    constructor(data: ICustomErrorData);
+}
+
+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 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;
+}
+
+declare class Mapper {
+    map<T>(data: any, ctor: IConstructor<T>): T;
+}
+
+declare class Random {
+    static slug(name: string, options: {
+        randomLength: number;
+    }): string;
+    static string(length: number): string;
+    static numberCode(length: number): 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 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 IConnectionMessageItem = {
-    type: 'connectionMessage';
-    connectionMessage: IChatMessage;
+type IModelValidationResult<V> = {
+    value: V;
+    error?: undefined;
+} | {
+    value?: undefined;
+    error: IModelValidationError;
 };
-type IFunctionCallItem = {
-    type: 'functionCall';
-    functionCall: IFunctionCall;
+type IArrayValidationResult<V> = {
+    value: V[];
+    error?: undefined;
+} | {
+    value?: undefined;
+    error: IArrayValidationError;
 };
-type IChatItem = IBotMessageItem | IConnectionMessageItem | IFunctionCallItem;
-type IChatItemType = (typeof chatItemTypeOptions)[number];
-interface IChatToolParameter {
-    type: string;
-    name: string;
-    description: string;
+type IValidator<V = any, O = any> = (value: V, options: O) => IValidationResult<V>;
+interface IPropertyValidatorInfo {
+    propertyName: string;
+    validator: IValidator;
+    validatorOptions?: any;
 }
-interface IChatTool {
-    language: string;
-    name: string;
-    description: string;
-    parameters: IChatToolParameter[];
+type IModelValidatorsInfo<V> = {
+    modelConstructor: IConstructor<V>;
+    properties: {
+        [prop: string]: {
+            isOptional?: boolean;
+            validators?: IPropertyValidatorInfo[];
+        } | undefined;
+    };
+};
+
+interface IValidateArrayOptions {
 }
-interface IChatAdapterNextItemReq {
-    model: string;
-    systemPrompt: string;
-    tools: IChatTool[];
-    prevItems: IChatItem[];
+interface IValidateArrayOptionsWithItemsValidators extends IValidateArrayOptions {
+    itemsValidator?: {
+        validator: IValidator;
+        options: any;
+    }[];
 }
-interface IChatAdapter {
-    nextItem(req: IChatAdapterNextItemReq): Promise<IChatItem>;
+declare function validateArray(value: any, options?: IValidateArrayOptionsWithItemsValidators): IArrayValidationResult<any>;
+
+declare function isArray(options?: IValidateArrayOptions): (target: object, propertyKey: string | symbol) => void;
+
+interface IValidatorMetadata {
+    modelConstructor: IConstructor<any>;
+    propertyName: string;
+    validator: IValidator;
+    validatorOptions?: any;
 }
 
-type IChatItemData = IEntityData & IChatItem;
-declare class ChatItem extends Entity<IChatItemData> {
-    getType(): "botMessage" | "connectionMessage" | "functionCall";
-    getContent(): IPrimitive | IStorableData | IPrimitive[] | IStorableData[];
-    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 ICommandHandler<C extends Command<any>> {
+    handle(command: C): void | Promise<void>;
+}
+
+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 IJobData extends IEntityData {
+    commandName: string;
+    commandData: any;
+    startedAt?: number;
+    successAt?: number;
+    failedAt?: number;
+    error?: {
+        message: string;
+        stack?: string;
+        info?: any;
+    };
+}
+declare class Job extends Entity<IJobData> {
+    get commandName(): string;
+    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>;
+    discard(item: Job): Promise<void>;
+}
+
+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;
+}
+
+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>;
 }
 
-type IChatType = 'PRIVATE' | 'GROUP';
+declare function runAsyncCommandHandlers(handlers: IConstructor<ICommandHandler<any>>[]): void;
+
 interface IChatConnection extends IStorableData {
-    chatType: IChatType;
     channelName: string;
     id: string;
 }
+
+type IChatType = 'PRIVATE' | 'GROUP';
+
 interface IChatData extends IEntityData {
     type: IChatType;
     connections: IChatConnection[];
@@ -149,74 +338,22 @@ declare class Chat extends Entity<IChatData> {
     validate(): void;
 }
 
-interface IChatRepository {
-    create(chat: Chat): Promise<void>;
-    findByConnection(query: IChatConnection): Promise<Chat | null>;
-    findMemory(chatId: string): Promise<IChatMemory | null>;
-}
-declare class ChatRepository implements IChatRepository {
-    create(chat: Chat): Promise<void>;
-    findByConnection(query: IChatConnection): Promise<Chat | null>;
-    findMemory(chatId: string): Promise<IChatMemory | null>;
-}
-
-interface IChatFunctionCall {
-    id: string;
-    name: string;
-    arguments?: string;
-    result?: string;
-}
-
-interface IUserConnection extends IStorableData {
-    channelName: string;
-    id: string;
-}
-interface IUserData extends IEntityData {
-    shortName: string;
-    connections: IUserConnection[];
-    keyValueData: {
-        [key: string]: string;
-    };
-}
-declare class User extends Entity<IUserData> {
-    constructor(data: IUserData);
-    hasConnection(connection: IUserConnection): boolean;
-    getValue(key: string): string;
-    setValue(key: string, value: string): void;
-    addConnection(connection: IUserConnection): void;
+interface IMindsetFunctionConfig {
+    description: string;
 }
 
-interface IUserRepository {
-    create(chat: User): Promise<void>;
-    update(chat: User): Promise<void>;
-    findByConnection(query: IUserConnection): Promise<User | null>;
-}
-declare class UserRepository implements IUserRepository {
-    create(chat: User): Promise<void>;
-    update(chat: User): Promise<void>;
-    findByConnection(query: IUserConnection): Promise<User | null>;
-}
+declare function mindsetFunction(config: IMindsetFunctionConfig): (target: object, propertyKey: string | symbol) => void;
 
-interface IConnectionChatMessage extends IChatMessage {
-    chatConnection: IChatConnection;
-    userConnection: IUserConnection;
-    userId?: string;
-}
+declare const MINDSET_FUNCTION_DECORATION_FUNCTION = "mindsetFunction";
 
-interface IMessageContext {
-    message: IConnectionChatMessage;
-    chat: Chat;
-    user: User | null;
-}
-declare class MessageContext implements IMessageContext {
-    message: IConnectionChatMessage;
-    chat: Chat;
-    user: User | null;
-    constructor(message: IConnectionChatMessage, chat: Chat, user: User | null);
+interface IMindsetFunctionDecoration {
+    decorationName: string;
+    functionName: string;
+    constructor: Function;
+    paramsTypes: Function[];
+    decorationConfig: any;
 }
 
-type IConstructor<T> = new (...args: any[]) => T;
-
 interface IMindsetIdentity {
     name: string;
     language: string;
@@ -321,28 +458,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 const scoped: typeof tsyringe.scoped;
-declare const Lifecycle: typeof tsyringe.Lifecycle;
 
 declare class MindsetOperator implements IMindset {
     private mindset;
@@ -353,34 +479,97 @@ declare class MindsetOperator implements IMindset {
     skills(): Promise<string>;
     limits(): Promise<string>;
     systemPrompt(): Promise<string>;
-    tools(): IChatTool[];
-    tool(fn: IMindsetFunctionMetadata, module: IMindsetModuleMetadata): IChatTool;
-    private toolParameter;
-    /**
-     * @deprecated use id
-     */
+    tools(): IMindsetTool[];
+    protected tool(fn: IMindsetFunctionMetadata, module: IMindsetModuleMetadata): IMindsetTool;
+    protected toolParameter(param: IMindsetFunctionParamMetadata): IMindsetToolParameter;
     callFunction(name: string, params: string): Promise<string>;
-    /**
-     * @deprecated use id
-     */
-    allFunctionsDescriptors(): Promise<{
-        readonly type: "function";
-        readonly name: string;
-        readonly description: string;
-        readonly parameters: {
-            readonly type: "object";
-            readonly properties: {};
-            readonly required: string[];
-        };
-    }[]>;
-    /**
-     * @deprecated use id
-     */
-    private functionDescriptor;
-    /**
-     * @deprecated use id
-     */
-    private toolParam;
+}
+
+interface IChatMessage extends IStorableData {
+    senderId?: string;
+    senderName?: string;
+    text?: string;
+}
+
+interface IFunctionCall extends IStorableData {
+    id: string;
+    name: string;
+    arguments?: string;
+    result?: string;
+}
+
+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 IChatAdapterNextItemReq {
+    model: string;
+    systemPrompt: string;
+    tools: IMindsetTool[];
+    prevItems: IChatItem[];
+}
+interface IChatAdapter {
+    nextItem(req: IChatAdapterNextItemReq): Promise<IChatItem>;
+}
+
+declare class ChatAdapter implements IChatAdapter {
+    nextItem(req: IChatAdapterNextItemReq): Promise<IChatItem>;
+}
+
+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 ChatMemory implements IChatMemory {
+    findLastItems(count: number): Promise<ChatItem[]>;
+    create(item: ChatItem): Promise<void>;
+}
+
+interface IChatBot {
+    sendMessage(message: IChatMessage, callback: (message: IChatMessage) => void): void | Promise<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 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;
@@ -397,127 +586,156 @@ declare class ChatBotMetadataStore {
     getChatBotsMetadata(): IChatBotMetadata[];
 }
 
-interface IChatBotAdapter {
-    generateNextChatItem(chatItems: ChatItem[]): Promise<ChatItem>;
+interface IchatControllerConfig {
 }
-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<any>;
-    protected buildFunctionCallItem(id: string, functionName: string, functionArguments: string): Promise<any>;
+
+declare function chatController(config?: IchatControllerConfig): (target: IConstructor<any>) => void;
+
+interface IChatControllerMetadata {
+    controllerConstructor: Function;
 }
 
-interface IChatBot {
-    sendMessage(message: IChatMessage, callback: (message: IChatMessage) => void): void | Promise<void>;
+interface IReceivedMessage {
+    message: IChatMessage;
+    reply: (message: IChatMessage) => void;
 }
 
-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>;
+interface IChannelMessage extends IReceivedMessage {
+    chatConnection: IChatConnection;
 }
 
-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 IChatChannel {
+    listen(callback: (received: IChannelMessage) => void): void;
+    connect(): void;
 }
 
-declare class OpenaiChatBotAdapter extends ChatBotAdapter {
-    private openai;
-    private model;
-    private logger;
-    constructor(mindset: MindsetOperator);
-    generateNextChatItem(chatItems: ChatItem[]): Promise<ChatItem>;
-    private mapChatItems;
+interface IChannelMetadata {
+    controllerConstructor: IConstructor<any>;
+    functionName: string;
+    channelConstructor: IConstructor<IChatChannel>;
+    channelConfig?: object;
 }
 
-declare class OpenaiChatAdapter implements IChatAdapter {
-    private openai;
+declare class ControllerMetadataStore {
+    private channels;
+    private chatControllers;
+    saveChannelMetadata(channelMetadata: IChannelMetadata): void;
+    saveChatControllerMetadata(controllerMetadata: IChatControllerMetadata): void;
+    getChatControllerMetadata(controllerConstructor: Function): {
+        config: IChatControllerMetadata;
+        channels: IChannelMetadata[];
+    } | null;
+}
+
+declare class 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;
-    nextItem(req: IChatAdapterNextItemReq): Promise<IChatItem>;
-    private mapChatItems;
-    private mapConectionMessage;
-    private mapBotMessage;
-    private mapFunctionCall;
-    private mapTool;
-    private mapResponse;
+    getHttpServer(): Server;
+    listen(): void;
 }
 
-declare class ClaudeChatBotAdapter extends ChatBotAdapter {
-    private anthropic;
-    private model;
+declare class ExpressProvider {
+    private httpServerProvider;
+    private expressApp;
     private logger;
-    constructor(mindset: MindsetOperator);
-    generateNextChatItem(chatItems: ChatItem[]): Promise<ChatItem>;
-    private mapChatItems;
+    constructor(httpServerProvider: HttpServerProvider);
+    getExpress(): Express;
+    listen(): void;
+    private createExpress;
 }
 
-interface ICommandConfig {
-    name?: string;
+interface IGetConfig {
+    path?: string;
+}
+
+declare function get(config?: string | IGetConfig): (target: object, propertyKey: string | symbol) => void;
+
+interface IMiddleware {
+    handle(req: Request, res: Response, container: DependencyContainer$1): Promise<void>;
+}
+
+declare function middleware(middlewareConstructor: IConstructor<IMiddleware>): (target: object, propertyKey: string | symbol) => void;
+
+interface IPostConfig {
+    path?: string;
+}
+
+declare function post(config?: string | IPostConfig): (target: object, propertyKey: string | symbol) => void;
+
+interface IRestControllerConfig {
+    path: string;
 }
-declare function command(config?: ICommandConfig): (target: IConstructor<any>) => void;
 
-declare class Command<T extends IStorableData> extends Storable<T> {
-    getData(): T;
-}
+declare function restController(config: string | IRestControllerConfig): (target: IConstructor<any>) => void;
 
-interface ICommandHandler<C extends Command<any>> {
-    handle(command: C): void | Promise<void>;
+interface IEndPointMetadata {
+    method: 'get' | 'post';
+    path?: string;
+    controllerConstructor: IConstructor<any>;
+    functionName: string;
+    paramsTypes: any[];
 }
 
-interface ICommandHandlerConfig<C extends Command<any>> {
-    command: IConstructor<C>;
+interface IMiddlewareMetadata {
+    controllerConstructor: IConstructor<any>;
+    functionName: string;
+    middlewareConstructor: IConstructor<IMiddleware>;
 }
-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 IRestControllerMetadata {
+    controllerConstructor: IConstructor<any>;
+    path: string;
 }
 
-interface IJobData extends IEntityData {
-    commandName: string;
-    commandData: any;
-    startedAt?: number;
-    successAt?: number;
-    failedAt?: number;
-    error?: {
-        message: string;
-        stack?: string;
-        info?: any;
-    };
+declare class RestControllerMetadataStore {
+    private endPoints;
+    private middlewares;
+    private restControllers;
+    saveControllerMetadata(controllerMetadata: IRestControllerMetadata): void;
+    saveEndPointMetadata(endPointMetadata: IEndPointMetadata): void;
+    saveMiddlewareMetadata(middlewareMetadata: IMiddlewareMetadata): void;
+    getControllerEndPointsInfo(controllerConstructor: IConstructor<any>): {
+        middlewares: IMiddlewareMetadata[];
+        controller: IRestControllerMetadata;
+        method: "get" | "post";
+        path?: string;
+        controllerConstructor: IConstructor<any>;
+        functionName: string;
+        paramsTypes: any[];
+    }[];
 }
-declare class Job extends Entity<IJobData> {
-    get commandName(): string;
-    setAsStarted(): void;
-    setAsSuccess(): void;
-    setAsFailed(error: Error): void;
+
+declare function runRestControllers(controllers: IConstructor<any>[]): void;
+
+declare class Auth<D extends IStorableData> {
+    private authInfo;
+    require(): D;
+    assign(authInfo: D): void;
 }
 
-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 class SocketServerProvider {
+    private httpServerProvider;
+    private socketServer;
+    private logger;
+    constructor(httpServerProvider: HttpServerProvider);
+    getSocketServer(): Server$1;
+    listen(): void;
+    private createSocketServer;
 }
 
 type IPgRepositoryConfig<P extends Entity<IEntityData>> = {
@@ -572,123 +790,65 @@ declare class PgCrudRepository<P extends Entity<IEntityData>> extends PgReposito
     discard(item: P): Promise<void>;
 }
 
-declare class JobRepository extends PgCrudRepository<Job> {
+declare class PgJobRepository extends PgCrudRepository<Job> implements IJobRepository {
     constructor(pool: Pool);
 }
 
-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;
-}
-
-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;
-
-declare class Auth<D extends IStorableData> {
-    private authInfo;
-    require(): D;
-    assign(authInfo: D): void;
+declare class DummyClaudeChatBotAdapter {
 }
 
-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 class DummyDeepSeekChatBotAdapter {
 }
 
-interface IReceivedMessage extends IMessageContext {
-    reply: (message: IChatMessage) => void;
-}
-interface IChatChannel {
-    listen(callback: (message: IReceivedMessage) => void): void;
-    connect(): void;
+declare class OpenaiChatAdapter implements IChatAdapter {
+    private openai;
+    private logger;
+    nextItem(req: IChatAdapterNextItemReq): Promise<IChatItem>;
+    private mapChatItems;
+    private mapConectionMessage;
+    private mapBotMessage;
+    private mapFunctionCall;
+    private mapTool;
+    private mapResponse;
 }
 
-declare class UserResolver {
-    private userRepository;
-    constructor(userRepository: UserRepository);
-    resolve(connection: IUserConnection): Promise<User | null>;
+declare class PgChatRepository extends PgCrudRepository<Chat> implements IChatRepository {
+    constructor(pool: Pool);
+    findByConnection(query: IChatConnection): Promise<Chat | null>;
+    findMemory(chatId: string): Promise<IChatMemory | null>;
 }
 
-interface IchatControllerConfig {
+declare class PgChatMemory extends PgCrudRepository<ChatItem> implements IChatMemory {
+    private chatId;
+    constructor(pool: Pool, chatId: string);
+    findLastItems(count: number): Promise<ChatItem[]>;
 }
 
-declare function chatController(config?: IchatControllerConfig): (target: IConstructor<any>) => void;
-
-interface IChatControllerMetadata {
-    controllerConstructor: Function;
+declare class RamChatMemory implements IChatMemory {
+    private memory;
+    findLastItems(count: number): Promise<ChatItem[]>;
+    create(item: ChatItem): Promise<void>;
+    clearMemory(): Promise<void>;
 }
 
-interface IChannelMetadata {
-    controllerConstructor: IConstructor<any>;
-    functionName: string;
-    channelConstructor: IConstructor<IChatChannel>;
-    channelConfig?: object;
+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 ControllerMetadataStore {
-    private channels;
-    private chatControllers;
-    saveChannelMetadata(channelMetadata: IChannelMetadata): void;
-    saveChatControllerMetadata(controllerMetadata: IChatControllerMetadata): void;
-    getChatControllerMetadata(controllerConstructor: Function): {
-        config: IChatControllerMetadata;
-        channels: IChannelMetadata[];
-    } | null;
-}
+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;
 }
@@ -700,16 +860,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;
@@ -719,12 +869,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;
 }
 
@@ -740,11 +888,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;
 }
 
@@ -790,21 +936,6 @@ interface IWhatsAppRepository {
     findByBusinessNumber(number: string): Promise<WhatsApp | null>;
 }
 
-type IEnvType = 'development' | 'staging' | 'testing' | 'production';
-declare class Env {
-    private envType;
-    constructor();
-    isDevelopment(): boolean;
-    isProduction(): boolean;
-    isTesting(): boolean;
-    requireString(varName: string, options?: {
-        default?: string;
-    }): string;
-    requireNumber(varName: string, options?: {
-        default?: number;
-    }): number;
-}
-
 declare class EnvWhatsAppRepository implements IWhatsAppRepository {
     private env;
     constructor(env: Env);
@@ -920,19 +1051,7 @@ declare class PgWhatsAppRepository extends PgCrudRepository<WhatsApp> implements
     findByBusinessNumber(number: string): Promise<WhatsApp | 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;
-}
-
-type IWhatsAppMessageListener = (message: IConnectionChatMessage) => Promise<void>;
+type IWhatsAppMessageListener = (message: Omit<IChannelMessage, 'reply'>) => Promise<void>;
 interface IListenWhatsAppMessageRequest {
     to: string;
     listener: IWhatsAppMessageListener;
@@ -990,13 +1109,11 @@ declare class WhatsAppSender {
 
 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;
 }
 
@@ -1040,21 +1157,13 @@ declare class WhatsAppSenderByDevConnection extends WhatsAppSender {
     handleGetWhatsAppTemplate(request: IGetWhatsAppTemplateRequest): Promise<IWhatsAppTemplate | null>;
 }
 
-interface ICustomErrorData {
-    message: string;
-    humanMessage?: string;
-    code?: string;
-    httpCode?: number;
-    cause?: Error;
-    info?: any;
-}
-declare class CustomError extends Error {
-    humanMessage?: string;
-    code?: string;
-    httpCode?: number;
-    info?: any;
-    constructor(data: ICustomErrorData);
+interface IHtmlModuleOptions {
+    url: string;
+    title: string;
 }
+declare function HtmlModule(options: IHtmlModuleOptions): {
+    new (): {};
+};
 
 declare function jwtGuard(): (target: object, propertyKey: string | symbol) => void;
 
@@ -1084,10 +1193,6 @@ declare class JwtRefreshToken<A extends IStorableData> extends Entity<IJwtRefres
     get authInfo(): A;
 }
 
-declare class Mapper {
-    map<T>(data: any, ctor: IConstructor<T>): T;
-}
-
 declare class JwtSigner {
     private config;
     private mapper;
@@ -1109,69 +1214,6 @@ declare class Jwt {
     createToken(): Promise<JwtAccessAndRefreshTokenDto>;
 }
 
-interface IGetConfig {
-    path?: string;
-}
-
-declare function get(config?: string | IGetConfig): (target: object, propertyKey: string | symbol) => void;
-
-interface IMiddleware {
-    handle(req: Request, res: Response, container: DependencyContainer$1): Promise<void>;
-}
-
-declare function middleware(middlewareConstructor: IConstructor<IMiddleware>): (target: object, propertyKey: string | symbol) => void;
-
-interface IPostConfig {
-    path?: string;
-}
-
-declare function post(config?: string | IPostConfig): (target: object, propertyKey: string | symbol) => void;
-
-interface IRestControllerConfig {
-    path: string;
-}
-
-declare function restController(config: string | IRestControllerConfig): (target: IConstructor<any>) => void;
-
-interface IEndPointMetadata {
-    method: 'get' | 'post';
-    path?: string;
-    controllerConstructor: IConstructor<any>;
-    functionName: string;
-    paramsTypes: any[];
-}
-
-interface IMiddlewareMetadata {
-    controllerConstructor: IConstructor<any>;
-    functionName: string;
-    middlewareConstructor: IConstructor<IMiddleware>;
-}
-
-interface IRestControllerMetadata {
-    controllerConstructor: IConstructor<any>;
-    path: string;
-}
-
-declare class RestControllerMetadataStore {
-    private endPoints;
-    private middlewares;
-    private restControllers;
-    saveControllerMetadata(controllerMetadata: IRestControllerMetadata): void;
-    saveEndPointMetadata(endPointMetadata: IEndPointMetadata): void;
-    saveMiddlewareMetadata(middlewareMetadata: IMiddlewareMetadata): void;
-    getControllerEndPointsInfo(controllerConstructor: IConstructor<any>): {
-        middlewares: IMiddlewareMetadata[];
-        controller: IRestControllerMetadata;
-        method: "get" | "post";
-        path?: string;
-        controllerConstructor: IConstructor<any>;
-        functionName: string;
-        paramsTypes: any[];
-    }[];
-}
-
-declare function runRestControllers(controllers: IConstructor<any>[]): void;
-
 declare class JwtGuardMiddleware implements IMiddleware {
     private config;
     private auth;
@@ -1179,258 +1221,42 @@ declare class JwtGuardMiddleware implements IMiddleware {
     handle(req: Request, res: Response, container: DependencyContainer$1): Promise<void>;
 }
 
-declare class SendOneTimePasswordRequest {
-    fromEmail: string;
-    toEmail: string;
-}
-
-declare class ValidateOneTimePasswordRequest {
-    userEmail: string;
-    otp: string;
-}
-
-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>;
-}
-
-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>;
-}
-
-declare class RegisterUserWithEmailRequest {
-    email: string;
-    shortName: string;
-}
-
-declare class RegisterUserModule {
-    private userRepository;
-    private context;
-    constructor(userRepository: UserRepository, context: MessageContext);
-    registerUserWithEmail(request: RegisterUserWithEmailRequest): Promise<string>;
-}
-
-interface IHtmlModuleOptions {
-    url: string;
-    title: string;
-}
-declare function HtmlModule(options: IHtmlModuleOptions): {
-    new (): {};
-};
-
-declare class PgUserRepository extends PgCrudRepository<User> implements IUserRepository {
-    constructor(pool: Pool);
-    findByConnection(query: IUserConnection): Promise<User | null>;
-}
-
-declare class RamUserRepository implements IUserRepository {
-    private items;
-    create(chat: User): Promise<void>;
-    findByConnection(query: IUserConnection): Promise<User | null>;
-    update(chat: User): Promise<void>;
-}
-
-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 Random {
-    static slug(name: string, options: {
-        randomLength: number;
-    }): string;
-    static string(length: number): string;
-    static numberCode(length: number): 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>;
-}
-declare function runChannel(props: IrunChannelProps): void;
-
-interface IServerProvider<T, ST extends T> {
-    replace: IConstructor<T>;
-    with: IConstructor<ST>;
-    singleton?: true;
-}
-interface IServerConfig {
-    controllers: IConstructor<any>[];
-    providers?: IServerProvider<unknown, unknown>[];
-}
-declare function runServer(config: IServerConfig): void;
-
 declare function isBoolean(): (target: object, propertyKey: string | symbol) => void;
 
+declare function validateIsBoolean(value: any): IValidationResult<boolean>;
+
 declare function isDate(): (target: object, propertyKey: string | symbol) => void;
 
-declare function isModel(model: IConstructor<any>): (target: object, propertyKey: string | symbol) => void;
+declare function validateIsDate(value: any): IValidationResult<Date>;
 
 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 isOptional(): (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 max(limit: any): (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 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 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 IValidatorMetadata {
-    modelConstructor: IConstructor<any>;
-    propertyName: string;
-    validator: IValidator;
-    validatorOptions?: any;
-}
-
-declare class ValidationMetadataStore {
-    private validators;
-    saveValidatorMetadata(validatorMetadata: IValidatorMetadata): void;
-    getModelValidatorsInfo<V>(modelConstructor: IConstructor<V>): IModelValidatorsInfo<V>;
-    private getConstructorPropertiesValidatorsInfo;
-}
-
-interface IValidateArrayOptions {
-}
-interface IValidateArrayOptionsWithItemsValidators extends IValidateArrayOptions {
-    itemsValidator?: {
-        validator: IValidator;
-        options: any;
-    }[];
+interface IValidateMinOptions {
+    limit: any;
 }
-declare function validateArray(value: any, options?: IValidateArrayOptionsWithItemsValidators): IArrayValidationResult<any>;
-
-declare function isArray(options?: IValidateArrayOptions): (target: object, propertyKey: string | symbol) => void;
-
-declare function validateIsBoolean(value: any): IValidationResult<boolean>;
-
-declare function validateIsDate(value: any): IValidationResult<Date>;
-
-declare function validateIsNotEmpty(value: any): IValidationResult<any>;
-
-declare function validateIsNumber(value: any): IValidationResult<number>;
+declare function validateMin(value: any, options: IValidateMinOptions): IValidationResult<any>;
 
-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 IValidateMinOptions {
-    limit: any;
-}
-declare function validateMin(value: any, options: IValidateMinOptions): IValidationResult<any>;
-
-declare function validateIsPresent(value: any): IValidationResult<any>;
-
-declare function validateModel<V>(value: any, info: IModelValidatorsInfo<V>): IModelValidationResult<V>;
-
-declare function validate<V>(value: any, modelConstructor: IConstructor<V>): IModelValidationResult<V>;
-
-declare function modelInfo<V>(modelConstructor: IConstructor<V>): IModelValidatorsInfo<V>;
-
-export { Async, Auth, AuthenticationModule, Chat, ChatBot, ChatBotAdapter, ChatBotMetadataStore, ChatItem, ChatMemory, ChatRepository, ChatResolver, ClaudeChatBotAdapter, CmdChannel, Command, CommandMetadataStore, Container, ControllerMetadataStore, CustomError, DeepSeekChatBotAdapter, EmailService, Entity, Env, EnvWhatsAppRepository, ExpressProvider, HtmlModule, HttpServerProvider, type IArrayValidationError, type IArrayValidationResult, type IBotMessageItem, type IChannelMetadata, type IChatAdapter, type IChatAdapterNextItemReq, type IChatBot, type IChatBotAdapter, type IChatBotMetadata, type IChatChannel, type IChatConnection, type IChatControllerMetadata, type IChatData, type IChatFunctionCall, type IChatItem, type IChatItemData, type IChatItemType, type IChatMemory, type IChatMessage, type IChatRepository, type IChatTool, type IChatToolParameter, type IChatType, type ICommandConfig, type ICommandHandler, type ICommandHandlerConfig, type IConnectionChatMessage, type IConnectionMessageItem, type IConstructor, type ICrudRepository, type ICustomErrorData, type IEmailService, type IEndPointMetadata, type IEntityData, type IEnvType, type IFunctionCall, type IFunctionCallItem, type IGetConfig, type IGetWhatsAppTemplateRequest, type IHtmlModuleOptions, type IJobData, type IJobEvent, type IJobEventListener, type IJwtRefreshTokenData, type IListenWhatsAppMessageRequest, type IMessageContext, type IMessageMetadata, type IMiddleware, type IMiddlewareMetadata, type IMindset, type IMindsetDecoration, type IMindsetFunctionConfig, type IMindsetFunctionDecoration, type IMindsetFunctionMetadata, type IMindsetFunctionParamMetadata, type IMindsetIdentity, type IMindsetMetadata, type IMindsetModuleConfig, type IMindsetModuleDecoration, type IMindsetModuleMetadata, type IModelValidationError, type IModelValidationResult, type IModelValidatorsInfo, type IOtpService, type IParamConfig, type IParamDecoration, type IPersistentData, type IPgRepositoryConfig, type IPostConfig, type IPrimitive, type IPropertyValidatorInfo, type IReceivedMessage, type IRestControllerConfig, type IRestControllerMetadata, type ISendEmailRequest, type ISendWhatsAppRequest, type ISendWhatsAppTemplateRequest, type IServerConfig, type IServerProvider, type ISocketChannelConfig, type ISocketChannelReceivedMessage, type IStorableData, type ITelegramChannelConfig, type IUserConnection, type IUserData, type IUserRepository, 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, type IrunChannelProps, 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, MessageContext, Mindset, MindsetMetadataStore, MindsetOperator, OpenaiChatAdapter, OpenaiChatBotAdapter, OtpService, PARAM_DECORATION_IS_OPTIONAL, PARAM_DECORATION_PARAM, Persistent, PgChatMemory, PgChatRepository, PgCrudRepository, PgRepositoryBase, PgUserRepository, PgWhatsAppRepository, RamChatMemory, RamChatRepository, RamUserRepository, Random, RegisterUserModule, RegisterUserWithEmailRequest, RestControllerMetadataStore, SendOneTimePasswordRequest, SocketChannel, SocketChannelConfig, SocketServerProvider, Storable, TelegramChannel, TelegramChannelConfig, User, UserRepository, UserResolver, ValidateOneTimePasswordRequest, ValidationMetadataStore, WhatsApp, WhatsAppChannel, WhatsAppReceiver, WhatsAppReceiverByDevConnection, WhatsAppReceiverByWebHook, WhatsAppRepository, WhatsAppSender, WhatsAppSenderByCloudApi, WhatsAppSenderByDevConnection, WhatsappChannelConfig, chatBot, chatController, 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, prepareChatContainer, restController, runAsyncCommandHandlers, runChannel, runRestControllers, runServer, scoped, singleton, socket, telegram, validate, validateArray, validateIsBoolean, validateIsDate, validateIsNotEmpty, validateIsNumber, validateIsPresent, validateIsString, validateMax, validateMin, validateModel, whatsapp };
+export { Async, Auth, Chat, ChatAdapter, ChatBot, ChatBotMetadataStore, ChatItem, ChatMemory, ChatRepository, ChatResolver, CmdChannel, Command, CommandMetadataStore, Container, ControllerMetadataStore, CustomError, DummyClaudeChatBotAdapter, DummyDeepSeekChatBotAdapter, Entity, Env, EnvWhatsAppRepository, ExpressProvider, HtmlModule, HttpServerProvider, type IArrayValidationError, type IArrayValidationResult, type IBotMessageItem, type IChannelMessage, type IChannelMetadata, type IChatAdapter, type IChatAdapterNextItemReq, 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 IEndPointMetadata, type IEntityData, type IEnvType, type IFunctionCall, type IFunctionCallItem, type IGetConfig, type IGetWhatsAppTemplateRequest, type IHtmlModuleOptions, type IHumanMessageItem, type IJobData, type IJobEvent, type IJobEventListener, type IJobRepository, type IJwtRefreshTokenData, 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 IParamConfig, type IParamDecoration, type IPersistentData, type IPgRepositoryConfig, type IPostConfig, 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, 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 };