wsp-ms-core 1.0.6 → 1.0.8-7.5

package/dist/index.d.ts

@@ -1,24 +1,25 @@
-import { RowDataPacket, PoolConnection, Pool } from 'mysql2/promise';
 import { RequestHandler, ErrorRequestHandler } from 'express';
+import { Pool, RowDataPacket, PoolConnection } from 'mysql2/promise';
 
 declare abstract class ValueObject<TPrimitive = unknown> {
     protected readonly _value: TPrimitive;
     protected constructor(value: TPrimitive);
     protected abstract validate(value: TPrimitive): void;
+    abstract toPrimitives(): Record<string, unknown>;
+    toProps(): TPrimitive;
     get value(): TPrimitive;
     toString(): string;
     equals(vo?: ValueObject<TPrimitive> | null): boolean;
 }
 
-declare class UUID extends ValueObject<string> {
-    private constructor();
-    protected validate(uuid: string): void;
-    static create(uuid?: string): UUID;
-    static isValid(uuid: string): boolean;
-}
-
 declare class DateTime extends ValueObject<string> {
     static readonly DEFAULT_FORMAT: string;
+    static readonly FORMAT: string;
+    static readonly FORMAT_Y_M = "Y-M";
+    static readonly FORMAT_Y_M_D = "Y-M-D";
+    static readonly FORMAT_Y_M_D_H_m_s = "Y-M-D H:M:S";
+    static readonly FORMAT_D_M_Y = "D-M-Y";
+    private static readonly FORMATS;
     private readonly _dt;
     private static fromLuxon;
     private static toUtcFormat;
@@ -44,42 +45,87 @@ declare class DateTime extends ValueObject<string> {
     get second(): number;
     getMonthName(locale?: string): string;
     getWeekdayName(locale?: string): string;
+    getDayName(locale?: string): string;
+    format(format: string): string;
+    toPrimitives(): Record<string, unknown>;
     static create(input?: string | number): DateTime;
+    static now(): DateTime;
 }
 
-declare abstract class DomainEntity<T extends Record<string, string | number | boolean>> {
-    readonly uuid: UUID;
-    private readonly _createdAt;
-    private _updatedAt;
-    private _deletedAt?;
+type UUIDVersion = 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8;
+interface UUIDValidationOptions {
+    /** Versiones permitidas (por defecto: 1–8) */
+    allowedVersions?: UUIDVersion[];
+    /** Permitir el NIL UUID "00000000-0000-0000-0000-000000000000" (por defecto: false) */
+    allowNil?: boolean;
+}
+declare class UUID extends ValueObject<string> {
+    static readonly NIL = "00000000-0000-0000-0000-000000000000";
+    private constructor();
+    protected validate(uuid: string): void;
+    toPrimitives(): Record<string, unknown>;
+    static create(uuid?: string): UUID;
+    static version(uuid: string): UUIDVersion | undefined;
+    static isNil(uuid: string): boolean;
+    static isRFCStyle(uuid: string): boolean;
+    static isValid(uuid: string, opts?: UUIDValidationOptions): boolean;
+}
+
+declare abstract class BaseEvent {
+    protected readonly _tenantUuid: UUID;
+    protected readonly _version: string;
+    protected readonly _type: string;
+    protected readonly _payload: Record<string, unknown>;
+    protected readonly _occurredAt: DateTime;
+    protected constructor(tenantUuid: UUID, version: string, type: string, payload: Record<string, unknown>);
+    get tenantUuid(): UUID;
+    get version(): string;
+    get type(): string;
+    get payload(): Record<string, unknown>;
+    get ocurredAt(): DateTime;
+}
+
+declare class DomainEvent extends BaseEvent {
+    protected readonly _aggregateUuid: UUID;
+    protected readonly _aggregateType: string;
+    protected constructor(tenantUuid: UUID, version: string, type: string, payload: Record<string, unknown>, aggregateUuid: UUID, aggregateType: string);
+    get aggregateUuid(): UUID;
+    get aggregateType(): string;
+}
+
+interface BaseEntity {
+    uuid: UUID;
+    createdAt: DateTime;
+    updatedAt: DateTime;
+    deletedAt: DateTime | undefined;
+}
+declare abstract class DomainEntity<T extends BaseEntity> {
     protected readonly props: T;
-    protected constructor(uuid: UUID, props: T, audit?: {
-        createdAt?: DateTime;
-        updatedAt?: DateTime;
-        deletedAt?: DateTime;
-    });
+    protected _events: DomainEvent[];
+    protected constructor(props: T);
+    protected recordEvent(event: DomainEvent): void;
     protected touch(): void;
+    get uuid(): UUID;
     get createdAt(): DateTime;
     get updatedAt(): DateTime;
     get deletedAt(): DateTime | undefined;
     get isDeleted(): boolean;
+    pullEvents(): DomainEvent[];
     abstract equals(entity?: DomainEntity<T>): boolean;
-    softDelete(): void;
+    abstract toProps(): T;
     abstract toPrimitives(): Record<string, unknown>;
 }
 
-declare abstract class DomainError extends Error {
-    readonly type: string;
-    protected constructor(type: string, message?: string);
+declare abstract class BaseObject<T = unknown> {
+    protected readonly props: T;
+    protected constructor(props: T);
+    abstract toProps(): T;
+    abstract toPrimitives(): Record<string, unknown>;
 }
 
-declare abstract class DomainEvent<T = unknown> {
+declare abstract class DomainError extends Error {
     readonly type: string;
-    private readonly _occurredAt;
-    private readonly _payload;
-    protected constructor(payload: T);
-    get payload(): T;
-    get occurredAt(): DateTime;
+    protected constructor(type: string, message?: string);
 }
 
 declare class FatalError extends DomainError {
@@ -95,6 +141,101 @@ declare class UsageError extends DomainError {
     constructor(type: string, vars?: Record<string, any>);
 }
 
+declare class PaymentGateway extends ValueObject<string> {
+    static readonly SUPPORTED: readonly string[];
+    private static readonly EXTERNALS;
+    static readonly MERCADOPAGO: PaymentGateway;
+    static readonly HANDY: PaymentGateway;
+    static readonly WONA_DEBIT: PaymentGateway;
+    static readonly WONA_CARD: PaymentGateway;
+    static readonly WONA_CASH: PaymentGateway;
+    static readonly WONA_TRANSFER: PaymentGateway;
+    static readonly WONA_MERCADOPAGO: PaymentGateway;
+    private constructor();
+    protected validate(value: string): void;
+    isExternal(): boolean;
+    get isMercadoPago(): boolean;
+    get isHandy(): boolean;
+    get isWonaDebit(): boolean;
+    get isWonaCard(): boolean;
+    get isWonaCash(): boolean;
+    get isWonaTransfer(): boolean;
+    get isWonaMercadoPago(): boolean;
+    toPrimitives(): Record<string, unknown>;
+    static create(gateway: string): PaymentGateway;
+}
+
+declare class PaymentStatus extends ValueObject<string> {
+    static readonly SUPPORTED: readonly string[];
+    static readonly DONE: PaymentStatus;
+    static readonly PENDING: PaymentStatus;
+    static readonly IN_PROGRESS: PaymentStatus;
+    static readonly FAILED: PaymentStatus;
+    static readonly CANCELED: PaymentStatus;
+    static readonly HOLD: PaymentStatus;
+    static readonly PENDING_REFUND: PaymentStatus;
+    static readonly REFUNDED: PaymentStatus;
+    private constructor();
+    protected validate(status: string): void;
+    get isDone(): boolean;
+    get isPending(): boolean;
+    get isInProgress(): boolean;
+    get isFailed(): boolean;
+    get isCanceled(): boolean;
+    get isHold(): boolean;
+    get isPendingRefund(): boolean;
+    get isRefunded(): boolean;
+    toPrimitives(): Record<string, unknown>;
+    static create(gateway: string): PaymentStatus;
+}
+
+declare class Country extends ValueObject<string> {
+    static COUNTRIES: {
+        [key: string]: {
+            alpha2: string;
+            alpha3: string;
+            numeric: string;
+            uuid: string;
+            phoneCode: string;
+            url: string;
+        };
+    };
+    private static readonly NAMES;
+    static readonly DEFAULT: Country;
+    static readonly ARGENTINA: Country;
+    static readonly ECUADOR: Country;
+    static readonly PERU: Country;
+    static readonly BRASIL: Country;
+    static readonly CHILE: Country;
+    static readonly VENEZUELA: Country;
+    static readonly COLOMBIA: Country;
+    static readonly BOLIVIA: Country;
+    static readonly PARAGUAY: Country;
+    static readonly USA: Country;
+    private readonly _name;
+    private readonly _alpha2;
+    private readonly _alpha3;
+    private readonly _numeric;
+    private readonly _uuid;
+    private readonly _phoneCode;
+    private readonly _url;
+    private constructor();
+    protected validate(country: string): void;
+    name(): string;
+    alpha2(): string;
+    alpha3(): string;
+    numeric(): string;
+    uuid(): string;
+    phoneCode(): string;
+    url(): string;
+    static findCountryByAlpha2(alpha2: string): Country;
+    static findCountryByUUID(uuid: string): Country;
+    static create(country: string): Country;
+    static createOrDefault(country: string): Country;
+    toPrimitives(): Record<string, unknown>;
+    static isValid(country: string): boolean;
+}
+
 declare class Currency extends ValueObject<string> {
     static readonly ALPHA_REGEX: RegExp;
     static readonly NUM_REGEX: RegExp;
@@ -108,6 +249,7 @@ declare class Currency extends ValueObject<string> {
     readonly numeric: number;
     private constructor();
     protected validate(alpha: string): void;
+    toPrimitives(): Record<string, unknown>;
     static create(raw: string | number): Currency;
     static isValid(raw: string | number): boolean;
 }
@@ -116,6 +258,7 @@ declare class Email extends ValueObject<string> {
     static readonly REGEX: RegExp;
     private constructor();
     protected validate(value: string): void;
+    toPrimitives(): Record<string, unknown>;
     static create(raw: string): Email;
     static isValid(raw: string): boolean;
 }
@@ -158,39 +301,103 @@ declare class Language extends ValueObject<string> {
     private constructor();
     protected validate(value: string): void;
     base(): string;
+    toPrimitives(): Record<string, unknown>;
     static create(raw: string): Language;
 }
 
-declare class Price extends ValueObject<{
+interface PriceProps {
     amount: number;
     currency: Currency;
-}> {
+}
+declare class Price extends ValueObject<PriceProps> {
     static readonly MIN_AMOUNT: number;
-    readonly amount: number;
-    readonly currency: Currency;
+    static readonly MAX_AMOUNT: number;
     private constructor();
     protected validate(props: {
         amount: number;
         currency: Currency;
     }): void;
+    get amount(): number;
+    get currency(): Currency;
     equals(other?: Price | null): boolean;
     private assertSameCurrency;
     add(other: Price): Price;
     subtract(other: Price): Price;
+    toPrimitives(): Record<string, unknown>;
     static create(amount: number, currency: Currency | string | number): Price;
+    static createFromPrimitives(data: Record<string, unknown>): Price;
+}
+
+declare class ProcessStatus extends ValueObject<string> {
+    static readonly SUPPORTED: readonly string[];
+    static readonly PENDING: ProcessStatus;
+    static readonly PROCESSING: ProcessStatus;
+    static readonly PROCESSED: ProcessStatus;
+    static readonly FAILED: ProcessStatus;
+    static readonly DEAD: ProcessStatus;
+    private constructor();
+    protected validate(value: string): void;
+    toPrimitives(): Record<string, unknown>;
+    static create(status: string): ProcessStatus;
 }
 
-interface EventBus {
-    publish(event: DomainEvent): Promise<void>;
+declare class OutboxRecord {
+    private readonly _eventUuid;
+    private readonly _eventType;
+    private readonly _tenantUuid;
+    private readonly _aggregateUuid;
+    private readonly _aggregateType;
+    private readonly _topic;
+    private readonly _payload;
+    private _status;
+    private _attempts;
+    private _errorMessage;
+    private _publishedAt;
+    private _lastAttempt;
+    private readonly _createdAt;
+    constructor(eventUuid: UUID, eventType: string, tenantUuid: UUID, aggregateUuid: UUID, aggregateType: string, topic: string, payload: string, status: ProcessStatus, attempts: number, errorMessage: string | undefined, publishedAt: DateTime | undefined, lastAttempt: DateTime | undefined, createdAt?: DateTime);
+    get eventUuid(): UUID;
+    get tenantUuid(): UUID;
+    get aggregateUuid(): UUID;
+    get aggregateType(): string;
+    get eventType(): string;
+    get topic(): string;
+    get payload(): string;
+    get status(): ProcessStatus;
+    get attempts(): number;
+    get errorMessage(): string | undefined;
+    get publishedAt(): DateTime | undefined;
+    get lastAttempt(): DateTime | undefined;
+    get createdAt(): DateTime;
+    incrementAttempts(): void;
+    markProcessed(): void;
+    markProcessing(): void;
+    markWithError(error: string): void;
+    toPrimitives(): Record<string, unknown>;
+    static reconstitute(data: Record<string, any>): OutboxRecord;
 }
 
 interface EventBusRepository {
-    save(event: DomainEvent): Promise<void>;
-    listPending(limit: number): Promise<DomainEvent[]>;
-    markProcessed(id: number): Promise<void>;
-    incrementRetries(id: number): Promise<void>;
+    create(event: OutboxRecord): Promise<void>;
+    update(event: OutboxRecord): Promise<void>;
+    listPending(limit: number): Promise<OutboxRecord[]>;
+}
+
+declare class IntegrationEvent extends BaseEvent {
+    protected readonly _aggregateUuid: UUID;
+    protected readonly _aggregateType: string;
+    protected constructor(tenantUuid: UUID, version: string, type: string, payload: Record<string, unknown>, aggregateUuid: UUID, aggregateType: string);
+    get aggregateUuid(): UUID;
+    get aggregateType(): string;
 }
 
+interface DatabaseConnector<C extends DatabaseConnection = DatabaseConnection> {
+    getConnection(options?: {
+        readonly?: boolean;
+    }): Promise<C>;
+    query(sql: string, params: any[]): Promise<any[]>;
+    closePool(): Promise<void>;
+}
 interface DatabaseConnection<Q = string, Params = unknown[], Row = Record<string, unknown>> {
     query<T = Row>(statement: Q, params?: Params): Promise<T[]>;
     begin(): Promise<void>;
@@ -200,25 +407,83 @@ interface DatabaseConnection<Q = string, Params = unknown[], Row = Record<string
     close(): Promise<void>;
 }
 
-interface DatabaseConnector<C extends DatabaseConnection = DatabaseConnection> {
-    getConnection(options?: {
-        readonly?: boolean;
-    }): Promise<C>;
-    closePool(): Promise<void>;
+interface UnitOfWork<C extends DatabaseConnection = DatabaseConnection> {
+    readonly connection: C;
+    execute<T>(fn: () => Promise<T>): Promise<T>;
 }
 
-interface Logger {
-    debug(type: string, message: string, meta?: Record<string, any>): void;
-    info(type: string, message: string, meta?: Record<string, any>): void;
-    warn(type: string, message: string, meta?: Record<string, any>): void;
-    error(type: string, message: string, meta?: Record<string, any>): void;
-    fatal(type: string, message: string, meta?: Record<string, any>): void;
+type MapperEvent = (event: BaseEvent) => OutboxRecord;
+declare class EventBus {
+    private static readonly MAPPERS;
+    private readonly repository;
+    constructor(repository: EventBusRepository);
+    publish(event: BaseEvent): Promise<void>;
+    publishMany(events: BaseEvent[]): Promise<void>;
+    static addMapper(eventType: string, mapper: MapperEvent): void;
+}
+
+declare class BasicUnitOfWork implements UnitOfWork {
+    readonly connection: DatabaseConnection;
+    constructor(conn: DatabaseConnection);
+    execute<T>(fn: () => Promise<T>): Promise<T>;
+}
+
+declare class BasicUnitOfWorkFactory {
+    private readonly connector;
+    constructor(connector: DatabaseConnector);
+    create(): Promise<BasicUnitOfWork>;
+}
+
+interface EventMessage {
+    topic: string;
+    producer: string;
+    tenant: UUID;
+    message: string;
+}
+interface EventManagerConnection {
+    userName: string;
+    password: string;
+    brokers: string[];
+}
+type RouteCallback = (e: EventMessage) => void;
+interface RoutesCallbackList {
+    [key: string]: RouteCallback;
+}
+declare abstract class EventManager {
+    protected _connection: EventManagerConnection;
+    protected _topics: string[];
+    protected _callbackList: RoutesCallbackList;
+    protected _onStart: CallableFunction | null;
+    protected _onConnected: CallableFunction | null;
+    protected _onSubscribe: CallableFunction | null;
+    protected _onMessage: CallableFunction | null;
+    protected _onError: CallableFunction | null;
+    protected _onCrash: CallableFunction | null;
+    protected _onReconnect: CallableFunction | null;
+    protected constructor(connection: EventManagerConnection);
+    protected execRoute(topic: string, event: EventMessage): Promise<void>;
+    protected execCallback(callback: CallableFunction | null, data: any): Promise<void>;
+    abstract send(event: EventMessage): void;
+    abstract start(): void;
+    abstract restart(): void;
+    abstract stop(): void;
+    abstract pause(): void;
+    route(topic: string, callback: RouteCallback): void;
+    onStart(callback: CallableFunction): void;
+    onConnected(callback: CallableFunction): void;
+    onSubscribe(callback: CallableFunction): void;
+    onMessage(callback: CallableFunction): void;
+    onError(callback: CallableFunction): void;
+    onCrash(callback: CallableFunction): void;
+    onReconnect(callback: CallableFunction): void;
+    get topics(): string[];
+    get callbackList(): RoutesCallbackList;
 }
 
 interface HttpRequest {
     readonly headers: Record<string, string>;
     readonly params: Record<string, string>;
-    readonly query: Record<string, string>;
+    readonly query: Record<string, unknown>;
     readonly lang: string;
     readonly body: any;
     readonly files?: Record<string, UploadedFile | UploadedFile[]>;
@@ -226,6 +491,7 @@ interface HttpRequest {
 interface HttpResponse {
     statusCode: number;
     body: any;
+    headers?: Record<string, string | number | readonly string[]>;
 }
 interface UploadedFile {
     fieldName: string;
@@ -239,6 +505,46 @@ interface HttpController {
     handle(request: HttpRequest): Promise<HttpResponse>;
 }
 
+interface Logger {
+    debug(type: string, message: string, meta?: Record<string, any>): void;
+    info(type: string, message: string, meta?: Record<string, any>): void;
+    warn(type: string, message: string, meta?: Record<string, any>): void;
+    error(type: string, message: string, meta?: Record<string, any>): void;
+    fatal(type: string, message: string, meta?: Record<string, any>): void;
+}
+
+declare class InboxRecord {
+    private readonly _eventUuid;
+    private readonly _tenantUuid;
+    private readonly _topic;
+    private readonly _producer;
+    private readonly _payload;
+    private _status;
+    private _attempts;
+    private _errorMessage;
+    private _lastAttempt;
+    private _processedAt;
+    private readonly _createdAt;
+    constructor(eventUuid: UUID, tenantUuid: UUID, topic: string, producer: string, payload: string, status: ProcessStatus, attempts?: number, errorMessage?: string | undefined, lastAttempt?: DateTime | undefined, processedAt?: DateTime | undefined, createdAt?: DateTime);
+    get eventUuid(): UUID;
+    get tenantUuid(): UUID;
+    get topic(): string;
+    get producer(): string;
+    get payload(): string;
+    get status(): ProcessStatus;
+    get attempts(): number;
+    get errorMessage(): string | undefined;
+    get lastAttempt(): DateTime | undefined;
+    get processedAt(): DateTime | undefined;
+    get createdAt(): DateTime;
+    incrementAttempts(): void;
+    markProcessed(): void;
+    markProcessing(): void;
+    markWithError(error: string): void;
+    toPrimitives(): Record<string, unknown>;
+    static reconstitute(data: Record<string, any>): InboxRecord;
+}
+
 interface ErrorTemplate {
     type: string;
     languages: Record<string, string>;
@@ -266,15 +572,36 @@ declare class ErrorManager {
     static addTemplate(template: ErrorTemplate): void;
 }
 
-declare class MysqlConnection implements DatabaseConnection<string, any[], RowDataPacket> {
-    private readonly _conn;
-    constructor(conn: PoolConnection);
-    query<R = RowDataPacket>(statement: string, params?: any[]): Promise<R[]>;
-    begin(): Promise<void>;
-    commit(): Promise<void>;
-    rollback(): Promise<void>;
-    transaction<T>(fn: (conn: this) => Promise<T>): Promise<T>;
-    close(): Promise<void>;
+declare class EventBusMysqlRepository implements EventBusRepository {
+    private readonly connection;
+    constructor(connection: DatabaseConnection);
+    private recordToRowValues;
+    create(record: OutboxRecord): Promise<void>;
+    update(record: OutboxRecord): Promise<void>;
+    listPending(limit: number): Promise<OutboxRecord[]>;
+}
+
+declare function adaptExpressRoute(Controller: new () => HttpController): RequestHandler;
+declare function adaptExpressErrorHandler(errorManager: ErrorManager): ErrorRequestHandler;
+
+declare class HttpHealthCheckController implements HttpController {
+    handle(request: HttpRequest): Promise<HttpResponse>;
+}
+declare class HttpNotFoundController implements HttpController {
+    handle(request: HttpRequest): Promise<HttpResponse>;
+}
+
+declare class KafkaManager extends EventManager {
+    private readonly kafka;
+    private readonly consumer;
+    private readonly producer;
+    constructor(connection: EventManagerConnection);
+    private run;
+    send(e: EventMessage): Promise<void>;
+    start(autocommit?: boolean): Promise<void>;
+    pause(): Promise<void>;
+    restart(): Promise<void>;
+    stop(): Promise<void>;
 }
 
 declare class MysqlConnector implements DatabaseConnector<MysqlConnection> {
@@ -282,27 +609,72 @@ declare class MysqlConnector implements DatabaseConnector<MysqlConnection> {
     private readonly _pool;
     constructor(pool?: Pool);
     private wrap;
+    query(sql: string, params?: any[]): Promise<any[]>;
     getConnection(): Promise<MysqlConnection>;
     closePool(): Promise<void>;
     static ping(): Promise<boolean>;
 }
+declare class MysqlConnection implements DatabaseConnection<string, any[], RowDataPacket> {
+    private readonly _conn;
+    constructor(conn: PoolConnection);
+    query<R = RowDataPacket>(statement: string, params?: any[]): Promise<R[]>;
+    begin(): Promise<void>;
+    commit(): Promise<void>;
+    rollback(): Promise<void>;
+    transaction<T>(fn: (conn: this) => Promise<T>): Promise<T>;
+    close(): Promise<void>;
+}
 
-declare function adaptExpressRoute(Controller: new () => HttpController): RequestHandler;
-declare function adaptErrorHandler(errorManager: ErrorManager): ErrorRequestHandler;
+declare class DefaultMysqlOutboxRunner {
+    private readonly uowFactory;
+    private readonly eventManager;
+    private readonly interval;
+    private readonly maxEvents;
+    private errors;
+    constructor(uowFactory: BasicUnitOfWorkFactory, eventManager: EventManager);
+    private addError;
+    private logErrors;
+    private sleep;
+    private processOutboxRecord;
+    private process;
+    start(): Promise<void>;
+}
 
-declare class HttpNotFoundController implements HttpController {
-    handle(request: HttpRequest): Promise<HttpResponse>;
+declare class DefaultMysqlInboxRunner {
+    private readonly uowFactory;
+    private readonly eventManager;
+    private readonly interval;
+    private readonly maxEvents;
+    private topics;
+    constructor(uowFactory: BasicUnitOfWorkFactory, eventManager: EventManager);
+    private saveEvent;
+    subscribeTo(topic: string): void;
+    private process;
+    start(): Promise<void>;
 }
 
-declare class HttpHealthCheckController implements HttpController {
-    handle(request: HttpRequest): Promise<HttpResponse>;
+interface ExchangeRatesProps {
+    base: Currency;
+    rates: Record<string, number>;
+    date: DateTime;
+}
+declare class ExchangeRates extends BaseObject<ExchangeRatesProps> {
+    constructor(props: ExchangeRatesProps);
+    private getRate;
+    get base(): Currency;
+    get rates(): Record<string, number>;
+    get date(): DateTime;
+    toProps(): ExchangeRatesProps;
+    toPrimitives(): Record<string, unknown>;
+    exchangeToBase(price: Price): Price;
+    static create(props: ExchangeRatesProps): ExchangeRates;
+    static createFromPrimitives(data: any): ExchangeRates;
 }
 
-declare class HttpErrorController implements HttpController {
-    private readonly error;
-    private readonly errorManager;
-    constructor(error: Error, errorManager: ErrorManager);
-    handle(request: HttpRequest): Promise<HttpResponse>;
+declare class StringVars {
+    static parse(str: string, ob: {
+        [key: string]: any;
+    }): string;
 }
 
-export { Currency, DatabaseConnection, DatabaseConnector, DateTime, DomainEntity, DomainError, DomainEvent, Email, ErrorManager, ErrorManagerHandleResult, ErrorTemplate, EventBus, EventBusRepository, FatalError, HttpController, HttpErrorController, HttpHealthCheckController, HttpNotFoundController, HttpRequest, HttpResponse, InternalError, Language, Logger, MysqlConnection, MysqlConnector, Price, UUID, UploadedFile, UsageError, ValueObject, adaptErrorHandler, adaptExpressRoute };
+export { BaseEntity, BaseEvent, BaseObject, BasicUnitOfWork, BasicUnitOfWorkFactory, Country, Currency, DatabaseConnection, DatabaseConnector, DateTime, DefaultMysqlInboxRunner, DefaultMysqlOutboxRunner, DomainEntity, DomainError, DomainEvent, Email, ErrorManager, ErrorManagerHandleResult, ErrorTemplate, EventBus, EventBusMysqlRepository, EventBusRepository, EventManager, EventManagerConnection, EventMessage, ExchangeRates, FatalError, HttpController, HttpHealthCheckController, HttpNotFoundController, HttpRequest, HttpResponse, InboxRecord, IntegrationEvent, InternalError, KafkaManager, Language, Logger, MysqlConnection, MysqlConnector, OutboxRecord, PaymentGateway, PaymentStatus, Price, ProcessStatus, RouteCallback, RoutesCallbackList, StringVars, UUID, UnitOfWork, UploadedFile, UsageError, ValueObject, adaptExpressErrorHandler, adaptExpressRoute };