import type { WikiIssueKind, WikiIssueRecord, WikiIssueStatus } from "./contracts.js";
import { type ScholarDatabase } from "./database.js";
import { type QmdIndexOptions } from "./external/qmd.js";
import { type VaultPaths } from "./vault.js";
export interface WikiPage {
    pageId: string;
    relativePath: string;
    title: string;
    digest: string;
    revision: number;
    status: "active" | "drifted" | "retired";
    quizWorthiness: "eligible" | "skip" | "unknown";
    updatedAt: string;
    body?: string;
}
export interface WikiPageInput {
    path: string;
    title?: string;
    description?: string;
    body: string;
    pageId?: string;
    quizWorthiness?: "eligible" | "skip" | "unknown";
    frontmatter?: Record<string, unknown>;
}
export type DriftResolution = "record-issue" | "restore";
export interface QmdAdapter {
    search(query: string, options?: {
        collection: string;
        scope: "wiki/**/*.md";
        limit?: number;
        ignoredPaths?: readonly string[];
    }): Promise<unknown> | unknown;
    index?: (options?: QmdIndexOptions) => Promise<void> | void;
}
export interface WikiAdapters {
    qmd?: QmdAdapter;
}
export interface WikiCreateResult {
    page: WikiPage;
    content: string;
}
export interface WikiPreparedUpdate extends WikiCreateResult {
    expectedDigest: string;
}
export interface DriftReport {
    page: WikiPage;
    drifted: boolean;
    authoredDigest: string;
    currentDigest: string;
    diff: string;
    choices: ["record-issue", "restore"];
}
export declare function isExecutableHtml(value: string): boolean;
export declare class WikiService {
    readonly db: ScholarDatabase;
    readonly paths: Partial<VaultPaths> & {
        root?: string;
    };
    readonly adapters: WikiAdapters;
    constructor(db: ScholarDatabase, paths: Partial<VaultPaths> & {
        root?: string;
    }, adapters?: WikiAdapters);
    private root;
    private qmdIgnoredPaths;
    refreshQmdIndex(): Promise<void>;
    private refreshQmd;
    private atomicWrite;
    private assertDestinationAbsent;
    private optionalBytes;
    private restoreOptional;
    private catalog;
    private catalogByPath;
    private snapshotPath;
    private authored;
    private authoredPage;
    private writeCatalog;
    private sourceRows;
    citedSourceIds(body: string): ReadonlySet<string>;
    private sourceAwareContent;
    private serializeContent;
    create(input: WikiPageInput): Promise<WikiCreateResult>;
    prepareUpdate(pageId: string, input: {
        body?: string;
        title?: string;
        description?: string;
        quizWorthiness?: WikiPage["quizWorthiness"];
        expectedDigest?: string;
        path?: string;
    }, updatedAt?: string): Promise<WikiPreparedUpdate>;
    update(pageId: string, input: {
        body?: string;
        title?: string;
        description?: string;
        quizWorthiness?: WikiPage["quizWorthiness"];
        expectedDigest?: string;
        path?: string;
    }, prepared?: WikiPreparedUpdate): Promise<WikiCreateResult>;
    rename(pageId: string, requestedPath: string): Promise<WikiPage>;
    retire(pageId: string): Promise<WikiPage>;
    readExact(requestedPath: string): Promise<Buffer>;
    semanticSearch(query: string, limit?: number): Promise<unknown[]>;
    lexicalSearch(query: string, limit?: number): Promise<unknown[]>;
    get(pageIdOrPath: string): Promise<WikiPage & {
        content: string;
    }>;
    list(): Promise<WikiPage[]>;
    private qmdPath;
    private search;
    report(input: {
        pageId?: string;
        heading?: string;
        pageDigest?: string;
        kind?: WikiIssueKind;
        description: string;
    }): Promise<WikiIssueRecord>;
    inspectDrift(pageId: string): Promise<DriftReport>;
    resolveDrift(pageId: string, choice: DriftResolution): Promise<{
        page: WikiPage;
        issue?: WikiIssueRecord;
        restored: true;
    }>;
    patchIssue(issueId: string, patch: {
        status?: WikiIssueStatus;
        resolution?: string;
    }): Promise<WikiIssueRecord>;
    resolveIssueAfterCorrection(issueId: string, resolution: string): Promise<WikiIssueRecord>;
    refreshProjections(write?: boolean): Promise<{
        indexPath: string;
        logPath: string;
        backlinks: Record<string, string[]>;
        lint: string[];
    }>;
    lintSync(pages?: WikiPage[], backlinks?: Record<string, string[]>): string[];
}
export declare function parseWikiMarkdown(content: string): {
    frontmatter: Record<string, unknown>;
    body: string;
};
//# sourceMappingURL=wiki.d.ts.map