import { EventEmitter } from "node:events";
import type { ZodType } from "zod";
import type { Disposable, ProjectorStore } from "./interfaces";
import type { ArtifactFactory, ArtifactType, Messages, Projection, ProjectionResults, ProjectionSort, ProjectorFactory, ReducibleFactory, Schema, Scope, Snapshot, State } from "./types";
/**
 * Internal message details used as main drivers of public interfaces and documentation
 */
export type MessageMetadata<M extends Messages = Messages> = {
    name: keyof M;
    schema: ZodType<M[keyof M]>;
    type: "command" | "event" | "message";
    handlers: string[];
    producer?: string;
};
/**
 * Artifact reflected metadata
 */
export type ArtifactMetadata<S extends State = State, C extends Messages = Messages, E extends Messages = Messages> = {
    type: ArtifactType;
    factory: ArtifactFactory<S, C, E>;
    schema?: Schema<S>;
    inputs: Array<{
        name: string;
        scope: Scope;
    }>;
    outputs: string[];
    projector?: {
        schema: Schema<Projection<S>>;
        store: ProjectorStore<S>;
        indexes: ProjectionSort<S>[];
    };
};
/**
 * Returns true to commit state in stream
 * @param snapshot - current snapshot
 */
export type CommitPredicate<S extends State = State, E extends Messages = Messages> = (snapshot: Snapshot<S, E>) => boolean;
/**
 * Registration options
 * - `scope?` the scope used to publish message handlers
 * - `store?` a projector store associated with projectors
 * - `commit?` flags when to store state snapshots in the aggregate stream
 */
export type WithOptions<S extends State, E extends Messages> = {
    scope?: Scope;
    projector?: {
        store: ProjectorStore<S>;
        indexes: ProjectionSort<S>[];
    };
    commit?: CommitPredicate<S, E>;
};
export declare interface Builder {
    on(event: "commit", listener: (args: {
        factory: ReducibleFactory;
        snapshot?: Snapshot;
    }) => void): this;
    on(event: "projection", listener: (args: {
        factory: ProjectorFactory;
        results: ProjectionResults;
    }) => void): this;
}
/**
 * Abstract application builder
 *
 * Concrete adapters should provide disposers and the listening framework
 */
export declare abstract class Builder extends EventEmitter implements Disposable {
    abstract readonly name: string;
    abstract listen(): Promise<void>;
    dispose(): Promise<void>;
    private _hasStreams;
    readonly messages: Map<string, MessageMetadata<Messages>>;
    readonly artifacts: Map<string, ArtifactMetadata<State, Messages, Messages>>;
    readonly commits: Map<string, CommitPredicate<State, Messages>>;
    constructor();
    private _reflect;
    /**
     * Flags app with streams
     */
    withStreams(): this;
    get hasStreams(): boolean;
    /**
     * Registers factory
     * @param factory the artifact factory
     * @param options the artifact options
     */
    with<S extends State, C extends Messages, E extends Messages, O extends Messages>(factory: ArtifactFactory<S, C, E, O>, options?: WithOptions<S, E>): this;
    /**
     * Builds message handlers
     * Concrete app adapters should provide their own building steps
     * @returns optional internal application object (e.g. express)
     */
    build(): unknown | undefined;
}
//# sourceMappingURL=builder.d.ts.map