import type { SprintClaim, GolfScorecard, SlopeEvent, WorkflowExecution, WorkflowStepResult } from '../core/types.js';
import type { CommonIssuesFile } from '../core/briefing.js';
import type { StoreStats } from '../core/store.js';
import type { SlopeStore, SlopeSession, SlopeSessionUpdate } from '../core/store.js';
type Pool = import('pg').Pool;
export interface PostgresStoreOptions {
    connectionString?: string;
    pool?: Pool;
    projectId?: string;
}
export declare class PostgresSlopeStore implements SlopeStore {
    private pool;
    private ownedPool;
    private projectId;
    private migrated;
    constructor(opts: PostgresStoreOptions);
    /** Run schema migrations with transaction-scoped advisory lock for concurrency safety */
    migrate(): Promise<void>;
    getSchemaVersion(): Promise<number>;
    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[]>;
    close(): void;
}
/** Create a PostgreSQL-backed SlopeStore. Requires `pg` package to be installed. */
export declare function createPostgresStore(opts: {
    connectionString?: string;
    pool?: unknown;
    projectId?: string;
}): Promise<SlopeStore>;
export {};
//# sourceMappingURL=index.d.ts.map