@stacksjs/dtsx 0.9.9 → 0.9.11

package/dist/docs.d.ts

@@ -0,0 +1,97 @@
+import type { Declaration } from './types';
+/**
+ * Parse JSDoc comments from a declaration
+ */
+export declare function parseJSDoc(comments: string[] | undefined): JSDocInfo;
+/**
+ * Extract documentation from source files
+ */
+export declare function extractDocumentation(files: string[], config?: Partial<DocsConfig>): Promise<Documentation>;
+/**
+ * Generate markdown documentation
+ */
+export declare function generateMarkdown(docs: Documentation, config?: Partial<DocsConfig>): string;
+/**
+ * Generate HTML documentation
+ */
+export declare function generateHTML(docs: Documentation, config?: Partial<DocsConfig>): string;
+/**
+ * Generate JSON documentation
+ */
+export declare function generateJSON(docs: Documentation, config?: Partial<DocsConfig>): string;
+/**
+ * Generate documentation in TypeDoc-compatible JSON format
+ */
+export declare function generateTypeDocJSON(docs: Documentation): string;
+/**
+ * Generate and write documentation files
+ */
+export declare function generateDocs(files: string[], config: DocsConfig): Promise<void>;
+/**
+ * Create a documentation generator with preset configuration
+ */
+export declare function createDocsGenerator(config?: Partial<DocsConfig>): {
+  extract: (files: string[]) => Promise<Documentation>
+  generateMarkdown: (docs: Documentation) => string
+  generateHTML: (docs: Documentation) => string
+  generateJSON: (docs: Documentation) => string
+  parseJSDoc: typeof parseJSDoc
+};
+/**
+ * Documentation configuration
+ */
+export declare interface DocsConfig {
+  format: 'markdown' | 'html' | 'json'
+  outdir: string
+  includePrivate?: boolean
+  includeInternal?: boolean
+  groupByCategory?: boolean
+  title?: string
+  description?: string
+  includeSourceLinks?: boolean
+  sourceBaseUrl?: string
+  includeTypes?: boolean
+  splitByModule?: boolean
+  template?: 'default' | 'minimal' | 'detailed'
+  customCss?: string
+  includeSidebar?: boolean
+}
+/**
+ * Parsed JSDoc information
+ */
+export declare interface JSDocInfo {
+  description: string
+  params: Array<{ name: string, type?: string, description: string, optional?: boolean }>
+  returns?: { type?: string, description: string }
+  examples: string[]
+  tags: Record<string, string[]>
+  deprecated?: string
+  since?: string
+  see: string[]
+  throws: Array<{ type?: string, description: string }>
+  category?: string
+}
+/**
+ * Documentation entry for a declaration
+ */
+export declare interface DocEntry {
+  name: string
+  kind: Declaration['kind']
+  signature: string
+  jsdoc: JSDocInfo
+  isExported: boolean
+  isDefault?: boolean
+  sourceFile?: string
+  sourceLine?: number
+  members?: DocEntry[]
+}
+/**
+ * Documentation output structure
+ */
+export declare interface Documentation {
+  title: string
+  description?: string
+  entries: DocEntry[]
+  categories: Map<string, DocEntry[]>
+  generatedAt: Date
+}

package/dist/errors.d.ts

@@ -0,0 +1,113 @@
+import type { DtsError, SourceLocation } from './types';
+/**
+ * Type guards for error types
+ */
+export declare function isDtsxError(error: unknown): error is DtsxError;
+export declare function isParseError(error: unknown): error is ParseError;
+export declare function isFileError(error: unknown): error is FileError;
+export declare function isConfigError(error: unknown): error is ConfigError;
+/**
+ * Wrap an unknown error in a DtsxError
+ */
+export declare function wrapError(error: unknown, code?: ErrorCode, message?: string): DtsxError;
+/**
+ * Calculate line and column from source code offset
+ */
+export declare function getLocationFromOffset(sourceCode: string, offset: number): SourceLocation;
+/**
+ * Create a formatted error message with source location context
+ */
+export declare function formatErrorWithContext(sourceCode: string, location: SourceLocation, message: string, filePath?: string): string;
+/**
+ * Create a DtsError from an exception
+ */
+export declare function createDtsError(error: unknown, file: string, _sourceCode?: string): DtsError;
+/**
+ * Format a DtsError for display
+ */
+export declare function formatDtsError(error: DtsError, sourceCode?: string): string;
+/**
+ * Aggregate multiple errors into a summary
+ */
+export declare function summarizeErrors(errors: DtsError[]): string;
+/**
+ * Error codes for categorizing errors
+ */
+export declare const ErrorCodes: {
+  PARSE_ERROR: 'PARSE_ERROR';
+  SYNTAX_ERROR: 'SYNTAX_ERROR';
+  FILE_NOT_FOUND: 'FILE_NOT_FOUND';
+  FILE_READ_ERROR: 'FILE_READ_ERROR';
+  FILE_WRITE_ERROR: 'FILE_WRITE_ERROR';
+  TYPE_INFERENCE_ERROR: 'TYPE_INFERENCE_ERROR';
+  UNRESOLVED_TYPE: 'UNRESOLVED_TYPE';
+  EXTRACTION_ERROR: 'EXTRACTION_ERROR';
+  PROCESSING_ERROR: 'PROCESSING_ERROR';
+  VALIDATION_ERROR: 'VALIDATION_ERROR';
+  INVALID_DECLARATION: 'INVALID_DECLARATION';
+  CONFIG_ERROR: 'CONFIG_ERROR';
+  INVALID_ENTRYPOINT: 'INVALID_ENTRYPOINT';
+  CIRCULAR_DEPENDENCY: 'CIRCULAR_DEPENDENCY';
+  TIMEOUT_ERROR: 'TIMEOUT_ERROR';
+  NOT_SUPPORTED: 'NOT_SUPPORTED';
+  UNKNOWN_ERROR: 'UNKNOWN_ERROR'
+};
+export type ErrorCode = typeof ErrorCodes[keyof typeof ErrorCodes];
+/**
+ * Base error class for dtsx errors
+ */
+export declare class DtsxError extends Error {
+  readonly code: ErrorCode;
+  readonly context?: Record<string, unknown>;
+  constructor(message: string, code?: ErrorCode, context?: Record<string, unknown>);
+  toString(): string;
+  toJSON(): Record<string, unknown>;
+}
+/**
+ * Error during file parsing
+ */
+export declare class ParseError extends DtsxError {
+  readonly filePath: string;
+  readonly line?: number;
+  readonly column?: number;
+  constructor(message: string, filePath: string, options?: { line?: number, column?: number, cause?: Error });
+  get locationString(): string;
+}
+/**
+ * Error during declaration extraction
+ */
+export declare class ExtractionError extends DtsxError {
+  readonly filePath: string;
+  readonly declarationKind?: string;
+  constructor(message: string, filePath: string, declarationKind?: string, cause?: Error);
+}
+/**
+ * Error during type processing
+ */
+export declare class ProcessingError extends DtsxError {
+  readonly declarationName?: string;
+  constructor(message: string, declarationName?: string, cause?: Error);
+}
+/**
+ * Error during file I/O operations
+ */
+export declare class FileError extends DtsxError {
+  readonly filePath: string;
+  readonly operation: 'read' | 'write' | 'delete' | 'stat' | 'glob';
+  constructor(message: string, filePath: string, operation: 'read' | 'write' | 'delete' | 'stat' | 'glob', cause?: Error);
+}
+/**
+ * Error during configuration loading or validation
+ */
+export declare class ConfigError extends DtsxError {
+  readonly configPath?: string;
+  readonly invalidKey?: string;
+  constructor(message: string, options?: { configPath?: string, invalidKey?: string, cause?: Error });
+}
+/**
+ * Error when circular dependency is detected
+ */
+export declare class CircularDependencyError extends DtsxError {
+  readonly cycle: string[];
+  constructor(cycle: string[]);
+}

package/dist/extractor/builders.d.ts

@@ -0,0 +1,38 @@
+import type { ClassDeclaration, FunctionDeclaration, InterfaceDeclaration, ModuleDeclaration, SourceFile, TypeAliasDeclaration } from 'typescript';
+/**
+ * Build clean function signature for DTS output
+ */
+export declare function buildFunctionSignature(node: FunctionDeclaration, sf: SourceFile): string;
+/**
+ * Build clean variable declaration for DTS
+ */
+export declare function buildVariableDeclaration(name: string, type: string | undefined, kind: string, isExported: boolean): string;
+/**
+ * Build clean interface declaration for DTS
+ */
+export declare function buildInterfaceDeclaration(node: InterfaceDeclaration, isExported: boolean, sf: SourceFile): string;
+/**
+ * Get interface body with proper formatting
+ */
+export declare function getInterfaceBody(node: InterfaceDeclaration, sf: SourceFile): string;
+/**
+ * Build clean type declaration for DTS
+ */
+export declare function buildTypeDeclaration(node: TypeAliasDeclaration, isExported: boolean, sf: SourceFile): string;
+/**
+ * Build clean class declaration for DTS
+ */
+export declare function buildClassDeclaration(node: ClassDeclaration, isExported: boolean, sf: SourceFile): string;
+/**
+ * Build clean class body for DTS (signatures only, no implementations)
+ * Excludes: private fields (#field), private methods (#method), static blocks
+ */
+export declare function buildClassBody(node: ClassDeclaration, sf: SourceFile): string;
+/**
+ * Build clean module declaration for DTS
+ */
+export declare function buildModuleDeclaration(node: ModuleDeclaration, isExported: boolean, sf: SourceFile): string;
+/**
+ * Build clean module body for DTS (signatures only, no implementations)
+ */
+export declare function buildModuleBody(node: ModuleDeclaration, sf: SourceFile): string;

package/dist/extractor/cache.d.ts

@@ -0,0 +1,47 @@
+import { hashContent } from './hash';
+import type { SourceFile } from 'typescript';
+/**
+ * Evict oldest entry if cache exceeds max size
+ * Uses O(n) scan instead of O(n log n) sort since we add one entry at a time
+ */
+export declare function evictOldestEntries(): void;
+/**
+ * Get or create a cached SourceFile
+ * Accepts an optional pre-computed contentHash to avoid re-hashing
+ */
+export declare function getSourceFile(filePath: string, sourceCode: string, precomputedHash?: number | bigint): SourceFile;
+/**
+ * Clear the SourceFile cache (useful for testing or memory management)
+ */
+export declare function clearSourceFileCache(): void;
+/**
+ * Get the current cache size (useful for debugging)
+ */
+export declare function getSourceFileCacheSize(): number;
+/**
+ * Async version of getSourceFile that yields to the event loop for large files
+ * Prevents blocking when processing many large files in parallel
+ */
+export declare function getSourceFileAsync(filePath: string, sourceCode: string, config?: AsyncParseConfig): Promise<SourceFile>;
+/**
+ * Batch parse multiple files asynchronously with concurrency control
+ * Useful for processing many files while keeping the event loop responsive
+ */
+export declare function batchParseSourceFiles(files: Array<{ filePath: string, sourceCode: string }>, config?: AsyncParseConfig & { concurrency?: number }): Promise<Map<string, SourceFile>>;
+/**
+ * Check if a file should use async parsing based on size
+ */
+export declare function shouldUseAsyncParsing(sourceCode: string, config?: AsyncParseConfig): boolean;
+/**
+ * Get statistics about pending parse operations
+ */
+export declare function getPendingParseCount(): number;
+/**
+ * Configuration for async parsing
+ */
+export declare interface AsyncParseConfig {
+  asyncThreshold?: number
+  chunkSize?: number
+  yieldInterval?: number
+}
+export { hashContent } from './hash';

package/dist/extractor/declarations.d.ts

@@ -0,0 +1,50 @@
+import type { ClassDeclaration, EnumDeclaration, ExportAssignment, ExportDeclaration, FunctionDeclaration, ImportDeclaration, InterfaceDeclaration, ModuleDeclaration, SourceFile, TypeAliasDeclaration, VariableStatement } from 'typescript';
+import type { Declaration } from '../types';
+/**
+ * Extract import declaration
+ */
+export declare function extractImportDeclaration(node: ImportDeclaration, sourceCode: string, sourceFile: SourceFile): Declaration;
+/**
+ * Extract export declaration
+ */
+export declare function extractExportDeclaration(node: ExportDeclaration, sourceCode: string, sourceFile: SourceFile, keepComments?: boolean): Declaration;
+/**
+ * Extract export assignment (export default)
+ */
+export declare function extractExportAssignment(node: ExportAssignment, sourceCode: string, sourceFile: SourceFile, keepComments?: boolean): Declaration;
+/**
+ * Extract function declaration with proper signature
+ */
+export declare function extractFunctionDeclaration(node: FunctionDeclaration, _sourceCode: string, sourceFile: SourceFile, keepComments: boolean): Declaration | null;
+/**
+ * Extract variable statement (only exported ones for DTS)
+ */
+export declare function extractVariableStatement(node: VariableStatement, _sourceCode: string, sourceFile: SourceFile, keepComments: boolean): Declaration[];
+/**
+ * Extract interface declaration
+ */
+export declare function extractInterfaceDeclaration(node: InterfaceDeclaration, _sourceCode: string, sourceFile: SourceFile, keepComments: boolean): Declaration;
+/**
+ * Extract type alias declaration
+ */
+export declare function extractTypeAliasDeclaration(node: TypeAliasDeclaration, _sourceCode: string, sourceFile: SourceFile, keepComments: boolean): Declaration;
+/**
+ * Extract class declaration
+ */
+export declare function extractClassDeclaration(node: ClassDeclaration, _sourceCode: string, sourceFile: SourceFile, keepComments: boolean): Declaration;
+/**
+ * Extract enum declaration
+ */
+export declare function extractEnumDeclaration(node: EnumDeclaration, sourceCode: string, sourceFile: SourceFile, keepComments: boolean): Declaration;
+/**
+ * Extract module/namespace declaration
+ */
+export declare function extractModuleDeclaration(node: ModuleDeclaration, _sourceCode: string, sourceFile: SourceFile, keepComments: boolean): Declaration;
+/**
+ * Find types that are referenced in declarations but not imported or declared
+ */
+export declare function findReferencedTypes(declarations: Declaration[], _sourceCode: string): Set<string>;
+/**
+ * Extract declarations for referenced types by searching the entire source file
+ */
+export declare function extractReferencedTypeDeclarations(sourceFile: SourceFile, referencedTypes: Set<string>, sourceCode: string, keepComments?: boolean): Declaration[];

package/dist/extractor/directives.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Triple-slash directive extraction — NO TypeScript dependency.
+ * Pure string processing for maximum startup speed.
+ */
+/**
+ * Extract triple-slash directives from source code.
+ * These are special comments like /// <reference types="..." />
+ */
+export declare function extractTripleSlashDirectives(sourceCode: string): string[];

package/dist/extractor/extract.d.ts

@@ -0,0 +1,10 @@
+import type { Declaration } from '../types';
+/**
+ * Extract declarations using the fast string scanner (no TS parser).
+ * Results are cached by file path + keepComments flag.
+ */
+export declare function extractDeclarations(sourceCode: string, filePath: string, keepComments?: boolean, isolatedDeclarations?: boolean): Declaration[];
+/**
+ * Clear the declaration cache (for benchmarks and testing)
+ */
+export declare function clearDeclarationCache(): void;

package/dist/extractor/hash.d.ts

@@ -0,0 +1 @@
+export declare function hashContent(content: string): number | bigint;

package/dist/extractor/helpers.d.ts

@@ -0,0 +1,39 @@
+import type { FunctionDeclaration, Node, ParameterDeclaration, SourceFile } from 'typescript';
+/**
+ * Get the text of a node from source code
+ */
+export declare function getNodeText(node: Node, sourceCode: string, sf?: SourceFile): string;
+/**
+ * Extract JSDoc comments from a node
+ */
+export declare function extractJSDocComments(node: Node, sourceFile: SourceFile): string[];
+/**
+ * Get parameter name without default values for DTS
+ */
+export declare function getParameterName(param: ParameterDeclaration, sf?: SourceFile): string;
+/**
+ * Check if a node has export modifier
+ */
+export declare function hasExportModifier(node: Node): boolean;
+/**
+ * Check if a function has async modifier
+ */
+export declare function hasAsyncModifier(node: FunctionDeclaration): boolean;
+/**
+ * Check if a non-exported function should be included (e.g., if it's referenced by exported items)
+ */
+export declare function shouldIncludeNonExportedFunction(_functionName?: string, _sourceCode?: string): boolean;
+/**
+ * Check if a non-exported interface should be included (e.g., if it's used by exported items)
+ */
+export declare function shouldIncludeNonExportedInterface(interfaceName: string, sourceCode: string): boolean;
+/**
+ * Check if a type is a built-in TypeScript type
+ */
+export declare function isBuiltInType(typeName: string): boolean;
+/**
+ * Extract type names from module/namespace text
+ */
+export declare function extractTypesFromModuleText(moduleText: string): string[];
+// Re-exported from directives.ts for backward compatibility
+export { extractTripleSlashDirectives } from './directives';

package/dist/extractor/index.d.ts

@@ -0,0 +1,70 @@
+import { extractClassDeclaration, extractEnumDeclaration, extractExportAssignment, extractExportDeclaration, extractFunctionDeclaration, extractImportDeclaration, extractInterfaceDeclaration, extractModuleDeclaration, extractTypeAliasDeclaration, extractVariableStatement, findReferencedTypes } from './declarations';
+import { getSourceFileAsync } from './cache';
+import { shouldIncludeNonExportedFunction, shouldIncludeNonExportedInterface } from './helpers';
+import type { AsyncParseConfig } from './cache';
+import type { Declaration } from '../types';
+export type { AsyncParseConfig } from './cache';
+/**
+ * Clear all extractor caches (source files and declarations)
+ */
+export declare function clearSourceFileCache(): void;
+/**
+ * Extract only public API declarations from TypeScript source code
+ * Uses fast string-based scanner (no TypeScript parser) for maximum performance.
+ * Delegates to extract.ts which owns the shared declaration cache with proper LRU eviction.
+ */
+export declare function extractDeclarations(sourceCode: string, filePath: string, keepComments?: boolean, isolatedDeclarations?: boolean): Declaration[];
+/**
+ * Async version of extractDeclarations that yields to the event loop for large files
+ * Use this when processing many files in parallel to prevent blocking
+ */
+export declare function extractDeclarationsAsync(sourceCode: string, filePath: string, keepComments?: boolean, config?: AsyncParseConfig): Promise<Declaration[]>;
+/**
+ * Batch extract declarations from multiple files asynchronously
+ * Useful for processing many files while keeping the event loop responsive
+ */
+export declare function batchExtractDeclarations(files: Array<{ filePath: string, sourceCode: string, keepComments?: boolean }>, config?: AsyncParseConfig & { concurrency?: number }): Promise<Map<string, Declaration[]>>;
+export {
+  buildClassBody,
+  buildClassDeclaration,
+  buildFunctionSignature,
+  buildInterfaceDeclaration,
+  buildModuleBody,
+  buildModuleDeclaration,
+  buildTypeDeclaration,
+  buildVariableDeclaration,
+  getInterfaceBody,
+} from './builders';
+export {
+  batchParseSourceFiles,
+  getPendingParseCount,
+  getSourceFileAsync,
+  getSourceFileCacheSize,
+  shouldUseAsyncParsing,
+} from './cache';
+export {
+  extractClassDeclaration,
+  extractEnumDeclaration,
+  extractExportAssignment,
+  extractExportDeclaration,
+  extractFunctionDeclaration,
+  extractImportDeclaration,
+  extractInterfaceDeclaration,
+  extractModuleDeclaration,
+  extractReferencedTypeDeclarations,
+  extractTypeAliasDeclaration,
+  extractVariableStatement,
+  findReferencedTypes,
+} from './declarations';
+export {
+  extractJSDocComments,
+  extractTripleSlashDirectives,
+  extractTypesFromModuleText,
+  getNodeText,
+  getParameterName,
+  hasAsyncModifier,
+  hasExportModifier,
+  isBuiltInType,
+  shouldIncludeNonExportedFunction,
+  shouldIncludeNonExportedInterface,
+} from './helpers';

package/dist/extractor/scanner.d.ts

@@ -0,0 +1,6 @@
+import type { Declaration } from '../types';
+/**
+ * Scan TypeScript source code and extract declarations without using the TypeScript parser.
+ * This is the fast path that replaces createSourceFile() + AST walk.
+ */
+export declare function scanDeclarations(_source: string, _filename: string, _keepComments?: boolean, _isolatedDeclarations?: boolean): Declaration[];

package/dist/extractor.d.ts

@@ -1,6 +1,5 @@
-import type { Declaration } from './types';
 /**
- * Extract only public API declarations from TypeScript source code
- * This focuses on what should be in .d.ts files, not implementation details
+ * Extractor module - re-exports from modular structure
+ * @deprecated Import from './extractor/index' directly for better tree-shaking
  */
-export declare function extractDeclarations(sourceCode: string, filePath: string, keepComments?: boolean): Declaration[];
+export * from './extractor/index';

package/dist/formats.d.ts

@@ -0,0 +1,50 @@
+import type { Declaration } from './types';
+/**
+ * Convert declarations to JSON Schema
+ */
+export declare function toJsonSchema(declarations: Declaration[], options?: Partial<FormatOptions>): string;
+/**
+ * Convert declarations to Zod schema
+ */
+export declare function toZod(declarations: Declaration[], options?: Partial<FormatOptions>): string;
+/**
+ * Convert declarations to Valibot schema
+ */
+export declare function toValibot(declarations: Declaration[], options?: Partial<FormatOptions>): string;
+/**
+ * Convert declarations to io-ts codec
+ */
+export declare function toIoTs(declarations: Declaration[], options?: Partial<FormatOptions>): string;
+/**
+ * Convert declarations to Yup schema
+ */
+export declare function toYup(declarations: Declaration[], options?: Partial<FormatOptions>): string;
+/**
+ * Convert declarations to ArkType schema
+ */
+export declare function toArkType(declarations: Declaration[], options?: Partial<FormatOptions>): string;
+/**
+ * Convert declarations to the specified format
+ */
+export declare function convertToFormat(declarations: Declaration[], options: FormatOptions): string;
+/**
+ * Get file extension for output format
+ */
+export declare function getFormatExtension(format: OutputFormat): string;
+/**
+ * Options for format conversion
+ */
+export declare interface FormatOptions {
+  format: OutputFormat
+  includeSchema?: boolean
+  jsonSchemaDraft?: '2020-12' | '2019-09' | 'draft-07'
+  allOptional?: boolean
+  includeDescriptions?: boolean
+  indent?: number
+  exportName?: string
+  useInfer?: boolean
+}
+/**
+ * Supported output formats
+ */
+export type OutputFormat = 'dts' | 'json-schema' | 'zod' | 'io-ts' | 'yup' | 'valibot' | 'arktype';

package/dist/formatter.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Format declaration file content
+ */
+export declare function formatDts(content: string, config?: FormatterConfig, filePath?: string): Promise<FormatResult>;
+/**
+ * Format multiple files
+ */
+export declare function formatFiles(files: Map<string, string>, config?: FormatterConfig): Promise<Map<string, FormatResult>>;
+/**
+ * Create a formatter with preset configuration
+ */
+export declare function createFormatter(config?: FormatterConfig): {
+  format: (content: string, filePath?: string) => Promise<FormatResult>
+  formatMany: (files: Map<string, string>) => Promise<Map<string, FormatResult>>
+};
+/**
+ * Quick format with sensible defaults
+ */
+export declare function quickFormat(content: string): Promise<string>;
+/**
+ * Formatter configuration options
+ */
+export declare interface FormatterConfig {
+  usePrettier?: boolean
+  prettierConfigPath?: string
+  prettierOptions?: PrettierOptions
+  builtIn?: BuiltInFormatterOptions
+}
+/**
+ * Prettier-compatible options
+ */
+export declare interface PrettierOptions {
+  printWidth?: number
+  tabWidth?: number
+  useTabs?: boolean
+  semi?: boolean
+  singleQuote?: boolean
+  trailingComma?: 'none' | 'es5' | 'all'
+  bracketSpacing?: boolean
+  parser?: string
+}
+/**
+ * Built-in formatter options (when Prettier is not available)
+ */
+export declare interface BuiltInFormatterOptions {
+  indentSize?: number
+  useTabs?: boolean
+  maxLineWidth?: number
+  trailingNewline?: boolean
+  normalizeWhitespace?: boolean
+  sortImports?: boolean
+  groupImports?: boolean
+}
+/**
+ * Result of formatting operation
+ */
+export declare interface FormatResult {
+  content: string
+  usedPrettier: boolean
+  warnings?: string[]
+}

package/dist/generator.d.ts

@@ -1,9 +1,18 @@
-import type { DtsGenerationConfig } from './types';
+import type { DtsGenerationConfig, GenerationStats } from './types';
 /**
  * Generate DTS files from TypeScript source files
  */
-export declare function generate(options?: Partial<DtsGenerationConfig>): Promise<void>;
+export declare function generate(options?: Partial<DtsGenerationConfig>): Promise<GenerationStats>;
 /**
  * Process a single TypeScript file and generate its DTS
  */
-export declare function processFile(filePath: string, config: DtsGenerationConfig): Promise<string>;
+export declare function processFile(filePath: string, config: DtsGenerationConfig): Promise<string>;
+/**
+ * Watch mode - regenerate DTS files on source changes
+ */
+export declare function watch(options?: Partial<DtsGenerationConfig>): Promise<void>;
+/**
+ * Process TypeScript source code from a string (for stdin support)
+ * Re-exported from process-source.ts for backward compatibility
+ */
+export { processSource } from './process-source';