@doccov/sdk 0.6.0 → 0.7.0

package/dist/index.d.ts

@@ -314,13 +314,15 @@ declare function readPackageJson(fs: FileSystem, dir: string): Promise<PackageJs
 *
 * @example
 * ```typescript
+* import { NodeFileSystem, analyzeProject } from '@doccov/sdk';
+*
 * // Single package
-* const fs = new NodeFileSystem('/path/to/package');
-* const project = await analyzeProject(fs);
+* const singleFs = new NodeFileSystem('/path/to/package');
+* const singleProject = await analyzeProject(singleFs);
 *
 * // Monorepo with target package
-* const fs = new NodeFileSystem('/path/to/monorepo');
-* const project = await analyzeProject(fs, { targetPackage: '@scope/core' });
+* const monoFs = new NodeFileSystem('/path/to/monorepo');
+* const monoProject = await analyzeProject(monoFs, { targetPackage: '@scope/core' });
 * ```
 */
 declare function analyzeProject2(fs: FileSystem, options?: AnalyzeProjectOptions): Promise<ProjectInfo>;
@@ -337,6 +339,141 @@ interface FilterOptions {
 	include?: string[];
 	exclude?: string[];
 }
+/**
+* Configuration types for DocCov.
+* These types are shared between CLI and API.
+*/
+/**
+* Documentation configuration options.
+*/
+interface DocsConfig {
+	/** Glob patterns for markdown docs to include */
+	include?: string[];
+	/** Glob patterns for markdown docs to exclude */
+	exclude?: string[];
+}
+/**
+* Check command configuration options.
+*/
+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;
+}
+/**
+* Lint severity level.
+*/
+type LintSeverity = "error" | "warn" | "off";
+/**
+* Lint rules configuration.
+*/
+interface LintRulesConfig {
+	/** Rule severity overrides */
+	rules?: Record<string, LintSeverity>;
+}
+/**
+* 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;
+	/** Lint configuration */
+	lint?: LintRulesConfig;
+}
+/**
+* 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'],
+*   },
+*   lint: {
+*     rules: {
+*       'require-description': 'error',
+*       'require-example': 'warn',
+*     },
+*   },
+* });
+* ```
+*/
+declare function defineConfig(config: DocCovConfig): DocCovConfig;
+/**
+* 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 SpecDocDrift2, SpecExport as SpecExport2 } from "@openpkg-ts/spec";
 import * as TS from "typescript";
 /**
@@ -474,7 +611,7 @@ declare function categorizeDrifts(drifts: SpecDocDrift2[]): {
 };
 import { SpecExport as SpecExport4 } from "@openpkg-ts/spec";
 import { SpecExport as SpecExport3 } from "@openpkg-ts/spec";
-type LintSeverity = "error" | "warn" | "off";
+type LintSeverity2 = "error" | "warn" | "off";
 interface LintViolation {
 	rule: string;
 	severity: "error" | "warn";
@@ -484,12 +621,12 @@ interface LintViolation {
 }
 interface LintRule {
 	name: string;
-	defaultSeverity: LintSeverity;
+	defaultSeverity: LintSeverity2;
 	check(exp: SpecExport3, rawJSDoc?: string): LintViolation[];
 	fix?(exp: SpecExport3, rawJSDoc?: string): JSDocPatch | null;
 }
 interface LintConfig {
-	rules: Record<string, LintSeverity>;
+	rules: Record<string, LintSeverity2>;
 }
 interface LintResult {
 	violations: LintViolation[];
@@ -702,6 +839,10 @@ interface DiffWithDocsOptions {
 * @example
 * ```ts
 * import { diffSpecWithDocs, parseMarkdownFiles } from '@doccov/sdk';
+* import type { OpenPkg } from '@openpkg-ts/spec';
+*
+* const oldSpec: OpenPkg = { openpkg: '0.2.0', meta: { name: 'my-pkg' }, exports: [] };
+* const newSpec: OpenPkg = { openpkg: '0.2.1', meta: { name: 'my-pkg' }, exports: [] };
 *
 * const markdownFiles = parseMarkdownFiles([
 *   { path: 'docs/guide.md', content: '...' },
@@ -846,4 +987,488 @@ declare function typecheckExample(example: string, packagePath: string, options?
 * Type-check multiple examples
 */
 declare function typecheckExamples(examples: string[], packagePath: string, options?: TypecheckOptions): TypecheckResult;
-export { typecheckExamples, typecheckExample, serializeJSDoc, safeParseJson, runExamplesWithPackage, runExamples, runExample, requireExample, requireDescription, readPackageJson, parseMarkdownFiles, parseMarkdownFile, parseJSDocToPatch, parseAssertions, noEmptyReturns, mergeFixes, mergeConfig, lintExports, lintExport, isFixableDrift, isExecutableLang, hasNonAssertionComments, hasDocsImpact, hasDocsForExport, getUndocumentedExports, getRunCommand, getRule, getPrimaryBuildScript, getInstallCommand, getDocumentedExports, getDocsImpactSummary, getDefaultConfig, generateFixesForExport, generateFix, formatPackageList, findRemovedReferences, findPackageByName, findJSDocLocation, findExportReferences, findDeprecatedReferences, extractPackageSpec, extractImports, extractFunctionCalls, diffSpecWithDocs, detectPackageManager, detectMonorepo, detectExampleRuntimeErrors, detectExampleAssertionFailures, detectEntryPoint, detectBuildInfo, createSourceFile, consistentParamStyle, categorizeDrifts, blockReferencesExport, applyPatchToJSDoc, applyEdits, analyzeProject2 as analyzeProject, analyzeFile, analyzeDocsImpact, analyze, allRules, WorkspacePackage, TypecheckResult, TypecheckOptions, SpecDiffWithDocs, SandboxFileSystem, RunExamplesWithPackageResult, RunExamplesWithPackageOptions, RunExampleOptions, ProjectInfo, PackageManagerInfo, PackageManager, PackageJson, PackageExports, OpenPkgSpec, OpenPkgOptions, OpenPkg4 as OpenPkg, NodeFileSystem, MonorepoType, MonorepoInfo, MemberChange, MarkdownDocFile, MarkdownCodeBlock, LintViolation, LintSeverity, LintRule, LintResult, LintConfig, JSDocTag, JSDocReturn, JSDocPatch, JSDocParam, JSDocEdit, FixType, FixSuggestion, FilterOptions, FileSystem, ExportReference, ExampleTypeError, ExampleRunResult, EntryPointSource, EntryPointInfo, DocsImpactResult, DocsImpactReference, DocsImpact, DocsChangeType, DocCovOptions, DocCov, DiffWithDocsOptions, Diagnostic, BuildInfo, ApplyEditsResult, AnalyzeProjectOptions, AnalyzeOptions, AnalysisResult };
+/**
+* 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;
+}
+/**
+* Function that runs a shell command.
+* Abstracts the difference between Node.js execSync and Sandbox runCommand.
+*/
+type CommandRunner = (cmd: string, args: string[], options: {
+	cwd: string;
+	timeout?: number;
+}) => Promise<CommandResult>;
+/**
+* Result of dependency installation.
+*/
+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[];
+}
+/**
+* Options for dependency installation.
+*/
+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;
+}
+/**
+* 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 installDependencies(fs: FileSystem, cwd: string, runCommand: CommandRunner, options?: InstallOptions): Promise<InstallResult>;
+/**
+* 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 createNodeCommandRunner(): CommandRunner;
+import { OpenPkg as OpenPkg6 } 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<OpenPkg6 | 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<OpenPkg6 | null>;
+/**
+* Options for creating a ScanOrchestrator.
+*/
+interface ScanOrchestratorOptions {
+	/** Progress callback for status updates */
+	onProgress?: ProgressCallback;
+	/** Command runner for executing shell commands */
+	commandRunner?: CommandRunner;
+	/** Skip external type resolution */
+	skipResolve?: boolean;
+}
+/**
+* Context for the current scan operation.
+*/
+interface ScanContext {
+	/** Parsed GitHub URL info */
+	parsed: ParsedGitHubUrl;
+	/** Target package name for monorepos */
+	packageName?: string;
+	/** Working directory for the scan */
+	workDir: string;
+	/** Entry point file path */
+	entryFile?: string;
+}
+/**
+* Orchestrates the scan workflow.
+*
+* The orchestrator coordinates:
+* 1. Repository cloning (for remote URLs)
+* 2. Monorepo detection and package resolution
+* 3. Entry point detection
+* 4. Dependency installation
+* 5. Build execution (if needed)
+* 6. Documentation analysis
+* 7. Summary extraction
+*
+* It's designed to be FileSystem-agnostic so it works with both:
+* - NodeFileSystem (CLI - local execution)
+* - SandboxFileSystem (API - isolated execution)
+*
+* @example
+* ```typescript
+* import { ScanOrchestrator, NodeFileSystem, createNodeCommandRunner } from '@doccov/sdk';
+*
+* const fs = new NodeFileSystem('/path/to/repo');
+* const orchestrator = new ScanOrchestrator(fs, {
+*   commandRunner: createNodeCommandRunner(),
+*   onProgress: (event) => console.log(event.message),
+* });
+*
+* const result = await orchestrator.scan({
+*   url: 'https://github.com/owner/repo',
+*   ref: 'main',
+* });
+*
+* console.log(`Coverage: ${result.coverage}%`);
+* ```
+*/
+declare class ScanOrchestrator {
+	private readonly fs;
+	private readonly options;
+	constructor(fs: FileSystem, options?: ScanOrchestratorOptions);
+	/**
+	* Emit a progress event.
+	*/
+	private emit;
+	/**
+	* Detect monorepo and resolve target package.
+	*
+	* @param packageName - Target package name (required for monorepos)
+	* @returns Target directory path (relative to workDir)
+	* @throws Error if monorepo requires --package flag
+	*/
+	detectPackage(packageName?: string): Promise<{
+		targetPath: string;
+		resolvedPackage?: string;
+	}>;
+	/**
+	* Detect entry point for the package.
+	*
+	* @param targetPath - Path to the package directory
+	* @returns Entry point file path (relative to workDir)
+	*/
+	detectEntry(targetPath: string): Promise<string>;
+	/**
+	* Install dependencies for the project.
+	*
+	* @param workDir - Working directory (absolute path)
+	* @returns Installation result
+	*/
+	install(workDir: string): Promise<InstallResult>;
+	/**
+	* Run build if needed.
+	*
+	* @param workDir - Working directory (absolute path)
+	* @param targetPath - Target package path (relative)
+	*/
+	build(workDir: string, targetPath: string): Promise<void>;
+	/**
+	* Run documentation analysis.
+	*
+	* @param entryFile - Path to entry file (absolute)
+	* @returns OpenPkg spec
+	*/
+	analyze(entryFile: string): Promise<OpenPkg7>;
+	/**
+	* Run a complete scan workflow.
+	*
+	* @param options - Scan options
+	* @returns Scan result with coverage statistics
+	*/
+	scan(options: ScanOptions): Promise<ScanResult>;
+}
+/**
+* Error thrown when a monorepo is detected but no package is specified.
+*/
+declare class MonorepoRequiresPackageError extends Error {
+	/** Available package names */
+	readonly availablePackages: string[];
+	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.
+*/
+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.
+*
+* 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 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 { NodeFileSystem, resolveTarget } from '@doccov/sdk';
+*
+* // Simple usage
+* const fs = new NodeFileSystem(process.cwd());
+* const { targetDir, entryFile } = await resolveTarget(fs, { cwd: process.cwd() });
+*
+* // With monorepo package
+* const { targetDir, entryFile, packageInfo } = await resolveTarget(fs, {
+*   cwd: process.cwd(),
+*   package: '@myorg/core',
+* });
+* ```
+*/
+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 };