import type { ApprovalResponse, ApprovalState, ApprovalVote, ArtifactCreateOptions, ArtifactRef, FabricEvent, SessionData, SessionEntry, SessionStore, StreamChunkStore } from "./types.js";
import type { RunEvent, RunStore } from "./persistence.js";
export declare class InMemorySessionStore implements SessionStore {
    /** Tag so callers (and runtime-mode resolution) can detect ephemeral storage. */
    readonly __inMemory = true;
    private readonly sessions;
    private readonly artifacts;
    private readonly approvalWaiters;
    load(id: string): Promise<SessionData | undefined>;
    save(data: SessionData): Promise<void>;
    listSessions(): Promise<SessionData[]>;
    appendEvent(sessionId: string, event: FabricEvent): Promise<void>;
    appendEntry(sessionId: string, entry: SessionEntry): Promise<void>;
    appendEntries(sessionId: string, entries: readonly SessionEntry[], options?: {
        expectedLeafId?: string | undefined;
    }): Promise<boolean>;
    waitForApproval(sessionId: string, approvalId: string, timeoutMs?: number): Promise<ApprovalResponse | undefined>;
    resolveApproval(sessionId: string, approvalId: string, response: ApprovalResponse): Promise<void>;
    voteApproval(sessionId: string, approvalId: string, vote: ApprovalVote): Promise<ApprovalState>;
    getApprovalState(sessionId: string, approvalId: string): Promise<ApprovalState | undefined>;
    listApprovalStates(sessionId: string): Promise<ApprovalState[]>;
    putArtifact(sessionId: string, name: string, content: string | Uint8Array, options?: ArtifactCreateOptions): Promise<ArtifactRef>;
    getArtifact(sessionId: string, artifactIdOrName: string): Promise<{
        ref: ArtifactRef;
        content: Uint8Array;
    } | undefined>;
    listArtifacts(sessionId: string): Promise<ArtifactRef[]>;
    delete(sessionId: string): Promise<void>;
    /** Serializable state used by durable adapters that wrap the reference semantics. */
    exportPersistenceSnapshot(): unknown;
    importPersistenceSnapshot(snapshot: unknown): void;
    private resolveApprovalWaiters;
    private removeApprovalWaiter;
    private ensure;
}
export declare const defaultSessionStore: InMemorySessionStore;
/**
 * No-op session store for `runtime: 'stateless'` mode. All writes are
 * discarded; reads always return the empty initial session. Use this
 * when the agent is intended as a pure request/response handler with
 * no persistence (typical for high-volume webhooks and edge runtimes).
 *
 * Approvals and artifact retrieval are not supported — wiring those
 * up requires a real store. Callers in stateless mode should not rely
 * on artifact persistence or approval gating.
 */
export declare class NoopSessionStore implements SessionStore {
    readonly __stateless = true;
    load(_id: string): Promise<SessionData | undefined>;
    save(_data: SessionData): Promise<void>;
    appendEvent(_sessionId: string, _event: FabricEvent): Promise<void>;
    appendEntry(_sessionId: string, _entry: SessionEntry): Promise<void>;
    appendEntries(_sessionId: string, _entries: readonly SessionEntry[], _options?: {
        expectedLeafId?: string | undefined;
    }): Promise<boolean>;
}
export declare const noopSessionStore: NoopSessionStore;
/**
 * Merge one idempotent, leaf-fenced entry batch into a session snapshot.
 * Exported for first-party storage adapters so every backend applies the same
 * conflict and exact-replay semantics before its single atomic write.
 */
export declare function mergeSessionEntryBatch(existing: SessionData, entries: readonly SessionEntry[], expectedLeafId?: string, enforceExpectedLeaf?: boolean): SessionData | false;
/**
 * A unified in-memory store that implements {@link SessionStore},
 * {@link StreamChunkStore}, and {@link RunStore}. Useful for testing and
 * dev environments where a single object needs to be passed as `store`,
 * `streamChunkStore`, and `runStore`.
 *
 * Backed by separate Maps for each concern so that stream chunks and
 * run data do not pollute session state.
 */
export declare class UnifiedInMemoryStore extends InMemorySessionStore implements StreamChunkStore, RunStore {
    private readonly streamSegments;
    private readonly runs;
    private readonly runEvents;
    appendStreamChunkSegment(streamKey: string, segmentIndex: number, body: string): Promise<boolean>;
    getStreamChunkSegments(streamKey: string): Promise<Array<{
        segmentIndex: number;
        body: string;
    }>>;
    saveRun(run: unknown): Promise<void>;
    getRun(id: string): Promise<unknown | undefined>;
    listRuns(): Promise<unknown[]>;
    appendRunEvent(runId: string, event: RunEvent): Promise<void>;
    getRunEvents(runId: string, fromIndex?: number): Promise<RunEvent[]>;
    /** Clean up stream segments and run data for a given session/run prefix. */
    deleteStreamData(streamKey: string): Promise<void>;
    deleteRun(runId: string): Promise<void>;
}
/**
 * Factory that returns a fresh {@link UnifiedInMemoryStore}.
 * The returned object can be passed as `store`, `streamChunkStore`,
 * and `runStore` simultaneously.
 */
export declare function createUnifiedInMemoryStore(): UnifiedInMemoryStore;
export declare function approvalStatesFromEntries(sessionId: string, entries: SessionEntry[]): ApprovalState[];
//# sourceMappingURL=store.d.ts.map