import type { AgentRecord, BlackboardEntry, Decision, DecisionAmendment, DecisionIndexEntry, DecisionStatus, Entity, HandoffIndexEntry, HandoffRecord, Relation } from "../../utils/types.js";
import type { IAgentStore, IBlackboardStore, IDecisionStore, IGraphStore, IHandoffStore, IIndexManager } from "../interfaces.js";
import type { EmbeddingIndex, IndexName } from "../../embeddings/index-manager.js";
import { type SqliteDatabase } from "./db.js";
export declare class SqliteBlackboardStore implements IBlackboardStore {
    private readonly db;
    constructor(db: SqliteDatabase);
    private rows;
    append(entry: Omit<BlackboardEntry, "id" | "timestamp">): Promise<BlackboardEntry>;
    read(filters?: {
        entry_types?: string[];
        tags?: string[];
        scope?: string;
        since?: string;
        limit?: number;
    }): Promise<{
        entries: BlackboardEntry[];
        total_count: number;
    }>;
    recent(n?: number, entry_types?: string[]): Promise<BlackboardEntry[]>;
    dismiss(ids: string[]): Promise<{
        dismissed: string[];
        not_found: string[];
    }>;
    resolve(ids: string[], opts: {
        by?: string;
        note?: string;
    }): Promise<{
        resolved: string[];
        not_found: string[];
    }>;
}
export declare class SqliteDecisionStore implements IDecisionStore {
    private readonly db;
    constructor(db: SqliteDatabase);
    private load;
    private save;
    create(input: Omit<Decision, "id" | "timestamp" | "status"> & {
        status?: "active" | "provisional";
    }): Promise<Decision>;
    get(id: string): Promise<Decision | null>;
    getByScope(scope: string): Promise<Decision[]>;
    updateStatus(id: string, status: DecisionStatus, extra?: Partial<Decision>): Promise<{
        persisted: boolean;
    }>;
    /**
     * Append-only metadata amendment (field D11). The sqlite index is a
     * read-time projection over the record, so rewriting the record keeps
     * every read model consistent. Deltas merge against the in-transaction
     * read: concurrent amends both survive.
     */
    amendMetadata(id: string, delta: {
        add_affected_files: string[];
        add_affected_symbols: string[];
        amendment: DecisionAmendment;
    }): Promise<void>;
    getIndex(): Promise<DecisionIndexEntry[]>;
    linkCommit(id: string, commitHash: string): Promise<void>;
    getByCommitHash(commitHash: string): Promise<Decision[]>;
}
export declare class SqliteGraphStore implements IGraphStore {
    private readonly db;
    /** Remove relations by id (wave-2 dedup pass). Unknown ids are ignored. */
    removeRelations(relationIds: Set<string>): Promise<{
        removed: number;
    }>;
    constructor(db: SqliteDatabase);
    private allEntities;
    addEntity(input: {
        name: string;
        type: Entity["type"];
        properties?: Record<string, string>;
    }): Promise<Entity>;
    addRelation(input: {
        source: string;
        target: string;
        type: Relation["type"];
        properties?: Record<string, string>;
    }): Promise<Relation>;
    getEntities(): Promise<Entity[]>;
    getRelations(): Promise<Relation[]>;
    getEntityById(id: string): Promise<Entity | undefined>;
    getEntityByName(name: string, type?: string): Promise<Entity[]>;
    removeEntities(entityIds: Set<string>): Promise<{
        removedEntities: number;
        removedRelations: number;
    }>;
}
export declare class SqliteAgentStore implements IAgentStore {
    private readonly db;
    constructor(db: SqliteDatabase);
    private load;
    private save;
    upsert(input: {
        agent_id: string;
        capabilities?: string[];
        role?: string;
        description?: string;
    }): Promise<AgentRecord>;
    touch(agentId: string): Promise<AgentRecord>;
    get(agentId: string): Promise<AgentRecord | null>;
    getAll(): Promise<AgentRecord[]>;
    findByCapabilities(tags: string[]): Promise<AgentRecord[]>;
}
export declare class SqliteHandoffStore implements IHandoffStore {
    private readonly db;
    constructor(db: SqliteDatabase);
    create(input: Omit<HandoffRecord, "id" | "created_at">): Promise<HandoffRecord>;
    get(id: string): Promise<HandoffRecord | null>;
    list(filters?: {
        source_agent?: string;
        target_agent?: string;
        scope?: string;
        since?: string;
        limit?: number;
    }): Promise<HandoffIndexEntry[]>;
    acknowledge(id: string, acknowledgedBy: string): Promise<HandoffRecord>;
    private toIndexEntry;
    private computeResultStatus;
}
export declare class SqliteIndexManager implements IIndexManager {
    private readonly db;
    constructor(db: SqliteDatabase);
    load(indexName: IndexName): Promise<EmbeddingIndex>;
    save(indexName: IndexName, index: EmbeddingIndex): Promise<void>;
    addEntry(indexName: IndexName, id: string, vector: number[], contentHash?: string): Promise<void>;
    removeEntries(indexName: IndexName, ids: string[]): Promise<void>;
    getVector(indexName: IndexName, id: string): Promise<number[] | null>;
}
//# sourceMappingURL=sqlite-stores.d.ts.map