import type EventBus from "./EventBus/EventBus";
import type IEventStoreDBAL from "./IEventStoreDBAL";
import type ISnapshotStoreDBAL from "./Snapshot/SnapshotStoreDBAL";
import type { UpcasterChain } from "./Upcasting/UpcasterChain";
import EventSourcedAggregateRoot from "../Domain/EventSourcedAggregateRoot";
import { Identity } from "../Domain/AggregateRoot";
import DomainEventStream from "../Domain/Event/DomainEventStream";
export type AggregateFactory<T extends EventSourcedAggregateRoot> = new (aggregateRootID: Identity) => T;
export default class EventStore<T extends EventSourcedAggregateRoot> {
    private readonly dbal;
    private readonly eventBus;
    private readonly snapshotStore?;
    private readonly modelConstructor;
    private readonly snapshotMargin;
    private readonly upcasterChain?;
    constructor(modelConstructor: AggregateFactory<T>, dbal: IEventStoreDBAL, eventBus: EventBus, snapshotStoreDbal?: ISnapshotStoreDBAL, snapshotMargin?: number, upcasterChain?: UpcasterChain);
    load(aggregateRootId: Identity): Promise<T>;
    save(entity: T): Promise<void>;
    append(aggregateId: string, stream: DomainEventStream, expectedVersion?: number): Promise<void>;
    private calculateExpectedVersion;
    replayFrom(uuid: string, from: number, to?: number): Promise<void>;
    private takeSnapshot;
    private isSnapshotNeeded;
    private fromSnapshot;
    private aggregateFactory;
    /**
     * Applies upcasting to all events in the stream.
     * Events are migrated through the upcaster chain to their latest versions.
     *
     * @param stream - The original event stream
     * @returns A new stream with upcasted events
     */
    private applyUpcasting;
}