@wabot-dev/framework 0.2.6 → 0.4.0-beta.1

package/dist/src/index.d.ts

@@ -7,48 +7,55 @@ import InterceptionOptions from 'tsyringe/dist/typings/types/interceptor-options
 import { Server } from 'http';
 import { Express, Request, Response } from 'express';
 import * as big_js from 'big.js';
-import { Pool } from 'pg';
+import { Pool, PoolClient } from 'pg';
+import { AsyncLocalStorage } from 'async_hooks';
 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 = {
-    [key: string]: IPrimitive | IPrimitive[] | IStorableData | IStorableData[];
-};
-declare class Storable<D extends IStorableData> {
-    protected data: D;
-    constructor(data: D);
-}
+type IStorablePrimitive = null | number | string | boolean | undefined;
+
+type IStorableType<T> = T extends IStorablePrimitive ? T : T extends (...args: any[]) => any ? never : T extends Array<infer U> ? Array<IStorableType<U>> : T extends object ? {
+    [K in keyof T]: IStorableType<T[K]>;
+} : never;
 
-declare class Auth<D extends IStorableData> {
+declare class Auth<D> {
     private authInfo;
     private overrided;
-    require(): D;
-    assign(authInfo: D): void;
-    override(authInfo: D): void;
+    require(): IStorableType<D>;
+    assign(authInfo: IStorableType<D>): void;
+    override(authInfo: IStorableType<D>): void;
     clear(): void;
     isAssigned(): boolean;
     wasOverrided(): boolean;
 }
 
-interface IEntityData extends IStorableData {
+type IStorableData<O extends object> = {
+    [K in keyof O]: IStorableType<O[K]>;
+};
+
+declare class Storable<D extends object> {
+    protected data: IStorableData<D>;
+    constructor(data: IStorableData<D>);
+}
+
+interface IEntityData {
     id?: string;
     createdAt?: number | null;
     discardedAt?: number | null;
 }
 declare class Entity<D extends IEntityData> extends Storable<D> {
-    get id(): string;
+    get id(): NonNullable<IStorableType<D["id"]>>;
     /**
      * @deprecated use id
      */
-    getId(): string;
+    getId(): NonNullable<IStorableType<D["id"]>>;
     get createdAt(): Date;
     /**
      * @deprecated use createdAt
      */
     getCreatedAt(): Date;
-    update(newData: Omit<D, 'id' | 'createdAt' | 'discardedAt'>): void;
+    update(newData: Partial<Omit<D, 'id' | 'createdAt' | 'discardedAt'>>): void;
     wasCreated(): boolean;
     validate(): void;
 }
@@ -334,62 +341,117 @@ declare class DescriptionMetadataStore {
     getModelDescriptions(model: IConstructor<any>): IDescriptionMetadata[];
 }
 
-interface ICommandConfig {
-    name?: string;
+interface ILockKey {
+    run<T>(fn: () => Promise<T>): Promise<T>;
+    tryRun<T>(fn: () => Promise<T>): Promise<T | undefined>;
 }
-declare function command(config?: ICommandConfig): (target: IConstructor<any>) => void;
 
-declare class Command<T extends IStorableData> extends Storable<T> {
-    getData(): T;
+interface ILocker {
+    withKey(key: string | number): ILockKey;
 }
+declare class Locker implements ILocker {
+    withKey(key: string | number): ILockKey;
+}
+
+interface ICommandConfig {
+    name: string;
+}
+declare function command<O extends object>(config: ICommandConfig | string): (target: IConstructor<IStorableData<O>>) => void;
 
-interface ICommandHandler<C extends Command<any>> {
+interface ICommandHandler<C extends object> {
     handle(command: C): void | Promise<void>;
 }
 
-interface ICommandHandlerConfig<C extends Command<any>> {
-    command: IConstructor<C>;
+interface ICommandHandlerConfig<C extends object> {
+    command: IConstructor<IStorableData<C>>;
+}
+declare function commandHandler<C extends object>(config: ICommandHandlerConfig<C> | IConstructor<IStorableData<C>>): (target: IConstructor<ICommandHandler<C>>) => void;
+
+interface ICronHandler {
+    handle(): void | Promise<void>;
+    handleError?(e: any): void | Promise<void>;
+}
+
+interface ICronJobScheduleConfig {
+    name: string;
+    commandName: string;
+    cron: string;
+    enabled: boolean;
+}
+
+interface ICronMetadata {
+    handlerConstructor: IConstructor<ICronHandler>;
+    config: ICronJobScheduleConfig;
 }
-declare function commandHandler<C extends Command<any>>(config: ICommandHandlerConfig<C>): (target: IConstructor<ICommandHandler<C>>) => void;
 
-declare class CommandMetadataStore {
+declare class AsyncMetadataStore {
     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;
+    private cronsMap;
+    registerCron(cron: IConstructor<ICronHandler>, config: ICronJobScheduleConfig): void;
+    requireCronMetadata(cron: IConstructor<ICronHandler>): ICronMetadata[];
+    registerCommand(command: IConstructor<any>, commandName: string): void;
+    registerCommandHandler<C extends object>(command: IConstructor<IStorableData<C>>, handlerConstructor: IConstructor<ICommandHandler<C>>): 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;
+    requireCommandNameForHandler(handlerConstructor: IConstructor<ICommandHandler<any>>): string;
+    getCommandName(command: IConstructor<any>): string | null;
+    getCommandForCommandName(commandName: string): IConstructor<any> | null;
 }
 
 interface IJobData extends IEntityData {
     commandName: string;
     commandData: any;
+    scheduledAt?: number;
     startedAt?: number;
     successAt?: number;
     failedAt?: number;
     retryAt?: number;
+    reintentsDelaysInSeconds?: number[];
+    intentNumber?: number;
     error?: {
+        time: number;
         message: string;
         stack?: string;
         info?: any;
     };
+    aceptableRunningTimeSeconds?: number;
+    stuckRetryAttempts?: number;
 }
 declare class Job extends Entity<IJobData> {
     get commandName(): string;
+    get commandData(): any;
+    get reintentsDelaysInSeconds(): number[] | undefined;
+    get aceptableRunningTimeSeconds(): number | undefined;
+    get stuckRetryAttempts(): number | undefined;
+    get runningSeconds(): number;
+    get successAt(): Date | null;
+    get failedAt(): Date | null;
+    get scheduledAt(): Date | null;
+    get intentNumber(): number;
+    wasSuccess(): boolean;
+    wasFailed(): boolean;
     hasFinished(): boolean;
+    isRunning(): boolean;
+    isScheduleReady(): boolean;
+    isStuck(): boolean;
     setAsStarted(): void;
     setAsSuccess(): void;
     setAsFailed(error: Error): void;
+    recover(): void;
 }
 
 interface IJobRepository extends ICrudRepository<Job> {
+    findPendingForRunFrom(date: Date, limit: number): Promise<Job[]>;
+    findRunningJobs(): Promise<Job[]>;
+    countRunningByCommand(commandName: string): Promise<number>;
 }
 
 declare class JobRepository implements IJobRepository {
+    findRunningJobs(): Promise<Job[]>;
+    findPendingForRunFrom(date: Date, limit: number): Promise<Job[]>;
     find(id: string): Promise<Job | null>;
     findOrThrow(id: string): Promise<Job>;
     findByIds(ids: string[]): Promise<Job[]>;
@@ -397,39 +459,60 @@ declare class JobRepository implements IJobRepository {
     create(item: Job): Promise<void>;
     update(item: Job): Promise<void>;
     delete(item: Job): Promise<void>;
+    countRunningByCommand(commandName: string): Promise<number>;
 }
 
-interface IJobEvent extends IStorableData {
-    jobId: string;
-    type: 'created';
+declare class JobRunner {
+    private jobRepository;
+    private handlerContainer;
+    private logger;
+    constructor(jobRepository: JobRepository, handlerContainer: AsyncMetadataStore);
+    run(job: Job): Promise<void>;
 }
-type IJobEventListener = (event: IJobEvent) => void | Promise<void>;
-declare class JobsEventsHub {
+
+declare class JobExecutor {
+    private locker;
+    private runner;
+    private repo;
+    private env;
+    private activeJobs;
     private logger;
-    private jobsEventsListener;
-    notifyJobCreated(job: Job): void;
-    listenJobsEvents(listener: IJobEventListener): void;
+    constructor(locker: Locker, runner: JobRunner, repo: JobRepository, env: Env);
+    remainingSlots(): number;
+    execute(job: Job): Promise<void>;
+    private tryAcquire;
+    private release;
 }
 
-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 JobScheduler {
+    private locker;
+    private repo;
+    private executor;
+    private env;
+    private timeout?;
+    private logger;
+    private commands;
+    private running;
+    constructor(locker: Locker, repo: JobRepository, executor: JobExecutor, env: Env);
+    start(commands: string[]): void;
+    stop(commands: string[]): void;
+    tryExecuteNow(job: Job): void;
+    private tick;
 }
 
-declare class JobRunner {
+declare class Async {
     private jobRepository;
-    private handlerContainer;
-    private logger;
-    constructor(jobRepository: JobRepository, handlerContainer: CommandMetadataStore);
-    run(job: Job): Promise<void>;
+    private metadataStore;
+    private jobScheduler;
+    constructor(jobRepository: JobRepository, metadataStore: AsyncMetadataStore, jobScheduler: JobScheduler);
+    runCommand<T>(ctor: IConstructor<T>, data: IValidateInputShape<T>): Promise<Job>;
 }
 
-declare function runAsyncCommandHandlers(handlers: IConstructor<ICommandHandler<any>>[]): void;
+declare function runCommandHandlers(handlers: IConstructor<ICommandHandler<any>>[]): void;
+declare function stopCommandHandlers(handlers: IConstructor<ICommandHandler<any>>[]): void;
 
-interface IChatConnection extends IStorableData {
+interface IChatConnection {
+    chatType: 'GROUP' | 'PRIVATE';
     channelName: string;
     id: string;
 }
@@ -444,6 +527,11 @@ declare class Chat extends Entity<IChatData> {
     constructor(data: IChatData);
     isPrivate(): boolean;
     isGroup(): boolean;
+    get connections(): {
+        chatType: "GROUP" | "PRIVATE";
+        channelName: string;
+        id: string;
+    }[];
     hasConnection(connection: IChatConnection): boolean;
     private validatePrivateChat;
     private validateGroupChat;
@@ -581,13 +669,28 @@ declare class MindsetOperator implements IMindset {
     functionErrorToString(error: any): Promise<string>;
 }
 
-interface IChatMessage extends IStorableData {
+interface IChatMessagesPublicImage {
+    name?: string;
+    publicUrl: string;
+    base64Url?: undefined;
+    mimeType: string;
+}
+interface IChatMessagesPrivateImage {
+    name?: string;
+    publicUrl?: undefined;
+    base64Url: string;
+    mimeType: string;
+}
+type IChatMessageImage = IChatMessagesPrivateImage | IChatMessagesPublicImage;
+
+interface IChatMessage {
     senderId?: string;
     senderName?: string;
     text?: string;
+    images?: IChatMessageImage[];
 }
 
-interface IFunctionCall extends IStorableData {
+interface IFunctionCall {
     id: string;
     name: string;
     arguments?: string;
@@ -598,13 +701,19 @@ declare const chatItemTypeOptions: readonly ["botMessage", "humanMessage", "func
 type IBotMessageItem = {
     type: 'botMessage';
     botMessage: IChatMessage;
+    humanMessage?: undefined;
+    functionCall?: undefined;
 };
 type IHumanMessageItem = {
     type: 'humanMessage';
+    botMessage?: undefined;
     humanMessage: IChatMessage;
+    functionCall?: undefined;
 };
 type IFunctionCallItem = {
     type: 'functionCall';
+    botMessage?: undefined;
+    humanMessage?: undefined;
     functionCall: IFunctionCall;
 };
 type IChatItem = IBotMessageItem | IHumanMessageItem | IFunctionCallItem;
@@ -641,7 +750,7 @@ declare class ChatItem extends Entity<IChatItemData> {
     get botMessage(): IChatMessage;
     get functionCall(): IFunctionCall;
     setFunctionResult(result: string): void;
-    getData(): IChatItemData;
+    getData(): IStorableData<IChatItemData>;
 }
 
 interface IChatMemory {
@@ -745,7 +854,7 @@ declare class ChatResolver {
 
 interface IMessageContext extends IReceivedMessage {
     chat: Chat;
-    authInfo?: IStorableData;
+    authInfo?: object;
 }
 
 declare function runChatControllers(controllers: IConstructor<any>[]): void;
@@ -768,13 +877,12 @@ declare class ExpressProvider {
     private createExpress;
 }
 
-interface IMoneyData extends IStorableData {
+interface IMoneyData {
     amount: string;
     currency: string;
 }
 declare class Money extends Storable<IMoneyData> {
     getData(): {
-        [key: string]: IPrimitive | IStorableData | IPrimitive[] | IStorableData[];
         amount: string;
         currency: string;
     };
@@ -812,14 +920,15 @@ type IPgRepositoryConfig<P extends Entity<IEntityData>> = {
 declare class PgRepositoryBase<P extends Entity<IEntityData>> {
     protected pool: Pool;
     protected config: IPgRepositoryConfig<any>;
-    private tableIsCreated;
+    private tableIsReady;
     protected schema: string;
     protected table: string;
     protected columnsList: string[];
-    protected columnsAndTypes: string;
+    protected columnsAndTypes: string[];
     protected columns: string;
     protected vars: string;
     protected updates: string;
+    private logger;
     addColumns: {
         [columns: string]: {
             type: string;
@@ -830,9 +939,8 @@ declare class PgRepositoryBase<P extends Entity<IEntityData>> {
     protected values(item: P): (string | number | boolean | Date | null)[];
     protected exec(sql: string, values: any[]): Promise<void>;
     protected query(sql: string, values: any[]): Promise<P[]>;
-    protected connect(): Promise<Pool>;
-    protected ensureTable(): Promise<void>;
-    protected ensureColumns(): Promise<void>;
+    protected ensureTable(client: PoolClient): Promise<void>;
+    protected ensureColumns(client: PoolClient): Promise<void>;
 }
 
 declare class PgCrudRepository<P extends Entity<IEntityData>> extends PgRepositoryBase<P> implements ICrudRepository<P> {
@@ -847,6 +955,44 @@ declare class PgCrudRepository<P extends Entity<IEntityData>> extends PgReposito
     delete(item: P): Promise<void>;
 }
 
+declare class PgLocker implements ILocker {
+    private readonly pool;
+    constructor(pool: Pool);
+    withKey(key: string | number): ILockKey;
+}
+
+declare class PgLockKey implements ILockKey {
+    private readonly key;
+    private pool;
+    readonly value: bigint;
+    private logger;
+    constructor(key: string | number, pool: Pool);
+    run<T>(fn: () => Promise<T>): Promise<T>;
+    tryRun<T>(fn: () => Promise<T>): Promise<T | undefined>;
+    toString(): string;
+    private static hashString;
+}
+
+type ClientMap = Map<Pool, PoolClient>;
+declare const pgStorage: AsyncLocalStorage<ClientMap>;
+/**
+ * Get or initialize the client map for the current async context
+ */
+declare function getClientMap(): ClientMap;
+
+/**
+ * Runs a function with a shared Postgres client for the given pool.
+ * Reuses the client if already present in the async context.
+ */
+declare function withPgClient<T>(pool: Pool, fn: (client: PoolClient) => Promise<T>): Promise<T>;
+/**
+ * Get the current shared client for a pool.
+ * Falls back to the pool itself if no shared client exists.
+ */
+declare function getPgClient(pool: Pool): PoolClient | Pool;
+
+declare function withPgTransaction<T>(pool: Pool, fn: (client: PoolClient) => Promise<T>): Promise<T>;
+
 interface IEndPointConfig {
     path?: string;
     disableJsonParser?: boolean;
@@ -982,57 +1128,62 @@ declare function runSocketControllers(controllers: IConstructor<any>[]): void;
 
 declare class PgJobRepository extends PgCrudRepository<Job> implements IJobRepository {
     constructor(pool: Pool);
+    findPendingForRunFrom(date: Date, limit: number): Promise<Job[]>;
+    findRunningJobs(): Promise<Job[]>;
+    countRunningByCommand(commandName: string): Promise<number>;
 }
 
 declare function apiKeyHandshakeGuard(): (target: IConstructor<any>) => void;
 
 declare function apiKeyGuard(): (target: object, propertyKey: string | symbol) => void;
 
-interface IApiKeyData<A extends IStorableData> extends IEntityData {
+interface IApiKeyData<A extends object> extends IEntityData {
     secretHash?: string;
     metadata?: Record<string, string>;
     authInfo: A;
     name: string;
 }
-declare class ApiKey<A extends IStorableData> extends Entity<IApiKeyData<A>> {
+declare class ApiKey<A extends object> extends Entity<IApiKeyData<A>> {
     static PREFIX: string;
     static hashSecret(secret: string): string;
-    get authInfo(): A;
-    get metadata(): Record<string, string>;
+    get authInfo(): IStorableType<A>;
+    get metadata(): {
+        [x: string]: string;
+    };
     get name(): string;
-    setAuthInfo(authInfo: A): void;
+    setAuthInfo(authInfo: IStorableType<A>): void;
     generateSecret(): string;
     isValidSecret(secret: string): boolean;
     validateSecret(secret: string): void;
 }
 
-interface IApiKeyRepository<A extends IStorableData> {
+interface IApiKeyRepository<A extends object> {
     find(id: string): Promise<ApiKey<A> | null>;
     findOrThrow(id: string): Promise<ApiKey<A>>;
     findByMetadata(metadata: Record<string, string>): Promise<ApiKey<A>[]>;
     create(item: ApiKey<A>): Promise<void>;
     generate(req: IGenerateApiKeyReq<A>): Promise<IGenerateApiKeyRes<A>>;
     findBySecret(secret: string): Promise<ApiKey<A> | null>;
-    findAndValidate(secret: string): Promise<A>;
+    findAndValidate(secret: string): Promise<IStorableType<A>>;
 }
-interface IGenerateApiKeyReq<A extends IStorableData> extends IStorableData {
+interface IGenerateApiKeyReq<A extends object> {
     name: string;
     metadata?: Record<string, string>;
-    authInfo: A;
+    authInfo: IStorableType<A>;
 }
-interface IGenerateApiKeyRes<A extends IStorableData> {
+interface IGenerateApiKeyRes<A extends object> {
     apiKey: ApiKey<A>;
     secret: string;
 }
 
-declare class ApiKeyRepository<A extends IStorableData> implements IApiKeyRepository<A> {
+declare class ApiKeyRepository<A extends object> implements IApiKeyRepository<A> {
     find(id: string): Promise<ApiKey<A> | null>;
     findOrThrow(id: string): Promise<ApiKey<A>>;
     findByMetadata(metadata: Record<string, string>): Promise<ApiKey<A>[]>;
     create(item: ApiKey<A>): Promise<void>;
     generate(req: IGenerateApiKeyReq<A>): Promise<IGenerateApiKeyRes<A>>;
     findBySecret(secret: string): Promise<ApiKey<A> | null>;
-    findAndValidate(secret: string): Promise<A>;
+    findAndValidate(secret: string): Promise<IStorableType<A>>;
 }
 
 declare class ApiKeyHandshakeGuardMiddleware implements IHandshakeMiddleware {
@@ -1049,23 +1200,23 @@ declare class ApiKeyGuardMiddleware implements IMiddleware {
     handle(req: Request, res: Response, container: DependencyContainer$1): Promise<void>;
 }
 
-declare class PgApiKeyRepository<A extends IStorableData> extends PgCrudRepository<ApiKey<A>> implements IApiKeyRepository<A> {
+declare class PgApiKeyRepository<A extends object> extends PgCrudRepository<ApiKey<A>> implements IApiKeyRepository<A> {
     constructor(pool: Pool);
-    findAndValidate(secret: string): Promise<A>;
+    findAndValidate(secret: string): Promise<IStorableType<A>>;
     findBySecret(secret: string): Promise<ApiKey<A> | null>;
     findByMetadata(metadata: Record<string, string>): Promise<ApiKey<A>[]>;
     generate(req: IGenerateApiKeyReq<A>): Promise<IGenerateApiKeyRes<A>>;
 }
 
-interface IRemoteApiKeyFetcher<A extends IStorableData> {
-    fetchAuthInfoBySecret: (secret: string) => Promise<A | null>;
+interface IRemoteApiKeyFetcher<A extends object> {
+    fetchAuthInfoBySecret: (secret: string) => Promise<IStorableType<A> | null>;
 }
-declare class RemoteApiKeyRepository<A extends IStorableData> implements IApiKeyRepository<A> {
+declare class RemoteApiKeyRepository<A extends object> implements IApiKeyRepository<A> {
     private fetcher;
     private cacheSeconds;
     private cacheBySecret;
     constructor(fetcher: IRemoteApiKeyFetcher<A>, cacheSeconds: number);
-    findAndValidate(secret: string): Promise<A>;
+    findAndValidate(secret: string): Promise<IStorableType<A>>;
     find(id: string): Promise<ApiKey<A> | null>;
     findOrThrow(id: string): Promise<ApiKey<A>>;
     findBySecret(secret: string): Promise<ApiKey<A> | null>;
@@ -1078,18 +1229,20 @@ declare function jwtHandshakeGuard(): (target: IConstructor<any>) => void;
 
 declare function jwtGuard(): (target: object, propertyKey: string | symbol) => void;
 
-interface IJwtRefreshTokenData<A extends IStorableData> extends IEntityData {
+interface IJwtRefreshTokenData<A extends object> extends IEntityData {
     secretHash?: string;
     metadata?: Record<string, string>;
     authInfo: A;
     expirationTime: number;
     revokedAt?: number;
 }
-declare class JwtRefreshToken<A extends IStorableData> extends Entity<IJwtRefreshTokenData<A>> {
+declare class JwtRefreshToken<A extends object> extends Entity<IJwtRefreshTokenData<A>> {
     static PREFIX: string;
     static hashSecret(secret: string): string;
-    get authInfo(): A;
-    get metadata(): Record<string, string>;
+    get authInfo(): IStorableType<A>;
+    get metadata(): {
+        [x: string]: string;
+    };
     get expirationTime(): Date;
     isExpired(): boolean;
     revoke(): void;
@@ -1100,8 +1253,8 @@ declare class JwtRefreshToken<A extends IStorableData> extends Entity<IJwtRefres
     validateToken(secret: string): void;
 }
 
-interface IJwtRefreshTokenRepository<D extends IStorableData> extends ICrudRepository<JwtRefreshToken<D>> {
-    findAndValidate(secret: string): Promise<D>;
+interface IJwtRefreshTokenRepository<D extends object> extends ICrudRepository<JwtRefreshToken<D>> {
+    findAndValidate(secret: string): Promise<IStorableType<D>>;
     findByMetadata(metadata: Record<string, string>): Promise<JwtRefreshToken<D>[]>;
 }
 
@@ -1128,12 +1281,12 @@ declare class JwtSigner {
     private config;
     private mapper;
     constructor(config: JwtConfig, mapper: Mapper);
-    signAccessToken<D extends IStorableData>(info: D | JwtRefreshToken<any>): Promise<JwtTokenDto>;
+    signAccessToken<D extends object>(info: IStorableType<D> | JwtRefreshToken<any>): Promise<JwtTokenDto>;
 }
 
-declare class JwtRefreshTokenRepository<D extends IStorableData> implements IJwtRefreshTokenRepository<D> {
+declare class JwtRefreshTokenRepository<D extends object> implements IJwtRefreshTokenRepository<D> {
     findByMetadata(metadata: Record<string, string>): Promise<JwtRefreshToken<D>[]>;
-    findAndValidate(secret: string): Promise<D>;
+    findAndValidate(secret: string): Promise<IStorableType<D>>;
     find(id: string): Promise<JwtRefreshToken<D> | null>;
     findOrThrow(id: string): Promise<JwtRefreshToken<D>>;
     findByIds(ids: string[]): Promise<JwtRefreshToken<D>[]>;
@@ -1167,9 +1320,9 @@ declare class JwtGuardMiddleware implements IMiddleware {
     handle(req: Request, res: Response, container: DependencyContainer$1): Promise<void>;
 }
 
-declare class PgJwtRefreshTokenRepository<D extends IStorableData> extends PgCrudRepository<JwtRefreshToken<D>> implements IJwtRefreshTokenRepository<D> {
+declare class PgJwtRefreshTokenRepository<D extends object> extends PgCrudRepository<JwtRefreshToken<D>> implements IJwtRefreshTokenRepository<D> {
     constructor(pool: Pool);
-    findAndValidate(secret: string): Promise<D>;
+    findAndValidate(secret: string): Promise<IStorableType<D>>;
     findBySecret(secret: string): Promise<JwtRefreshToken<D> | null>;
     findByMetadata(metadata: Record<string, string>): Promise<JwtRefreshToken<D>[]>;
 }
@@ -1341,11 +1494,11 @@ declare class WhatsappChannelConfig implements IWhatsappChannelConfig {
 
 declare function whatsApp(config: string | IWhatsappChannelConfig): (target: object, propertyKey: string | symbol) => void;
 
-interface IWhatsAppBusinessNumber extends IStorableData {
+interface IWhatsAppBusinessNumber {
     id: string;
     number: string;
 }
-interface IWhatsAppBusinessAccount extends IStorableData {
+interface IWhatsAppBusinessAccount {
     id: string;
 }
 interface IWhatsAppData extends IEntityData {
@@ -1361,7 +1514,10 @@ declare class WhatsApp extends Entity<IWhatsAppData> {
     getSlug(): string;
     getBusinessAccount(): IWhatsAppBusinessAccount;
     getAppSecret(): string;
-    getBusinessNumbers(): IWhatsAppBusinessNumber[];
+    getBusinessNumbers(): {
+        id: string;
+        number: string;
+    }[];
     getAccessToken(): string;
     hasBusinessNumber(number: string): boolean;
     getBussinessNumber(number: string): IWhatsAppBusinessNumber | null;
@@ -1629,4 +1785,4 @@ declare function HtmlModule(options: IHtmlModuleOptions): {
     new (): {};
 };
 
-export { AnthropicChatAdapter, ApiKey, ApiKeyGuardMiddleware, ApiKeyHandshakeGuardMiddleware, ApiKeyRepository, Async, Auth, Chat, ChatAdapter, ChatBot, ChatBotMetadataStore, ChatItem, ChatMemory, ChatRepository, ChatResolver, CmdChannel, Command, CommandMetadataStore, Container, ControllerMetadataStore, CustomError, DeepSeekChatAdapter, DescriptionMetadataStore, EXPRESS_REQ, EXPRESS_RES, Entity, Env, EnvWhatsAppRepository, ExpressProvider, GoogleChatAdapter, type GoogleChatAdapterV2Options, HtmlModule, HttpServerProvider, type IApiKeyData, type IApiKeyRepository, type IArrayValidationError, type IArrayValidationResult, type IBotMessageItem, type IChannelMessage, type IChannelMetadata, type IChatAdapter, type IChatAdapterNextItemsReq, type IChatAdapterNextItemsRes, 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 IDescriptionMetadata, type IEndPointConfig, type IEndPointMetadata, type IEntityData, type IEnvType, type IFunctionCall, type IFunctionCallItem, type IGenerateApiKeyReq, type IGenerateApiKeyRes, type IGetWhatsAppTemplateRequest, type IHandshakeMiddleware, type IHandshakeMiddlewareMetadata, 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 IMindsetConfig, type IMindsetIdentity, type IMindsetLlm, type IMindsetMetadata, type IMindsetModuleConfig, type IMindsetModuleMetadata, type IMindsetTool, type IMindsetToolParameter, type IModelValidationError, type IModelValidationResult, type IModelValidatorsInfo, type IMoneyData, type IPersistentData, type IPgRepositoryConfig, type IPrimitive, type IPropertyValidatorInfo, type IReceivedMessage, type IRemoteApiKeyFetcher, type IRestControllerConfig, type IRestControllerMetadata, type ISendWhatsAppRequest, type ISendWhatsAppTemplateRequest, type ISocketChannelConfig, type ISocketChannelReceivedMessage, type ISocketControllerConfig, type ISocketControllerMetadata, type ISocketEventConfig, type ISocketEventMetadata, type IStorableData, type ITelegramChannelConfig, type IValidateArrayOptions, type IValidateArrayOptionsWithItemsValidators, type IValidateInputShape, type IValidateIsInOptions, type IValidateIsRecordOptions, 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, JwtGuardMiddleware, JwtHandshakeGuardMiddleware, JwtRefreshToken, JwtRefreshTokenRepository, JwtSigner, JwtTokenDto, Lifecycle, Logger, Mapper, Mindset, MindsetMetadataStore, MindsetOperator, Money, MoneyDto, OpenaiChatAdapter, Password, type PasswordHashOptions, Persistent, PgApiKeyRepository, PgChatMemory, PgChatRepository, PgCrudRepository, PgJobRepository, PgJwtRefreshTokenRepository, PgRepositoryBase, PgWhatsAppRepository, RamChatMemory, RamChatRepository, Random, RemoteApiKeyRepository, RestControllerMetadataStore, RestRequest, SocketChannel, SocketChannelConfig, SocketChannelReceivedMessage, 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, apiKeyHandshakeGuard, chatBot, chatController, chatItemTypeOptions, cmd, command, commandHandler, container, description, handshakeMiddlewares, inject, injectable, isArray, isBoolean, isDate, isIn, isModel, isNotEmpty, isNumber, isOptional, isPresent, isRecord, isString, jwtGuard, jwtHandshakeGuard, max, middleware, min, mindset, mindsetModule, modelInfo, onDelete, onGet, onPost, onPut, onSocketEvent, readJsonFromFile, restController, runAsyncCommandHandlers, runChatControllers, runRestControllers, runSocketControllers, scoped, singleton, socket, socketController, telegram, validateAndTransform, validateArray, validateIsBoolean, validateIsDate, validateIsIn, validateIsNotEmpty, validateIsNumber, validateIsPresent, validateIsRecord, validateIsString, validateMax, validateMin, validateModel, whatsApp, writeJsonToFile };
+export { AnthropicChatAdapter, ApiKey, ApiKeyGuardMiddleware, ApiKeyHandshakeGuardMiddleware, ApiKeyRepository, Async, AsyncMetadataStore, Auth, Chat, ChatAdapter, ChatBot, ChatBotMetadataStore, ChatItem, ChatMemory, ChatRepository, ChatResolver, type ClientMap, CmdChannel, Container, ControllerMetadataStore, CustomError, DeepSeekChatAdapter, DescriptionMetadataStore, EXPRESS_REQ, EXPRESS_RES, Entity, Env, EnvWhatsAppRepository, ExpressProvider, GoogleChatAdapter, type GoogleChatAdapterV2Options, HtmlModule, HttpServerProvider, type IApiKeyData, type IApiKeyRepository, type IArrayValidationError, type IArrayValidationResult, type IBotMessageItem, type IChannelMessage, type IChannelMetadata, type IChatAdapter, type IChatAdapterNextItemsReq, type IChatAdapterNextItemsRes, 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 IDescriptionMetadata, type IEndPointConfig, type IEndPointMetadata, type IEntityData, type IEnvType, type IFunctionCall, type IFunctionCallItem, type IGenerateApiKeyReq, type IGenerateApiKeyRes, type IGetWhatsAppTemplateRequest, type IHandshakeMiddleware, type IHandshakeMiddlewareMetadata, type IHtmlModuleOptions, type IHumanMessageItem, type IJobData, type IJobRepository, type IJwtRefreshTokenData, type IJwtRefreshTokenRepository, type ILanguageModelUsage, type IListenWhatsAppMessageRequest, type ILockKey, type ILocker, type IMessageContext, type IMiddleware, type IMiddlewareMetadata, type IMindset, type IMindsetConfig, type IMindsetIdentity, type IMindsetLlm, type IMindsetMetadata, type IMindsetModuleConfig, type IMindsetModuleMetadata, type IMindsetTool, type IMindsetToolParameter, type IModelValidationError, type IModelValidationResult, type IModelValidatorsInfo, type IMoneyData, type IPersistentData, type IPgRepositoryConfig, type IPropertyValidatorInfo, type IReceivedMessage, type IRemoteApiKeyFetcher, type IRestControllerConfig, type IRestControllerMetadata, type ISendWhatsAppRequest, type ISendWhatsAppTemplateRequest, type ISocketChannelConfig, type ISocketChannelReceivedMessage, type ISocketControllerConfig, type ISocketControllerMetadata, type ISocketEventConfig, type ISocketEventMetadata, type IStorableData, type ITelegramChannelConfig, type IValidateArrayOptions, type IValidateArrayOptionsWithItemsValidators, type IValidateInputShape, type IValidateIsInOptions, type IValidateIsRecordOptions, 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, Jwt, JwtAccessAndRefreshTokenDto, JwtConfig, JwtGuardMiddleware, JwtHandshakeGuardMiddleware, JwtRefreshToken, JwtRefreshTokenRepository, JwtSigner, JwtTokenDto, Lifecycle, Locker, Logger, Mapper, Mindset, MindsetMetadataStore, MindsetOperator, Money, MoneyDto, OpenaiChatAdapter, Password, type PasswordHashOptions, Persistent, PgApiKeyRepository, PgChatMemory, PgChatRepository, PgCrudRepository, PgJobRepository, PgJwtRefreshTokenRepository, PgLockKey, PgLocker, PgRepositoryBase, PgWhatsAppRepository, RamChatMemory, RamChatRepository, Random, RemoteApiKeyRepository, RestControllerMetadataStore, RestRequest, SocketChannel, SocketChannelConfig, SocketChannelReceivedMessage, 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, apiKeyHandshakeGuard, chatBot, chatController, chatItemTypeOptions, cmd, command, commandHandler, container, description, getClientMap, getPgClient, handshakeMiddlewares, inject, injectable, isArray, isBoolean, isDate, isIn, isModel, isNotEmpty, isNumber, isOptional, isPresent, isRecord, isString, jwtGuard, jwtHandshakeGuard, max, middleware, min, mindset, mindsetModule, modelInfo, onDelete, onGet, onPost, onPut, onSocketEvent, pgStorage, readJsonFromFile, restController, runChatControllers, runCommandHandlers, runRestControllers, runSocketControllers, scoped, singleton, socket, socketController, stopCommandHandlers, telegram, validateAndTransform, validateArray, validateIsBoolean, validateIsDate, validateIsIn, validateIsNotEmpty, validateIsNumber, validateIsPresent, validateIsRecord, validateIsString, validateMax, validateMin, validateModel, whatsApp, withPgClient, withPgTransaction, writeJsonToFile };