/**
 * SolutionProvider - Manages fixpack solutions with vector-based error matching
 * Stores reusable remediation templates for recurring issues
 */
export interface Solution {
    id: number;
    title: string;
    description: string;
    category: 'devops' | 'deploy' | 'workspace' | 'tsconfig' | 'migration' | 'build' | 'runtime' | 'test' | 'security' | 'performance';
    component?: string;
    tags: string[];
    project_root?: string;
    repo_name?: string;
    package_manager?: string;
    monorepo_tool?: string;
    success_count: number;
    failure_count: number;
    success_rate: number;
    last_applied_at?: Date;
    verified_on?: Date;
    created_at: Date;
    updated_at: Date;
}
export interface ErrorSignature {
    id: number;
    solution_id: number;
    text: string;
    regexes: string[];
    embedding?: number[];
    meta?: Record<string, any>;
    created_at: Date;
}
export interface RemediationStep {
    id: number;
    solution_id: number;
    step_order: number;
    kind: 'cmd' | 'patch' | 'copy' | 'script' | 'env';
    payload: Record<string, any>;
    description?: string;
    timeout_ms: number;
    created_at: Date;
}
export interface ValidationCheck {
    id: number;
    solution_id: number;
    check_order: number;
    cmd: string;
    expect_substring?: string;
    expect_exit_code: number;
    timeout_ms: number;
    created_at: Date;
}
export interface SolutionMatch {
    solution: Solution;
    score: number;
    signature_text: string;
    step_count: number;
    steps?: RemediationStep[];
    checks?: ValidationCheck[];
}
export interface CreateSolutionInput {
    title: string;
    description?: string;
    category: Solution['category'];
    component?: string;
    tags?: string[];
    project_root?: string;
    repo_name?: string;
    package_manager?: string;
    monorepo_tool?: string;
    signatures: {
        text: string;
        regexes?: string[];
        meta?: Record<string, any>;
    }[];
    steps: {
        step_order: number;
        kind: RemediationStep['kind'];
        payload: Record<string, any>;
        description?: string;
        timeout_ms?: number;
    }[];
    checks?: {
        check_order: number;
        cmd: string;
        expect_substring?: string;
        expect_exit_code?: number;
        timeout_ms?: number;
    }[];
}
export interface SolutionFilters {
    project_root?: string;
    category?: Solution['category'];
    component?: string;
    package_manager?: string;
    monorepo_tool?: string;
}
export declare class SolutionProvider {
    private pool;
    private embedding;
    private cache?;
    constructor(databaseUrl?: string, redisUrl?: string);
    /**
     * Find solutions matching an error message
     * Returns ranked matches by semantic similarity + regex matching
     */
    findSolutions(errorMessage: string, filters?: SolutionFilters, limit?: number): Promise<SolutionMatch[]>;
    /**
     * Create a new solution (fixpack)
     */
    createSolution(input: CreateSolutionInput): Promise<number>;
    /**
     * Get solution details including steps and checks
     */
    getSolution(solutionId: number, includeSteps?: boolean): Promise<SolutionMatch | null>;
    /**
     * Get all steps for a solution
     */
    getSteps(solutionId: number): Promise<RemediationStep[]>;
    /**
     * Get all validation checks for a solution
     */
    getChecks(solutionId: number): Promise<ValidationCheck[]>;
    /**
     * Record solution application (for success rate tracking)
     */
    recordApplication(solutionId: number, success: boolean): Promise<void>;
    /**
     * Link a pattern to a solution (for pattern-solution learning)
     */
    linkPatternToSolution(patternTag: string, patternCategory: string, solutionId: number, success: boolean): Promise<void>;
    /**
     * Get solutions for a specific pattern (ranked by success rate for this pattern)
     */
    getSolutionsForPattern(patternTag: string, patternCategory?: string, limit?: number): Promise<SolutionMatch[]>;
    /**
     * Detect patterns in query text and suggest solutions
     * Returns patterns found in the query with their top solutions
     */
    detectPatternsInQuery(queryText: string, limit?: number): Promise<Array<{
        patternTag: string;
        patternCategory: string;
        matchScore: number;
        solutionCount: number;
        topSolutionId: number | null;
        topSolutionTitle: string | null;
        topSolutionSuccessRate: number;
    }>>;
    /**
     * Get golden paths (best pattern-solution combinations)
     */
    getGoldenPaths(minApplications?: number, limit?: number): Promise<Array<{
        patternTag: string;
        patternCategory: string;
        solutionId: number;
        solutionTitle: string;
        successRate: number;
        applications: number;
        avgHelpfulRatio: number;
        projectsCount: number;
    }>>;
    /**
     * Update pattern-solution helpfulness scores from feedback
     */
    updatePatternSolutionHelpfulness(): Promise<void>;
    /**
     * Update solution metadata
     */
    updateSolution(solutionId: number, updates: Partial<Pick<Solution, 'title' | 'description' | 'tags' | 'verified_on'>>): Promise<void>;
    /**
     * Delete a solution and all its related data (cascade)
     */
    deleteSolution(solutionId: number): Promise<void>;
    /**
     * List all solutions with optional filters
     */
    listSolutions(filters?: SolutionFilters, limit?: number): Promise<Solution[]>;
    /**
     * Close database connection
     */
    close(): Promise<void>;
}
//# sourceMappingURL=solution.provider.d.ts.map