@dolittle/sdk.aggregates/Distribution/AggregateRootOperations.d.ts

Dolittle is a decentralized, distributed, event-driven microservice platform built to harness the power of events.

import { Logger } from 'winston';
import { Constructor } from '@dolittle/types';
import { EventSourceId, IEventStore, IEventTypes } from '@dolittle/sdk.events';
import { Cancellation } from '@dolittle/sdk.resilience';
import { AggregateRoot } from './AggregateRoot';
import { AggregateRootAction } from './AggregateRootAction';
import { IAggregateRootOperations } from './IAggregateRootOperations';
import { AggregateRootType } from './AggregateRootType';
/**
 * Represents an implementation of {@link IAggregateRootOperations<TAggregate>}.
 * @template TAggregateRoot
 */
export declare class AggregateRootOperations<TAggregateRoot extends AggregateRoot> extends IAggregateRootOperations<TAggregateRoot> {
    private readonly _type;
    private readonly _aggregateRootType;
    private readonly _eventSourceId;
    private readonly _eventStore;
    private readonly _eventTypes;
    private readonly _logger;
    /**
     * Initialises a new instance of the {@link AggregateRootOperations} class.
     * @param {Constructor<TAggregateRoot>} _type - The class implementing the aggregate root.
     * @param {AggregateRootType} _aggregateRootType - The aggregate root type associated with the aggregate root.
     * @param {EventSourceId} _eventSourceId - The event source id of the aggregate root to perform operations on.
     * @param {IEventStore} _eventStore - The event store to fetch committed events from and commit aggregate events with.
     * @param {IEventTypes} _eventTypes - All registered event types.
     * @param {Logger} _logger - The logger to use for logging.
     */
    constructor(_type: Constructor<TAggregateRoot>, _aggregateRootType: AggregateRootType, _eventSourceId: EventSourceId, _eventStore: IEventStore, _eventTypes: IEventTypes, _logger: Logger);
    /** @inheritdoc */
    perform(action: AggregateRootAction<TAggregateRoot>, cancellation?: Cancellation): Promise<void>;
    private commitAppliedEvents;
    private getUncommittedAggregateEvents;
    private reApplyEvents;
}
//# sourceMappingURL=AggregateRootOperations.d.ts.map