@dugongjs/core/application/aggregate-message-consumer/aggregate-message-consumer.d.ts

import type { AbstractDomainEvent } from "../../domain/abstract-domain-event/abstract-domain-event.js";
import type { EventSourcedAggregateRoot } from "../../domain/abstract-event-sourced-aggregate-root/event-sourced-aggregate-root.js";
import type { IMessageConsumer } from "../../ports/inbound/message-broker/i-message-consumer.js";
import type { IInboundMessageMapper } from "../../ports/index.js";
import type { IConsumedMessageRepository } from "../../ports/outbound/repository/i-consumed-message-repository.js";
import type { IDomainEventRepository } from "../../ports/outbound/repository/i-domain-event-repository.js";
import type { TransactionContext } from "../../ports/outbound/transaction-manager/i-transaction-manager.js";
import { AbstractAggregateHandler, type AbstractAggregateHandlerOptions } from "../abstract-aggregate-handler/abstract-aggregate-handler.js";
export type AggregateMessageConsumerOptions<TAggregateRootClass extends EventSourcedAggregateRoot, TMessage> = Omit<AbstractAggregateHandlerOptions<TAggregateRootClass>, "tenantId"> & {
    domainEventRepository: IDomainEventRepository;
    consumedMessageRepository: IConsumedMessageRepository;
    messageConsumer: IMessageConsumer<TMessage>;
    inboundMessageMapper: IInboundMessageMapper<TMessage>;
};
export type HandleMessageOptions = {
    skipPersistence?: boolean;
    processConsumedMessages?: boolean;
    maximumRetries?: number;
    retryInterval?: number;
};
export type HandleMessageContext<TDomainEvent extends InstanceType<typeof AbstractDomainEvent> = any, TMessage = any> = {
    transactionContext: TransactionContext;
    domainEvent: TDomainEvent;
    message: TMessage;
};
export type HandleMessage = <TDomainEvent extends InstanceType<typeof AbstractDomainEvent> = any, TMessage = any>(context: HandleMessageContext<TDomainEvent, TMessage>) => Promise<void>;
export declare class AggregateMessageConsumer<TAggregateRootClass extends EventSourcedAggregateRoot, TMessage> extends AbstractAggregateHandler<TAggregateRootClass> {
    private readonly domainEventRepository;
    private readonly consumedMessageRepository;
    private readonly messageConsumer;
    private readonly inboundMessageMapper;
    constructor(options: AggregateMessageConsumerOptions<TAggregateRootClass, TMessage>);
    getMessageChannelId(): string;
    getMessageConsumerId(consumerName: string): string;
    getLogPrefix(): string;
    getMessageLogContext(consumerName: string, domainEvent: AbstractDomainEvent<any>): Record<string, any>;
    registerMessageConsumerForAggregate(consumerName: string, handleMessage?: HandleMessage, options?: HandleMessageOptions): Promise<void>;
    private retryOnFailure;
}