import type { L0EventStore, L0EventStoreWithSnapshots, L0EventEnvelope, L0RecordedEvent, L0Snapshot } from "../types/events";
export declare class InMemoryEventStore implements L0EventStoreWithSnapshots {
    private streams;
    private snapshots;
    append(streamId: string, event: L0RecordedEvent): Promise<void>;
    getEvents(streamId: string): Promise<L0EventEnvelope[]>;
    exists(streamId: string): Promise<boolean>;
    getLastEvent(streamId: string): Promise<L0EventEnvelope | null>;
    getEventsAfter(streamId: string, afterSeq: number): Promise<L0EventEnvelope[]>;
    delete(streamId: string): Promise<void>;
    listStreams(): Promise<string[]>;
    saveSnapshot(snapshot: L0Snapshot): Promise<void>;
    getSnapshot(streamId: string): Promise<L0Snapshot | null>;
    getSnapshotBefore(streamId: string, seq: number): Promise<L0Snapshot | null>;
    clear(): void;
    getTotalEventCount(): number;
    getStreamCount(): number;
}
export declare class L0EventRecorder {
    private streamId;
    private eventStore;
    private seq;
    constructor(eventStore: L0EventStore, streamId?: string);
    getStreamId(): string;
    getSeq(): number;
    record(event: L0RecordedEvent): Promise<void>;
    recordStart(options: Extract<L0RecordedEvent, {
        type: "START";
    }>["options"]): Promise<void>;
    recordToken(value: string, index: number): Promise<void>;
    recordCheckpoint(at: number, content: string): Promise<void>;
    recordGuardrail(at: number, result: Extract<L0RecordedEvent, {
        type: "GUARDRAIL";
    }>["result"]): Promise<void>;
    recordDrift(at: number, result: Extract<L0RecordedEvent, {
        type: "DRIFT";
    }>["result"]): Promise<void>;
    recordRetry(reason: string, attempt: number, countsTowardLimit: boolean): Promise<void>;
    recordFallback(to: number): Promise<void>;
    recordContinuation(checkpoint: string, at: number): Promise<void>;
    recordComplete(content: string, tokenCount: number): Promise<void>;
    recordError(error: Extract<L0RecordedEvent, {
        type: "ERROR";
    }>["error"], failureType: Extract<L0RecordedEvent, {
        type: "ERROR";
    }>["failureType"], recoveryStrategy: Extract<L0RecordedEvent, {
        type: "ERROR";
    }>["recoveryStrategy"], policy: Extract<L0RecordedEvent, {
        type: "ERROR";
    }>["policy"]): Promise<void>;
}
export declare class L0EventReplayer {
    private eventStore;
    constructor(eventStore: L0EventStore);
    replay(streamId: string, options?: {
        speed?: number;
        fromSeq?: number;
        toSeq?: number;
    }): AsyncGenerator<L0EventEnvelope>;
    replayToState(streamId: string): Promise<ReplayedState>;
    replayTokens(streamId: string, options?: {
        speed?: number;
    }): AsyncGenerator<string>;
}
export interface ReplayedState {
    content: string;
    tokenCount: number;
    checkpoint: string;
    violations: import("../types/guardrails").GuardrailViolation[];
    driftDetected: boolean;
    retryAttempts: number;
    networkRetryCount: number;
    fallbackIndex: number;
    completed: boolean;
    error: import("../types/events").SerializedError | null;
    startTs: number;
    endTs: number;
}
export declare function createInMemoryEventStore(): InMemoryEventStore;
export declare function createEventRecorder(eventStore: L0EventStore, streamId?: string): L0EventRecorder;
export declare function createEventReplayer(eventStore: L0EventStore): L0EventReplayer;
//# sourceMappingURL=eventStore.d.ts.map