import type { AgentExperienceEvent, AgentExperienceEvidence } from './types.js';
export interface AgentExperienceJournalState {
    readonly version: 2;
    readonly events: readonly AgentExperienceEvent[];
    readonly reflections: Readonly<Record<string, {
        readonly status: 'pending' | 'processing' | 'processed';
        readonly attempts: number;
        readonly updatedAt: string;
        readonly lastError?: string;
        readonly claimId?: string;
        readonly leaseExpiresAt?: string;
        readonly completedOwners?: readonly string[];
    }>>;
}
export interface AgentExperienceJournalStore {
    read(): Promise<AgentExperienceJournalState>;
    write(state: AgentExperienceJournalState): Promise<void>;
    withLock?<T>(operation: () => Promise<T>): Promise<T>;
}
export interface AgentExperienceJournalStorage {
    read(): Promise<unknown | null>;
    write(value: unknown): Promise<void>;
    withLock?<T>(operation: () => Promise<T>): Promise<T>;
}
export interface AgentExperienceCaptureResult {
    readonly deduplicated: boolean;
    readonly pending: boolean;
    readonly event: AgentExperienceEvent;
    readonly episodeEventCount: number;
    readonly episodeEvidenceCount: number;
}
export interface AgentExperienceEpisode {
    readonly id: string;
    readonly events: readonly AgentExperienceEvent[];
    readonly evidence: readonly AgentExperienceEvidence[];
}
export interface AgentExperienceReflectionClaim {
    readonly claimId: string;
    readonly episodeId: string;
    readonly eventIds: readonly string[];
    readonly events: readonly AgentExperienceEvent[];
    readonly completedOwners: Readonly<Record<string, readonly string[]>>;
}
export declare class MemoryAgentExperienceJournalStore implements AgentExperienceJournalStore {
    private state;
    constructor(initial?: AgentExperienceJournalState);
    read(): Promise<AgentExperienceJournalState>;
    write(state: AgentExperienceJournalState): Promise<void>;
}
export declare class StorageAgentExperienceJournalStore implements AgentExperienceJournalStore {
    private readonly storage;
    constructor(storage: AgentExperienceJournalStorage);
    read(): Promise<AgentExperienceJournalState>;
    write(state: AgentExperienceJournalState): Promise<void>;
    withLock<T>(operation: () => Promise<T>): Promise<T>;
}
export declare class AgentExperienceJournal {
    private readonly store;
    private queue;
    constructor(store: AgentExperienceJournalStore);
    capture(value: AgentExperienceEvent): Promise<AgentExperienceCaptureResult>;
    pending(limit?: number): Promise<readonly AgentExperienceEvent[]>;
    isPending(eventId: string): Promise<boolean>;
    /** Atomically lease one episode so independent CLI/Hook processes cannot reflect it twice. */
    claimEpisode(episodeId: string, options?: {
        readonly now?: string;
        readonly leaseMs?: number;
    }): Promise<AgentExperienceReflectionClaim | null>;
    renewClaim(claim: AgentExperienceReflectionClaim, options?: {
        readonly now?: string;
        readonly leaseMs?: number;
    }): Promise<void>;
    markLearnerCompleted(claim: AgentExperienceReflectionClaim, owner: string, eventIds: readonly string[], updatedAt?: string): Promise<void>;
    completeClaim(claim: AgentExperienceReflectionClaim, updatedAt?: string): Promise<void>;
    failClaim(claim: AgentExperienceReflectionClaim, error: string, updatedAt?: string): Promise<void>;
    markProcessed(eventId: string, updatedAt?: string): Promise<void>;
    markProcessedMany(eventIds: readonly string[], updatedAt?: string): Promise<void>;
    markFailed(eventId: string, error: string, updatedAt?: string): Promise<void>;
    episode(episodeId: string): Promise<AgentExperienceEpisode | null>;
    list(options?: {
        readonly projectId?: string;
        readonly type?: AgentExperienceEvent['type'];
    }): Promise<readonly AgentExperienceEvent[]>;
    private serialized;
    private updateReflection;
    private finishClaim;
}
//# sourceMappingURL=experience-journal.d.ts.map