@phyzess/pappra 0.0.0-stage → 0.1.0-beta.2

package/dist/knowledge/paths.d.ts

@@ -0,0 +1,37 @@
+import type { Outcome } from '../schemas/outcome.js';
+import type { DocumentLocation } from '../schemas/document.js';
+import type { KnowledgeContext } from './context.js';
+import type { DiscoveredRepository } from '../workspace/types.js';
+export interface KnowledgePaths {
+    readonly sharedCatalog: string;
+    readonly privateCatalog: string;
+    readonly localDir: string;
+    readonly lockPath: string;
+    readonly journalsDir: string;
+}
+export declare function knowledgePaths(root: string): KnowledgePaths;
+/**
+ * Rejects a path if its final component or any existing ancestor resolves
+ * outside the allowed root. Missing parents are checked at their nearest
+ * existing ancestor; creation may add only descendants below that root.
+ */
+export declare function ensureKnowledgePathBoundary(root: string, path: string): Promise<Outcome<null>>;
+export interface ResolvedKnowledgeLocation {
+    readonly location: DocumentLocation;
+    readonly absolutePath: string;
+    readonly containmentRoot: string;
+    readonly canonicalPath: string;
+    readonly repository: DiscoveredRepository | null;
+    readonly access: 'read' | 'write';
+    readonly normalizedPath: string;
+}
+export interface ResolveLocationOptions {
+    readonly forWrite?: boolean;
+    readonly forCreate?: boolean;
+}
+export declare function resolveKnowledgeLocation(context: KnowledgeContext, location: DocumentLocation, options?: ResolveLocationOptions): Promise<Outcome<ResolvedKnowledgeLocation>>;
+export declare function readKnowledgeFile(path: string, maxBytes: number): Promise<Outcome<{
+    readonly bytes: Buffer;
+    readonly digest: string;
+    readonly size: number;
+}>>;

package/dist/knowledge/paths.js

@@ -0,0 +1,236 @@
+import { basename, dirname, join, resolve } from 'node:path';
+import { failed, succeeded } from '../schemas/outcome.js';
+import { diagnosticCodes } from '../schemas/errors.js';
+import { isPathInside, normalizePortableRelativePath, resolvePortableRelativePath, samePath, } from '../schemas/paths.js';
+import { observePath, readFileBounded, resolveRealpath } from '../infra/fs.js';
+export function knowledgePaths(root) {
+    const localDir = join(root, '.pappra', 'local', 'knowledge');
+    return {
+        sharedCatalog: join(root, '.pappra', 'knowledge', 'catalog.json'),
+        privateCatalog: join(localDir, 'catalog.json'),
+        localDir,
+        lockPath: join(localDir, 'apply.lock'),
+        journalsDir: join(localDir, 'journals'),
+    };
+}
+const managedStatePrefixes = [
+    '.pappra/local',
+    '.pappra/generated',
+    '.pappra/knowledge/catalog.json',
+];
+/**
+ * Rejects a path if its final component or any existing ancestor resolves
+ * outside the allowed root. Missing parents are checked at their nearest
+ * existing ancestor; creation may add only descendants below that root.
+ */
+export async function ensureKnowledgePathBoundary(root, path) {
+    if (!isPathInside(root, path)) {
+        return failed(diagnosticCodes.document_path_unsafe, `Path is outside the allowed knowledge root: ${path}`, {
+            nextAction: 'Use a path inside the workspace or an explicit repository.',
+        });
+    }
+    const realRoot = await resolveRealpath(root);
+    if (realRoot === null) {
+        return failed(diagnosticCodes.document_path_unsafe, `Cannot resolve knowledge root: ${root}`, { nextAction: 'Use an existing readable workspace root.' });
+    }
+    const candidate = await resolveRealpath(path);
+    if (candidate !== null) {
+        return isPathInside(realRoot, candidate)
+            ? succeeded(null)
+            : failed(diagnosticCodes.document_path_unsafe, `Knowledge path resolves outside its root: ${path} -> ${candidate}`, {
+                nextAction: 'Keep knowledge paths as regular files inside the workspace.',
+            });
+    }
+    let ancestor = dirname(path);
+    for (;;) {
+        let observation;
+        try {
+            observation = await observePath(ancestor);
+        }
+        catch (error) {
+            return failed(diagnosticCodes.fileUnreadable, `Cannot inspect knowledge parent ${ancestor}: ${error instanceof Error ? error.message : String(error)}`, {
+                nextAction: 'Check permissions; Pappra did not write through this path.',
+            });
+        }
+        if (observation.kind !== 'missing') {
+            if (observation.kind !== 'directory') {
+                return failed(diagnosticCodes.document_path_unsafe, `Knowledge parent is not a directory: ${ancestor}`, {
+                    nextAction: 'Inspect the parent path; Pappra does not write through it.',
+                });
+            }
+            const real = await resolveRealpath(ancestor);
+            return real !== null && isPathInside(realRoot, real)
+                ? succeeded(null)
+                : failed(diagnosticCodes.document_path_unsafe, `Knowledge parent escapes its root: ${ancestor}`, {
+                    nextAction: 'Inspect or remove the symlinked parent explicitly.',
+                });
+        }
+        const parent = dirname(ancestor);
+        if (samePath(parent, ancestor)) {
+            return failed(diagnosticCodes.document_path_unsafe, `Cannot find an existing parent for ${path}`, { nextAction: 'Create the parent inside the workspace first.' });
+        }
+        ancestor = parent;
+    }
+}
+async function nestedWorkspaceBoundary(allowedRoot, startDirectory) {
+    if (!isPathInside(allowedRoot, startDirectory))
+        return null;
+    let current = startDirectory;
+    while (!samePath(current, allowedRoot)) {
+        if ((await observePath(join(current, '.pappra'))).kind !== 'missing') {
+            return current;
+        }
+        const parent = dirname(current);
+        if (samePath(parent, current) || !isPathInside(allowedRoot, parent)) {
+            return null;
+        }
+        current = parent;
+    }
+    return null;
+}
+async function canonicalTargetPath(path) {
+    let current = path;
+    const missingSegments = [];
+    for (;;) {
+        const real = await resolveRealpath(current);
+        if (real !== null) {
+            return missingSegments.length === 0
+                ? real
+                : resolve(real, ...missingSegments.reverse());
+        }
+        const parent = dirname(current);
+        if (samePath(parent, current))
+            return null;
+        missingSegments.push(basename(current));
+        current = parent;
+    }
+}
+function containingRepository(context, target) {
+    let match = null;
+    for (const repository of context.repositories) {
+        if (!isPathInside(repository.root, target))
+            continue;
+        if (match === null || repository.root.length > match.root.length) {
+            match = repository;
+        }
+    }
+    return match;
+}
+export async function resolveKnowledgeLocation(context, location, options = {}) {
+    const normalizedPath = normalizePortableRelativePath(location.path);
+    if (normalizedPath === '.' || location.path !== normalizedPath) {
+        return failed(diagnosticCodes.document_path_unsafe, `Document path must be a normalized non-empty relative path: ${location.path}`, {
+            nextAction: 'Use a forward-slash relative path such as docs/architecture.md.',
+        });
+    }
+    let containmentRoot = context.root;
+    let repository = null;
+    let access = 'write';
+    if (location.kind === 'workspace') {
+        if (managedStatePrefixes.some((prefix) => normalizedPath === prefix || normalizedPath.startsWith(`${prefix}/`))) {
+            return failed(diagnosticCodes.document_path_unsafe, `Document path is Pappra-managed state: ${normalizedPath}`, {
+                nextAction: 'Keep knowledge documents outside local/generated state.',
+            });
+        }
+    }
+    else {
+        repository =
+            context.repositories.find((entry) => entry.id === location.sourceId) ??
+                null;
+        if (repository === null) {
+            return failed(diagnosticCodes.document_source_invalid, `Unknown explicit repository source: ${location.sourceId}`, {
+                nextAction: 'Declare the repository and its local mapping before registering its documents.',
+            });
+        }
+        containmentRoot = repository.root;
+        access = repository.access;
+    }
+    const absolutePath = location.kind === 'workspace'
+        ? resolvePortableRelativePath(context.root, normalizedPath)
+        : resolvePortableRelativePath(containmentRoot, normalizedPath);
+    if (!isPathInside(containmentRoot, absolutePath)) {
+        return failed(diagnosticCodes.document_path_unsafe, `Path is outside the allowed knowledge root: ${absolutePath}`, {
+            nextAction: 'Use a path inside the declared workspace/repository root.',
+        });
+    }
+    const canonicalTarget = await canonicalTargetPath(absolutePath);
+    if (canonicalTarget !== null) {
+        const targetRepository = containingRepository(context, canonicalTarget);
+        if (targetRepository !== null) {
+            repository = targetRepository;
+            access = targetRepository.access;
+        }
+    }
+    if (options.forWrite === true && access !== 'write') {
+        return failed(diagnosticCodes.document_access_denied, `Canonical document target is read-only: ${absolutePath}`, {
+            nextAction: 'Use a workspace/repository whose canonical checkout permits writes.',
+        });
+    }
+    let boundary;
+    try {
+        boundary = await nestedWorkspaceBoundary(containmentRoot, dirname(absolutePath));
+    }
+    catch (error) {
+        return failed(diagnosticCodes.fileUnreadable, `Cannot inspect nested workspace boundaries: ${error instanceof Error ? error.message : String(error)}`, { nextAction: 'Check permissions; no document path was written.' });
+    }
+    if (boundary !== null) {
+        return failed(diagnosticCodes.document_nested_workspace, `Document is inside nested workspace ${boundary}: ${absolutePath}`, { nextAction: 'Register the document in the nested workspace instead.' });
+    }
+    const boundaryCheck = await ensureKnowledgePathBoundary(containmentRoot, absolutePath);
+    if (!boundaryCheck.ok)
+        return boundaryCheck;
+    if (!options.forCreate) {
+        let observation;
+        try {
+            observation = await observePath(absolutePath);
+        }
+        catch (error) {
+            return failed(diagnosticCodes.fileUnreadable, `Cannot inspect document ${absolutePath}: ${error instanceof Error ? error.message : String(error)}`, { nextAction: 'Check permissions; the file was not read or written.' });
+        }
+        if (observation.kind === 'missing') {
+            return failed(diagnosticCodes.document_not_found, `Document file does not exist: ${absolutePath}`, { nextAction: 'Create or register an existing regular file.' });
+        }
+        if (observation.kind !== 'file') {
+            return failed(diagnosticCodes.document_path_unsafe, `Document path is not a regular file: ${absolutePath}`, {
+                nextAction: 'Symlinks, directories, FIFOs, and devices are not document files.',
+            });
+        }
+        const real = await resolveRealpath(absolutePath);
+        if (real === null || !isPathInside(containmentRoot, real)) {
+            return failed(diagnosticCodes.document_path_unsafe, `Document path resolves outside its root: ${absolutePath}`, {
+                nextAction: 'Keep documents as regular files inside the allowed root.',
+            });
+        }
+        if (options.forWrite === true && access !== 'write') {
+            return failed(diagnosticCodes.document_access_denied, `Document is read-only: ${absolutePath}`, {
+                nextAction: 'Write only through a writable workspace or repository.',
+            });
+        }
+    }
+    else {
+        let observation;
+        try {
+            observation = await observePath(absolutePath);
+        }
+        catch (error) {
+            return failed(diagnosticCodes.fileUnreadable, `Cannot inspect new document target ${absolutePath}: ${error instanceof Error ? error.message : String(error)}`, { nextAction: 'Check permissions; no document was written.' });
+        }
+        if (observation.kind !== 'missing') {
+            return failed(diagnosticCodes.document_already_registered, `New document target already exists: ${absolutePath}`, {
+                nextAction: 'Use proposeWrite to update the existing file; do not overwrite it as a new document.',
+            });
+        }
+    }
+    return succeeded({
+        location,
+        absolutePath,
+        containmentRoot,
+        canonicalPath: canonicalTarget ?? absolutePath,
+        repository,
+        access,
+        normalizedPath,
+    });
+}
+export async function readKnowledgeFile(path, maxBytes) {
+    return readFileBounded(path, maxBytes);
+}

package/dist/knowledge/refs.d.ts

@@ -0,0 +1,36 @@
+import type { Diagnostic } from '../schemas/diagnostics.js';
+import type { DocumentRecord, DocumentSource, DocumentVisibility } from '../schemas/document.js';
+import type { KnowledgeContext } from './context.js';
+import type { KnowledgeCatalogs } from './catalog.js';
+import { type ResolvedKnowledgeLocation } from './paths.js';
+export type Freshness = 'current' | 'needs-review' | 'unknown';
+export interface FreshnessReason {
+    readonly code: string;
+    readonly message: string;
+}
+export interface SourceCheck {
+    readonly kind: DocumentSource['kind'];
+    readonly ref: string;
+    readonly status: 'current' | 'needs-review' | 'unknown';
+    readonly message: string;
+}
+export interface FreshnessReport {
+    readonly freshness: Freshness;
+    readonly reasons: readonly FreshnessReason[];
+    readonly sourceChecks: readonly SourceCheck[];
+    readonly coverage: {
+        readonly sources: 'checked';
+        readonly pathReferences: 'unchecked';
+        readonly repositoryContent: 'not-scanned';
+    };
+}
+export declare function findRecord(catalogs: KnowledgeCatalogs, documentId: string): DocumentRecord | null;
+export declare function findCanonicalAlias(context: KnowledgeContext, catalogs: KnowledgeCatalogs, target: ResolvedKnowledgeLocation, ignoreDocumentId?: string | null): Promise<DocumentRecord | null>;
+export declare function findRecordByLocation(catalogs: KnowledgeCatalogs, key: string): DocumentRecord | null;
+export declare function inspectFreshness(context: KnowledgeContext, catalogs: KnowledgeCatalogs, record: DocumentRecord, maxBytes: number): Promise<FreshnessReport>;
+export interface RegisteredReference {
+    readonly documentId: string;
+    readonly relation: 'source' | 'superseded-by';
+}
+export declare function findRegisteredReferences(catalogs: KnowledgeCatalogs, targetDocumentId: string): readonly RegisteredReference[];
+export declare function validateSources(context: KnowledgeContext, catalogs: KnowledgeCatalogs, documentId: string, visibility: DocumentVisibility, sources: readonly DocumentSource[]): readonly Diagnostic[];

package/dist/knowledge/refs.js

@@ -0,0 +1,267 @@
+import { createDiagnostic } from '../schemas/diagnostics.js';
+import { diagnosticCodes } from '../schemas/errors.js';
+import { isPathInside, resolvePortableRelativePath, samePath, } from '../schemas/paths.js';
+import { observePath } from '../infra/fs.js';
+import { readKnowledgeFile, resolveKnowledgeLocation, } from './paths.js';
+export function findRecord(catalogs, documentId) {
+    if (catalogs.idConflicts.has(documentId))
+        return null;
+    return catalogs.records.get(documentId) ?? null;
+}
+export async function findCanonicalAlias(context, catalogs, target, ignoreDocumentId = null) {
+    for (const record of catalogs.records.values()) {
+        if (record.documentId === ignoreDocumentId)
+            continue;
+        const resolved = await resolveKnowledgeLocation(context, record.location);
+        if (resolved.ok &&
+            samePath(resolved.value.canonicalPath, target.canonicalPath)) {
+            return record;
+        }
+    }
+    return null;
+}
+export function findRecordByLocation(catalogs, key) {
+    if (catalogs.locationConflicts.has(key))
+        return null;
+    for (const record of catalogs.records.values()) {
+        const recordKey = record.location.kind === 'workspace'
+            ? `workspace:${record.location.path}`
+            : `source:${record.location.sourceId}:${record.location.path}`;
+        if (recordKey === key)
+            return record;
+    }
+    return null;
+}
+function sourceRef(source) {
+    return source.kind === 'document'
+        ? `document:${source.documentId}`
+        : `code:${source.repositoryId}:${source.path}@${source.version}`;
+}
+async function checkDocumentSource(context, catalogs, source, maxBytes) {
+    const target = findRecord(catalogs, source.documentId);
+    if (target === null) {
+        return {
+            kind: 'document',
+            ref: sourceRef(source),
+            status: 'needs-review',
+            message: `Referenced document ${source.documentId} is missing or ambiguous.`,
+        };
+    }
+    const resolved = await resolveKnowledgeLocation(context, target.location);
+    if (!resolved.ok) {
+        return {
+            kind: 'document',
+            ref: sourceRef(source),
+            status: 'needs-review',
+            message: `Referenced document cannot be read: ${resolved.message}`,
+        };
+    }
+    const file = await readKnowledgeFile(resolved.value.absolutePath, maxBytes);
+    if (!file.ok) {
+        return {
+            kind: 'document',
+            ref: sourceRef(source),
+            status: 'needs-review',
+            message: `Referenced document cannot be read: ${file.message}`,
+        };
+    }
+    return file.value.digest === source.digest
+        ? {
+            kind: 'document',
+            ref: sourceRef(source),
+            status: 'current',
+            message: 'Referenced document digest matches.',
+        }
+        : {
+            kind: 'document',
+            ref: sourceRef(source),
+            status: 'needs-review',
+            message: 'Referenced document digest changed since this source was recorded.',
+        };
+}
+async function checkCodeSource(context, source) {
+    const repository = context.repositories.find((entry) => entry.id === source.repositoryId);
+    if (repository === undefined) {
+        return {
+            kind: 'code',
+            ref: sourceRef(source),
+            status: 'needs-review',
+            message: `Repository ${source.repositoryId} is not available.`,
+        };
+    }
+    const path = resolvePortableRelativePath(repository.root, source.path);
+    if (!isPathInside(repository.root, path)) {
+        return {
+            kind: 'code',
+            ref: sourceRef(source),
+            status: 'needs-review',
+            message: `Code source path escapes repository ${source.repositoryId}.`,
+        };
+    }
+    const observation = await observePath(path);
+    if (observation.kind !== 'file') {
+        return {
+            kind: 'code',
+            ref: sourceRef(source),
+            status: 'needs-review',
+            message: `Code source is not a regular file: ${source.path}`,
+        };
+    }
+    if (repository.git.head === null) {
+        return {
+            kind: 'code',
+            ref: sourceRef(source),
+            status: 'unknown',
+            message: `Repository ${source.repositoryId} has no observable HEAD.`,
+        };
+    }
+    return repository.git.head === source.version
+        ? {
+            kind: 'code',
+            ref: sourceRef(source),
+            status: 'current',
+            message: 'Repository HEAD matches the recorded code version.',
+        }
+        : {
+            kind: 'code',
+            ref: sourceRef(source),
+            status: 'needs-review',
+            message: `Repository HEAD ${repository.git.head} differs from recorded version ${source.version}.`,
+        };
+}
+export async function inspectFreshness(context, catalogs, record, maxBytes) {
+    const reasons = [];
+    const resolved = await resolveKnowledgeLocation(context, record.location);
+    let fileCheck = 'unknown';
+    if (!resolved.ok) {
+        reasons.push({ code: resolved.code, message: resolved.message });
+    }
+    else {
+        const file = await readKnowledgeFile(resolved.value.absolutePath, maxBytes);
+        if (!file.ok) {
+            reasons.push({ code: file.code, message: file.message });
+        }
+        else if (file.value.digest !== record.digest) {
+            fileCheck = 'needs-review';
+            reasons.push({
+                code: diagnosticCodes.document_file_changed,
+                message: 'Document bytes differ from the registered digest.',
+            });
+        }
+        else {
+            fileCheck = 'current';
+        }
+    }
+    const sourceChecks = [];
+    for (const source of record.sources) {
+        const check = source.kind === 'document'
+            ? await checkDocumentSource(context, catalogs, source, maxBytes)
+            : await checkCodeSource(context, source);
+        sourceChecks.push(check);
+        if (check.status === 'needs-review') {
+            reasons.push({
+                code: diagnosticCodes.document_source_invalid,
+                message: check.message,
+            });
+        }
+    }
+    const hasUnknown = sourceChecks.some((entry) => entry.status === 'unknown');
+    const freshness = reasons.length > 0 || fileCheck === 'needs-review'
+        ? 'needs-review'
+        : hasUnknown
+            ? 'unknown'
+            : 'current';
+    return {
+        freshness,
+        reasons,
+        sourceChecks,
+        coverage: {
+            sources: 'checked',
+            pathReferences: 'unchecked',
+            repositoryContent: 'not-scanned',
+        },
+    };
+}
+export function findRegisteredReferences(catalogs, targetDocumentId) {
+    const references = [];
+    for (const record of catalogs.records.values()) {
+        if (record.documentId === targetDocumentId)
+            continue;
+        for (const source of record.sources) {
+            if (source.kind === 'document' &&
+                source.documentId === targetDocumentId) {
+                references.push({
+                    documentId: record.documentId,
+                    relation: 'source',
+                });
+            }
+        }
+        if (record.supersededBy === targetDocumentId) {
+            references.push({
+                documentId: record.documentId,
+                relation: 'superseded-by',
+            });
+        }
+    }
+    return references;
+}
+export function validateSources(context, catalogs, documentId, visibility, sources) {
+    const diagnostics = [];
+    for (const source of sources) {
+        if (source.kind === 'document') {
+            if (source.documentId === documentId) {
+                diagnostics.push(createDiagnostic({
+                    code: diagnosticCodes.document_source_invalid,
+                    severity: 'error',
+                    message: `Document ${documentId} cannot cite itself as a source.`,
+                    source: context.configPath,
+                    hint: 'Use an existing other document or a code version as the source.',
+                }));
+            }
+            else {
+                const target = findRecord(catalogs, source.documentId);
+                if (target === null) {
+                    diagnostics.push(createDiagnostic({
+                        code: diagnosticCodes.document_source_invalid,
+                        severity: 'error',
+                        message: `Document source ${source.documentId} does not exist in the catalog.`,
+                        source: context.configPath,
+                        hint: 'Register the source document first; Pappra does not invent source history.',
+                    }));
+                }
+                else if (visibility === 'shareable' &&
+                    target.visibility === 'private') {
+                    diagnostics.push(createDiagnostic({
+                        code: diagnosticCodes.document_visibility_invalid,
+                        severity: 'error',
+                        message: `A shareable document cannot cite private source ${source.documentId}.`,
+                        source: context.configPath,
+                        hint: 'Keep private references out of the shared catalog or share the source explicitly.',
+                    }));
+                }
+            }
+        }
+        else {
+            const repository = context.repositories.find((entry) => entry.id === source.repositoryId);
+            if (repository === undefined) {
+                diagnostics.push(createDiagnostic({
+                    code: diagnosticCodes.document_source_invalid,
+                    severity: 'error',
+                    message: `Code source repository ${source.repositoryId} is not declared or mapped.`,
+                    source: context.configPath,
+                    hint: 'Declare the repository and map external checkouts before citing code.',
+                }));
+            }
+            else if (!isPathInside(repository.root, resolvePortableRelativePath(repository.root, source.path))) {
+                diagnostics.push(createDiagnostic({
+                    code: diagnosticCodes.document_source_invalid,
+                    severity: 'error',
+                    message: `Code source path escapes repository ${source.repositoryId}: ${source.path}`,
+                    source: context.configPath,
+                    hint: 'Use a relative path inside the repository checkout.',
+                }));
+            }
+        }
+    }
+    return diagnostics;
+}

package/dist/knowledge/service.d.ts

@@ -0,0 +1,21 @@
+import { type FreshnessReport } from './refs.js';
+import type { ApplyWriteInput, ApplyWriteResult, ArchiveDocumentResult, DeleteExplicitInput, DeleteExplicitResult, DocumentCheckResult, ListDocumentsOptions, ListDocumentsResult, PreviewDeleteInput, PreviewDeleteResult, ProposeWriteInput, ProposeWriteResult, ReadDocumentResult, RegisterDocumentInput, RegisterDocumentResult, ShareDocumentResult, SupersedeDocumentInput, SupersedeDocumentResult, KnowledgeServiceOptions } from './types.js';
+export declare class KnowledgeService {
+    #private;
+    readonly root: string;
+    constructor(root: string, options?: KnowledgeServiceOptions);
+    register(input: RegisterDocumentInput): Promise<RegisterDocumentResult>;
+    read(documentId: string): Promise<ReadDocumentResult>;
+    list(options?: ListDocumentsOptions): Promise<ListDocumentsResult>;
+    check(options?: {
+        readonly includePrivate?: boolean;
+    }): Promise<DocumentCheckResult>;
+    proposeWrite(input: ProposeWriteInput): Promise<ProposeWriteResult>;
+    applyWrite(input: ApplyWriteInput): Promise<ApplyWriteResult>;
+    archive(documentId: string): Promise<ArchiveDocumentResult>;
+    supersede(input: SupersedeDocumentInput): Promise<SupersedeDocumentResult>;
+    share(documentId: string): Promise<ShareDocumentResult>;
+    previewDelete(input: PreviewDeleteInput): Promise<PreviewDeleteResult>;
+    deleteExplicit(input: DeleteExplicitInput): Promise<DeleteExplicitResult>;
+}
+export type { ApplyWriteResult, ArchiveDocumentResult, DeleteExplicitResult, DocumentCheckResult, ListDocumentsResult, PreviewDeleteResult, ProposeWriteResult, ReadDocumentResult, RegisterDocumentResult, ShareDocumentResult, SupersedeDocumentResult, FreshnessReport, };