import type { KnowledgeEntry, KnowledgeSource } from "./plugin.js";
import type { RetrievalResultMetadata } from './retrieval.js';
export interface KnowledgeSourceStatus {
    source: KnowledgeSource;
    status: "idle" | "syncing" | "synced" | "error";
    lastSyncTime?: number;
    entryCount?: number;
}
export interface SearchOptions {
    limit?: number;
    sources?: string[];
    minScore?: number;
    embeddingProfileHash?: string;
}
export interface SyncResult {
    source: string;
    added: number;
    updated: number;
    errors: string[];
}
export interface GetKnowledgeResult extends RetrievalResultMetadata {
    results: KnowledgeEntry[];
    warnings: string[];
    budgetTokens: number;
    tokenCount?: number;
    truncatedCount: number;
    rejectedLowScore?: number;
    rejectedIncompatibleSources?: number;
    retrievalDiagnostics?: Record<string, unknown>;
}
export type KnowledgeChunkKind = 'api' | 'behavior' | 'migration' | 'error' | 'overview';
export interface KnowledgeNeed {
    entity?: string;
    symbol?: string;
    kind: KnowledgeChunkKind;
    version?: string;
    required?: boolean;
}
export interface KnowledgeScoreDetails {
    profileVersion: string;
    channelRanks: Partial<Record<'exact' | 'bm25' | 'entity' | 'manifest' | 'vector', number>>;
    rawScore: number;
    normalizedScore: number;
    pageScore: number;
    qualityScore: number;
    finalScore: number;
    authority: KnowledgeAuthority;
    versionCompatible: boolean;
    provenanceComplete: boolean;
    graphRelation?: {
        seedId: string;
        type: string;
        evidence: string;
    };
}
export type KnowledgeSourceKind = 'official' | 'plugin' | 'project' | 'dependency';
export type KnowledgeAuthority = 'official' | 'maintainer' | 'project' | 'community' | 'generated';
export type KnowledgeReadinessStatus = 'missing' | 'compiling' | 'ready' | 'degraded' | 'error';
export type KnowledgeTaskKind = 'overview' | 'create' | 'modify' | 'debug' | 'test' | 'build' | 'migrate' | 'explain';
export interface KnowledgeVersionPolicy {
    mode: 'exact' | 'exact_major' | 'compatible' | 'unversioned';
    expectedVersion?: string;
    allowPrerelease?: boolean;
}
export interface KnowledgeProvenance {
    sourceId: string;
    sourceKind: KnowledgeSourceKind;
    sourceUri: string;
    sourceVersion?: string;
    contentHash: string;
    retrievedAt: number;
    compilerVersion: string;
    immutable: true;
}
export interface KnowledgeCoverageGap {
    id: string;
    projectId: string;
    sourceId: string;
    kind: 'missing_source' | 'missing_entity' | 'missing_api' | 'incompatible_version' | 'compile_failure';
    entity?: string;
    symbol?: string;
    requiredVersion?: string;
    availableVersion?: string;
    taskKind?: KnowledgeTaskKind;
    reason: string;
    detectedAt: number;
    resolvedAt?: number;
}
export interface KnowledgeReadiness {
    status: KnowledgeReadinessStatus;
    activeContentHash?: string;
    documents: number;
    chunks: number;
    vectors: number;
    coverage: number;
    lastSuccessfulRefresh?: number;
    lastAttempt?: number;
    degradation?: {
        reason: string;
        category: 'source_unavailable' | 'compile_failed' | 'vector_degraded' | 'version_mismatch' | 'partial';
        recoverable: boolean;
        previousHealthyRevisionRetained: boolean;
    };
}
export interface KnowledgeSourceSchema {
    id: string;
    sourceId: string;
    sourceKind: KnowledgeSourceKind;
    authority: KnowledgeAuthority;
    versionPolicy: KnowledgeVersionPolicy;
    allowedEntities: string[];
    supportedTaskKinds: KnowledgeTaskKind[];
    refreshStrategy: 'manual' | 'startup' | 'on_demand' | 'interval';
    refreshIntervalMs?: number;
    schemaVersion: number;
    contentHash: string;
}
export interface NormalizedKnowledgePage {
    id: string;
    projectId: string;
    sourceId: string;
    sourceSchemaId: string;
    title: string;
    markdown: string;
    frontmatter: Record<string, unknown>;
    entities: string[];
    symbols: string[];
    links: string[];
    version?: string;
    contentHash: string;
    provenance: KnowledgeProvenance;
    compiledAt: number;
}
export interface KnowledgeChunk {
    id: string;
    pageId: string;
    projectId: string;
    sourceId: string;
    index: number;
    kind: KnowledgeChunkKind;
    headingBreadcrumbs: string[];
    content: string;
    embeddingText: string;
    originalStart: number;
    originalEnd: number;
    entities: string[];
    symbols: string[];
    links: string[];
    contentHash: string;
    oversizedAtomic: boolean;
    provenance: KnowledgeProvenance;
    analysisTerms: string[];
}
export interface KnowledgeEvidenceSpan {
    start: number;
    end: number;
    quote: string;
    kind?: string;
    hash: string;
}
export interface KnowledgeAnalysisItem {
    value: string;
    evidence: KnowledgeEvidenceSpan;
}
export interface KnowledgeAnalysisManifest {
    version: string;
    sourceId: string;
    contentHash: string;
    entities: KnowledgeAnalysisItem[];
    symbols: KnowledgeAnalysisItem[];
    concepts: KnowledgeAnalysisItem[];
    constraints: KnowledgeAnalysisItem[];
    contradictions: KnowledgeAnalysisItem[];
    relations: Array<{
        source: string;
        target: string;
        type: string;
        evidence: KnowledgeEvidenceSpan;
    }>;
}
export interface ProjectKnowledgeProfile {
    projectId: string;
    profileHash: string;
    generatedAt: number;
    packageManager?: {
        name: string;
        version?: string;
    };
    languages: string[];
    frameworks: Array<{
        name: string;
        version?: string;
        packageName?: string;
    }>;
    dependencies: Record<string, string>;
    activeSkills: string[];
    supportedTaskKinds: KnowledgeTaskKind[];
}
export interface KnowledgeSourceCatalogEntry {
    sourceId: string;
    schemaId: string;
    sourceKind: KnowledgeSourceKind;
    authority: KnowledgeAuthority;
    version?: string;
    contentHash: string;
    readiness: KnowledgeReadiness;
    entities: string[];
    symbols: string[];
    taskKinds: KnowledgeTaskKind[];
    activeRevisionId?: string;
}
export interface KnowledgeSourceCatalog {
    projectId: string;
    profileHash: string;
    catalogHash: string;
    generatedAt: number;
    sources: KnowledgeSourceCatalogEntry[];
    coverageGaps: KnowledgeCoverageGap[];
}
//# sourceMappingURL=knowledge.d.ts.map