import type { KnowledgeEntry, KnowledgeSource, KnowledgeSourceStatus, SyncResult } from "@devflow-tools/sdk";
import type { EmbeddingProviderContract } from '@devflow-tools/sdk';
import { KnowledgeStore } from "./knowledge-store.js";
import { estimateKnowledgeTokens as estimateTokens } from "./result-quality.js";
import { type CompiledKnowledgeSource } from './knowledge-compiler.js';
import { SourceCatalog } from './source-catalog.js';
import { type DependencySourceCompileResult } from './dependency-source-compiler.js';
import { KnowledgeSourceService } from './knowledge-source-service.js';
import { KnowledgeQueryService, type KnowledgeSearchOptions, type KnowledgeSearchStatus } from './knowledge-query-service.js';
export type { KnowledgeSearchOptions, KnowledgeSearchStatus } from './knowledge-query-service.js';
export interface KnowledgeSyncOptions {
    withHeadings?: boolean;
    deferVectorBackfill?: boolean;
}
export interface LocalKnowledgeCatalogActivationResult {
    source: string;
    chunks: number;
    vectors: number;
    activated: boolean;
    errors: string[];
}
export declare const DEFAULT_KNOWLEDGE_TOKEN_BUDGET = 3000;
export declare const estimateKnowledgeTokens: typeof estimateTokens;
export declare class KnowledgeEngine {
    private projectRoot;
    private projectId;
    private knowledgeAssetRoot;
    private hybridSearch;
    private store;
    private embedder;
    private compiler;
    private catalog;
    readonly sources: KnowledgeSourceService;
    readonly query: KnowledgeQueryService;
    private compatibilityRejectionCount;
    private lowScoreRejectionCount;
    constructor(opts: {
        projectRoot: string;
        projectId: string;
        embedder?: EmbeddingProviderContract;
        dataSource?: {
            databasePath: string;
            assetRoot: string;
        };
    });
    private get knowledgeDir();
    private pluginDir;
    private ensureManifestSourceSchema;
    private resolvePersistedSourceVersion;
    registerSource(source: KnowledgeSource, operationTimestamp?: number): Promise<void>;
    syncDocs(pluginName?: string, options?: KnowledgeSyncOptions): Promise<SyncResult[]>;
    ingestSourceMarkdown(input: {
        source: string;
        title: string;
        markdown: string;
        sourceUri: string;
        version?: string;
        deferVectorBackfill?: boolean;
        operationTimestamp?: number;
    }): Promise<CompiledKnowledgeSource>;
    activatePersistedLocalSources(source?: string): LocalKnowledgeCatalogActivationResult[];
    private replaceDocument;
    private replaceCompiledSource;
    compileDependency(packageName: string): DependencySourceCompileResult;
    getProjectProfile(): Promise<ReturnType<SourceCatalog['refreshProjectProfile']>>;
    getSourceCatalog(): Promise<ReturnType<SourceCatalog['getCatalog']>>;
    getCoverageGaps(): Promise<ReturnType<KnowledgeStore['listCoverageGaps']>>;
    search(query: string, options?: KnowledgeSearchOptions): Promise<KnowledgeEntry[]>;
    searchWithStatus(query: string, options?: KnowledgeSearchOptions): Promise<KnowledgeSearchStatus>;
    private searchReadOnlyInternal;
    private packEntries;
    backfillVectors(options?: {
        source?: string;
        batchSize?: number;
        operationTimestamp?: number;
        onProgress?: (progress: {
            processed: number;
            remaining: number;
            lastId?: string;
        }) => void;
    }): Promise<{
        processed: number;
        remaining: number;
    }>;
    getVectorCoverage(): {
        chunks: number;
        vectors: number;
        bySource: Array<{
            source: string;
            chunks: number;
            vectors: number;
        }>;
    };
    getScopes(): string[];
    getDistinctSources(): string[];
    getIndexHealth(): ReturnType<KnowledgeStore['getIndexHealth']> & {
        compatibilityRejectionCount: number;
        lowScoreRejectionCount: number;
    };
    getSourceReadiness(): ReturnType<KnowledgeStore['getSourceReadiness']>;
    lookup(symbol: string, scope?: string): Promise<KnowledgeEntry | null>;
    getSources(): Promise<KnowledgeSourceStatus[]>;
    close(): void;
}
//# sourceMappingURL=knowledge-engine.d.ts.map