// Generated by dts-bundle v0.7.3

/**
 * Takes events from an event store an produces derived data from it.
 */
export interface Aggregator<TResult = any, TEvents = Events> {
    /**
     * The result of the aggregate.
     */
    result: TResult;
    /**
     * Called for every event that is part of this aggregate.
     *
     * @param event The event to process.
     */
    process(event: Event<TEvents>): Promise<void>;
    /**
     * Called before the events are processed.
     */
    before?(): Promise<void>;
    /**
     * Called after the events have been processed.
     */
    after?(): Promise<void>;
}

export interface BaseEvent<Payload = any> {
    id: string;
    type: string;
    timestamp: string;
    payload: Payload;
}

export type Event<TEvents = Events> = EventImpl<keyof TEvents, TEvents>;
type EventImpl<TKey, TEvents> = TKey extends keyof TEvents ? EventType<TKey, TEvents[TKey]> : never;
type EventType<TKey, TPayload> = {
    id: string;
    type: TKey;
    timestamp: string;
    payload: TPayload;
};
export {};

export class EventStore<TEvents extends Record<string, any> = Events> {
    readonly storageAdapter: StorageAdapter;
    constructor(options?: EventStoreOptions);
    emit<TEventType extends keyof TEvents>(
        type: TEventType,
        payload: TEvents[TEventType]
    ): Promise<BaseEvent<TEvents[TEventType]>>;
    aggregate<TAggregator extends Aggregator<any, TEvents>>(aggregator: TAggregator): Promise<TAggregator["result"]>;
    aggregate<TAggregator extends new () => Aggregator<any, TEvents>>(
        aggregator: TAggregator
    ): Promise<InstanceType<TAggregator>["result"]>;
    forEach(callback: ForEachCallback): Promise<void>;
}

export interface EventStoreOptions {
    /**
     * The storage adapter to use for the event store.
     * If none is given, it defaults to the MemoryStorageAdapter.
     */
    storageAdapter?: StorageAdapter;
}

global {
    /**
     * Can be used to declare global events using interface declaration merging.
     */
    namespace Faustt.EventStore {
        interface Events {}
    }
}
export type Events = Faustt.EventStore.Events;

export interface DexieStorageAdapterOptions {
    dexie: typeof import("dexie").default;
}
export class DexieStorageAdapter extends StorageAdapter {
    constructor(options?: DexieStorageAdapterOptions);
    store(event: BaseEvent): Promise<void>;
    forEach(callback: ForEachCallback): Promise<void>;
}

export class MemoryStorageAdapter extends StorageAdapter {
    store(event: BaseEvent): Promise<void>;
    forEach(callback: ForEachCallback): Promise<void>;
}

export type ForEachCallback<Event = any> = (event: Event) => void | Promise<void>;
export abstract class StorageAdapter {
    abstract store(event: BaseEvent): Promise<void>;
    abstract forEach(callback: ForEachCallback): Promise<void>;
}