export interface PipelineThreadRole {
    thread: string;
    role: string;
    description: string;
    trace_tags?: string;
}
export interface PipelineKeySlice {
    name: string;
    thread: string;
    description: string;
}
export interface SmartFilterConfig {
    enabled: boolean;
    description?: string;
    detection_sql?: string;
    fallback_sql?: string;
}
export interface PinInstruction {
    pattern: string;
    match_by: 'name' | 'uri';
    priority: number;
    reason: string;
    expand?: boolean;
    main_thread_only?: boolean;
    smart_filter?: SmartFilterConfig;
    smartPin?: boolean;
    skipPin?: boolean;
    activeProcessNames?: string[];
}
export interface TeachingContent {
    title: string;
    summary: string;
    mermaid?: string;
    thread_roles: PipelineThreadRole[];
    key_slices: PipelineKeySlice[];
}
export interface PipelineMeta {
    pipeline_id: string;
    display_name: string;
    description: string;
    icon: string;
    family: string;
    doc_path?: string;
}
export interface CommonIssue {
    id: string;
    name: string;
    description?: string;
    detection_skill?: string;
}
export interface PipelineAnalysis {
    common_issues?: CommonIssue[];
    recommended_skills?: string[];
}
export interface PipelineDefinition {
    name: string;
    version: string;
    type: 'pipeline_definition';
    category: string;
    meta: PipelineMeta;
    detection?: {
        required_signals?: Array<{
            thread?: string;
            thread_pattern?: string;
            slice?: string;
            slice_pattern?: string;
            min_count?: number;
        }>;
        scoring_signals?: Array<{
            signal: string;
            slice_pattern?: string;
            thread_pattern?: string;
            weight: number;
            min_count?: number;
            condition?: string;
        }>;
        exclude_if?: Array<{
            thread?: string;
            thread_pattern?: string;
            slice?: string;
            slice_pattern?: string;
        }>;
    };
    teaching: TeachingContent;
    auto_pin: {
        instructions: PinInstruction[];
    };
    analysis?: PipelineAnalysis;
}
declare class PipelineSkillLoaderClass {
    private pipelineCache;
    private initialized;
    private pipelinesDir;
    constructor();
    private validateDetection;
    /**
     * Load all pipeline skills from the pipelines directory
     */
    loadPipelines(): Promise<void>;
    /**
     * Get a pipeline definition by ID
     */
    getPipeline(pipelineId: string): PipelineDefinition | null;
    /**
     * Get all loaded pipelines
     */
    getAllPipelines(): PipelineDefinition[];
    /**
     * Get all pipeline IDs
     */
    getAllPipelineIds(): string[];
    /**
     * Get auto-pin instructions for a pipeline
     */
    getAutoPinInstructions(pipelineId: string): PinInstruction[];
    /**
     * Get smart filter configurations for a pipeline
     * Returns a map of pattern -> SmartFilterConfig
     */
    getSmartFilterConfigs(pipelineId: string): Map<string, SmartFilterConfig>;
    /**
     * Get teaching content for a pipeline
     */
    getTeachingContent(pipelineId: string): TeachingContent | null;
    /**
     * Get pipeline meta information
     */
    getPipelineMeta(pipelineId: string): PipelineMeta | null;
    /**
     * Get recommended skills for a pipeline
     */
    getRecommendedSkills(pipelineId: string): string[];
    /**
     * Get common issues for a pipeline
     */
    getCommonIssues(pipelineId: string): CommonIssue[];
    /**
     * Check if loader is initialized
     */
    isInitialized(): boolean;
    /**
     * Reload all pipeline skills
     */
    reload(): Promise<void>;
    /**
     * Default pin instructions for fallback
     */
    private getDefaultPinInstructions;
}
export declare const pipelineSkillLoader: PipelineSkillLoaderClass;
/**
 * Ensure pipeline skill loader is initialized
 * Safe to call concurrently - will only initialize once
 */
export declare function ensurePipelineSkillsInitialized(): Promise<void>;
/**
 * Get pipeline skill loader instance
 */
export declare function getPipelineSkillLoader(): PipelineSkillLoaderClass;
/**
 * Convenience function to get auto-pin instructions
 */
export declare function getAutoPinInstructions(pipelineId: string): Promise<PinInstruction[]>;
/**
 * Convenience function to get teaching content
 */
export declare function getTeachingContent(pipelineId: string): Promise<TeachingContent | null>;
/**
 * Convenience function to get smart filter configs
 */
export declare function getSmartFilterConfigs(pipelineId: string): Promise<Map<string, SmartFilterConfig>>;
export {};
//# sourceMappingURL=pipelineSkillLoader.d.ts.map