import type { PreparedAdmission as ContractPreparedAdmission, SourceKind as ContractSourceKind, SourceManifest as ContractSourceManifest, ExtractProgressPhase, SourceRecord } from "../contracts.js";
import { type ScholarDatabase } from "../database.js";
import type { DoclingResult as ExternalDoclingResult } from "../external/docling.js";
import { type VaultPaths } from "../vault.js";
import { atomizeExtraction, validateChunkEndpoints } from "./source-chunks.js";
import { digestBytes } from "./source-files.js";
export interface VaultPathsLike extends Partial<VaultPaths> {
    root?: string;
    inbox?: string;
    sources?: string;
    work?: string;
}
export type SourceKind = ContractSourceKind;
export type InputKind = SourceKind | "upload" | "pasted";
export interface StageMetadata {
    version: 1;
    requestedKind: InputKind;
    kind: SourceKind;
    displayName: string;
    originalName?: string;
    sourceUri?: string;
    mediaType?: string;
    repositoryRevision?: string;
    payload: "payload";
}
export interface SourceStageRequest {
    kind?: InputKind;
    path?: string;
    filePath?: string;
    url?: string;
    text?: string;
    bytes?: Uint8Array;
    name?: string;
    displayName?: string;
    mediaType?: string;
    originalName?: string;
}
export interface PreparedSourceStage {
    readonly stageId: string;
}
export interface FileSnapshot {
    path: string;
    size: number;
    digest: string;
    absolutePath: string;
    identity?: PhysicalIdentity;
}
export interface PhysicalIdentity {
    device: string;
    inode: string;
    mode: number;
    size: number;
    mtimeNs: string;
}
export interface TreeSnapshot {
    root: string;
    relativePath: string;
    kind: SourceKind;
    identity: PhysicalIdentity;
    digest: string;
    bytes: number;
    files: FileSnapshot[];
    revision?: string;
    metadata?: StageMetadata;
}
export interface InboxEntry {
    relativePath: string;
    absolutePath: string;
    kind: SourceKind;
    identity: PhysicalIdentity;
    digest?: string;
    bytes?: number;
    metadata?: StageMetadata;
    error?: string;
}
export interface SourceClaim {
    claimId: string;
    entry: InboxEntry;
    snapshot: TreeSnapshot;
    claimedAt: string;
}
export interface AdmissionResult {
    sourceId: string;
    manifest: SourceManifest;
    packetPath: string;
    removedInbox: boolean;
    claim: SourceClaim;
}
export interface SourceRemovalPreview {
    sourceId: string;
    packetPath: string;
    currentDigest: string;
    dependentPageIds: string[];
    confirmationId: string;
}
export interface SourceRemovalResult extends SourceRemovalPreview {
    removed: boolean;
}
export interface SourceChunk {
    index: number;
    startAtom: number;
    endAtom: number;
    startByte: number;
    endByte: number;
    digest: string;
    body: Buffer;
}
export interface SourceManifest extends Omit<ContractSourceManifest, "converter" | "files" | "chunks"> {
    id: string;
    sourceId: string;
    kind: SourceKind;
    displayName: string;
    originalName: string;
    originalUrl?: string;
    sourceUri?: string;
    revision?: string;
    repositoryRevision?: string;
    mediaType?: string;
    inputKind?: InputKind;
    stagedMetadata?: StageMetadata;
    capturedAt: string;
    converter?: {
        name: string;
        version: string;
    };
    normalizer: {
        name: "markdown-blank-lines";
        version: "2";
    };
    originalBytes: number;
    originalByteLength: number;
    originalDigest: string;
    extractionBytes: number;
    extractedByteLength: number;
    extractionDigest: string;
    extractedDigest: string;
    files: Array<ContractSourceManifest["files"][number] & {
        path: string;
        bytes: number;
    }>;
    chunks: Array<ContractSourceManifest["chunks"][number] & {
        index: number;
        startAtom: number;
        endAtom: number;
        startByte: number;
        endByte: number;
        digest: string;
        body?: never;
    }>;
}
export type PreparedAdmission = ContractPreparedAdmission;
export type SourcePreparationObserver = (phase: ExtractProgressPhase) => void | Promise<void>;
interface PreparedAttachment {
    path: string;
    byteLength: number;
    digest: string;
}
export interface PersistedPreparedAdmission extends PreparedAdmission {
    entryRelativePath: string;
    entryIdentity: PhysicalIdentity;
    snapshotIdentity: PhysicalIdentity;
    snapshotBytes: number;
    revision?: string;
    metadata?: StageMetadata;
    converter?: {
        name: string;
        version: string;
    };
    attachments: PreparedAttachment[];
    extractedDigest: string;
    extractedByteLength: number;
}
export interface SourceAdapters {
    docling?: ((input: {
        claim: SourceClaim;
        originalPath: string;
        kind: SourceKind;
        mediaType?: string;
    }) => Promise<DoclingResult | ExternalDoclingResult> | DoclingResult | ExternalDoclingResult) | {
        convert(input: {
            claim: SourceClaim;
            originalPath: string;
            kind: SourceKind;
            mediaType?: string;
        }): Promise<DoclingResult | ExternalDoclingResult> | DoclingResult | ExternalDoclingResult;
    };
    fetchUrl?: (url: string) => Promise<{
        bytes: Uint8Array;
        mediaType?: string;
        name?: string;
    }>;
    gitRevision?: ((root: string) => Promise<string> | string) | {
        revision(root: string): Promise<string> | string;
    };
}
export interface DoclingResult {
    extracted: Uint8Array | string;
    converter?: {
        name: string;
        version?: string;
    };
    attachments?: Array<{
        path: string;
        bytes: Uint8Array | string;
    }>;
}
export interface ChunkPlanEndpoint {
    endLine: number;
}
export interface SourceHttpResponse {
    status: number;
    location?: string;
    mediaType?: string;
}
export declare function requestSourceToFile(url: URL, target: string, timeoutMs?: number): Promise<SourceHttpResponse>;
export declare class SourceService {
    readonly db: ScholarDatabase;
    readonly paths: VaultPathsLike;
    readonly adapters: SourceAdapters;
    private readonly retainedSourceStages;
    private readonly retainedPrepared;
    constructor(db: ScholarDatabase, paths: VaultPathsLike, adapters?: SourceAdapters);
    private inbox;
    private assertSourceOutsideInbox;
    private readonly completedPrepared;
    private ensureInbox;
    private sourceStageRoot;
    private sources;
    private work;
    private preparedRoot;
    private preparedMetadataPath;
    private loadPrepared;
    private revalidateClaim;
    private assertPreparedClaim;
    private defaultFetch;
    private privateStageRoot;
    private retainSourceStage;
    private loadSourceStage;
    publishPreparedStage(stage: PreparedSourceStage): Promise<InboxEntry>;
    cleanupPreparedStage(stage: PreparedSourceStage): Promise<void>;
    private stageEnvelope;
    prepareStage(request: SourceStageRequest): Promise<PreparedSourceStage>;
    stage(request: SourceStageRequest): Promise<InboxEntry>;
    discover(): Promise<InboxEntry[]>;
    private snapshotForEntry;
    claim(entry: InboxEntry): Promise<SourceClaim>;
    prepareClaim(input: SourceClaim | InboxEntry, observer?: SourcePreparationObserver): Promise<PreparedAdmission>;
    cleanupPrepared(preparedId: string): Promise<void>;
    private publishPacket;
    publishPreparedClaim(input: {
        prepared: PreparedAdmission;
        preparedId: string;
        claimId: string;
        digest: string;
        endpoints?: readonly number[];
    }): Promise<AdmissionResult>;
    private isRepository;
    private revision;
    private sourceIdFor;
    private removeInboxAfterAdmission;
    private normalizeExistingPacket;
    admitClaim(claim: SourceClaim, options?: {
        endpoints?: Array<number | ChunkPlanEndpoint>;
    }): Promise<AdmissionResult>;
    private recordFailure;
    recordExtractFailure(entry: InboxEntry, error: unknown, claim?: SourceClaim): void;
    admitClaims(entries?: InboxEntry[]): Promise<Array<{
        claim?: SourceClaim;
        result?: AdmissionResult;
        error?: string;
    }>>;
    private recordSource;
    list(): Array<Record<string, unknown>>;
    publishedAttachment(sourceId: string, attachmentDigest: string): Promise<import("./source-packets.js").VerifiedSourceAttachment>;
    publishedPackets(sourceIds?: readonly string[]): Promise<Array<{
        readonly source: SourceRecord;
        readonly manifest: SourceManifest;
        readonly packetPath: string;
    }>>;
    private discoverCurrentCitationDependencies;
    private refreshDependencies;
    private currentDependentPageIds;
    private affectedOpenQuizIds;
    private affectedSubmittedQuizIds;
    private affectedOpenQuizIdsForPages;
    private affectedSubmittedQuizIdsForPages;
    private sourceDependencyRows;
    private removalConfirmationId;
    private removalLocations;
    private validRemovalPacket;
    private removalCleanupPending;
    private reconcileRemovalState;
    private quizSheetPath;
    removalPreview(sourceId: string): SourceRemovalPreview;
    removeConfirmed(sourceId: string, confirmation: string | {
        confirmationId?: string;
    }): Promise<SourceRemovalResult>;
}
export { atomizeExtraction, validateChunkEndpoints };
export declare const sha256: typeof digestBytes;
//# sourceMappingURL=source-service.d.ts.map