@wabot-dev/framework 0.1.0-beta.44 → 0.1.0-beta.46

package/dist/src/index.d.ts

@@ -6,11 +6,11 @@ import DependencyContainer, { PreResolutionInterceptorCallback, PostResolutionIn
 import InterceptionOptions from 'tsyringe/dist/typings/types/interceptor-options';
 import { Server } from 'http';
 import { Express, Request, Response } from 'express';
-import { Server as Server$1 } from 'socket.io';
 import * as big_js from 'big.js';
 import { Pool } from 'pg';
-import { Socket } from 'socket.io-client';
+import { Server as Server$1, Socket } from 'socket.io';
 import { Algorithm } from 'jsonwebtoken';
+import { Socket as Socket$1 } from 'socket.io-client';
 
 type IPrimitive = null | number | string | boolean | undefined;
 type IStorableData = {
@@ -131,6 +131,20 @@ declare class Mapper {
     map<T>(data: any, ctor: IConstructor<T>): T;
 }
 
+interface PasswordHashOptions {
+    password: string;
+    saltLength?: number;
+    keyLength?: number;
+}
+declare class Password {
+    static hash(options: PasswordHashOptions): string;
+    static isValid(req: {
+        password: string;
+        hash: string;
+    }): boolean;
+    static generate(length: number): string;
+}
+
 declare class Random {
     static slug(name: string, options: {
         randomLength: number;
@@ -235,6 +249,44 @@ declare function validate<V>(value: any, modelConstructor: IConstructor<V>): IMo
 
 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>;
+
+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 min(limit: any): (target: object, propertyKey: string | symbol) => void;
+
+interface IValidateMinOptions {
+    limit: any;
+}
+declare function validateMin(value: any, options: IValidateMinOptions): IValidationResult<any>;
+
+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 ICommandConfig {
     name?: string;
 }
@@ -686,80 +738,6 @@ declare class ExpressProvider {
     private createExpress;
 }
 
-interface IEndPointConfig {
-    path?: string;
-    disableJsonParser?: boolean;
-    disableUrlEncodedParser?: boolean;
-}
-
-declare function get(config?: string | IEndPointConfig): (target: object, propertyKey: string | symbol) => void;
-
-interface IMiddleware {
-    handle(req: Request, res: Response, container: DependencyContainer$1): Promise<void>;
-}
-
-declare function middleware(middlewareConstructor: IConstructor<IMiddleware>): (target: object, propertyKey: string | symbol) => void;
-
-declare function post(config?: string | IEndPointConfig): (target: object, propertyKey: string | symbol) => void;
-
-interface IRestControllerConfig {
-    path: string;
-}
-
-declare function restController(config: string | IRestControllerConfig): (target: IConstructor<any>) => void;
-
-interface IEndPointMetadata {
-    method: 'get' | 'post';
-    config?: IEndPointConfig;
-    controllerConstructor: IConstructor<any>;
-    functionName: string;
-    paramsTypes: any[];
-}
-
-interface IMiddlewareMetadata {
-    controllerConstructor: IConstructor<any>;
-    functionName: string;
-    middlewareConstructor: IConstructor<IMiddleware>;
-}
-
-interface IRestControllerMetadata {
-    controllerConstructor: IConstructor<any>;
-    path: string;
-}
-
-declare class RestControllerMetadataStore {
-    private endPoints;
-    private middlewares;
-    private restControllers;
-    saveControllerMetadata(controllerMetadata: IRestControllerMetadata): void;
-    saveEndPointMetadata(endPointMetadata: IEndPointMetadata): void;
-    saveMiddlewareMetadata(middlewareMetadata: IMiddlewareMetadata): void;
-    getControllerEndPointsInfo(controllerConstructor: IConstructor<any>): {
-        middlewares: IMiddlewareMetadata[];
-        controller: IRestControllerMetadata;
-        method: "get" | "post";
-        config?: IEndPointConfig;
-        controllerConstructor: IConstructor<any>;
-        functionName: string;
-        paramsTypes: any[];
-    }[];
-}
-
-declare function runRestControllers(controllers: IConstructor<any>[]): void;
-
-declare const EXPRESS_REQ = "EXPRESS_REQ";
-declare const EXPRESS_RES = "EXPRESS_RES";
-
-declare class SocketServerProvider {
-    private httpServerProvider;
-    private socketServer;
-    private logger;
-    constructor(httpServerProvider: HttpServerProvider);
-    getSocketServer(): Server$1;
-    listen(): void;
-    private createSocketServer;
-}
-
 interface IMoneyData extends IStorableData {
     amount: string;
     currency: string;
@@ -782,6 +760,11 @@ declare class Money extends Storable<IMoneyData> {
     static zero(currency: string): Money;
 }
 
+declare class MoneyDto {
+    amount: string;
+    currency: string;
+}
+
 type IPgRepositoryConfig<P extends Entity<IEntityData>> = {
     schema?: string;
     table: string;
@@ -834,106 +817,372 @@ declare class PgCrudRepository<P extends Entity<IEntityData>> extends PgReposito
     discard(item: P): Promise<void>;
 }
 
-declare class PgJobRepository extends PgCrudRepository<Job> implements IJobRepository {
-    constructor(pool: Pool);
+interface IEndPointConfig {
+    path?: string;
+    disableJsonParser?: boolean;
+    disableUrlEncodedParser?: boolean;
 }
 
-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 function get(config?: string | IEndPointConfig): (target: object, propertyKey: string | symbol) => void;
 
-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;
+interface IMiddleware {
+    handle(req: Request, res: Response, container: DependencyContainer$1): Promise<void>;
 }
 
-declare class GoogleChatAdapter implements IChatAdapter {
-    private env;
-    private genai;
-    private logger;
-    constructor(env: Env);
-    nextItem(req: IChatAdapterNextItemReq): Promise<IChatAdapterNextItemRes>;
-    private mapChatItems;
-    private mapHumanMessage;
-    private mapBotMessage;
-    private mapFunctionCall;
-    private mapTool;
-    private mapResponse;
-}
+declare function middleware(middlewareConstructor: IConstructor<IMiddleware>): (target: object, propertyKey: string | symbol) => void;
 
-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 function post(config?: string | IEndPointConfig): (target: object, propertyKey: string | symbol) => void;
+
+interface IRestControllerConfig {
+    path: string;
 }
 
-declare class PgChatRepository extends PgCrudRepository<Chat> implements IChatRepository {
-    constructor(pool: Pool);
-    findByConnection(query: IChatConnection): Promise<Chat | null>;
-    findMemory(chatId: string): Promise<IChatMemory | null>;
+declare function restController(config: string | IRestControllerConfig): (target: IConstructor<any>) => void;
+
+interface IEndPointMetadata {
+    method: 'get' | 'post';
+    config?: IEndPointConfig;
+    controllerConstructor: IConstructor<any>;
+    functionName: string;
+    paramsTypes: any[];
 }
 
-declare class PgChatMemory extends PgCrudRepository<ChatItem> implements IChatMemory {
-    private chatId;
-    constructor(pool: Pool, chatId: string);
-    findLastItems(count: number): Promise<ChatItem[]>;
+interface IMiddlewareMetadata {
+    controllerConstructor: IConstructor<any>;
+    functionName: string;
+    middlewareConstructor: IConstructor<IMiddleware>;
 }
 
-declare class RamChatMemory implements IChatMemory {
-    private memory;
-    findLastItems(count: number): Promise<ChatItem[]>;
-    create(item: ChatItem): Promise<void>;
-    clearMemory(): Promise<void>;
+interface IRestControllerMetadata {
+    controllerConstructor: IConstructor<any>;
+    path: string;
 }
 
-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 RestControllerMetadataStore {
+    private endPoints;
+    private middlewares;
+    private restControllers;
+    saveControllerMetadata(controllerMetadata: IRestControllerMetadata): void;
+    saveEndPointMetadata(endPointMetadata: IEndPointMetadata): void;
+    saveMiddlewareMetadata(middlewareMetadata: IMiddlewareMetadata): void;
+    getControllerEndPointsInfo(controllerConstructor: IConstructor<any>): {
+        middlewares: IMiddlewareMetadata[];
+        controller: IRestControllerMetadata;
+        method: "get" | "post";
+        config?: IEndPointConfig;
+        controllerConstructor: IConstructor<any>;
+        functionName: string;
+        paramsTypes: any[];
+    }[];
 }
 
-declare class WabotChatAdapter implements IChatAdapter {
-    private apiKey;
-    private baseUrl;
+declare function runRestControllers(controllers: IConstructor<any>[]): void;
+
+declare const EXPRESS_REQ = "EXPRESS_REQ";
+declare const EXPRESS_RES = "EXPRESS_RES";
+
+declare class SocketServerProvider {
+    private httpServerProvider;
+    private socketServer;
     private logger;
-    constructor(env: Env);
-    nextItem(req: IChatAdapterNextItemReq): Promise<IChatAdapterNextItemRes>;
+    constructor(httpServerProvider: HttpServerProvider);
+    getSocketServer(): Server$1;
+    listen(): void;
+    private createSocketServer;
 }
 
-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 IConnectionMiddleware {
+    handle(socket: Socket, container: DependencyContainer$1): Promise<void>;
+}
+
+declare function connectionMiddleware(middlewareConstructor: IConstructor<IConnectionMiddleware>): (target: object, propertyKey: string | symbol) => void;
+
+interface ISocketConnectionConfig {
+    namespace: string;
+}
+
+declare function socketConnection(config?: string | ISocketConnectionConfig): (target: object, propertyKey: string | symbol) => void;
+
+interface ISocketControllerConfig {
+    namespace: string;
+}
+
+declare function socketController(config?: string | ISocketControllerConfig): (target: IConstructor<any>) => void;
+
+interface ISocketEventConfig {
+    namespace?: string;
+    event: string;
+}
+
+declare function socketEvent(config: string | ISocketEventConfig): (target: object, propertyKey: string | symbol) => void;
+
+interface IConnectionMiddlewareMetadata {
+    controllerConstructor: IConstructor<any>;
+    functionName: string;
+    middlewareConstructor: IConstructor<IConnectionMiddleware>;
+}
+
+interface ISocketConnectionMetadata {
+    config?: ISocketConnectionConfig;
+    controllerConstructor: IConstructor<any>;
+    functionName: string;
+    paramsTypes: any[];
+}
+
+interface ISocketControllerMetadata {
+    controllerConstructor: IConstructor<any>;
+    config?: ISocketControllerConfig;
+}
+
+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);
+}
+
+declare function apiKeyGuard(): (target: object, propertyKey: string | symbol) => void;
+
+interface IApiKeyData extends IEntityData {
+    passwordHash?: string;
+    authInfo: IStorableData;
+}
+interface IApiKeySecretData {
+    id: string;
+    pass: string;
+}
+declare class ApiKey extends Entity<IApiKeyData> {
+    get authInfo(): IStorableData;
+    generatePassword(): string;
+    isValidPassword(password: string): boolean;
+    validatePassword(password: string): void;
+    static inflate(secret: string): IApiKeySecretData;
+    static deflate(data: IApiKeySecretData): string;
+}
+
+interface IApiKeyRepository {
+    find(id: string): Promise<ApiKey | null>;
+    findOrThrow(id: string): Promise<ApiKey>;
+    create(item: ApiKey): Promise<void>;
+}
+
+declare class ApiKeyRepository implements IApiKeyRepository {
+    find(id: string): Promise<ApiKey | null>;
+    findOrThrow(id: string): Promise<ApiKey>;
+    create(item: ApiKey): Promise<void>;
+}
+
+declare class ApiKeyGuardMiddleware implements IMiddleware {
+    private apiKeyRepository;
+    private auth;
+    constructor(apiKeyRepository: ApiKeyRepository, auth: Auth<any>);
+    handle(req: Request, res: Response, container: DependencyContainer$1): Promise<void>;
+}
+
+declare class PgApiKeyRepository extends PgCrudRepository<ApiKey> implements IApiKeyRepository {
+    constructor(pool: Pool);
+}
+
+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;
+}
+declare class JwtRefreshToken<A extends IStorableData> extends Entity<IJwtRefreshTokenData<A>> {
+    get authInfo(): A;
+}
+
+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>;
+    signRefreshToken(refreshToken: JwtRefreshToken<any>): Promise<JwtTokenDto>;
+    signAccessAndRefreshToken(refreshToken: JwtRefreshToken<any>): Promise<JwtAccessAndRefreshTokenDto>;
+}
+
+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>;
+    discard(item: JwtRefreshToken<D>): Promise<void>;
+}
+
+declare class Jwt {
+    private auth;
+    private jwtSigner;
+    private jwtRefreshTokenRepository;
+    constructor(auth: Auth<any>, jwtSigner: JwtSigner, jwtRefreshTokenRepository: JwtRefreshTokenRepository<any>);
+    createToken(): Promise<JwtAccessAndRefreshTokenDto>;
+}
+
+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 genai;
+    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 {
@@ -990,7 +1239,7 @@ declare class WhatsappChannelConfig implements IWhatsappChannelConfig {
     constructor(number: string);
 }
 
-declare function whatsapp(config: IWhatsappChannelConfig): (target: object, propertyKey: string | symbol) => void;
+declare function whatsApp(config: string | IWhatsappChannelConfig): (target: object, propertyKey: string | symbol) => void;
 
 interface IWhatsAppBusinessNumber extends IStorableData {
     id: string;
@@ -1031,7 +1280,23 @@ declare class EnvWhatsAppRepository implements IWhatsAppRepository {
     private getFromEnvVars;
 }
 
-type IWhatsAppTemplateParameter = {
+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: Omit<IChannelMessage, 'reply'>) => Promise<void>;
+interface IListenWhatsAppMessageRequest {
+    to: string;
+    listener: IWhatsAppMessageListener;
+}
+declare class WhatsAppReceiver {
+    connect(): Promise<void>;
+    listenMessage(request: IListenWhatsAppMessageRequest): void;
+}
+
+type IWhatsAppCloudTemplateParameter = {
     type: 'text';
     text: string;
     parameter_name?: string;
@@ -1048,111 +1313,38 @@ type IWhatsAppTemplateParameter = {
         fallback_value: string;
     };
 };
-interface IWhatsAppTemplateMessage {
+interface IWhatsAppCloudTemplateMessage {
     templateName: string;
     languageCode: string;
-    parameters: IWhatsAppTemplateParameter[];
+    parameters: IWhatsAppCloudTemplateParameter[];
 }
 
-interface IWhatsAppTemplateResponse {
-    data: IWhatsAppTemplate[];
-    paging: IWhatsAppApiPaging;
+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 IWhatsAppApiPaging {
-    cursors: IWhatsAppApiCursors;
+interface IWhatsAppCloudApiPaging {
+    cursors: IWhatsAppCloudApiCursors;
 }
-interface IWhatsAppApiCursors {
+interface IWhatsAppCloudApiCursors {
     before: string;
     after: string;
 }
 
-interface IWhatsAppWebhookPayload {
-    object: 'whatsapp_business_account';
-    entry: IEntry[];
-}
-interface IEntry {
-    id: string;
-    changes: IChange[];
-}
-type IChange = IMessagesChange;
-interface IMessagesChange {
-    value: IMessagesChangeValue;
-    field: 'messages';
-}
-interface IMessagesChangeValue {
-    messaging_product: 'whatsapp';
-    metadata: IMessageMetadata;
-    contacts?: IWhatsAppContact[];
-    messages?: IWhatsAppMessage[];
-}
-interface IMessageMetadata {
-    display_phone_number: string;
-    phone_number_id: string;
-}
-interface IWhatsAppContact {
-    profile: {
-        name: string;
-    };
-    wa_id: string;
-}
-type IWhatsAppMessage = ITextMessage | IAudioMessage;
-interface IBaseMessage {
-    from: string;
-    id: string;
-    timestamp: string;
-    type: string;
-}
-interface ITextMessage extends IBaseMessage {
-    type: 'text';
-    text: {
-        body: string;
-    };
-}
-interface IAudioMessage extends IBaseMessage {
-    type: 'audio';
-    audio: {
-        mime_type: string;
-        sha256: string;
-        id: string;
-        voice: boolean;
-    };
-}
-
-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: 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>;
-    listenMessage(request: IListenWhatsAppMessageRequest): void;
-    protected handlePayload(payload: IWhatsAppWebhookPayload): Promise<void>;
-    private emmitMessage;
-}
-
 declare class WhatsAppRepository implements IWhatsAppRepository {
     findBySlug(slug: string): Promise<WhatsApp | null>;
     findByBusinessNumber(number: string): Promise<WhatsApp | null>;
@@ -1166,7 +1358,7 @@ interface ISendWhatsAppRequest {
 interface ISendWhatsAppTemplateRequest {
     from: string;
     to: string;
-    templateMessage: IWhatsAppTemplateMessage;
+    templateMessage: IWhatsAppCloudTemplateMessage;
     senderName: string;
 }
 interface IGetWhatsAppTemplateRequest {
@@ -1178,20 +1370,16 @@ interface IWhatsAppSenderOptions {
     writeChatMemory?: boolean;
 }
 declare class WhatsAppSender {
-    protected logger: Logger;
     protected chatRepository: ChatRepository;
     protected chatResolver: ChatResolver;
     protected whatsAppRepository: WhatsAppRepository;
-    constructor(logger: Logger, chatRepository: ChatRepository, chatResolver: ChatResolver, whatsAppRepository: WhatsAppRepository);
-    protected handleSendRequest(request: ISendWhatsAppRequest): Promise<void>;
-    protected handleSendTemplateRequest(request: ISendWhatsAppTemplateRequest): Promise<void>;
-    protected handleGetWhatsAppTemplate(request: IGetWhatsAppTemplateRequest): Promise<IWhatsAppTemplate | null>;
+    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 {
@@ -1204,151 +1392,141 @@ declare class WhatsAppChannel implements IChatChannel {
     connect(): void;
 }
 
-declare class WabotDevConnection {
-    private devProxy;
-    private devProxySocket;
-    private devToken;
-    private logger;
-    static isTokenAvailable(): boolean;
-    constructor();
-    getSocket(): Promise<Socket>;
+interface IWhatsAppCloudWebhookPayload {
+    object: 'whatsapp_business_account';
+    entry: IWhatsAppCloudEntry[];
 }
-
-declare class WhatsAppReceiverByDevConnection extends WhatsAppReceiver {
-    private wabotDevConnection;
-    constructor(wabotDevConnection: WabotDevConnection);
-    connect(): Promise<void>;
+interface IWhatsAppCloudEntry {
+    id: string;
+    changes: IWhatsAppCloudChange[];
+}
+type IWhatsAppCloudChange = IWhatsAppCloudMessagesChange;
+interface IWhatsAppCloudMessagesChange {
+    value: IWhatsAppCloudMessagesChangeValue;
+    field: 'messages';
+}
+interface IWhatsAppCloudMessagesChangeValue {
+    messaging_product: 'whatsapp';
+    metadata: IWhatsAppCloudMessageMetadata;
+    contacts?: IWhatsAppCloudContact[];
+    messages?: IWhatsAppCloudMessage[];
+}
+interface IWhatsAppCloudMessageMetadata {
+    display_phone_number: string;
+    phone_number_id: string;
+}
+interface IWhatsAppCloudContact {
+    profile: {
+        name: string;
+    };
+    wa_id: string;
+}
+type IWhatsAppCloudMessage = IWhatsAppCloudTextMessage | IWhatsAppCloudAudioMessage;
+interface IWhatsAppCloudBaseMessage {
+    from: string;
+    id: string;
+    timestamp: string;
+    type: string;
+}
+interface IWhatsAppCloudTextMessage extends IWhatsAppCloudBaseMessage {
+    type: 'text';
+    text: {
+        body: string;
+    };
+}
+interface IWhatsAppCloudAudioMessage extends IWhatsAppCloudBaseMessage {
+    type: 'audio';
+    audio: {
+        mime_type: string;
+        sha256: string;
+        id: string;
+        voice: boolean;
+    };
 }
 
-declare class WhatsAppReceiverByWebHook extends WhatsAppReceiver {
+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 class WhatsAppSenderByCloudApi extends WhatsAppSender {
+    private logger;
     constructor(chatRepository: ChatRepository, chatResolver: ChatResolver, whatsAppRepository: WhatsAppRepository);
-    handleSendRequest(request: ISendWhatsAppRequest): Promise<void>;
-    handleSendTemplateRequest(request: ISendWhatsAppTemplateRequest): Promise<void>;
-    handleGetWhatsAppTemplate(request: IGetWhatsAppTemplateRequest): Promise<IWhatsAppTemplate | null>;
-}
-
-declare class WhatsAppSenderByDevConnection extends WhatsAppSender {
-    private wabotDevConnection;
-    constructor(wabotDevConnection: WabotDevConnection, chatRepository: ChatRepository, chatResolver: ChatResolver, whatsAppRepository: WhatsAppRepository);
-    handleSendRequest(request: ISendWhatsAppRequest): Promise<void>;
-    handleSendTemplateRequest(request: ISendWhatsAppTemplateRequest): Promise<void>;
-    handleGetWhatsAppTemplate(request: IGetWhatsAppTemplateRequest): Promise<IWhatsAppTemplate | null>;
-}
-
-interface IHtmlModuleOptions {
-    url: string;
-    title: string;
-}
-declare function HtmlModule(options: IHtmlModuleOptions): {
-    new (): {};
-};
-
-declare function jwtGuard(): (target: object, propertyKey: string | symbol) => void;
-
-declare class JwtTokenDto {
-    token?: string;
-    expiration?: Date;
+    sendWhatsApp(request: ISendWhatsAppRequest, options?: IWhatsAppSenderOptions): Promise<void>;
+    sendWhatsAppTemplate(request: ISendWhatsAppTemplateRequest, options?: IWhatsAppSenderOptions): Promise<void>;
+    protected getWhatsAppTemplate(request: IGetWhatsAppTemplateRequest): Promise<IWhatsAppCloudTemplate | null>;
 }
 
-declare class JwtAccessAndRefreshTokenDto {
-    access?: JwtTokenDto;
-    refresh?: JwtTokenDto;
+interface IWhatsAppProxyMessageContent {
+    text: string;
 }
 
-declare class JwtConfig {
-    secretOrPublicKey: string;
-    secretOrPrivateKey: string;
-    algorithm: Algorithm;
-    accessExpirationSeconds: number;
-    refreshExpirationSeconds: number;
-    constructor(env: Env);
+interface IWhatsAppProxyMessage {
+    from: string;
+    to: string;
+    senderName?: string;
+    content: IWhatsAppProxyMessageContent;
 }
 
-interface IJwtRefreshTokenData<A extends IStorableData> extends IEntityData {
-    authInfo: A;
+declare const WHATSAPP_PROXY_SEND_MESSAGE_EVENT: "sendMessage";
+interface IWhatsAppProxySendMessageEventReq {
+    event: typeof WHATSAPP_PROXY_SEND_MESSAGE_EVENT;
+    data: IWhatsAppProxyMessage;
 }
-declare class JwtRefreshToken<A extends IStorableData> extends Entity<IJwtRefreshTokenData<A>> {
-    get authInfo(): A;
+declare const WHATSAPP_PROXY_LISTEN_MESSAGE_EVENT: "listenMessage";
+interface IWhatsAppProxyListenMessageEventReq {
+    event: typeof WHATSAPP_PROXY_LISTEN_MESSAGE_EVENT;
+    data: IWhatsAppProxyListenMessageEventData;
 }
-
-declare class JwtSigner {
-    private config;
-    private mapper;
-    constructor(config: JwtConfig, mapper: Mapper);
-    signAccessToken<D extends IStorableData>(info: D | JwtRefreshToken<any>): Promise<JwtTokenDto>;
-    signRefreshToken(refreshToken: JwtRefreshToken<any>): Promise<JwtTokenDto>;
-    signAccessAndRefreshToken(refreshToken: JwtRefreshToken<any>): Promise<JwtAccessAndRefreshTokenDto>;
+interface IWhatsAppProxyListenMessageEventData {
+    from?: string[];
+    to: string[];
 }
-
-declare class JwtRefreshTokenRepository<D extends IStorableData> extends PgCrudRepository<JwtRefreshToken<D>> {
-    constructor(pool: Pool);
+declare const WHATSAPP_MESSAGE_EVENT: "message";
+interface IWhatsAppProxyMessageEventReq {
+    event: typeof WHATSAPP_MESSAGE_EVENT;
+    data: IWhatsAppProxyMessage;
 }
 
-declare class Jwt {
-    private auth;
-    private jwtSigner;
-    private jwtRefreshTokenRepository;
-    constructor(auth: Auth<any>, jwtSigner: JwtSigner, jwtRefreshTokenRepository: JwtRefreshTokenRepository<any>);
-    createToken(): Promise<JwtAccessAndRefreshTokenDto>;
-}
-
-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 WhatsAppWabotProxyConnection {
+    private baseUrl;
+    private socket;
+    private apiKey;
+    private logger;
+    constructor(env: Env);
+    getSocket(): Promise<Socket$1>;
 }
 
-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>;
-
-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 min(limit: any): (target: object, propertyKey: string | symbol) => void;
-
-interface IValidateMinOptions {
-    limit: any;
+declare class WhatsAppReceiverByWabotProxy extends WhatsAppReceiver {
+    private connection;
+    private loger;
+    constructor(connection: WhatsAppWabotProxyConnection);
+    connect(): Promise<void>;
+    listenMessage(request: IListenWhatsAppMessageRequest): void;
 }
-declare function validateMin(value: any, options: IValidateMinOptions): IValidationResult<any>;
 
-declare function max(limit: any): (target: object, propertyKey: string | symbol) => void;
-
-interface IValidateMaxOptions {
-    limit: any;
+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 function validateMax(value: any, options: IValidateMaxOptions): IValidationResult<any>;
 
-declare class MoneyDto {
-    amount: string;
-    currency: string;
+interface IHtmlModuleOptions {
+    url: string;
+    title: string;
 }
+declare function HtmlModule(options: IHtmlModuleOptions): {
+    new (): {};
+};
 
-export { AnthropicChatAdapter, Async, Auth, Chat, ChatAdapter, ChatBot, ChatBotMetadataStore, ChatItem, ChatMemory, ChatRepository, ChatResolver, CmdChannel, Command, CommandMetadataStore, Container, ControllerMetadataStore, CustomError, DeepSeekChatAdapter, EXPRESS_REQ, EXPRESS_RES, Entity, Env, EnvWhatsAppRepository, ExpressProvider, GoogleChatAdapter, HtmlModule, HttpServerProvider, type IArrayValidationError, type IArrayValidationResult, type IBotMessageItem, type IChannelMessage, type IChannelMetadata, type IChatAdapter, type IChatAdapterNextItemReq, type IChatAdapterNextItemRes, type IChatBot, type IChatBotMetadata, type IChatChannel, type IChatConnection, type IChatControllerMetadata, type IChatData, type IChatItem, type IChatItemData, type IChatItemType, type IChatMemory, type IChatMessage, type IChatRepository, type IChatType, type ICommandConfig, type ICommandHandler, type ICommandHandlerConfig, type IConstructor, type ICrudRepository, type ICustomErrorData, type IEndPointConfig, type IEndPointMetadata, type IEntityData, type IEnvType, type IFunctionCall, type IFunctionCallItem, type IGetWhatsAppTemplateRequest, type IHtmlModuleOptions, type IHumanMessageItem, type IJobData, type IJobEvent, type IJobEventListener, type IJobRepository, type IJwtRefreshTokenData, type ILanguageModelUsage, type IListenWhatsAppMessageRequest, type IMessageContext, type IMessageMetadata, type IMiddleware, type IMiddlewareMetadata, type IMindset, type IMindsetDecoration, type IMindsetFunctionConfig, type IMindsetFunctionDecoration, type IMindsetFunctionMetadata, type IMindsetFunctionParamMetadata, type IMindsetIdentity, type 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 IStorableData, type ITelegramChannelConfig, type IValidateArrayOptions, type IValidateArrayOptionsWithItemsValidators, type IValidateMaxOptions, type IValidateMinOptions, type IValidationError, type IValidationResult, type IValidator, type IValidatorMetadata, type IWhatsAppBusinessAccount, type IWhatsAppBusinessNumber, type IWhatsAppContact, type IWhatsAppData, type IWhatsAppMessage, type IWhatsAppMessageListener, type IWhatsAppRepository, type IWhatsAppSenderOptions, type IWhatsAppTemplate, type IWhatsAppTemplateComponent, type IWhatsAppTemplateMessage, type IWhatsAppTemplateParameter, type IWhatsAppTemplateResponse, type IWhatsAppWebhookPayload, type IWhatsappChannelConfig, type IchatControllerConfig, Job, JobRepository, JobRunner, JobsEventsHub, Jwt, JwtAccessAndRefreshTokenDto, JwtConfig, JwtGuardMiddleware, JwtRefreshToken, JwtRefreshTokenRepository, JwtSigner, JwtTokenDto, Lifecycle, Logger, MINDSET_DECORATION_MINDSET, MINDSET_FUNCTION_DECORATION_FUNCTION, MINDSET_MODULE_DECORATION_MODULE, Mapper, Mindset, MindsetMetadataStore, MindsetOperator, Money, MoneyDto, OpenaiChatAdapter, PARAM_DECORATION_IS_OPTIONAL, PARAM_DECORATION_PARAM, Persistent, PgChatMemory, PgChatRepository, PgCrudRepository, PgJobRepository, PgRepositoryBase, PgWhatsAppRepository, RamChatMemory, RamChatRepository, Random, RestControllerMetadataStore, SocketChannel, SocketChannelConfig, SocketServerProvider, Storable, TelegramChannel, TelegramChannelConfig, ValidationMetadataStore, WabotChatAdapter, 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 };
+export { AnthropicChatAdapter, ApiKey, 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 IApiKeySecretData, 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 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 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, 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, apiKeyGuard, chatBot, chatController, chatItemTypeOptions, cmd, command, commandHandler, connectionMiddleware, container, get, inject, injectable, isArray, isBoolean, isDate, isModel, isNotEmpty, isNumber, isOptional, isPresent, isString, jwtConnectionGuard, jwtGuard, max, middleware, min, mindset, mindsetFunction, mindsetModule, modelInfo, param, post, restController, runAsyncCommandHandlers, runChatControllers, runRestControllers, runSocketControllers, scoped, singleton, socket, socketConnection, socketController, socketEvent, telegram, validate, validateArray, validateIsBoolean, validateIsDate, validateIsNotEmpty, validateIsNumber, validateIsPresent, validateIsString, validateMax, validateMin, validateModel, whatsApp };