wsp-ms-core 1.0.7 → 1.0.8-7.5

package/dist/index.d.mts

@@ -0,0 +1,680 @@
+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 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;
+    private constructor();
+    protected validate(value: string): void;
+    plusYears(years: number): DateTime;
+    plusMonths(months: number): DateTime;
+    plusDays(days: number): DateTime;
+    plusHours(hours: number): DateTime;
+    plusMinutes(minutes: number): DateTime;
+    plusSeconds(seconds: number): DateTime;
+    minusYears(years: number): DateTime;
+    minusMonths(months: number): DateTime;
+    minusDays(days: number): DateTime;
+    minusHours(hours: number): DateTime;
+    minusMinutes(minutes: number): DateTime;
+    minusSeconds(seconds: number): DateTime;
+    get year(): number;
+    get month(): number;
+    get day(): number;
+    get hour(): number;
+    get minute(): number;
+    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;
+}
+
+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 _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;
+    abstract toProps(): T;
+    abstract toPrimitives(): Record<string, unknown>;
+}
+
+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 DomainError extends Error {
+    readonly type: string;
+    protected constructor(type: string, message?: string);
+}
+
+declare class FatalError extends DomainError {
+    constructor(type: string, message?: string);
+}
+
+declare class InternalError extends DomainError {
+    constructor(type: string, message?: string);
+}
+
+declare class UsageError extends DomainError {
+    readonly vars: Record<string, any>;
+    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;
+    private static readonly ALPHA_TO_NUM;
+    private static readonly NUM_TO_ALPHA;
+    static readonly USD: Currency;
+    static readonly EUR: Currency;
+    static readonly UYU: Currency;
+    static readonly ARS: Currency;
+    static readonly BRL: Currency;
+    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;
+}
+
+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;
+}
+
+declare class Language extends ValueObject<string> {
+    static readonly SUPPORTED: readonly string[];
+    static readonly DEFAULT: Language;
+    static readonly ENGLISH: Language;
+    static readonly ENGLISH_UNITED_STATES: Language;
+    static readonly ENGLISH_UNITED_KINGDOM: Language;
+    static readonly ENGLISH_AUSTRALIA: Language;
+    static readonly ENGLISH_CANADA: Language;
+    static readonly ENGLISH_NEW_ZEALAND: Language;
+    static readonly ENGLISH_IRELAND: Language;
+    static readonly ENGLISH_SOUTH_AFRICA: Language;
+    static readonly ENGLISH_JAMAICA: Language;
+    static readonly ENGLISH_BELIZE: Language;
+    static readonly ENGLISH_TRINIDAD: Language;
+    static readonly PORTUGUESE_BRAZIL: Language;
+    static readonly PORTUGUESE_PORTUGAL: Language;
+    static readonly SPANISH: Language;
+    static readonly SPANISH_ARGENTINA: Language;
+    static readonly SPANISH_GUATEMALA: Language;
+    static readonly SPANISH_COSTA_RICA: Language;
+    static readonly SPANISH_PANAMA: Language;
+    static readonly SPANISH_REPUBLICA_DOMINICANA: Language;
+    static readonly SPANISH_MEXICO: Language;
+    static readonly SPANISH_VENEZUELA: Language;
+    static readonly SPANISH_COLOMBIA: Language;
+    static readonly SPANISH_PERU: Language;
+    static readonly SPANISH_ECUADOR: Language;
+    static readonly SPANISH_CHILE: Language;
+    static readonly SPANISH_URUGUAY: Language;
+    static readonly SPANISH_PARAGUAY: Language;
+    static readonly SPANISH_BOLIVIA: Language;
+    static readonly SPANISH_EL_SALVADOR: Language;
+    static readonly SPANISH_HONDURAS: Language;
+    static readonly SPANISH_NICARAGUA: Language;
+    static readonly SPANISH_PUERTO_RICO: Language;
+    private constructor();
+    protected validate(value: string): void;
+    base(): string;
+    toPrimitives(): Record<string, unknown>;
+    static create(raw: string): Language;
+}
+
+interface PriceProps {
+    amount: number;
+    currency: Currency;
+}
+declare class Price extends ValueObject<PriceProps> {
+    static readonly MIN_AMOUNT: number;
+    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;
+}
+
+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 {
+    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>;
+    commit(): Promise<void>;
+    rollback(toSavepoint?: string): Promise<void>;
+    transaction<T>(fn: (conn: this) => Promise<T>): Promise<T>;
+    close(): Promise<void>;
+}
+
+interface UnitOfWork<C extends DatabaseConnection = DatabaseConnection> {
+    readonly connection: C;
+    execute<T>(fn: () => Promise<T>): Promise<T>;
+}
+
+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, unknown>;
+    readonly lang: string;
+    readonly body: any;
+    readonly files?: Record<string, UploadedFile | UploadedFile[]>;
+}
+interface HttpResponse {
+    statusCode: number;
+    body: any;
+    headers?: Record<string, string | number | readonly string[]>;
+}
+interface UploadedFile {
+    fieldName: string;
+    originalName: string;
+    encoding: string;
+    mimetype: string;
+    buffer: Buffer;
+    size: number;
+}
+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>;
+}
+type ErrorManagerHandleResult = {
+    status: number | string;
+    message: string;
+};
+declare class ErrorManager {
+    private readonly logger;
+    private static readonly DEFAULT_MESSAGES;
+    static readonly APP_ERRORS: {
+        readonly UNDEFINED: "UNDEFINED_ERROR";
+        readonly PROCESS: "PROCESS_ERROR";
+        readonly DATABASE: "DATABASE_ERROR";
+    };
+    private static readonly TEMPLATES;
+    constructor(logger?: Logger | null);
+    private getDefaultMessage;
+    private onFatal;
+    private onInternal;
+    private onUsage;
+    private onUnknown;
+    handle(err: Error, lang: Language): ErrorManagerHandleResult;
+    static addTemplate(template: ErrorTemplate): 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> {
+    static readonly DEFAULT_POOL_SIZE: number;
+    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 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 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>;
+}
+
+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 StringVars {
+    static parse(str: string, ob: {
+        [key: string]: any;
+    }): string;
+}
+
+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 };