import type { StreamPart } from '../types/stream.js';
export interface LoggedEvent {
    index: number;
    eventId: string;
    runId: string;
    at: number;
    part: StreamPart;
}
/** Durable session event log — the keystone interface backend authors implement against. */
export interface SessionEventLog {
    /**
     * Append already-scrubbed parts for a session. At-least-once: a durable backend recovering
     * after restart may re-append; consumers dedupe on `eventId`, so ids must be derived from
     * stable content, not from a counter. Backends must not re-scrub.
     */
    append(sessionId: string, parts: StreamPart[], runId: string): Promise<void>;
    /**
     * Read events from an absolute `from` index. Over a truncated range returns a synthesized
     * `log-truncated` marker rather than silently fewer events. Real events keep their storage
     * index; the marker is derived from session drop counters and surfaced at
     * `max(from, droppedFrom)` so a reader's index sequence is always increasing.
     */
    read(sessionId: string, from: number, limit?: number): Promise<{
        events: LoggedEvent[];
        next: number;
    }>;
    /**
     * Stream every retained event at or after `from`, in strictly increasing index order, exactly
     * once. Synthesizes the same `log-truncated` marker as `read` when `from` falls in a dropped
     * range; use `read` for catch-up over dropped ranges.
     */
    follow(sessionId: string, from: number, signal?: AbortSignal): AsyncIterable<LoggedEvent>;
    /** Highest assigned index, or -1 when the session has no events. */
    tail(sessionId: string): Promise<number>;
    /** Remove all retained state for a session. */
    delete(sessionId: string): Promise<void>;
}
/** Floor for maxBytes — must fit the largest serialised event we can commit (poison marker). */
declare const MIN_MAX_BYTES = 256;
declare const POISON_MARKER_BYTES = 198;
export interface MemorySessionEventLogOptions {
    maxEvents?: number;
    maxBytes?: number;
}
export declare class MemorySessionEventLog implements SessionEventLog {
    private readonly sessions;
    private readonly maxEvents;
    private readonly maxBytes;
    constructor(options?: MemorySessionEventLogOptions);
    private getSession;
    append(sessionId: string, parts: StreamPart[], runId: string): Promise<void>;
    private doAppend;
    private commitEvent;
    private store;
    private enforceCeiling;
    private wakeWaiters;
    read(sessionId: string, from: number, limit?: number): Promise<{
        events: LoggedEvent[];
        next: number;
    }>;
    follow(sessionId: string, from: number, signal?: AbortSignal): AsyncIterable<LoggedEvent>;
    tail(sessionId: string): Promise<number>;
    delete(sessionId: string): Promise<void>;
}
export { MIN_MAX_BYTES, POISON_MARKER_BYTES };