@doccov/sdk 0.9.0 → 0.10.0

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { SpecDocDrift, SpecExport } from "@openpkg-ts/spec";
+import { DriftCategory, SpecDocDrift, SpecExport } from "@openpkg-ts/spec";
 interface ExampleRunResult {
 	success: boolean;
 	stdout: string;
@@ -48,6 +48,37 @@ declare function runExamplesWithPackage(examples: string[], options: RunExamples
 import { OpenPkg } from "@openpkg-ts/spec";
 type OpenPkgSpec = OpenPkg;
 /**
+* Result of computing drift for a single export.
+*/
+type ExportDriftResult = {
+	id: string;
+	drift: SpecDocDrift[];
+};
+/**
+* Result of computing drift for all exports.
+*/
+type DriftResult = {
+	exports: Map<string, SpecDocDrift[]>;
+};
+/**
+* Build a registry of all export/type names for cross-reference validation.
+*/
+declare function buildExportRegistry(spec: OpenPkgSpec): Set<string>;
+/**
+* Compute drift for all exports in a spec.
+*
+* @param spec - The OpenPkg spec to analyze
+* @returns Drift results per */
+declare function computeDrift(spec: OpenPkgSpec): DriftResult;
+/**
+* Compute drift for a single export.
+*
+* @param entry - The to analyze
+* @param exportRegistry - Registry of known names for link validation
+* @returns Array of drift issues detected
+*/
+declare function computeExportDrift(entry: SpecExport, exportRegistry?: Set<string>): SpecDocDrift[];
+/**
 * Detect runtime errors in @example blocks.
 * Results are provided externally after running examples via runExamples().
 */
@@ -70,589 +101,1585 @@ declare function hasNonAssertionComments(code: string): boolean;
 */
 declare function detectExampleAssertionFailures(entry: SpecExport, runtimeResults: Map<number, ExampleRunResult>): SpecDocDrift[];
 /**
-* Project detection types for I/O-agnostic project analysis.
-* Used by both CLI (NodeFileSystem) and API (SandboxFileSystem).
+* Extended drift with category and fixability metadata.
 */
+interface CategorizedDrift extends SpecDocDrift {
+	category: DriftCategory;
+	fixable: boolean;
+}
 /**
-* Minimal filesystem interface for I/O-agnostic detection.
-* Implementations: NodeFileSystem (CLI), SandboxFileSystem (API)
+* Categorize a single drift issue.
+*
+* @param drift - The drift to categorize
+* @returns The drift with category and fixable metadata
+*
+* @example
+* ```ts
+* const drift: SpecDocDrift = {
+*   type: 'param-type-mismatch',
+*   target: 'userId',
+*   issue: 'Type mismatch'
+* };
+* const categorized = categorizeDrift(drift);
+* console.log(categorized.category); // => 'structural'
+* console.log(categorized.fixable);  // => true
+* ```
 */
-interface FileSystem {
-	/** Check if a file or directory exists */
-	exists(path: string): Promise<boolean>;
-	/** Read file contents as string */
-	readFile(path: string): Promise<string>;
-	/** List directory contents (file/folder names only) */
-	readDir(path: string): Promise<string[]>;
-	/** Check if path is a directory */
-	isDirectory(path: string): Promise<boolean>;
-}
-/** Supported package managers */
-type PackageManager = "npm" | "yarn" | "pnpm" | "bun";
-/** Package manager detection result with install/run commands */
-interface PackageManagerInfo {
-	/** Package manager name */
-	name: PackageManager;
-	/** Lockfile that was detected (null if none found) */
-	lockfile: string | null;
-	/** Arguments for install command, e.g. ['install', '--frozen-lockfile'] */
-	installArgs: string[];
-	/** Prefix for running scripts, e.g. ['npm', 'run'] or ['pnpm'] */
-	runPrefix: string[];
-}
-/** Monorepo type based on configuration */
-type MonorepoType = "npm-workspaces" | "pnpm-workspaces" | "lerna" | "none";
-/** Monorepo detection result */
-interface MonorepoInfo {
-	/** Whether this is a monorepo */
-	isMonorepo: boolean;
-	/** Type of monorepo configuration */
-	type: MonorepoType;
-	/** Workspace patterns from config (e.g. ['packages/*']) */
-	patterns: string[];
-	/** Resolved workspace packages */
-	packages: WorkspacePackage[];
-}
-/** A package within a monorepo workspace */
-interface WorkspacePackage {
-	/** Package name from package.json */
-	name: string;
-	/** Relative path to package directory */
-	path: string;
-	/** Whether the package is marked as private */
-	private: boolean;
-}
-/** Entry point source - where the entry was detected from */
-type EntryPointSource = "types" | "exports" | "main" | "module" | "fallback";
-/** Entry point detection result */
-interface EntryPointInfo {
-	/** Path to entry file (relative to package root) */
-	path: string;
-	/** Where the entry point was detected from */
-	source: EntryPointSource;
-	/** Whether this is a .d.ts file (no source available) */
-	isDeclarationOnly: boolean;
-}
-/** Build configuration detection result */
-interface BuildInfo {
-	/** Build-related script names found (e.g. ['build', 'build:types']) */
-	scripts: string[];
-	/** Whether any build script was found */
-	hasBuildScript: boolean;
-	/** Whether TypeScript is configured/installed */
-	hasTypeScript: boolean;
-	/** Indicators for exotic project types */
-	exoticIndicators: {
-		/** WASM project (Cargo.toml or wasm-pack scripts) */
-		wasm: boolean;
-		/** napi-rs native addon project */
-		napi: boolean;
-	};
-}
-/** Complete project analysis result */
-interface ProjectInfo {
-	/** Package manager info */
-	packageManager: PackageManagerInfo;
-	/** Monorepo info */
-	monorepo: MonorepoInfo;
-	/** Entry point info */
-	entryPoint: EntryPointInfo;
-	/** Build info */
-	build: BuildInfo;
-}
-/** Options for analyzeProject() */
-interface AnalyzeProjectOptions {
-	/** Target package name for monorepos */
-	targetPackage?: string;
-}
+declare function categorizeDrift(drift: SpecDocDrift): CategorizedDrift;
 /**
-* Detect build configuration and exotic project indicators.
+* Group drifts by category.
 *
-* @param fs - FileSystem implementation
-* @param packagePath - Path to package directory (default: ".")
-* @returns Build info including scripts and exotic indicators
+* @param drifts - Array of drift issues to group
+* @returns Drifts organized by category
+*
+* @example
+* ```ts
+* const grouped = groupDriftsByCategory(spec.docs.drift ?? []);
+* console.log(grouped.structural.length); // Number of structural issues
+* console.log(grouped.semantic.length);   // Number of semantic issues
+* console.log(grouped.example.length);    // Number of example issues
+* ```
 */
-declare function detectBuildInfo(fs: FileSystem, packagePath?: string): Promise<BuildInfo>;
+declare function groupDriftsByCategory(drifts: SpecDocDrift[]): Record<DriftCategory, CategorizedDrift[]>;
 /**
-* Get the primary build script name to run.
-* Prefers 'build' over 'compile' over 'tsc'.
+* Summary of drift issues by category.
 */
-declare function getPrimaryBuildScript(buildInfo: BuildInfo): string | null;
+interface DriftSummary {
+	total: number;
+	byCategory: Record<DriftCategory, number>;
+	fixable: number;
+}
 /**
-* Detect the TypeScript entry point for a package.
+* Get drift summary counts by category.
 *
-* Priority order:
-* 1. package.json -> types or typings field
-* 2. package.json -> exports["."].types
-* 3. package.json -> main field (resolve to .ts)
-* 4. package.json -> module field (resolve to .ts)
-* 5. Common fallback paths
+* @param drifts - Array of drift issues
+* @returns Summary with totals, category breakdown, and fixable count
 *
-* @param fs - FileSystem implementation
-* @param packagePath - Path to package directory (default: ".")
-* @returns Entry point info
-* @throws Error if no entry point can be found
+* @example
+* ```ts
+* const summary = getDriftSummary(exportEntry.docs?.drift ?? []);
+* console.log(`${summary.total} issues: ${summary.fixable} fixable`);
+* // => "5 issues: 3 fixable"
+* ```
 */
-declare function detectEntryPoint(fs: FileSystem, packagePath?: string): Promise<EntryPointInfo>;
-import { Sandbox } from "@vercel/sandbox";
+declare function getDriftSummary(drifts: SpecDocDrift[]): DriftSummary;
 /**
-* Node.js filesystem implementation for CLI usage.
-* Wraps Node.js fs module with a base path.
+* Format drift summary for CLI output (single line).
+*
+* @param summary - Drift summary to format
+* @returns Human-readable summary string
+*
+* @example
+* ```ts
+* const summary = getDriftSummary(drifts);
+* console.log(formatDriftSummaryLine(summary));
+* // => "5 issues (3 structural, 1 semantic, 1 example)"
+* ```
 */
-declare class NodeFileSystem implements FileSystem {
-	private basePath;
-	constructor(basePath: string);
-	private resolve;
-	exists(relativePath: string): Promise<boolean>;
-	readFile(relativePath: string): Promise<string>;
-	readDir(relativePath: string): Promise<string[]>;
-	isDirectory(relativePath: string): Promise<boolean>;
+declare function formatDriftSummaryLine(summary: DriftSummary): string;
+import { OpenPkg as OpenPkg2, SpecDocDrift as SpecDocDrift2, SpecDocsMetadata, SpecExport as SpecExport3 } from "@openpkg-ts/spec";
+import { SpecExport as SpecExport2, SpecExportKind } from "@openpkg-ts/spec";
+import * as TS from "typescript";
+/**
+* Represents a single parameter in a JSDoc patch
+*/
+interface JSDocParam {
+	name: string;
+	type?: string;
+	description?: string;
+	optional?: boolean;
 }
 /**
-* Vercel Sandbox filesystem implementation for API usage.
-* Uses sandbox.runCommand() with shell commands.
+* Represents a return type in a JSDoc patch
 */
-declare class SandboxFileSystem implements FileSystem {
-	private sandbox;
-	constructor(sandbox: Sandbox);
-	exists(path: string): Promise<boolean>;
-	readFile(path: string): Promise<string>;
-	readDir(path: string): Promise<string[]>;
-	isDirectory(path: string): Promise<boolean>;
+interface JSDocReturn {
+	type?: string;
+	description?: string;
 }
 /**
-* Detect if a project is a monorepo and list its packages.
-*
-* Detection triggers (in order):
-* 1. package.json has workspaces field (npm/yarn)
-* 2. pnpm-workspace.yaml exists
-* 3. lerna.json exists
+* Represents a generic tag in a JSDoc patch
 */
-declare function detectMonorepo(fs: FileSystem): Promise<MonorepoInfo>;
+interface JSDocTag {
+	name: string;
+	text: string;
+}
 /**
-* Find a package by name or path in a list of workspace packages.
+* A patchable representation of a JSDoc comment
 */
-declare function findPackageByName(packages: WorkspacePackage[], nameOrPath: string): WorkspacePackage | undefined;
+interface JSDocPatch {
+	description?: string;
+	params?: JSDocParam[];
+	returns?: JSDocReturn;
+	examples?: string[];
+	deprecated?: string | false;
+	async?: boolean;
+	type?: string;
+	typeParams?: Array<{
+		name: string;
+		constraint?: string;
+		description?: string;
+	}>;
+	otherTags?: JSDocTag[];
+}
 /**
-* Format package list for display in error messages.
+* Represents an edit to be applied to a source file
 */
-declare function formatPackageList(packages: WorkspacePackage[], limit?: number): string;
+interface JSDocEdit {
+	filePath: string;
+	symbolName: string;
+	startLine: number;
+	endLine: number;
+	hasExisting: boolean;
+	existingJSDoc?: string;
+	newJSDoc: string;
+	indent: string;
+}
 /**
-* Detect package manager based on lockfile presence and package.json hints.
-*
-* Resolution order:
-* 1. packageManager field in package.json (e.g., "pnpm@9.0.0")
-* 2. Most recently modified lockfile (when multiple exist)
-* 3. Static priority order: pnpm > bun > yarn > npm
-* 4. Default to npm
+* Result of applying edits to source files
 */
-declare function detectPackageManager(fs: FileSystem): Promise<PackageManagerInfo>;
+interface ApplyEditsResult {
+	filesModified: number;
+	editsApplied: number;
+	errors: Array<{
+		file: string;
+		error: string;
+	}>;
+}
 /**
-* Get install command for a package manager.
-* Returns [command, ...args] array.
+* Parse a JSDoc comment string into a patchable structure
 */
-declare function getInstallCommand(pm: PackageManagerInfo): string[];
+declare function parseJSDocToPatch(jsDocText: string): JSDocPatch;
 /**
-* Get run command for a package manager script.
-* Returns [command, ...args, scriptName] array.
+* Apply a partial patch to an existing JSDoc patch, preserving unmodified content
 */
-declare function getRunCommand(pm: PackageManagerInfo, script: string): string[];
+declare function applyPatchToJSDoc(existing: JSDocPatch, updates: Partial<JSDocPatch>): JSDocPatch;
 /**
-* Safely parse a JSON file, returning null on any error.
+* Serialize a JSDocPatch back to a formatted comment string
 */
-declare function safeParseJson<T = Record<string, unknown>>(fs: FileSystem, path: string): Promise<T | null>;
+declare function serializeJSDoc(patch: JSDocPatch, indent?: string): string;
 /**
-* Standard package.json structure for detection purposes.
+* Find the JSDoc location for a declaration in a source file
 */
-interface PackageJson {
-	name?: string;
-	version?: string;
-	private?: boolean;
-	main?: string;
-	module?: string;
-	types?: string;
-	typings?: string;
-	exports?: PackageExports;
-	workspaces?: string[] | {
-		packages: string[];
-	};
-	scripts?: Record<string, string>;
-	dependencies?: Record<string, string>;
-	devDependencies?: Record<string, string>;
-}
+declare function findJSDocLocation(sourceFile: TS.SourceFile, symbolName: string, approximateLine?: number): {
+	startLine: number;
+	endLine: number;
+	declarationLine: number;
+	hasExisting: boolean;
+	existingJSDoc?: string;
+	indent: string;
+} | null;
 /**
-* Package.json exports field structure.
+* Apply a batch of edits to source files
 */
-type PackageExports = string | {
-	"."?: string | {
-		types?: string;
-		import?: string;
-		require?: string;
-		default?: string;
-	};
-	[key: string]: unknown;
-};
+declare function applyEdits(edits: JSDocEdit[]): Promise<ApplyEditsResult>;
 /**
-* Read and parse package.json from a directory.
+* Create a TypeScript source file from a file path
 */
-declare function readPackageJson(fs: FileSystem, dir: string): Promise<PackageJson | null>;
+declare function createSourceFile(filePath: string): TS.SourceFile;
 /**
-* Analyze a project's structure for scanning.
-*
-* This is the main entry point for project detection. It combines all
-* detection functions into a single call that returns complete project info.
-*
-* For monorepos, you must specify the target package via options.targetPackage.
-* If not specified and a monorepo is detected, an error is thrown with the
-* list of available packages.
-*
-* @param fs - FileSystem implementation (NodeFileSystem or SandboxFileSystem)
-* @param options - Options including targetPackage for monorepos
-* @returns Complete project info
-* @throws Error if monorepo detected without targetPackage specified
-* @throws Error if targetPackage not found in monorepo
-*
-* @example
-* ```typescript
-* import { NodeFileSystem, analyzeProject } from '@doccov/sdk';
-*
-* // Single package
-* const singleFs = new NodeFileSystem('/path/to/package');
-* const singleProject = await analyzeProject(singleFs);
-*
-* // Monorepo with target package
-* const monoFs = new NodeFileSystem('/path/to/monorepo');
-* const monoProject = await analyzeProject(monoFs, { targetPackage: '@scope/core' });
-* ```
+* Quality rule severity levels.
 */
-declare function analyzeProject2(fs: FileSystem, options?: AnalyzeProjectOptions): Promise<ProjectInfo>;
-interface DocCovOptions {
-	includePrivate?: boolean;
-	followImports?: boolean;
-	maxDepth?: number;
-	resolveExternalTypes?: boolean;
-}
-/** @deprecated Use DocCovOptions instead */
-type OpenPkgOptions = DocCovOptions;
-declare function extractPackageSpec(entryFile: string, packageDir?: string, content?: string, options?: OpenPkgOptions): Promise<OpenPkgSpec>;
-interface FilterOptions {
-	include?: string[];
-	exclude?: string[];
+type QualitySeverity = "error" | "warn" | "off";
+/**
+* Context passed to quality rule checks.
+*/
+interface RuleContext {
+	export: SpecExport2;
+	rawJSDoc?: string;
 }
 /**
-* Configuration types for DocCov.
-* These types are shared between CLI and API.
+* A violation reported by a quality rule.
 */
+interface QualityViolation {
+	ruleId: string;
+	severity: "error" | "warn";
+	message: string;
+	line?: number;
+	fixable: boolean;
+}
 /**
-* Documentation configuration options.
+* A quality rule checks one aspect of documentation quality.
+* Rules can contribute to coverage score, lint violations, or both.
 */
-interface DocsConfig {
-	/** Glob patterns for markdown docs to include */
-	include?: string[];
-	/** Glob patterns for markdown docs to exclude */
-	exclude?: string[];
+interface QualityRule {
+	/** Unique rule identifier */
+	id: string;
+	/** Human-readable name */
+	name: string;
+	/** What this rule checks */
+	description: string;
+	/**
+	* Which kinds this rule applies to.
+	* If undefined, applies to all kinds.
+	*/
+	appliesTo?: SpecExportKind[];
+	/**
+	* Does this rule contribute to coverage score?
+	* If true, the rule is counted as a "signal" for coverage calculation.
+	*/
+	affectsCoverage: boolean;
+	/**
+	* Default lint severity. Set to 'off' if rule is coverage-only.
+	*/
+	defaultSeverity: QualitySeverity;
+	/**
+	* Check if the satisfies this rule.
+	* Returns true if satisfied, false if not.
+	*/
+	check(ctx: RuleContext): boolean;
+	/**
+	* Get detailed violation info when check returns false.
+	* Only called if check() returns false and severity !== 'off'.
+	*/
+	getViolation?(ctx: RuleContext): QualityViolation;
+	/**
+	* Generate a fix for the violation.
+	* Only called if check() returns false and fix is requested.
+	*/
+	fix?(ctx: RuleContext): JSDocPatch | null;
 }
 /**
-* Check command configuration options.
+* User configuration for quality rules.
 */
-interface CheckConfig {
-	/** Enable lint checks (default: true) */
-	lint?: boolean;
-	/** Enable typecheck for examples (default: true) */
-	typecheck?: boolean;
-	/** Enable runtime execution of examples (default: false) */
-	exec?: boolean;
+interface QualityConfig {
+	rules: Record<string, QualitySeverity>;
 }
 /**
-* Lint severity level.
+* Result of evaluating quality for a single export.
 */
-type LintSeverity = "error" | "warn" | "off";
+interface QualityResult {
+	/** Coverage score (0-100) */
+	coverageScore: number;
+	/** Coverage details */
+	coverage: {
+		/** Rule IDs that passed */
+		satisfied: string[];
+		/** Rule IDs that failed */
+		missing: string[];
+		/** All applicable rule IDs */
+		applicable: string[];
+	};
+	/** Lint violations (only for rules with severity !== 'off') */
+	violations: QualityViolation[];
+	/** Summary counts */
+	summary: {
+		errorCount: number;
+		warningCount: number;
+		fixableCount: number;
+	};
+}
 /**
-* Lint rules configuration.
+* Aggregate result for multiple exports.
 */
-interface LintRulesConfig {
-	/** Rule severity overrides */
-	rules?: Record<string, LintSeverity>;
+interface AggregateQualityResult {
+	byExport: Map<string, QualityResult>;
+	overall: {
+		coverageScore: number;
+		totalViolations: number;
+		errorCount: number;
+		warningCount: number;
+	};
 }
 /**
-* Normalized DocCov configuration.
-* This is the parsed/normalized form used by commands.
+* An enriched with computed documentation metadata.
+* Extends SpecExport with the `docs` field for coverage analysis.
 */
-interface DocCovConfig {
-	/** Export include patterns */
-	include?: string[];
-	/** Export exclude patterns */
-	exclude?: string[];
-	/** Plugins (future) */
-	plugins?: unknown[];
-	/** Documentation configuration */
-	docs?: DocsConfig;
-	/** Check command configuration */
-	check?: CheckConfig;
-	/** Lint configuration */
-	lint?: LintRulesConfig;
+type EnrichedExport = SpecExport3 & {
+	docs?: EnrichedDocsMetadata;
+};
+/**
+* Extended docs metadata with quality violations.
+*/
+type EnrichedDocsMetadata = SpecDocsMetadata & {
+	violations?: QualityViolation[];
+};
+/**
+* An enriched OpenPkg spec with computed documentation metadata.
+* Extends OpenPkg with per-and aggregate coverage data.
+*/
+type EnrichedOpenPkg = Omit<OpenPkg2, "exports"> & {
+	exports: EnrichedExport[];
+	docs?: EnrichedDocsMetadata;
+	/** Drift summary with category breakdown (if drift exists) */
+	driftSummary?: DriftSummary;
+};
+interface EnrichOptions {
+	/**
+	* Per-drift issues to include in enrichment.
+	* Map from ID to drift issues.
+	*/
+	driftByExport?: Map<string, SpecDocDrift2[]>;
+	/**
+	* Quality configuration with rule severities.
+	*/
+	qualityConfig?: QualityConfig;
+	/**
+	* Per-raw JSDoc text for style rule checks.
+	* Map from ID to raw JSDoc string.
+	*/
+	rawJSDocByExport?: Map<string, string>;
 }
 /**
-* Define a DocCov configuration.
-* Helper function for type-safe configuration in doccov.config.ts.
+* Enrich an OpenPkg spec with documentation coverage metadata.
 *
-* @param config - Configuration object
-* @returns The configuration object (for type inference)
+* This function computes coverage scores using quality rules,
+* detects drift issues, and produces an EnrichedOpenPkg.
+*
+* @param spec - The pure OpenPkg spec to enrich
+* @param options - Optional enrichment configuration
+* @returns An enriched spec with documentation metadata
 *
 * @example
-* ```typescript
-* // doccov.config.ts
-* import { defineConfig } from '@doccov/sdk';
+* ```ts
+* import { DocCov, enrichSpec } from '@doccov/sdk';
 *
-* defineConfig({
-*   include: ['MyClass', 'myFunction'],
-*   exclude: ['internal*'],
-*   docs: {
-*     include: ['docs/**\/*.md'],
-*   },
-*   lint: {
-*     rules: {
-*       'require-description': 'error',
-*       'require-example': 'warn',
-*     },
-*   },
-* });
+* const doccov = new DocCov();
+* const { spec } = await doccov.analyzeFileWithDiagnostics('src/index.ts');
+*
+* // Enrich with coverage data
+* const enriched = enrichSpec(spec);
+* console.log(enriched.docs?.coverageScore); // e.g., 85
+* console.log(enriched.docs?.missing); // e.g., ['has-examples']
 * ```
 */
-declare function defineConfig(config: DocCovConfig): DocCovConfig;
+declare function enrichSpec(spec: OpenPkg2, options?: EnrichOptions): EnrichedOpenPkg;
+import { OpenPkg as OpenPkg3 } from "@openpkg-ts/spec";
+import { DriftCategory as DriftCategory2, SpecDocDrift as SpecDocDrift3 } from "@openpkg-ts/spec";
 /**
-* Source of filter options.
+* DocCov report schema version.
 */
-type FilterSource = "config" | "override" | "combined";
+declare const REPORT_VERSION = "1.0.0";
 /**
-* Resolved filter options after merging config and overrides.
+* Default directory for DocCov outputs.
 */
-interface ResolvedFilters {
-	/** Include patterns */
-	include?: string[];
-	/** Exclude patterns */
-	exclude?: string[];
-	/** Source of the filters */
-	source?: FilterSource;
-	/** Whether filters were applied from config */
-	fromConfig: boolean;
-	/** Whether filters were applied from overrides */
-	fromOverride: boolean;
-}
+declare const DEFAULT_REPORT_DIR = ".doccov";
 /**
-* Parse a comma-separated list flag into an array.
-*
-* @param value - String or string array from CLI flag
-* @returns Parsed array, or undefined if empty
-*
-* @example
-* ```typescript
-* parseListFlag('a,b,c'); // ['a', 'b', 'c']
-* parseListFlag(['a,b', 'c']); // ['a', 'b', 'c']
-* parseListFlag(undefined); // undefined
-* ```
+* Default path for cached DocCov reports.
 */
-declare function parseListFlag(value?: string | string[]): string[] | undefined;
+declare const DEFAULT_REPORT_PATH = ".doccov/report.json";
 /**
-* Merge filter options from config and CLI/API overrides.
-*
-* Merge behavior:
-* - Include: CLI values intersect with config values (narrowing)
-* - Exclude: CLI values are added to config values (expanding)
+* File extensions for each report format.
+*/
+declare const REPORT_EXTENSIONS: Record<string, string>;
+/**
+* Get the default report path for a given format.
 *
-* @param config - Configuration (from doccov.config.ts)
-* @param overrides - Override filters (from CLI flags or API params)
-* @returns Merged filter options
+* @param format - The report format (json, markdown, html, github)
+* @param dir - The output directory (defaults to .doccov)
+* @returns The full path to the report file
 *
 * @example
-* ```typescript
-* const config = { include: ['A', 'B', 'C'] };
-* const overrides = { include: ['B', 'C', 'D'] };
-*
-* const resolved = mergeFilters(config, overrides);
-* // resolved.include = ['B', 'C'] (intersection)
+* ```ts
+* getReportPath('markdown'); // '.doccov/report.md'
+* getReportPath('html', 'reports'); // 'reports/report.html'
 * ```
 */
-declare function mergeFilters(config: DocCovConfig | null, overrides: FilterOptions): ResolvedFilters;
-import { SpecDocDrift as SpecDocDrift2, SpecExport as SpecExport2 } from "@openpkg-ts/spec";
-import * as TS from "typescript";
+declare function getReportPath(format: string, dir?: string): string;
 /**
-* Represents a single parameter in a JSDoc patch
+* Drift summary with category breakdown.
 */
-interface JSDocParam {
-	name: string;
-	type?: string;
-	description?: string;
-	optional?: boolean;
+interface DriftReportSummary {
+	/**
+	* Total number of drift issues.
+	*/
+	total: number;
+	/**
+	* Count of issues per category.
+	*/
+	byCategory: Record<DriftCategory2, number>;
+	/**
+	* Number of auto-fixable issues.
+	*/
+	fixable: number;
 }
 /**
-* Represents a return type in a JSDoc patch
+* Drift report with progressive disclosure structure.
+*
+* Provides three levels of detail:
+* 1. Summary - total counts by category
+* 2. By category - grouped drift issues
+* 3. All - flat list for backward compatibility
 */
-interface JSDocReturn {
-	type?: string;
-	description?: string;
+interface DriftReport {
+	/**
+	* High-level summary counts.
+	*/
+	summary: DriftReportSummary;
+	/**
+	* Issues grouped by category.
+	*/
+	byCategory: Record<DriftCategory2, CategorizedDrift[]>;
+	/**
+	* Flat list of all drift issues (backward compatible).
+	*/
+	all: CategorizedDrift[];
 }
 /**
-* Represents a generic tag in a JSDoc patch
+* Coverage summary for an entire package or project.
 */
-interface JSDocTag {
-	name: string;
-	text: string;
+interface CoverageSummary {
+	/**
+	* Overall coverage score (0-100).
+	*/
+	score: number;
+	/**
+	* Total number of exports analyzed.
+	*/
+	totalExports: number;
+	/**
+	* Number of fully documented exports.
+	*/
+	documentedExports: number;
+	/**
+	* Breakdown of missing documentation by rule ID.
+	*/
+	missingByRule: Record<string, number>;
+	/**
+	* Total number of drift issues detected.
+	*/
+	driftCount: number;
+	/**
+	* Drift summary with category breakdown.
+	*/
+	driftSummary?: DriftReportSummary;
 }
 /**
-* A patchable representation of a JSDoc comment
+* Coverage data for a single export.
 */
-interface JSDocPatch {
-	description?: string;
-	params?: JSDocParam[];
-	returns?: JSDocReturn;
-	examples?: string[];
-	deprecated?: string | false;
-	async?: boolean;
-	type?: string;
-	typeParams?: Array<{
+interface ExportCoverageData {
+	/**
+	* Export name.
+	*/
+	name: string;
+	/**
+	* Export kind (function, class, etc.).
+	*/
+	kind: string;
+	/**
+	* Coverage score for this (0-100).
+	*/
+	coverageScore: number;
+	/**
+	* Missing documentation rule IDs.
+	*/
+	missing?: string[];
+	/**
+	* Drift issues for this export.
+	*/
+	drift?: SpecDocDrift3[];
+}
+/**
+* DocCov report - a persistable coverage analysis result.
+*
+* This is the format saved to `.doccov/report.json` and returned
+* by the `check` command with `--format json`.
+*/
+interface DocCovReport {
+	/**
+	* JSON Schema reference for validation.
+	*/
+	$schema: string;
+	/**
+	* Report format version.
+	*/
+	version: string;
+	/**
+	* ISO 8601 timestamp when report was generated.
+	*/
+	generatedAt: string;
+	/**
+	* Package/project metadata.
+	*/
+	spec: {
 		name: string;
-		constraint?: string;
-		description?: string;
-	}>;
-	otherTags?: JSDocTag[];
+		version?: string;
+	};
+	/**
+	* Aggregate coverage summary.
+	*/
+	coverage: CoverageSummary;
+	/**
+	* Per-coverage data, keyed by ID.
+	*/
+	exports: Record<string, ExportCoverageData>;
 }
 /**
-* Represents an edit to be applied to a source file
+* Generate a DocCov report from an OpenPkg spec.
+*
+* @param spec - The pure OpenPkg spec to analyze
+* @returns A DocCov report with coverage analysis
+*
+* @example
+* ```ts
+* import { DocCov, generateReport } from '@doccov/sdk';
+*
+* const doccov = new DocCov();
+* const { spec } = await doccov.analyzeFileWithDiagnostics('src/index.ts');
+* const report = generateReport(spec);
+*
+* console.log(`Coverage: ${report.coverage.score}%`);
+* ```
 */
-interface JSDocEdit {
-	filePath: string;
-	symbolName: string;
-	startLine: number;
-	endLine: number;
-	hasExisting: boolean;
-	existingJSDoc?: string;
-	newJSDoc: string;
-	indent: string;
+declare function generateReport(spec: OpenPkg3): DocCovReport;
+/**
+* Generate a DocCov report from an already-enriched spec.
+*
+* Use this when you've already called enrichSpec() and want to avoid
+* recomputing coverage data.
+*
+* @param enriched - The enriched OpenPkg spec
+* @returns A DocCov report with coverage analysis
+*/
+declare function generateReportFromEnriched(enriched: EnrichedOpenPkg): DocCovReport;
+/**
+* Load a cached DocCov report from disk.
+*
+* @param reportPath - Path to the report file (defaults to .doccov/report.json)
+* @returns The cached report, or null if not found
+*/
+declare function loadCachedReport(reportPath?: string): DocCovReport | null;
+/**
+* Save a DocCov report to disk.
+*
+* @param report - The report to save
+* @param reportPath - Path to save the report (defaults to .doccov/report.json)
+*/
+declare function saveReport(report: DocCovReport, reportPath?: string): void;
+/**
+* Check if a cached report is still valid.
+*
+* A report is considered stale if:
+* - It doesn't exist
+* - The spec version has changed
+* - Source files have been modified since generation
+*
+* @param reportPath - Path to the report file
+* @param sourceFiles - Source files to check modification times against
+* @returns True if the cached report is still valid
+*/
+declare function isCachedReportValid(reportPath?: string, sourceFiles?: string[]): boolean;
+/**
+* Compute a hash of file contents.
+* Uses truncated SHA-256 for balance of speed and collision resistance.
+*
+* @param filePath - Absolute path to the file
+* @returns 16-character hex hash, or null if file doesn't exist
+*/
+declare function hashFile(filePath: string): string | null;
+/**
+* Hash a string value.
+*
+* @param content - String to hash
+* @returns 16-character hex hash
+*/
+declare function hashString(content: string): string;
+/**
+* Hash multiple files and return a map of relative paths to hashes.
+*
+* @param filePaths - Array of absolute file paths
+* @param cwd - Base directory for relative path calculation
+* @returns Map of relative paths to their content hashes
+*/
+declare function hashFiles(filePaths: string[], cwd: string): Record<string, string>;
+/**
+* Compare two hash maps and return changed files.
+*
+* @param cached - Hash map from cache
+* @param current - Current hash map
+* @returns Array of file paths that changed, were added, or were removed
+*/
+declare function diffHashes(cached: Record<string, string>, current: Record<string, string>): string[];
+import { OpenPkg as OpenPkg4 } from "@openpkg-ts/spec";
+/** Current cache format version */
+declare const CACHE_VERSION = "1.0.0";
+/** Default cache file path */
+declare const SPEC_CACHE_FILE = ".doccov/spec.cache.json";
+/**
+* Configuration that affects spec generation output.
+*/
+interface SpecCacheConfig {
+	resolveExternalTypes: boolean;
 }
 /**
-* Result of applying edits to source files
+* Cached spec with validation metadata.
 */
-interface ApplyEditsResult {
-	filesModified: number;
-	editsApplied: number;
-	errors: Array<{
-		file: string;
-		error: string;
-	}>;
+interface SpecCache {
+	/** Cache format version for migrations */
+	cacheVersion: string;
+	/** When cache was generated (ISO timestamp) */
+	generatedAt: string;
+	/** OpenPkg spec version (e.g., "0.3.0") */
+	specVersion: string;
+	/** Entry file that was analyzed (relative path) */
+	entryFile: string;
+	/** Hash validation data */
+	hashes: {
+		/** Hash of tsconfig.json content (null if not found) */
+		tsconfig: string | null;
+		/** Hash of package.json content */
+		packageJson: string;
+		/** Source file hashes: relative filepath → content hash */
+		sourceFiles: Record<string, string>;
+	};
+	/** Analysis configuration that affects output */
+	config: SpecCacheConfig;
+	/** The cached OpenPkg spec */
+	spec: OpenPkg4;
 }
 /**
-* Parse a JSDoc comment string into a patchable structure
+* Result of cache validation.
 */
-declare function parseJSDocToPatch(jsDocText: string): JSDocPatch;
+interface CacheValidationResult {
+	/** Whether the cache is valid */
+	valid: boolean;
+	/** Reason for invalidation (if invalid) */
+	reason?: "cache-version-mismatch" | "entry-file-changed" | "config-changed" | "tsconfig-changed" | "package-json-changed" | "source-files-changed";
+	/** Files that changed (if reason is source-files-changed) */
+	changedFiles?: string[];
+}
 /**
-* Apply a partial patch to an existing JSDoc patch, preserving unmodified content
+* Context needed for cache operations.
 */
-declare function applyPatchToJSDoc(existing: JSDocPatch, updates: Partial<JSDocPatch>): JSDocPatch;
+interface CacheContext {
+	/** Entry file being analyzed (absolute path) */
+	entryFile: string;
+	/** Source files included in analysis (absolute paths) */
+	sourceFiles: string[];
+	/** Path to tsconfig.json (absolute, or null if not found) */
+	tsconfigPath: string | null;
+	/** Path to package.json (absolute) */
+	packageJsonPath: string;
+	/** Configuration that affects output */
+	config: SpecCacheConfig;
+	/** Working directory */
+	cwd: string;
+}
 /**
-* Serialize a JSDocPatch back to a formatted comment string
+* Load cached spec from disk.
+*
+* @param cwd - Working directory
+* @returns Cached spec, or null if not found or invalid JSON
 */
-declare function serializeJSDoc(patch: JSDocPatch, indent?: string): string;
+declare function loadSpecCache(cwd: string): SpecCache | null;
 /**
-* Find the JSDoc location for a declaration in a source file
+* Save spec to cache.
+*
+* @param spec - OpenPkg spec to cache
+* @param context - Cache context with file paths and config
 */
-declare function findJSDocLocation(sourceFile: TS.SourceFile, symbolName: string, approximateLine?: number): {
-	startLine: number;
-	endLine: number;
-	declarationLine: number;
-	hasExisting: boolean;
-	existingJSDoc?: string;
-	indent: string;
-} | null;
+declare function saveSpecCache(spec: OpenPkg4, context: CacheContext): void;
 /**
-* Apply a batch of edits to source files
+* Validate if cached spec is still valid.
+*
+* Checks:
+* 1. Cache version matches
+* 2. Entry file matches
+* 3. Config matches
+* 4. tsconfig.json hash matches
+* 5. package.json hash matches
+* 6. All source file hashes match
+*
+* @param cache - Cached spec to validate
+* @param context - Current cache context
+* @returns Validation result
 */
-declare function applyEdits(edits: JSDocEdit[]): Promise<ApplyEditsResult>;
+declare function validateSpecCache(cache: SpecCache, context: CacheContext): CacheValidationResult;
 /**
-* Create a TypeScript source file from a file path
+* Clear the spec cache.
+*
+* @param cwd - Working directory
+* @returns True if cache was deleted, false if it didn't exist
 */
-declare function createSourceFile(filePath: string): TS.SourceFile;
+declare function clearSpecCache(cwd: string): boolean;
 /**
-* Types of fixes that can be generated
+* Get cache file path for a given working directory.
+*
+* @param cwd - Working directory
+* @returns Absolute path to cache file
 */
-type FixType = "add-param" | "remove-param" | "update-param-type" | "update-param-optionality" | "update-return-type" | "update-assertion" | "add-template" | "update-template-constraint" | "add-deprecated" | "remove-deprecated" | "add-async" | "remove-async" | "update-property-type";
+declare function getSpecCachePath(cwd: string): string;
 /**
-* A fix suggestion with the patch to apply
+* Configuration types for DocCov.
+* These types are shared between CLI and API.
 */
-interface FixSuggestion {
-	type: FixType;
-	driftType: SpecDocDrift2["type"];
-	target: string;
-	description: string;
-	patch: Partial<JSDocPatch>;
+/**
+* Documentation configuration options.
+*/
+interface DocsConfig {
+	/** Glob patterns for markdown docs to include */
+	include?: string[];
+	/** Glob patterns for markdown docs to exclude */
+	exclude?: string[];
+}
+/**
+* Example validation modes.
+*/
+type ExampleValidationMode = "presence" | "typecheck" | "run";
+/**
+* Check command configuration options.
+*/
+interface CheckConfig {
+	/**
+	* Example validation modes to run.
+	* Can be a single mode, array of modes, or comma-separated string.
+	* - 'presence': Check that @example blocks exist on exports
+	* - 'typecheck': Compile examples with TypeScript
+	* - 'run': Execute examples and validate assertions
+	*/
+	examples?: ExampleValidationMode | ExampleValidationMode[] | string;
+	/** Minimum coverage percentage required (0-100) */
+	minCoverage?: number;
+	/** Maximum drift percentage allowed (0-100) */
+	maxDrift?: number;
+}
+/**
+* Quality rule severity level.
+*/
+type QualitySeverity2 = "error" | "warn" | "off";
+/**
+* Quality rules configuration.
+*/
+interface QualityRulesConfig {
+	/** Rule severity overrides */
+	rules?: Record<string, QualitySeverity2>;
+}
+/**
+* Normalized DocCov configuration.
+* This is the parsed/normalized form used by commands.
+*/
+interface DocCovConfig {
+	/** Export include patterns */
+	include?: string[];
+	/** Export exclude patterns */
+	exclude?: string[];
+	/** Plugins (future) */
+	plugins?: unknown[];
+	/** Documentation configuration */
+	docs?: DocsConfig;
+	/** Check command configuration */
+	check?: CheckConfig;
+	/** Quality rules configuration */
+	quality?: QualityRulesConfig;
+}
+/**
+* Define a DocCov configuration.
+* Helper function for type-safe configuration in doccov.config.ts.
+*
+* @param config - Configuration object
+* @returns The configuration object (for type inference)
+*
+* @example
+* ```typescript
+* // doccov.config.ts
+* import { defineConfig } from '@doccov/sdk';
+*
+* defineConfig({
+*   include: ['MyClass', 'myFunction'],
+*   exclude: ['internal*'],
+*   docs: {
+*     include: ['docs/**\/*.md'],
+*   },
+*   quality: {
+*     rules: {
+*       'has-description': 'error',
+*       'has-examples': 'warn',
+*     },
+*   },
+* });
+* ```
+*/
+declare function defineConfig(config: DocCovConfig): DocCovConfig;
+/**
+* Project detection types for I/O-agnostic project analysis.
+* Used by both CLI (NodeFileSystem) and API (SandboxFileSystem).
+*/
+/**
+* Minimal filesystem interface for I/O-agnostic detection.
+* Implementations: NodeFileSystem (CLI), SandboxFileSystem (API)
+*/
+interface FileSystem {
+	/** Check if a file or directory exists */
+	exists(path: string): Promise<boolean>;
+	/** Read file contents as string */
+	readFile(path: string): Promise<string>;
+	/** List directory contents (file/folder names only) */
+	readDir(path: string): Promise<string[]>;
+	/** Check if path is a directory */
+	isDirectory(path: string): Promise<boolean>;
+}
+/** Supported package managers */
+type PackageManager = "npm" | "yarn" | "pnpm" | "bun";
+/** Package manager detection result with install/run commands */
+interface PackageManagerInfo {
+	/** Package manager name */
+	name: PackageManager;
+	/** Lockfile that was detected (null if none found) */
+	lockfile: string | null;
+	/** Arguments for install command, e.g. ['install', '--frozen-lockfile'] */
+	installArgs: string[];
+	/** Prefix for running scripts, e.g. ['npm', 'run'] or ['pnpm'] */
+	runPrefix: string[];
+}
+/** Monorepo type based on configuration */
+type MonorepoType = "npm-workspaces" | "pnpm-workspaces" | "lerna" | "none";
+/** Monorepo detection result */
+interface MonorepoInfo {
+	/** Whether this is a monorepo */
+	isMonorepo: boolean;
+	/** Type of monorepo configuration */
+	type: MonorepoType;
+	/** Workspace patterns from config (e.g. ['packages/*']) */
+	patterns: string[];
+	/** Resolved workspace packages */
+	packages: WorkspacePackage[];
+}
+/** A package within a monorepo workspace */
+interface WorkspacePackage {
+	/** Package name from package.json */
+	name: string;
+	/** Relative path to package directory */
+	path: string;
+	/** Whether the package is marked as private */
+	private: boolean;
+}
+/** Entry point source - where the entry was detected from */
+type EntryPointSource = "types" | "exports" | "main" | "module" | "fallback";
+/** Entry point detection result */
+interface EntryPointInfo {
+	/** Path to entry file (relative to package root) */
+	path: string;
+	/** Where the entry point was detected from */
+	source: EntryPointSource;
+	/** Whether this is a .d.ts file (no source available) */
+	isDeclarationOnly: boolean;
+}
+/** Build configuration detection result */
+interface BuildInfo {
+	/** Build-related script names found (e.g. ['build', 'build:types']) */
+	scripts: string[];
+	/** Whether any build script was found */
+	hasBuildScript: boolean;
+	/** Whether TypeScript is configured/installed */
+	hasTypeScript: boolean;
+	/** Indicators for exotic project types */
+	exoticIndicators: {
+		/** WASM project (Cargo.toml or wasm-pack scripts) */
+		wasm: boolean;
+		/** napi-rs native addon project */
+		napi: boolean;
+	};
+}
+/** Complete project analysis result */
+interface ProjectInfo {
+	/** Package manager info */
+	packageManager: PackageManagerInfo;
+	/** Monorepo info */
+	monorepo: MonorepoInfo;
+	/** Entry point info */
+	entryPoint: EntryPointInfo;
+	/** Build info */
+	build: BuildInfo;
+}
+/** Options for analyzeProject() */
+interface AnalyzeProjectOptions {
+	/** Target package name for monorepos */
+	targetPackage?: string;
+}
+/**
+* Detect build configuration and exotic project indicators.
+*
+* @param fs - FileSystem implementation
+* @param packagePath - Path to package directory (default: ".")
+* @returns Build info including scripts and exotic indicators
+*/
+declare function detectBuildInfo(fs: FileSystem, packagePath?: string): Promise<BuildInfo>;
+/**
+* Get the primary build script name to run.
+* Prefers 'build' over 'compile' over 'tsc'.
+*/
+declare function getPrimaryBuildScript(buildInfo: BuildInfo): string | null;
+/**
+* Detect the TypeScript entry point for a package.
+*
+* Priority order:
+* 1. package.json -> types or typings field
+* 2. package.json -> exports["."].types
+* 3. package.json -> main field (resolve to .ts)
+* 4. package.json -> module field (resolve to .ts)
+* 5. Common fallback paths
+*
+* @param fs - FileSystem implementation
+* @param packagePath - Path to package directory (default: ".")
+* @returns Entry point info
+* @throws Error if no entry point can be found
+*/
+declare function detectEntryPoint(fs: FileSystem, packagePath?: string): Promise<EntryPointInfo>;
+import { Sandbox } from "@vercel/sandbox";
+/**
+* Node.js filesystem implementation for CLI usage.
+* Wraps Node.js fs module with a base path.
+*/
+declare class NodeFileSystem implements FileSystem {
+	private basePath;
+	constructor(basePath: string);
+	private resolve;
+	exists(relativePath: string): Promise<boolean>;
+	readFile(relativePath: string): Promise<string>;
+	readDir(relativePath: string): Promise<string[]>;
+	isDirectory(relativePath: string): Promise<boolean>;
+}
+/**
+* Vercel Sandbox filesystem implementation for API usage.
+* Uses sandbox.runCommand() with shell commands.
+*/
+declare class SandboxFileSystem implements FileSystem {
+	private sandbox;
+	constructor(sandbox: Sandbox);
+	exists(path: string): Promise<boolean>;
+	readFile(path: string): Promise<string>;
+	readDir(path: string): Promise<string[]>;
+	isDirectory(path: string): Promise<boolean>;
+}
+/**
+* Detect if a project is a monorepo and list its packages.
+*
+* Detection triggers (in order):
+* 1. package.json has workspaces field (npm/yarn)
+* 2. pnpm-workspace.yaml exists
+* 3. lerna.json exists
+*/
+declare function detectMonorepo(fs: FileSystem): Promise<MonorepoInfo>;
+/**
+* Find a package by name or path in a list of workspace packages.
+*/
+declare function findPackageByName(packages: WorkspacePackage[], nameOrPath: string): WorkspacePackage | undefined;
+/**
+* Format package list for display in error messages.
+*/
+declare function formatPackageList(packages: WorkspacePackage[], limit?: number): string;
+/**
+* Detect package manager based on lockfile presence and package.json hints.
+*
+* Resolution order:
+* 1. packageManager field in package.json (e.g., "pnpm@9.0.0")
+* 2. Most recently modified lockfile (when multiple exist)
+* 3. Static priority order: pnpm > bun > yarn > npm
+* 4. Default to npm
+*/
+declare function detectPackageManager(fs: FileSystem): Promise<PackageManagerInfo>;
+/**
+* Get install command for a package manager.
+* Returns [command, ...args] array.
+*/
+declare function getInstallCommand(pm: PackageManagerInfo): string[];
+/**
+* Get run command for a package manager script.
+* Returns [command, ...args, scriptName] array.
+*/
+declare function getRunCommand(pm: PackageManagerInfo, script: string): string[];
+/**
+* Safely parse a JSON file, returning null on any error.
+*/
+declare function safeParseJson<T = Record<string, unknown>>(fs: FileSystem, path: string): Promise<T | null>;
+/**
+* Standard package.json structure for detection purposes.
+*/
+interface PackageJson {
+	name?: string;
+	version?: string;
+	private?: boolean;
+	main?: string;
+	module?: string;
+	types?: string;
+	typings?: string;
+	exports?: PackageExports;
+	workspaces?: string[] | {
+		packages: string[];
+	};
+	scripts?: Record<string, string>;
+	dependencies?: Record<string, string>;
+	devDependencies?: Record<string, string>;
+}
+/**
+* Package.json exports field structure.
+*/
+type PackageExports = string | {
+	"."?: string | {
+		types?: string;
+		import?: string;
+		require?: string;
+		default?: string;
+	};
+	[key: string]: unknown;
+};
+/**
+* Read and parse package.json from a directory.
+*/
+declare function readPackageJson(fs: FileSystem, dir: string): Promise<PackageJson | null>;
+/**
+* Analyze a project's structure for scanning.
+*
+* This is the main entry point for project detection. It combines all
+* detection functions into a single call that returns complete project info.
+*
+* For monorepos, you must specify the target package via options.targetPackage.
+* If not specified and a monorepo is detected, an error is thrown with the
+* list of available packages.
+*
+* @param fs - FileSystem implementation (NodeFileSystem or SandboxFileSystem)
+* @param options - Options including targetPackage for monorepos
+* @returns Complete project info
+* @throws Error if monorepo detected without targetPackage specified
+* @throws Error if targetPackage not found in monorepo
+*
+* @example
+* ```typescript
+* import { NodeFileSystem, analyzeProject } from '@doccov/sdk';
+*
+* // Single package
+* const singleFs = new NodeFileSystem('/path/to/package');
+* const singleProject = await analyzeProject(singleFs);
+*
+* // Monorepo with target package
+* const monoFs = new NodeFileSystem('/path/to/monorepo');
+* const monoProject = await analyzeProject(monoFs, { targetPackage: '@scope/core' });
+* ```
+*/
+declare function analyzeProject2(fs: FileSystem, options?: AnalyzeProjectOptions): Promise<ProjectInfo>;
+/**
+* Example validation types and utilities.
+*/
+/**
+* Individual example validations that can be run.
+*/
+type ExampleValidation = "presence" | "typecheck" | "run";
+/**
+* All validations (used when --examples is passed without values).
+*/
+declare const ALL_VALIDATIONS: ExampleValidation[];
+/**
+* Describes what each validation does.
+*/
+declare const VALIDATION_INFO: Record<ExampleValidation, {
+	label: string;
+	description: string;
+}>;
+/**
+* Parse --examples flag value into validation set.
+*
+* @example
+* parseExamplesFlag(true)                  // ['presence', 'typecheck', 'run']
+* parseExamplesFlag('presence')            // ['presence']
+* parseExamplesFlag('typecheck,run')       // ['typecheck', 'run']
+* parseExamplesFlag(undefined)             // [] (no validation)
+*/
+declare function parseExamplesFlag(value: boolean | string | undefined): ExampleValidation[];
+/**
+* Check if a specific validation is enabled.
+*/
+declare function shouldValidate(validations: ExampleValidation[], check: ExampleValidation): boolean;
+import { SpecExport as SpecExport4 } from "@openpkg-ts/spec";
+interface ExampleTypeError {
+	/** Index of the example in the examples array */
+	exampleIndex: number;
+	/** Line number within the example (1-based) */
+	line: number;
+	/** Column number (1-based) */
+	column: number;
+	/** Error message from TypeScript */
+	message: string;
+	/** TypeScript diagnostic code */
+	code: number;
+}
+interface TypecheckResult {
+	/** All type errors found across examples */
+	errors: ExampleTypeError[];
+	/** Number of examples that passed */
+	passed: number;
+	/** Number of examples that failed */
+	failed: number;
+}
+interface TypecheckOptions {
+	/** Path to tsconfig.json (auto-detected if not provided) */
+	tsconfig?: string;
+	/** Package name for imports (auto-detected from package.json if not provided) */
+	packageName?: string;
+	/** Export names to include in the virtual import statement */
+	exportNames?: string[];
+}
+/**
+* Options for example validation.
+*/
+interface ExampleValidationOptions {
+	/** Which validations to run */
+	validations: ExampleValidation[];
+	/** Path to the package being validated */
+	packagePath: string;
+	/** Package name (for import resolution) */
+	packageName?: string;
+	/** All names (for import statements in typecheck) */
+	exportNames?: string[];
+	/** Timeout for runtime execution (ms) */
+	timeout?: number;
+	/** Timeout for package installation (ms) */
+	installTimeout?: number;
+	/** Callback for LLM assertion parsing fallback */
+	llmAssertionParser?: (example: string) => Promise<{
+		hasAssertions: boolean;
+		assertions: LLMAssertion[];
+	} | null>;
+}
+/**
+* LLM-parsed assertion from non-standard comment syntax.
+*/
+interface LLMAssertion {
+	expected: string;
+	suggestedSyntax: string;
+}
+/**
+* Result of a single example type error.
+*/
+interface ExampleValidationTypeError {
+	exportName: string;
+	exampleIndex: number;
+	error: ExampleTypeError;
+}
+/**
+* Result of example presence validation.
+*/
+interface PresenceResult {
+	total: number;
+	withExamples: number;
+	missing: string[];
+}
+/**
+* Result of example typecheck validation.
+*/
+interface TypecheckValidationResult {
+	passed: number;
+	failed: number;
+	errors: ExampleValidationTypeError[];
+}
+/**
+* Runtime drift issue (runtime error or assertion failure).
+*/
+interface RuntimeDrift {
+	exportName: string;
+	issue: string;
+	suggestion?: string;
+}
+/**
+* Result of example runtime validation.
+*/
+interface RunValidationResult {
+	passed: number;
+	failed: number;
+	drifts: RuntimeDrift[];
+	installSuccess: boolean;
+	installError?: string;
+}
+/**
+* Unified result from example validation.
+*/
+interface ExampleValidationResult {
+	/** Which validations were run */
+	validations: ExampleValidation[];
+	/** Presence validation results (if run) */
+	presence?: PresenceResult;
+	/** Typecheck validation results (if run) */
+	typecheck?: TypecheckValidationResult;
+	/** Runtime validation results (if run) */
+	run?: RunValidationResult;
+	/** Total number of issues found */
+	totalIssues: number;
+}
+/**
+* Validate examples across exports.
+*
+* Runs only the validations specified. Each validation is independent:
+* - `presence`: checks examples exist (doesn't require typecheck or run)
+* - `typecheck`: type-checks examples (doesn't require presence or run)
+* - `run`: executes examples (doesn't require presence or typecheck)
+*/
+declare function validateExamples(exports: SpecExport4[], options: ExampleValidationOptions): Promise<ExampleValidationResult>;
+interface DocCovOptions {
+	includePrivate?: boolean;
+	followImports?: boolean;
+	maxDepth?: number;
+	resolveExternalTypes?: boolean;
+	/** Enable spec caching (default: true) */
+	useCache?: boolean;
+	/** Working directory for cache operations (default: process.cwd()) */
+	cwd?: string;
+}
+/** @deprecated Use DocCovOptions instead */
+type OpenPkgOptions = DocCovOptions;
+declare function extractPackageSpec(entryFile: string, packageDir?: string, content?: string, options?: OpenPkgOptions): Promise<OpenPkgSpec>;
+interface FilterOptions {
+	include?: string[];
+	exclude?: string[];
+}
+/**
+* Source of filter options.
+*/
+type FilterSource = "config" | "override" | "combined";
+/**
+* Resolved filter options after merging config and overrides.
+*/
+interface ResolvedFilters {
+	/** Include patterns */
+	include?: string[];
+	/** Exclude patterns */
+	exclude?: string[];
+	/** Source of the filters */
+	source?: FilterSource;
+	/** Whether filters were applied from config */
+	fromConfig: boolean;
+	/** Whether filters were applied from overrides */
+	fromOverride: boolean;
+}
+/**
+* Parse a comma-separated list flag into an array.
+*
+* @param value - String or string array from CLI flag
+* @returns Parsed array, or undefined if empty
+*
+* @example
+* ```typescript
+* parseListFlag('a,b,c'); // ['a', 'b', 'c']
+* parseListFlag(['a,b', 'c']); // ['a', 'b', 'c']
+* parseListFlag(undefined); // undefined
+* ```
+*/
+declare function parseListFlag(value?: string | string[]): string[] | undefined;
+/**
+* Merge filter options from config and CLI/API overrides.
+*
+* Merge behavior:
+* - Include: CLI values intersect with config values (narrowing)
+* - Exclude: CLI values are added to config values (expanding)
+*
+* @param config - Configuration (from doccov.config.ts)
+* @param overrides - Override filters (from CLI flags or API params)
+* @returns Merged filter options
+*
+* @example
+* ```typescript
+* const config = { include: ['A', 'B', 'C'] };
+* const overrides = { include: ['B', 'C', 'D'] };
+*
+* const resolved = mergeFilters(config, overrides);
+* // resolved.include = ['B', 'C'] (intersection)
+* ```
+*/
+declare function mergeFilters(config: DocCovConfig | null, overrides: FilterOptions): ResolvedFilters;
+import { SpecDocDrift as SpecDocDrift4, SpecExport as SpecExport5 } from "@openpkg-ts/spec";
+/**
+* Types of fixes that can be generated
+*/
+type FixType = "add-param" | "remove-param" | "update-param-type" | "update-param-optionality" | "update-return-type" | "update-assertion" | "add-template" | "update-template-constraint" | "add-deprecated" | "remove-deprecated" | "add-async" | "remove-async" | "update-property-type";
+/**
+* A fix suggestion with the patch to apply
+*/
+interface FixSuggestion {
+	type: FixType;
+	driftType: SpecDocDrift4["type"];
+	target: string;
+	description: string;
+	patch: Partial<JSDocPatch>;
+}
+/**
+* Check if a drift type can be fixed deterministically
+*/
+declare function isFixableDrift(drift: SpecDocDrift4): boolean;
+/**
+* Generate a fix for a single drift issue
+*/
+declare function generateFix(drift: SpecDocDrift4, exportEntry: SpecExport5, existingPatch?: JSDocPatch): FixSuggestion | null;
+/**
+* Generate all fixes for an export's drift issues
+*/
+declare function generateFixesForExport(exportEntry: SpecExport5, existingPatch?: JSDocPatch): FixSuggestion[];
+/**
+* Merge multiple fix patches into a single patch
+*/
+declare function mergeFixes(fixes: FixSuggestion[], basePatch?: JSDocPatch): JSDocPatch;
+/**
+* Get a summary of fixable vs non-fixable drifts
+*/
+declare function categorizeDrifts(drifts: SpecDocDrift4[]): {
+	fixable: SpecDocDrift4[];
+	nonFixable: SpecDocDrift4[];
+};
+import { OpenPkg as OpenPkg5 } from "@openpkg-ts/spec";
+/**
+* Parsed components of a GitHub URL.
+*/
+interface ParsedGitHubUrl {
+	/** Repository owner (user or org) */
+	owner: string;
+	/** Repository name */
+	repo: string;
+	/** Git ref (branch or tag) */
+	ref: string;
+}
+/**
+* Parse a GitHub URL or shorthand into components.
+*
+* Supported formats:
+* - https://github.com/owner/repo
+* - https://github.com/owner/repo/tree/branch
+* - https://github.com/owner/repo/tree/v1.0.0
+* - github.com/owner/repo
+* - owner/repo (shorthand)
+* - git@github.com:owner/repo.git
+*
+* @param input - GitHub URL or shorthand
+* @param defaultRef - Default ref if not specified in URL (default: 'main')
+* @returns Parsed components
+* @throws Error if the URL format is invalid
+*
+* @example
+* ```typescript
+* import { parseGitHubUrl } from '@doccov/sdk';
+*
+* const parsed = parseGitHubUrl('https://github.com/vercel/next.js/tree/canary');
+* // { owner: 'vercel', repo: 'next.js', ref: 'canary' }
+*
+* const shorthand = parseGitHubUrl('vercel/next.js');
+* // { owner: 'vercel', repo: 'next.js', ref: 'main' }
+* ```
+*/
+declare function parseGitHubUrl(input: string, defaultRef?: string): ParsedGitHubUrl;
+/**
+* Build a clone URL from parsed components.
+*
+* @param parsed - Parsed GitHub URL components
+* @returns HTTPS clone URL
+*
+* @example
+* ```typescript
+* const cloneUrl = buildCloneUrl({ owner: 'vercel', repo: 'next.js', ref: 'main' });
+* // 'https://github.com/vercel/next.js.git'
+* ```
+*/
+declare function buildCloneUrl(parsed: ParsedGitHubUrl): string;
+/**
+* Build a display-friendly URL (without protocol or .git suffix).
+*
+* @param parsed - Parsed GitHub URL components
+* @returns Display URL like 'github.com/owner/repo'
+*
+* @example
+* ```typescript
+* const displayUrl = buildDisplayUrl({ owner: 'vercel', repo: 'next.js', ref: 'main' });
+* // 'github.com/vercel/next.js'
+* ```
+*/
+declare function buildDisplayUrl(parsed: ParsedGitHubUrl): string;
+/**
+* Build a raw.githubusercontent.com URL for a file.
+*
+* @param parsed - Parsed GitHub URL components
+* @param filePath - Path to the file in the repo
+* @returns Raw content URL
+*/
+declare function buildRawUrl(parsed: ParsedGitHubUrl, filePath: string): string;
+/**
+* Fetch an OpenPkg spec from a GitHub repository.
+*
+* Tries the specified ref first, then falls back to 'master' if not found.
+*
+* @param parsed - Parsed GitHub URL components
+* @returns The OpenPkg spec, or null if not found
+*
+* @example
+* ```typescript
+* import { parseGitHubUrl, fetchSpecFromGitHub } from '@doccov/sdk';
+*
+* const parsed = parseGitHubUrl('vercel/next.js');
+* const spec = await fetchSpecFromGitHub(parsed);
+* if (spec) {
+*   console.log(`Coverage: ${spec.docs?.coverageScore}%`);
+* }
+* ```
+*/
+declare function fetchSpecFromGitHub(parsed: ParsedGitHubUrl): Promise<OpenPkg5 | null>;
+/**
+* Fetch an OpenPkg spec from a GitHub repository by owner/repo/branch.
+*
+* Convenience function that creates ParsedGitHubUrl internally.
+*
+* @param owner - Repository owner
+* @param repo - Repository name
+* @param branch - Branch name (default: 'main')
+* @returns The OpenPkg spec, or null if not found
+*/
+declare function fetchSpec(owner: string, repo: string, branch?: string): Promise<OpenPkg5 | null>;
+/**
+* Scan types for CLI, API, and SDK consumers.
+* Single source of truth for scan-related interfaces.
+*/
+/**
+* Result of scanning a repository for documentation coverage.
+* Used by CLI scan command, API endpoints, and SDK consumers.
+*/
+interface ScanResult {
+	/** GitHub repository owner */
+	owner: string;
+	/** GitHub repository name */
+	repo: string;
+	/** Git ref (branch/tag) that was scanned */
+	ref: string;
+	/** Package name if scanning a monorepo package */
+	packageName?: string;
+	/** Overall documentation coverage percentage (0-100) */
+	coverage: number;
+	/** Number of public exports analyzed */
+	exportCount: number;
+	/** Number of types analyzed */
+	typeCount: number;
+	/** Number of documentation drift issues found */
+	driftCount: number;
+	/** Names of exports missing documentation */
+	undocumented: string[];
+	/** Drift issues found during analysis */
+	drift: DriftIssue[];
+}
+/**
+* A documentation drift issue.
+*/
+interface DriftIssue {
+	/** Name of the with drift */
+	export: string;
+	/** Type of drift (e.g., 'param-mismatch', 'return-type') */
+	type: string;
+	/** Human-readable description of the issue */
+	issue: string;
+	/** Optional suggestion for fixing the issue */
+	suggestion?: string;
+}
+/**
+* Options for running a scan.
+*/
+interface ScanOptions {
+	/** GitHub URL or owner/repo shorthand */
+	url: string;
+	/** Git ref (branch/tag) to scan */
+	ref?: string;
+	/** Target package name for monorepos */
+	package?: string;
+	/** Skip dependency installation */
+	skipInstall?: boolean;
+	/** Skip external type resolution */
+	skipResolve?: boolean;
+}
+/**
+* Stages of the scan pipeline.
+*/
+type ProgressStage = "cloning" | "detecting" | "installing" | "building" | "analyzing" | "complete";
+/**
+* Progress event emitted during scan operations.
+*/
+interface ProgressEvent {
+	/** Current stage of the scan */
+	stage: ProgressStage;
+	/** Human-readable message */
+	message: string;
+	/** Progress percentage (0-100), if known */
+	progress?: number;
+}
+/**
+* Callback for receiving progress events.
+*/
+type ProgressCallback = (event: ProgressEvent) => void;
+/**
+* Result of running a command.
+*/
+interface CommandResult {
+	/** Exit code (0 = success) */
+	exitCode: number;
+	/** Standard output */
+	stdout: string;
+	/** Standard error */
+	stderr: string;
 }
 /**
-* Check if a drift type can be fixed deterministically
+* Function that runs a shell command.
+* Abstracts the difference between Node.js execSync and Sandbox runCommand.
 */
-declare function isFixableDrift(drift: SpecDocDrift2): boolean;
+type CommandRunner = (cmd: string, args: string[], options: {
+	cwd: string;
+	timeout?: number;
+}) => Promise<CommandResult>;
 /**
-* Generate a fix for a single drift issue
+* Result of dependency installation.
 */
-declare function generateFix(drift: SpecDocDrift2, exportEntry: SpecExport2, existingPatch?: JSDocPatch): FixSuggestion | null;
+interface InstallResult {
+	/** Whether installation succeeded */
+	success: boolean;
+	/** Package manager that was used */
+	packageManager: PackageManager;
+	/** If a fallback was used, which one */
+	fallbackUsed?: PackageManager;
+	/** Error message if installation failed */
+	error?: string;
+	/** Detailed error messages from each attempt */
+	errors?: string[];
+}
 /**
-* Generate all fixes for an export's drift issues
+* Options for dependency installation.
 */
-declare function generateFixesForExport(exportEntry: SpecExport2, existingPatch?: JSDocPatch): FixSuggestion[];
+interface InstallOptions {
+	/** Timeout in milliseconds for install commands (default: 180000) */
+	timeout?: number;
+	/** Order of fallback package managers to try */
+	fallbackOrder?: PackageManager[];
+	/** Progress callback for status updates */
+	onProgress?: ProgressCallback;
+}
 /**
-* Merge multiple fix patches into a single patch
+* Install dependencies for a project.
+*
+* This consolidates the install logic from CLI scan.ts and API scan-stream.ts:
+* 1. Detect package manager from lockfile
+* 2. Try primary install command
+* 3. Fall back to other package managers if primary fails
+*
+* @param fs - FileSystem implementation for package manager detection
+* @param cwd - Working directory to install in
+* @param runCommand - Function to run shell commands
+* @param options - Installation options
+* @returns Result of the installation attempt
+*
+* @example
+* ```typescript
+* import { NodeFileSystem, installDependencies, createNodeCommandRunner } from '@doccov/sdk';
+*
+* const fs = new NodeFileSystem('/path/to/repo');
+* const result = await installDependencies(fs, '/path/to/repo', createNodeCommandRunner());
+*
+* if (result.success) {
+*   console.log(`Installed using ${result.packageManager}`);
+* } else {
+*   console.error(`Install failed: ${result.error}`);
+* }
+* ```
 */
-declare function mergeFixes(fixes: FixSuggestion[], basePatch?: JSDocPatch): JSDocPatch;
+declare function installDependencies(fs: FileSystem, cwd: string, runCommand: CommandRunner, options?: InstallOptions): Promise<InstallResult>;
 /**
-* Get a summary of fixable vs non-fixable drifts
+* Create a command runner for Node.js environments using execSync.
+* This is used by the CLI for local dependency installation.
+*
+* @returns CommandRunner that uses child_process.execSync
+*
+* @example
+* ```typescript
+* const runner = createNodeCommandRunner();
+* const result = await runner('npm', ['install'], { cwd: '/path/to/repo' });
+* ```
 */
-declare function categorizeDrifts(drifts: SpecDocDrift2[]): {
-	fixable: SpecDocDrift2[];
-	nonFixable: SpecDocDrift2[];
-};
-import { SpecExport as SpecExport4 } from "@openpkg-ts/spec";
-import { SpecExport as SpecExport3 } from "@openpkg-ts/spec";
-type LintSeverity2 = "error" | "warn" | "off";
-interface LintViolation {
-	rule: string;
-	severity: "error" | "warn";
-	message: string;
-	line?: number;
-	fixable: boolean;
-}
-interface LintRule {
-	name: string;
-	defaultSeverity: LintSeverity2;
-	check(exp: SpecExport3, rawJSDoc?: string): LintViolation[];
-	fix?(exp: SpecExport3, rawJSDoc?: string): JSDocPatch | null;
-}
-interface LintConfig {
-	rules: Record<string, LintSeverity2>;
-}
-interface LintResult {
-	violations: LintViolation[];
-	errorCount: number;
-	warningCount: number;
-	fixableCount: number;
-}
-/** All available lint rules */
-declare const allRules: LintRule[];
-/** Default configuration with rule defaults */
-declare function getDefaultConfig(): LintConfig;
-/** Get a rule by name */
-declare function getRule(name: string): LintRule | undefined;
-/** Lint a single */
-declare function lintExport(exp: SpecExport4, rawJSDoc?: string, config?: LintConfig): LintViolation[];
-/** Lint multiple exports and aggregate results */
-declare function lintExports(exports: Array<{
-	export: SpecExport4;
-	rawJSDoc?: string;
-}>, config?: LintConfig): LintResult;
-/** Merge user config with defaults */
-declare function mergeConfig(userConfig: Partial<LintConfig>): LintConfig;
-declare const consistentParamStyle: LintRule;
-declare const noEmptyReturns: LintRule;
-declare const requireDescription: LintRule;
-declare const requireExample: LintRule;
+declare function createNodeCommandRunner(): CommandRunner;
 import { SpecDiff } from "@openpkg-ts/spec";
 type MemberChangeType = "added" | "removed" | "signature-changed";
 interface MemberChange {
@@ -809,7 +1836,7 @@ declare function getDocumentedExports(markdownFiles: MarkdownDocFile[], exportNa
 * Get all exports that lack documentation
 */
 declare function getUndocumentedExports(markdownFiles: MarkdownDocFile[], exportNames: string[]): string[];
-import { CategorizedBreaking, OpenPkg as OpenPkg3, SpecDiff as SpecDiff2 } from "@openpkg-ts/spec";
+import { CategorizedBreaking, OpenPkg as OpenPkg7, SpecDiff as SpecDiff2 } from "@openpkg-ts/spec";
 /**
 * Extended spec diff result with docs impact
 */
@@ -855,7 +1882,7 @@ interface DiffWithDocsOptions {
 * }
 * ```
 */
-declare function diffSpecWithDocs(oldSpec: OpenPkg3, newSpec: OpenPkg3, options?: DiffWithDocsOptions): SpecDiffWithDocs;
+declare function diffSpecWithDocs(oldSpec: OpenPkg7, newSpec: OpenPkg7, options?: DiffWithDocsOptions): SpecDiffWithDocs;
 /**
 * Check if a diff has any docs impact
 */
@@ -925,6 +1952,10 @@ interface AnalysisResult {
 	spec: OpenPkgSpec;
 	diagnostics: Diagnostic[];
 	metadata: AnalysisMetadata;
+	/** True if result came from cache (no fresh analysis) */
+	fromCache?: boolean;
+	/** Cache validation details (if cache was checked) */
+	cacheStatus?: CacheValidationResult;
 }
 interface AnalysisMetadata {
 	baseDir: string;
@@ -932,6 +1963,8 @@ interface AnalysisMetadata {
 	packageJsonPath?: string;
 	hasNodeModules: boolean;
 	resolveExternalTypes: boolean;
+	/** Source files included in analysis (for caching) */
+	sourceFiles?: string[];
 }
 interface AnalyzeOptions {
 	filters?: FilterOptions;
@@ -944,6 +1977,23 @@ declare class DocCov {
 	analyzeProject(entryPath: string, analyzeOptions?: AnalyzeOptions): Promise<OpenPkgSpec>;
 	analyzeWithDiagnostics(code: string, fileName?: string, analyzeOptions?: AnalyzeOptions): Promise<AnalysisResult>;
 	analyzeFileWithDiagnostics(filePath: string, analyzeOptions?: AnalyzeOptions): Promise<AnalysisResult>;
+	/**
+	* Try to load spec from cache.
+	* Returns null if cache is invalid or doesn't exist.
+	*/
+	private tryLoadFromCache;
+	/**
+	* Save analysis result to cache.
+	*/
+	private saveToCache;
+	/**
+	* Find tsconfig.json starting from a directory.
+	*/
+	private findTsConfig;
+	/**
+	* Find package.json starting from a directory.
+	*/
+	private findPackageJson;
 	private normalizeDiagnostic;
 	private mapSeverity;
 	private normalizeMetadata;
@@ -952,351 +2002,118 @@ declare class DocCov {
 declare function analyze(code: string, options?: AnalyzeOptions): Promise<OpenPkgSpec>;
 declare function analyzeFile(filePath: string, options?: AnalyzeOptions): Promise<OpenPkgSpec>;
 /** @deprecated Use DocCov instead */
-declare const OpenPkg4: typeof DocCov;
-interface ExampleTypeError {
-	/** Index of the example in the examples array */
-	exampleIndex: number;
-	/** Line number within the example (1-based) */
-	line: number;
-	/** Column number (1-based) */
-	column: number;
-	/** Error message from TypeScript */
-	message: string;
-	/** TypeScript diagnostic code */
-	code: number;
-}
-interface TypecheckResult {
-	/** All type errors found across examples */
-	errors: ExampleTypeError[];
-	/** Number of examples that passed */
-	passed: number;
-	/** Number of examples that failed */
-	failed: number;
-}
-interface TypecheckOptions {
-	/** Path to tsconfig.json (auto-detected if not provided) */
-	tsconfig?: string;
-	/** Package name for imports (auto-detected from package.json if not provided) */
-	packageName?: string;
-}
-/**
-* Type-check a single example
-*/
-declare function typecheckExample(example: string, packagePath: string, options?: TypecheckOptions): ExampleTypeError[];
-/**
-* Type-check multiple examples
-*/
-declare function typecheckExamples(examples: string[], packagePath: string, options?: TypecheckOptions): TypecheckResult;
-/**
-* Scan types for CLI, API, and SDK consumers.
-* Single source of truth for scan-related interfaces.
-*/
-/**
-* Result of scanning a repository for documentation coverage.
-* Used by CLI scan command, API endpoints, and SDK consumers.
-*/
-interface ScanResult {
-	/** GitHub repository owner */
-	owner: string;
-	/** GitHub repository name */
-	repo: string;
-	/** Git ref (branch/tag) that was scanned */
-	ref: string;
-	/** Package name if scanning a monorepo package */
-	packageName?: string;
-	/** Overall documentation coverage percentage (0-100) */
-	coverage: number;
-	/** Number of public exports analyzed */
-	exportCount: number;
-	/** Number of types analyzed */
-	typeCount: number;
-	/** Number of documentation drift issues found */
-	driftCount: number;
-	/** Names of exports missing documentation */
-	undocumented: string[];
-	/** Drift issues found during analysis */
-	drift: DriftIssue[];
-}
-/**
-* A documentation drift issue.
-*/
-interface DriftIssue {
-	/** Name of the with drift */
-	export: string;
-	/** Type of drift (e.g., 'param-mismatch', 'return-type') */
-	type: string;
-	/** Human-readable description of the issue */
-	issue: string;
-	/** Optional suggestion for fixing the issue */
-	suggestion?: string;
-}
-/**
-* Options for running a scan.
-*/
-interface ScanOptions {
-	/** GitHub URL or owner/repo shorthand */
-	url: string;
-	/** Git ref (branch/tag) to scan */
-	ref?: string;
-	/** Target package name for monorepos */
-	package?: string;
-	/** Skip dependency installation */
-	skipInstall?: boolean;
-	/** Skip external type resolution */
-	skipResolve?: boolean;
-}
-/**
-* Stages of the scan pipeline.
-*/
-type ProgressStage = "cloning" | "detecting" | "installing" | "building" | "analyzing" | "complete";
-/**
-* Progress event emitted during scan operations.
-*/
-interface ProgressEvent {
-	/** Current stage of the scan */
-	stage: ProgressStage;
-	/** Human-readable message */
-	message: string;
-	/** Progress percentage (0-100), if known */
-	progress?: number;
-}
-/**
-* Callback for receiving progress events.
-*/
-type ProgressCallback = (event: ProgressEvent) => void;
-import { OpenPkg as OpenPkg5 } from "@openpkg-ts/spec";
-/**
-* Summary of a spec's documentation coverage.
-* Simpler than full ReportStats - focused on scan output.
-*/
-interface SpecSummary {
-	/** Overall coverage percentage */
-	coverage: number;
-	/** Number of exports */
-	exportCount: number;
-	/** Number of types */
-	typeCount: number;
-	/** Number of drift issues */
-	driftCount: number;
-	/** Names of undocumented or partially documented exports */
-	undocumented: string[];
-	/** Drift issues */
-	drift: DriftIssue[];
-}
-/**
-* Extract a summary from an OpenPkg spec.
-* 
-* This consolidates the logic previously duplicated in:
-* - CLI scan.ts (drift collection)
-* - CLI reports/stats.ts (computeStats)
-* - API scan-stream.ts (inline extraction script)
-* 
-* @param spec - The OpenPkg spec to summarize
-* @returns Summary of documentation coverage
-* 
-* @example
-* ```typescript
-* import { extractSpecSummary } from '@doccov/sdk';
-* 
-* const summary = extractSpecSummary(spec);
-* console.log(`Coverage: ${summary.coverage}%`);
-* console.log(`Undocumented: ${summary.undocumented.length}`);
-* ```
-*/
-declare function extractSpecSummary(spec: OpenPkg5): SpecSummary;
-import { OpenPkg as OpenPkg7 } from "@openpkg-ts/spec";
-/**
-* Result of running a command.
-*/
-interface CommandResult {
-	/** Exit code (0 = success) */
-	exitCode: number;
-	/** Standard output */
-	stdout: string;
-	/** Standard error */
-	stderr: string;
-}
+declare const OpenPkg8: typeof DocCov;
+import { SpecExport as SpecExport6 } from "@openpkg-ts/spec";
+import { SpecExportKind as SpecExportKind2 } from "@openpkg-ts/spec";
 /**
-* Function that runs a shell command.
-* Abstracts the difference between Node.js execSync and Sandbox runCommand.
+* Core quality rules - these affect coverage score.
 */
-type CommandRunner = (cmd: string, args: string[], options: {
-	cwd: string;
-	timeout?: number;
-}) => Promise<CommandResult>;
+declare const CORE_RULES: QualityRule[];
 /**
-* Result of dependency installation.
+* Style rules - these don't affect coverage, only lint.
 */
-interface InstallResult {
-	/** Whether installation succeeded */
-	success: boolean;
-	/** Package manager that was used */
-	packageManager: PackageManager;
-	/** If a fallback was used, which one */
-	fallbackUsed?: PackageManager;
-	/** Error message if installation failed */
-	error?: string;
-	/** Detailed error messages from each attempt */
-	errors?: string[];
-}
+declare const STYLE_RULES: QualityRule[];
 /**
-* Options for dependency installation.
+* All built-in quality rules.
 */
-interface InstallOptions {
-	/** Timeout in milliseconds for install commands (default: 180000) */
-	timeout?: number;
-	/** Order of fallback package managers to try */
-	fallbackOrder?: PackageManager[];
-	/** Progress callback for status updates */
-	onProgress?: ProgressCallback;
-}
+declare const BUILTIN_RULES: QualityRule[];
 /**
-* Install dependencies for a project.
-*
-* This consolidates the install logic from CLI scan.ts and API scan-stream.ts:
-* 1. Detect package manager from lockfile
-* 2. Try primary install command
-* 3. Fall back to other package managers if primary fails
-*
-* @param fs - FileSystem implementation for package manager detection
-* @param cwd - Working directory to install in
-* @param runCommand - Function to run shell commands
-* @param options - Installation options
-* @returns Result of the installation attempt
-*
-* @example
-* ```typescript
-* import { NodeFileSystem, installDependencies, createNodeCommandRunner } from '@doccov/sdk';
-*
-* const fs = new NodeFileSystem('/path/to/repo');
-* const result = await installDependencies(fs, '/path/to/repo', createNodeCommandRunner());
-*
-* if (result.success) {
-*   console.log(`Installed using ${result.packageManager}`);
-* } else {
-*   console.error(`Install failed: ${result.error}`);
-* }
-* ```
+* Get rules that affect coverage calculation.
 */
-declare function installDependencies(fs: FileSystem, cwd: string, runCommand: CommandRunner, options?: InstallOptions): Promise<InstallResult>;
+declare function getCoverageRules(): QualityRule[];
 /**
-* Create a command runner for Node.js environments using execSync.
-* This is used by the CLI for local dependency installation.
-*
-* @returns CommandRunner that uses child_process.execSync
-*
-* @example
-* ```typescript
-* const runner = createNodeCommandRunner();
-* const result = await runner('npm', ['install'], { cwd: '/path/to/repo' });
-* ```
+* Get rules applicable to a specific kind.
 */
-declare function createNodeCommandRunner(): CommandRunner;
-import { OpenPkg as OpenPkg6 } from "@openpkg-ts/spec";
+declare function getRulesForKind(kind: SpecExportKind2): QualityRule[];
 /**
-* Parsed components of a GitHub URL.
+* Get a rule by ID.
 */
-interface ParsedGitHubUrl {
-	/** Repository owner (user or org) */
-	owner: string;
-	/** Repository name */
-	repo: string;
-	/** Git ref (branch or tag) */
-	ref: string;
-}
+declare function getRule(id: string): QualityRule | undefined;
 /**
-* Parse a GitHub URL or shorthand into components.
-*
-* Supported formats:
-* - https://github.com/owner/repo
-* - https://github.com/owner/repo/tree/branch
-* - https://github.com/owner/repo/tree/v1.0.0
-* - github.com/owner/repo
-* - owner/repo (shorthand)
-* - git@github.com:owner/repo.git
-*
-* @param input - GitHub URL or shorthand
-* @param defaultRef - Default ref if not specified in URL (default: 'main')
-* @returns Parsed components
-* @throws Error if the URL format is invalid
-*
-* @example
-* ```typescript
-* import { parseGitHubUrl } from '@doccov/sdk';
-*
-* const parsed = parseGitHubUrl('https://github.com/vercel/next.js/tree/canary');
-* // { owner: 'vercel', repo: 'next.js', ref: 'canary' }
-*
-* const shorthand = parseGitHubUrl('vercel/next.js');
-* // { owner: 'vercel', repo: 'next.js', ref: 'main' }
-* ```
+* Get default configuration with all rule defaults.
 */
-declare function parseGitHubUrl(input: string, defaultRef?: string): ParsedGitHubUrl;
+declare function getDefaultConfig(): Record<string, QualitySeverity>;
 /**
-* Build a clone URL from parsed components.
+* Evaluate quality for a single export.
 *
-* @param parsed - Parsed GitHub URL components
-* @returns HTTPS clone URL
-*
-* @example
-* ```typescript
-* const cloneUrl = buildCloneUrl({ owner: 'vercel', repo: 'next.js', ref: 'main' });
-* // 'https://github.com/vercel/next.js.git'
-* ```
+* @param exp - The to evaluate
+* @param rawJSDoc - Optional raw JSDoc text for regex-based checks
+* @param config - Quality configuration with rule severities
+* @returns Quality result with coverage score and violations
 */
-declare function buildCloneUrl(parsed: ParsedGitHubUrl): string;
+declare function evaluateExportQuality(exp: SpecExport6, rawJSDoc?: string, config?: QualityConfig): QualityResult;
 /**
-* Build a display-friendly URL (without protocol or .git suffix).
-*
-* @param parsed - Parsed GitHub URL components
-* @returns Display URL like 'github.com/owner/repo'
+* Evaluate quality for multiple exports.
 *
-* @example
-* ```typescript
-* const displayUrl = buildDisplayUrl({ owner: 'vercel', repo: 'next.js', ref: 'main' });
-* // 'github.com/vercel/next.js'
-* ```
+* @param exports - Array of exports with optional raw JSDoc
+* @param config - Quality configuration with rule severities
+* @returns Aggregate result with per-and overall scores
 */
-declare function buildDisplayUrl(parsed: ParsedGitHubUrl): string;
+declare function evaluateQuality(exports: Array<{
+	export: SpecExport6;
+	rawJSDoc?: string;
+}>, config?: QualityConfig): AggregateQualityResult;
 /**
-* Build a raw.githubusercontent.com URL for a file.
+* Merge user configuration with defaults.
 *
-* @param parsed - Parsed GitHub URL components
-* @param filePath - Path to the file in the repo
-* @returns Raw content URL
+* @param userConfig - Partial user configuration
+* @returns Complete configuration with defaults filled in
 */
-declare function buildRawUrl(parsed: ParsedGitHubUrl, filePath: string): string;
+declare function mergeConfig(userConfig: Partial<QualityConfig>): QualityConfig;
 /**
-* Fetch an OpenPkg spec from a GitHub repository.
+* Options for resolving a target package/entry point.
+*/
+interface ResolveTargetOptions {
+	/** Working directory (usually process.cwd()) */
+	cwd: string;
+	/** Target package name for monorepos */
+	package?: string;
+	/** Explicit entry point path (relative to cwd or package dir) */
+	entry?: string;
+}
+/**
+* Result of resolving a target package/entry point.
+*/
+interface ResolvedTarget {
+	/** Resolved directory containing the package */
+	targetDir: string;
+	/** Resolved entry point file path (absolute) */
+	entryFile: string;
+	/** Package info if this is a monorepo package */
+	packageInfo?: WorkspacePackage;
+	/** Entry point detection info */
+	entryPointInfo: EntryPointInfo;
+}
+/**
+* Resolve a target package and entry point.
 *
-* Tries the specified ref first, then falls back to 'master' if not found.
+* This consolidates the repeated pattern from CLI commands:
+* 1. If --package specified, detect monorepo and find the package
+* 2. If no entry specified, auto-detect entry point
+* 3. If entry is a directory, detect entry point within it
 *
-* @param parsed - Parsed GitHub URL components
-* @returns The OpenPkg spec, or null if not found
+* @param fs - FileSystem implementation (NodeFileSystem or SandboxFileSystem)
+* @param options - Resolution options
+* @returns Resolved target info
+* @throws Error if monorepo package not found, or entry point detection fails
 *
 * @example
 * ```typescript
-* import { parseGitHubUrl, fetchSpecFromGitHub } from '@doccov/sdk';
-*
-* const parsed = parseGitHubUrl('vercel/next.js');
-* const spec = await fetchSpecFromGitHub(parsed);
-* if (spec) {
-*   console.log(`Coverage: ${spec.docs?.coverageScore}%`);
-* }
-* ```
-*/
-declare function fetchSpecFromGitHub(parsed: ParsedGitHubUrl): Promise<OpenPkg6 | null>;
-/**
-* Fetch an OpenPkg spec from a GitHub repository by owner/repo/branch.
+* import { NodeFileSystem, resolveTarget } from '@doccov/sdk';
 *
-* Convenience function that creates ParsedGitHubUrl internally.
+* // Simple usage
+* const fs = new NodeFileSystem(process.cwd());
+* const { targetDir, entryFile } = await resolveTarget(fs, { cwd: process.cwd() });
 *
-* @param owner - Repository owner
-* @param repo - Repository name
-* @param branch - Branch name (default: 'main')
-* @returns The OpenPkg spec, or null if not found
+* // With monorepo package
+* const { targetDir, entryFile, packageInfo } = await resolveTarget(fs, {
+*   cwd: process.cwd(),
+*   package: '@myorg/core',
+* });
+* ```
 */
-declare function fetchSpec(owner: string, repo: string, branch?: string): Promise<OpenPkg6 | null>;
+declare function resolveTarget(fs: FileSystem, options: ResolveTargetOptions): Promise<ResolvedTarget>;
+import { OpenPkg as OpenPkg9 } from "@openpkg-ts/spec";
 /**
 * Options for creating a ScanOrchestrator.
 */
@@ -1401,7 +2218,7 @@ declare class ScanOrchestrator {
 	* @param entryFile - Path to entry file (absolute)
 	* @returns OpenPkg spec
 	*/
-	analyze(entryFile: string): Promise<OpenPkg7>;
+	analyze(entryFile: string): Promise<OpenPkg9>;
 	/**
 	* Run a complete scan workflow.
 	*
@@ -1419,56 +2236,51 @@ declare class MonorepoRequiresPackageError extends Error {
 	constructor(availablePackages: string[]);
 }
 /**
-* Options for resolving a target package/entry point.
-*/
-interface ResolveTargetOptions {
-	/** Working directory (usually process.cwd()) */
-	cwd: string;
-	/** Target package name for monorepos */
-	package?: string;
-	/** Explicit entry point path (relative to cwd or package dir) */
-	entry?: string;
-}
-/**
-* Result of resolving a target package/entry point.
+* Summary of a spec's documentation coverage.
+* Simpler than full ReportStats - focused on scan output.
 */
-interface ResolvedTarget {
-	/** Resolved directory containing the package */
-	targetDir: string;
-	/** Resolved entry point file path (absolute) */
-	entryFile: string;
-	/** Package info if this is a monorepo package */
-	packageInfo?: WorkspacePackage;
-	/** Entry point detection info */
-	entryPointInfo: EntryPointInfo;
+interface SpecSummary {
+	/** Overall coverage percentage */
+	coverage: number;
+	/** Number of exports */
+	exportCount: number;
+	/** Number of types */
+	typeCount: number;
+	/** Number of drift issues */
+	driftCount: number;
+	/** Names of undocumented or partially documented exports */
+	undocumented: string[];
+	/** Drift issues */
+	drift: DriftIssue[];
 }
 /**
-* Resolve a target package and entry point.
+* Extract a summary from an enriched OpenPkg spec.
 *
-* This consolidates the repeated pattern from CLI commands:
-* 1. If --package specified, detect monorepo and find the package
-* 2. If no entry specified, auto-detect entry point
-* 3. If entry is a directory, detect entry point within it
+* This consolidates the logic previously duplicated in:
+* - CLI scan.ts (drift collection)
+* - CLI reports/stats.ts (computeStats)
+* - API scan-stream.ts (inline extraction script)
 *
-* @param fs - FileSystem implementation (NodeFileSystem or SandboxFileSystem)
-* @param options - Resolution options
-* @returns Resolved target info
-* @throws Error if monorepo package not found, or entry point detection fails
+* @param spec - The enriched OpenPkg spec to summarize (must be enriched via enrichSpec())
+* @returns Summary of documentation coverage
 *
 * @example
 * ```typescript
-* import { NodeFileSystem, resolveTarget } from '@doccov/sdk';
-*
-* // Simple usage
-* const fs = new NodeFileSystem(process.cwd());
-* const { targetDir, entryFile } = await resolveTarget(fs, { cwd: process.cwd() });
+* import { enrichSpec, extractSpecSummary } from '@doccov/sdk';
 *
-* // With monorepo package
-* const { targetDir, entryFile, packageInfo } = await resolveTarget(fs, {
-*   cwd: process.cwd(),
-*   package: '@myorg/core',
-* });
+* const enriched = enrichSpec(spec);
+* const summary = extractSpecSummary(enriched);
+* console.log(`Coverage: ${summary.coverage}%`);
+* console.log(`Undocumented: ${summary.undocumented.length}`);
 * ```
 */
-declare function resolveTarget(fs: FileSystem, options: ResolveTargetOptions): Promise<ResolvedTarget>;
-export { typecheckExamples, typecheckExample, serializeJSDoc, safeParseJson, runExamplesWithPackage, runExamples, runExample, resolveTarget, requireExample, requireDescription, readPackageJson, parseMarkdownFiles, parseMarkdownFile, parseListFlag, parseJSDocToPatch, parseGitHubUrl, parseAssertions, noEmptyReturns, mergeFixes, mergeFilters, mergeConfig, lintExports, lintExport, isFixableDrift, isExecutableLang, installDependencies, hasNonAssertionComments, hasDocsImpact, hasDocsForExport, getUndocumentedExports, getRunCommand, getRule, getPrimaryBuildScript, getInstallCommand, getDocumentedExports, getDocsImpactSummary, getDefaultConfig, generateFixesForExport, generateFix, formatPackageList, findRemovedReferences, findPackageByName, findJSDocLocation, findExportReferences, findDeprecatedReferences, fetchSpecFromGitHub, fetchSpec, extractSpecSummary, extractPackageSpec, extractImports, extractFunctionCalls, diffSpecWithDocs, detectPackageManager, detectMonorepo, detectExampleRuntimeErrors, detectExampleAssertionFailures, detectEntryPoint, detectBuildInfo, defineConfig, createSourceFile, createNodeCommandRunner, consistentParamStyle, categorizeDrifts, buildRawUrl, buildDisplayUrl, buildCloneUrl, blockReferencesExport, applyPatchToJSDoc, applyEdits, analyzeProject2 as analyzeProject, analyzeFile, analyzeDocsImpact, analyze, allRules, WorkspacePackage, TypecheckResult, TypecheckOptions, SpecSummary, SpecDiffWithDocs, ScanResult, ScanOrchestratorOptions, ScanOrchestrator, ScanOptions, ScanContext, SandboxFileSystem, RunExamplesWithPackageResult, RunExamplesWithPackageOptions, RunExampleOptions, ResolvedTarget, ResolvedFilters, ResolveTargetOptions, ProjectInfo, ProgressStage, ProgressEvent, ProgressCallback, ParsedGitHubUrl, PackageManagerInfo, PackageManager, PackageJson, PackageExports, OpenPkgSpec, OpenPkgOptions, OpenPkg4 as OpenPkg, NodeFileSystem, MonorepoType, MonorepoRequiresPackageError, MonorepoInfo, MemberChange, MarkdownDocFile, MarkdownCodeBlock, LintViolation, LintSeverity2 as LintSeverity, LintRulesConfig, LintRule, LintResult, LintConfig, JSDocTag, JSDocReturn, JSDocPatch, JSDocParam, JSDocEdit, InstallResult, InstallOptions, FixType, FixSuggestion, FilterSource, FilterOptions, FileSystem, ExportReference, ExampleTypeError, ExampleRunResult, EntryPointSource, EntryPointInfo, DriftIssue, DocsImpactResult, DocsImpactReference, DocsImpact, DocsConfig, DocsChangeType, DocCovOptions, DocCovConfig, DocCov, DiffWithDocsOptions, Diagnostic, CommandRunner, CommandResult, CheckConfig, BuildInfo, ApplyEditsResult, AnalyzeProjectOptions, AnalyzeOptions, AnalysisResult };
+declare function extractSpecSummary(spec: EnrichedOpenPkg): SpecSummary;
+/**
+* Type-check a single example
+*/
+declare function typecheckExample(example: string, packagePath: string, options?: TypecheckOptions): ExampleTypeError[];
+/**
+* Type-check multiple examples
+*/
+declare function typecheckExamples(examples: string[], packagePath: string, options?: TypecheckOptions): TypecheckResult;
+export { validateSpecCache, validateExamples, typecheckExamples, typecheckExample, shouldValidate, serializeJSDoc, saveSpecCache, saveReport, safeParseJson, runExamplesWithPackage, runExamples, runExample, resolveTarget, readPackageJson, parseMarkdownFiles, parseMarkdownFile, parseListFlag, parseJSDocToPatch, parseGitHubUrl, parseExamplesFlag, parseAssertions, mergeFixes, mergeFilters, mergeConfig, loadSpecCache, loadCachedReport, isFixableDrift, isExecutableLang, isCachedReportValid, installDependencies, hashString, hashFiles, hashFile, hasNonAssertionComments, hasDocsImpact, hasDocsForExport, groupDriftsByCategory, getUndocumentedExports, getSpecCachePath, getRunCommand, getRulesForKind, getRule, getReportPath, getPrimaryBuildScript, getInstallCommand, getDriftSummary, getDocumentedExports, getDocsImpactSummary, getDefaultConfig, getCoverageRules, generateReportFromEnriched, generateReport, generateFixesForExport, generateFix, formatPackageList, formatDriftSummaryLine, findRemovedReferences, findPackageByName, findJSDocLocation, findExportReferences, findDeprecatedReferences, fetchSpecFromGitHub, fetchSpec, extractSpecSummary, extractPackageSpec, extractImports, extractFunctionCalls, evaluateQuality, evaluateExportQuality, enrichSpec, diffSpecWithDocs, diffHashes, detectPackageManager, detectMonorepo, detectExampleRuntimeErrors, detectExampleAssertionFailures, detectEntryPoint, detectBuildInfo, defineConfig, createSourceFile, createNodeCommandRunner, computeExportDrift, computeDrift, clearSpecCache, categorizeDrifts, categorizeDrift, buildRawUrl, buildExportRegistry, buildDisplayUrl, buildCloneUrl, blockReferencesExport, applyPatchToJSDoc, applyEdits, analyzeProject2 as analyzeProject, analyzeFile, analyzeDocsImpact, analyze, WorkspacePackage, VALIDATION_INFO, TypecheckValidationResult, TypecheckResult, TypecheckOptions, SpecSummary, SpecDiffWithDocs, SpecCacheConfig, SpecCache, ScanResult, ScanOrchestratorOptions, ScanOrchestrator, ScanOptions, ScanContext, SandboxFileSystem, STYLE_RULES, SPEC_CACHE_FILE, RuntimeDrift, RunValidationResult, RunExamplesWithPackageResult, RunExamplesWithPackageOptions, RunExampleOptions, RuleContext, ResolvedTarget, ResolvedFilters, ResolveTargetOptions, REPORT_VERSION, REPORT_EXTENSIONS, QualityViolation, QualitySeverity2 as QualitySeverity, QualityRulesConfig, QualityRule, QualityResult, QualityConfig, ProjectInfo, ProgressStage, ProgressEvent, ProgressCallback, PresenceResult, ParsedGitHubUrl, PackageManagerInfo, PackageManager, PackageJson, PackageExports, OpenPkgSpec, OpenPkgOptions, OpenPkg8 as OpenPkg, NodeFileSystem, MonorepoType, MonorepoRequiresPackageError, MonorepoInfo, MemberChange, MarkdownDocFile, MarkdownCodeBlock, LLMAssertion, JSDocTag, JSDocReturn, JSDocPatch, JSDocParam, JSDocEdit, InstallResult, InstallOptions, FixType, FixSuggestion, FilterSource, FilterOptions, FileSystem, ExportReference, ExportDriftResult, ExportCoverageData, ExampleValidationTypeError, ExampleValidationResult, ExampleValidationOptions, ExampleValidationMode, ExampleValidation, ExampleTypeError, ExampleRunResult, EntryPointSource, EntryPointInfo, EnrichedOpenPkg, EnrichedExport, EnrichedDocsMetadata, EnrichOptions, DriftSummary, DriftResult, DriftReportSummary, DriftReport, DriftIssue, DocsImpactResult, DocsImpactReference, DocsImpact, DocsConfig, DocsChangeType, DocCovReport, DocCovOptions, DocCovConfig, DocCov, DiffWithDocsOptions, Diagnostic, DEFAULT_REPORT_PATH, DEFAULT_REPORT_DIR, CoverageSummary, CommandRunner, CommandResult, CheckConfig, CategorizedDrift, CacheValidationResult, CacheContext, CORE_RULES, CACHE_VERSION, BuildInfo, BUILTIN_RULES, ApplyEditsResult, AnalyzeProjectOptions, AnalyzeOptions, AnalysisResult, AggregateQualityResult, ALL_VALIDATIONS };