import { Result } from '@bfra.me/es/result';
import { PackageInfo, ReadmeContent, PackageAPI, SyncError, SyncSummary, FileChangeEvent, DocConfig, MDXDocument } from '../types.js';
import 'zod';

interface PackageScannerOptions {
    readonly rootDir: string;
    readonly includePatterns?: readonly string[];
    readonly excludePackages?: readonly string[];
    readonly parseSourceFiles?: boolean;
    readonly parseReadme?: boolean;
}
interface ScannedPackage {
    readonly info: PackageInfo;
    readonly readme?: ReadmeContent;
    readonly api?: PackageAPI;
    readonly sourceFiles: readonly string[];
    readonly needsDocumentation: boolean;
    readonly existingDocPath?: string;
}
interface ScanResult {
    readonly packages: readonly ScannedPackage[];
    readonly packagesNeedingDocs: readonly ScannedPackage[];
    readonly errors: readonly SyncError[];
    readonly durationMs: number;
}
declare function createPackageScanner(options: PackageScannerOptions): {
    readonly scan: () => Promise<ScanResult>;
    readonly scanPackage: (packagePath: string) => Promise<Result<ScannedPackage, SyncError>>;
};
declare function filterPackagesByPattern(packages: readonly ScannedPackage[], pattern: string): ScannedPackage[];
declare function groupPackagesByScope(packages: readonly ScannedPackage[]): Map<string, ScannedPackage[]>;

interface SyncOrchestratorOptions {
    readonly config: DocConfig;
    readonly dryRun?: boolean;
    readonly verbose?: boolean;
    readonly onProgress?: (message: string) => void;
    readonly onError?: (error: SyncError) => void;
}
interface SyncOrchestrator {
    readonly syncAll: () => Promise<SyncSummary>;
    readonly syncPackages: (packageNames: readonly string[]) => Promise<SyncSummary>;
    readonly handleChanges: (events: readonly FileChangeEvent[]) => Promise<SyncSummary>;
    readonly startWatching: () => Promise<void>;
    readonly stopWatching: () => Promise<void>;
    readonly isWatching: () => boolean;
}
declare function createSyncOrchestrator(options: SyncOrchestratorOptions): SyncOrchestrator;
/** Prevents directory traversal attacks (SEC-002) */
declare function isValidFilePath(filePath: string, rootDir: string): boolean;

interface ValidationResult {
    readonly valid: boolean;
    readonly errors: readonly ValidationError[];
    readonly warnings: readonly ValidationWarning[];
}
interface ValidationError {
    readonly type: 'syntax' | 'frontmatter' | 'component' | 'content';
    readonly message: string;
    readonly line?: number;
    readonly column?: number;
}
interface ValidationWarning {
    readonly type: 'deprecation' | 'recommendation' | 'compatibility';
    readonly message: string;
    readonly line?: number;
}
interface ValidationPipelineOptions {
    readonly validateFrontmatter?: boolean;
    readonly validateComponents?: boolean;
    readonly validateContent?: boolean;
    readonly strict?: boolean;
}
declare function createValidationPipeline(options?: ValidationPipelineOptions): {
    readonly validate: (doc: MDXDocument) => ValidationResult;
    readonly validateContent: (content: string) => ValidationResult;
    readonly validateMultiple: (docs: readonly MDXDocument[]) => Result<Map<string, ValidationResult>, SyncError>;
};
declare function validateDocument(doc: MDXDocument, options?: ValidationPipelineOptions): Result<MDXDocument, SyncError>;
declare function validateContentString(content: string, options?: ValidationPipelineOptions): Result<string, SyncError>;

export { type PackageScannerOptions, type ScanResult, type ScannedPackage, type SyncOrchestrator, type SyncOrchestratorOptions, type ValidationError, type ValidationPipelineOptions, type ValidationResult, type ValidationWarning, createPackageScanner, createSyncOrchestrator, createValidationPipeline, filterPackagesByPattern, groupPackagesByScope, isValidFilePath, validateContentString, validateDocument };