import type { SprintClaim, GolfScorecard, SlopeEvent, WorkflowExecution, WorkflowStepResult } from '../core/index.js';
import type { CommonIssuesFile, StoreStats } from '../core/index.js';
import { SlopeStoreError } from '../core/index.js';
import type { SlopeStore, SlopeSession, SlopeSessionUpdate } from '../core/index.js';
import type { EmbeddingStore, EmbeddingEntry, EmbeddingSearchResult, EmbeddingStats, IndexMeta } from '../core/embedding-store.js';
type JournalMode = 'WAL' | 'TRUNCATE' | 'DELETE' | 'PERSIST' | 'MEMORY' | 'OFF';
interface JournalModeDatabase {
    pragma(sql: string, options?: {
        simple?: boolean;
    }): unknown;
    prepare(sql: string): {
        run(): unknown;
    };
}
export declare function configureSqliteJournalMode(db: JournalModeDatabase, env?: Record<string, string | undefined>): JournalMode;
export declare function createSqliteStoreUnavailableError(dbPath: string, err: unknown): SlopeStoreError;
/** Latest schema version — total number of migrations available. */
export declare const LATEST_SCHEMA_VERSION: number;
export declare class SqliteSlopeStore implements SlopeStore, EmbeddingStore {
    private db;
    private vecAvailable;
    private vecLoaded;
    private vecTableReady;
    constructor(dbPath: string);
    /** Lazy-load sqlite-vec extension. Non-fatal if unavailable — embedding methods will throw. */
    private ensureVecLoaded;
    /** Require sqlite-vec to be available. Throws if not. */
    private requireVec;
    /** Check if vec_embeddings virtual table exists, creating it if index_meta has dimensions. */
    private ensureVecTable;
    /** Versioned migration framework — runs each migration exactly once */
    private migrate;
    /** Get current schema version synchronously (internal use by migrate()) */
    private getSchemaVersionSync;
    /** Get current schema version (0 if no migrations applied) */
    getSchemaVersion(): Promise<number>;
    /** Get aggregate row counts from all store tables */
    getStats(): Promise<StoreStats>;
    registerSession(session: Omit<SlopeSession, 'started_at' | 'last_heartbeat_at'>): Promise<SlopeSession>;
    removeSession(sessionId: string): Promise<boolean>;
    updateSession(sessionId: string, updates: SlopeSessionUpdate): Promise<SlopeSession>;
    getActiveSessions(): Promise<SlopeSession[]>;
    getSessionsBySwarm(swarmId: string): Promise<SlopeSession[]>;
    updateHeartbeat(sessionId: string): Promise<void>;
    cleanStaleSessions(maxAgeMs: number): Promise<number>;
    claim(input: Omit<SprintClaim, 'id' | 'claimed_at'>): Promise<SprintClaim>;
    release(id: string): Promise<boolean>;
    list(sprintNumber: number): Promise<SprintClaim[]>;
    get(id: string): Promise<SprintClaim | undefined>;
    getActiveClaims(sprintNumber?: number): Promise<SprintClaim[]>;
    saveScorecard(card: GolfScorecard): Promise<void>;
    listScorecards(filter?: {
        minSprint?: number;
        maxSprint?: number;
    }): Promise<GolfScorecard[]>;
    loadCommonIssues(): Promise<CommonIssuesFile>;
    saveCommonIssues(issues: CommonIssuesFile): Promise<void>;
    insertEvent(event: Omit<SlopeEvent, 'id' | 'timestamp'>): Promise<SlopeEvent>;
    getEventsBySession(sessionId: string): Promise<SlopeEvent[]>;
    getEventsBySprint(sprintNumber: number): Promise<SlopeEvent[]>;
    getEventsByTicket(ticketKey: string): Promise<SlopeEvent[]>;
    createTestingSession(session: {
        branch?: string;
        sprint?: number;
        purpose?: string;
        worktree_path?: string;
        branch_name?: string;
    }): Promise<{
        id: string;
        started_at: string;
    }>;
    endTestingSession(sessionId: string): Promise<{
        ended_at: string;
        finding_count: number;
        worktree_path?: string;
        branch_name?: string;
    }>;
    getActiveTestingSession(): Promise<{
        id: string;
        branch?: string;
        sprint?: number;
        purpose?: string;
        worktree_path?: string;
        branch_name?: string;
        started_at: string;
    } | null>;
    addTestingFinding(finding: {
        session_id: string;
        description: string;
        severity?: string;
        ticket?: string;
    }): Promise<{
        id: string;
    }>;
    getTestingFindings(sessionId: string): Promise<Array<{
        id: string;
        description: string;
        severity: string;
        ticket?: string;
        created_at: string;
    }>>;
    startExecution(params: {
        workflow_name: string;
        sprint_id?: string;
        variables?: Record<string, string>;
        session_id?: string;
        definition_json?: string;
        definition_hash?: string;
    }): Promise<WorkflowExecution>;
    getExecution(executionId: string): Promise<WorkflowExecution | null>;
    getExecutionBySprint(sprintId: string): Promise<WorkflowExecution | null>;
    updateExecutionState(executionId: string, phase: string, step: string): Promise<void>;
    completeExecution(executionId: string, status: 'completed' | 'failed' | 'paused' | 'running'): Promise<void>;
    recordStepResult(params: {
        execution_id: string;
        step_id: string;
        phase: string;
        status: 'completed' | 'skipped' | 'failed';
        output?: Record<string, unknown>;
        exit_code?: number;
        item?: string;
        started_at?: string;
    }): Promise<WorkflowStepResult>;
    listExecutions(filter?: {
        sprint_id?: string;
        status?: string;
    }): Promise<WorkflowExecution[]>;
    saveEmbeddings(entries: EmbeddingEntry[]): Promise<void>;
    searchEmbeddings(queryVector: Float32Array, limit?: number): Promise<EmbeddingSearchResult[]>;
    getIndexedFiles(): Promise<Array<{
        filePath: string;
        gitSha: string;
        model: string;
    }>>;
    deleteEmbeddingsByFile(filePath: string): Promise<void>;
    getEmbeddingStats(): Promise<EmbeddingStats>;
    setIndexMeta(sha: string, model: string, dimensions: number): Promise<void>;
    getIndexMeta(): Promise<IndexMeta | null>;
    /** Recreate vec virtual table with new dimensions (used by `slope index --full`) */
    recreateVecTable(dimensions: number): void;
    /** Clear all embedding data (used by `slope index --full`) */
    clearAllEmbeddings(): void;
    close(): void;
}
/** Create a SlopeStore backed by SQLite */
export declare function createStore(opts: {
    storePath: string;
    cwd?: string;
}): SlopeStore;
export {};
//# sourceMappingURL=index.d.ts.map