@atomic-ehr/codegen 0.0.1-canary.20251006092200.fdb4a88 → 0.0.1-canary.20251007094146.5297616

package/dist/index.d.ts

@@ -1,82 +1,2141 @@
+import { CanonicalManager } from '@atomic-ehr/fhir-canonical-manager';
+import * as FS from '@atomic-ehr/fhirschema';
+import { FHIRSchema, StructureDefinition } from '@atomic-ehr/fhirschema';
+
 /**
- * Main entry point for the @atomic-ehr/codegen library
+ * CodeGen Logger
  *
- * ## Overview
+ * Clean, colorful logging designed for code generation tools
+ */
+interface LogOptions {
+    prefix?: string;
+    timestamp?: boolean;
+    verbose?: boolean;
+}
+/**
+ * Simple code generation logger with pretty colors and clean formatting
+ */
+declare class CodegenLogger {
+    private options;
+    constructor(options?: LogOptions);
+    private formatMessage;
+    /**
+     * Success message with checkmark
+     */
+    success(message: string): void;
+    /**
+     * Error message with X mark
+     */
+    error(message: string, error?: Error): void;
+    /**
+     * Warning message with warning sign
+     */
+    warn(message: string): void;
+    /**
+     * Info message with info icon
+     */
+    info(message: string): void;
+    /**
+     * Debug message (only shows in verbose mode)
+     */
+    debug(message: string): void;
+    /**
+     * Step message with rocket
+     */
+    step(message: string): void;
+    /**
+     * Progress message with clock
+     */
+    progress(message: string): void;
+    /**
+     * Plain message (no icon, just colored text)
+     */
+    plain(message: string, color?: (str: string) => string): void;
+    /**
+     * Dimmed/gray text for less important info
+     */
+    dim(message: string): void;
+    /**
+     * Create a child logger with a prefix
+     */
+    child(prefix: string): CodegenLogger;
+    /**
+     * Update options
+     */
+    configure(options: Partial<LogOptions>): void;
+}
+
+type Name = string & {
+    readonly __brand: unique symbol;
+};
+type CanonicalUrl = string & {
+    readonly __brand: unique symbol;
+};
+interface PackageMeta {
+    name: string;
+    version: string;
+}
+type RichFHIRSchema = Omit<FS.FHIRSchema, "package_meta" | "base" | "name" | "url"> & {
+    package_meta: PackageMeta;
+    name: Name;
+    url: CanonicalUrl;
+    base: CanonicalUrl;
+};
+type IdentifierBase = {
+    name: Name;
+    url: CanonicalUrl;
+    package: string;
+    version: string;
+};
+type PrimitiveIdentifier = {
+    kind: "primitive-type";
+} & IdentifierBase;
+type ComplexTypeIdentifier = {
+    kind: "complex-type";
+} & IdentifierBase;
+type ResourceIdentifier = {
+    kind: "resource";
+} & IdentifierBase;
+type ValueSetIdentifier = {
+    kind: "value-set";
+} & IdentifierBase;
+type NestedIdentifier = {
+    kind: "nested";
+} & IdentifierBase;
+type BindingIdentifier = {
+    kind: "binding";
+} & IdentifierBase;
+type ProfileIdentifier = {
+    kind: "profile";
+} & IdentifierBase;
+type LogicalIdentifier = {
+    kind: "logical";
+} & IdentifierBase;
+type Identifier = PrimitiveIdentifier | ComplexTypeIdentifier | ResourceIdentifier | NestedIdentifier | BindingIdentifier | ValueSetIdentifier | ProfileIdentifier | LogicalIdentifier;
+type TypeSchema = RegularTypeSchema | PrimitiveTypeSchema | ValueSetTypeSchema | BindingTypeSchema | ProfileTypeSchema;
+interface PrimitiveTypeSchema {
+    identifier: PrimitiveIdentifier;
+    description?: string;
+    base: Identifier;
+    dependencies?: Identifier[];
+}
+interface NestedType {
+    identifier: NestedIdentifier;
+    base: Identifier;
+    fields: Record<string, Field>;
+}
+interface ProfileTypeSchema {
+    identifier: ProfileIdentifier;
+    base: Identifier;
+    description?: string;
+    fields?: Record<string, Field>;
+    constraints?: Record<string, ProfileConstraint>;
+    extensions?: ProfileExtension[];
+    validation?: ValidationRule[];
+    dependencies?: Identifier[];
+    metadata?: ProfileMetadata;
+    nested?: NestedType[];
+}
+interface ProfileConstraint {
+    min?: number;
+    max?: string;
+    mustSupport?: boolean;
+    fixedValue?: any;
+    patternValue?: any;
+    binding?: {
+        strength: "required" | "extensible" | "preferred" | "example";
+        valueSet: string;
+    };
+    types?: Array<{
+        code: string;
+        profile?: string[];
+        targetProfile?: string[];
+    }>;
+    slicing?: {
+        discriminator: any[];
+        rules: string;
+        ordered?: boolean;
+    };
+}
+interface ProfileExtension {
+    path: string;
+    profile: string | string[];
+    min?: number;
+    max?: string;
+    mustSupport?: boolean;
+}
+interface ValidationRule {
+    path: string;
+    key: string;
+    severity: "error" | "warning" | "information";
+    human: string;
+    expression?: string;
+}
+interface ProfileMetadata {
+    publisher?: string;
+    contact?: any[];
+    copyright?: string;
+    purpose?: string;
+    experimental?: boolean;
+    date?: string;
+    jurisdiction?: any[];
+    package?: string;
+}
+interface RegularTypeSchema {
+    identifier: Identifier;
+    base?: Identifier;
+    description?: string;
+    fields?: {
+        [k: string]: Field;
+    };
+    nested?: NestedType[];
+    dependencies?: Identifier[];
+}
+interface RegularField {
+    type: Identifier;
+    reference?: Identifier[];
+    required?: boolean;
+    excluded?: boolean;
+    array?: boolean;
+    binding?: BindingIdentifier;
+    enum?: string[];
+    min?: number;
+    max?: number;
+}
+interface ChoiceFieldDeclaration {
+    choices: string[];
+    required?: boolean;
+    excluded?: boolean;
+    array?: boolean;
+    min?: number;
+    max?: number;
+}
+interface ChoiceFieldInstance {
+    choiceOf: string;
+    type: Identifier;
+    required?: boolean;
+    excluded?: boolean;
+    array?: boolean;
+    reference?: Identifier[];
+    binding?: BindingIdentifier;
+    enum?: string[];
+    min?: number;
+    max?: number;
+}
+type Concept = {
+    code: string;
+    display?: string;
+    system?: string;
+};
+interface ValueSetTypeSchema {
+    identifier: ValueSetIdentifier;
+    description?: string;
+    concept?: Concept[];
+    compose?: ValueSetCompose;
+}
+interface BindingTypeSchema {
+    identifier: BindingIdentifier;
+    description?: string;
+    type?: Identifier;
+    strength?: string;
+    enum?: string[];
+    valueset?: ValueSetIdentifier;
+    dependencies?: Identifier[];
+}
+type Field = RegularField | ChoiceFieldDeclaration | ChoiceFieldInstance;
+interface TypeschemaGeneratorOptions {
+    verbose?: boolean;
+    logger?: CodegenLogger;
+    treeshake?: string[];
+    manager?: ReturnType<typeof CanonicalManager> | null;
+}
+type TypeschemaParserOptions = {
+    format?: "auto" | "ndjson" | "json";
+    validate?: boolean;
+    strict?: boolean;
+};
+type ValueSet = {
+    resourceType: "ValueSet";
+    id: string;
+    name?: string;
+    url?: string;
+    description?: string;
+    compose?: ValueSetCompose;
+    expansion?: {
+        contains: Concept[];
+    };
+    experimental?: boolean;
+    immutable?: boolean;
+    extension?: any[];
+    status?: string;
+    identifier?: any[];
+    title?: string;
+    publisher?: string;
+    version?: string;
+    meta?: any;
+    date?: string;
+    contact?: any;
+};
+type ValueSetCompose = {
+    include: {
+        concept?: Concept[];
+        system?: string;
+        filter?: {}[];
+    }[];
+};
+type RichValueSet = Omit<ValueSet, "name" | "url"> & {
+    package_meta: PackageMeta;
+    name?: Name;
+    url?: CanonicalUrl;
+};
+
+type Register = {
+    appendFs(fs: FHIRSchema): void;
+    ensureCanonicalUrl(name: string | Name | CanonicalUrl): CanonicalUrl;
+    resolveSd(canonicalUrl: CanonicalUrl): StructureDefinition | undefined;
+    resolveFs(canonicalUrl: CanonicalUrl): RichFHIRSchema | undefined;
+    resolveFsGenealogy(canonicalUrl: CanonicalUrl): RichFHIRSchema[];
+    allSd(): StructureDefinition[];
+    allFs(): RichFHIRSchema[];
+    allVs(): RichValueSet[];
+    resolveVs(canonicalUrl: CanonicalUrl): RichValueSet | undefined;
+    complexTypeDict(): Record<string, RichFHIRSchema>;
+    resolveAny(canonicalUrl: CanonicalUrl): any | undefined;
+} & ReturnType<typeof CanonicalManager>;
+
+/**
+ * New Config Schema for High-Level API
  *
- * atomic-codegen is a comprehensive code generation toolkit for FHIR healthcare standards,
- * designed with TypeSchema as the intermediate format for maximum flexibility and type safety.
+ * Simple configuration system compatible ONLY with the new high-level APIBuilder.
+ * All legacy config functionality has been removed.
+ */
+/**
+ * TypeScript generator configuration options
+ */
+interface TypeScriptGeneratorConfig {
+    moduleFormat?: "esm" | "cjs";
+    generateIndex?: boolean;
+    includeDocuments?: boolean;
+    namingConvention?: "PascalCase" | "camelCase";
+    strictMode?: boolean;
+    includeProfiles?: boolean;
+    includeExtensions?: boolean;
+    includeCodeSystems?: boolean;
+    includeOperations?: boolean;
+    /** Generate individual TypeScript files for value sets (default: false) */
+    generateValueSets?: boolean;
+    /** Include helper validation functions in value set files (default: false) */
+    includeValueSetHelpers?: boolean;
+    /** Which binding strengths to generate value sets for (default: ['required']) */
+    valueSetStrengths?: ("required" | "preferred" | "extensible" | "example")[];
+    /** Directory name for value set files (relative to outputDir) (default: 'valuesets') */
+    valueSetDirectory?: string;
+    /** Value set generation mode (default: 'required-only') */
+    valueSetMode?: "all" | "required-only" | "custom";
+    fhirVersion?: "R4" | "R5";
+    resourceTypes?: string[];
+    maxDepth?: number;
+    profileOptions?: {
+        generateKind?: "interface" | "type" | "both";
+        includeConstraints?: boolean;
+        includeDocumentation?: boolean;
+        strictMode?: boolean;
+        subfolder?: string;
+    };
+    generateBuilders?: boolean;
+    builderOptions?: {
+        includeValidation?: boolean;
+        includeFactoryMethods?: boolean;
+        includeInterfaces?: boolean;
+        generateNestedBuilders?: boolean;
+        includeHelperMethods?: boolean;
+        supportPartialBuild?: boolean;
+        includeJSDoc?: boolean;
+        generateFactories?: boolean;
+        includeTypeGuards?: boolean;
+        handleChoiceTypes?: boolean;
+        generateArrayHelpers?: boolean;
+    };
+    validatorOptions?: {
+        includeCardinality?: boolean;
+        includeTypes?: boolean;
+        includeConstraints?: boolean;
+        includeInvariants?: boolean;
+        validateRequired?: boolean;
+        allowAdditional?: boolean;
+        strictValidation?: boolean;
+        collectMetrics?: boolean;
+        generateAssertions?: boolean;
+        generatePartialValidators?: boolean;
+        optimizePerformance?: boolean;
+        includeJSDoc?: boolean;
+        generateCompositeValidators?: boolean;
+    };
+    guardOptions?: {
+        includeRuntimeValidation?: boolean;
+        includeErrorMessages?: boolean;
+        treeShakeable?: boolean;
+        targetTSVersion?: "3.8" | "4.0" | "4.5" | "5.0";
+        strictGuards?: boolean;
+        includeNullChecks?: boolean;
+        verbose?: boolean;
+    };
+}
+/**
+ * TypeSchema Configuration
+ * Controls TypeSchema generation and caching behavior
+ */
+interface TypeSchemaConfig {
+    /** Enable persistent caching of generated TypeSchemas */
+    enablePersistence?: boolean;
+    /** Directory to store cached TypeSchemas (relative to outputDir) */
+    cacheDir?: string;
+    /** Maximum age of cached schemas in milliseconds before regeneration */
+    maxAge?: number;
+    /** Whether to validate cached schemas before reuse */
+    validateCached?: boolean;
+    /** Force regeneration of schemas even if cached */
+    forceRegenerate?: boolean;
+    /** Share cache across multiple codegen runs */
+    shareCache?: boolean;
+    /** Cache key prefix for namespacing */
+    cacheKeyPrefix?: string;
+    /** Only generate TypeSchemas for specific ResourceTypes (treeshaking) */
+    treeshake?: string[];
+    /** Generate single TypeSchema file instead of multiple files */
+    singleFile?: boolean;
+    /** Profile packages configuration */
+    profiles?: {
+        /** Auto-detect profiles in packages */
+        autoDetect?: boolean;
+    };
+}
+/**
+ * Main configuration schema for the new high-level API
+ */
+interface Config {
+    outputDir?: string;
+    verbose?: boolean;
+    overwrite?: boolean;
+    validate?: boolean;
+    cache?: boolean;
+    typescript?: TypeScriptGeneratorConfig;
+    typeSchema?: TypeSchemaConfig;
+    packages?: string[];
+    files?: string[];
+    $schema?: string;
+}
+/**
+ * Default configuration values
+ */
+declare const DEFAULT_CONFIG: Required<Config>;
+/**
+ * Configuration file names to search for
+ */
+declare const CONFIG_FILE_NAMES: string[];
+/**
+ * Validation error interface
+ */
+interface ConfigValidationError {
+    path: string;
+    message: string;
+    value?: unknown;
+}
+/**
+ * Configuration validation result
+ */
+interface ConfigValidationResult {
+    valid: boolean;
+    errors: ConfigValidationError[];
+    warnings: string[];
+    config?: Config;
+}
+/**
+ * Simple configuration validator
+ */
+declare class ConfigValidator {
+    /**
+     * Validate a configuration object
+     */
+    validate(config: unknown): ConfigValidationResult;
+    private validateTypeScriptConfig;
+    private validateValidatorOptions;
+    private validateGuardOptions;
+    private validateProfileOptions;
+    private validateTypeSchemaConfig;
+}
+/**
+ * Configuration loader with autoloading capabilities
+ */
+declare class ConfigLoader {
+    private validator;
+    /**
+     * Auto-load configuration from the current working directory
+     */
+    autoload(workingDir?: string): Promise<Config>;
+    /**
+     * Load configuration from a specific file
+     */
+    loadFromFile(filePath: string): Promise<Config>;
+    /**
+     * Find configuration file in the given directory
+     */
+    private findConfigFile;
+    /**
+     * Merge user config with defaults
+     */
+    private mergeWithDefaults;
+}
+/**
+ * Global config loader instance
+ */
+declare const configLoader: ConfigLoader;
+/**
+ * Convenience function to auto-load configuration
+ */
+declare function loadConfig(workingDir?: string): Promise<Config>;
+/**
+ * Type guard to check if an object is a valid Config
+ */
+declare function isConfig(obj: unknown): obj is Config;
+/**
+ * Define configuration with type safety and IntelliSense support.
+ * Similar to Vite's defineConfig function pattern.
  *
- * ## Key Features
+ * @example
+ * ```typescript
+ * import { defineConfig } from "@atomic-ehr/codegen";
  *
- * - **🔥 FHIR R4/R5 Support**: Complete FHIR resource and profile generation
- * - **🇺🇸 US Core Profiles**: Built-in support for US healthcare implementation guides
- * - **📋 TypeSchema Integration**: Uses TypeSchema as universal intermediate format
- * - **🎯 Type Safety**: Full TypeScript support with runtime validation
- * - **⚡ Performance**: Built with Bun for maximum speed
- * - **🏗️ Extensible**: Plugin architecture for custom generators
+ * export default defineConfig({
+ *   outputDir: "./generated",
+ *   packages: [
+ *     "hl7.fhir.r4.core@4.0.1",
+ *     "hl7.fhir.us.core@6.1.0"
+ *   ],
+ *   typescript: {
+ *     generateIndex: true,
+ *     strictMode: true
+ *   }
+ * });
+ * ```
+ */
+declare function defineConfig(config: Config): Config;
+
+/**
+ * TypeSchema Cache System
  *
- * ## Quick Start
+ * Caching system for TypeSchema documents with both in-memory and persistent file-based storage.
+ */
+
+/**
+ * TypeSchema Cache with optional persistent storage
+ */
+declare class TypeSchemaCache {
+    private cache;
+    private config;
+    private cacheDir?;
+    constructor(config?: TypeSchemaConfig);
+    /**
+     * Store a schema in the cache
+     */
+    set(schema: TypeSchema): Promise<void>;
+    /**
+     * Retrieve a schema by identifier
+     */
+    get(identifier: Identifier): TypeSchema | null;
+    /**
+     * Retrieve a schema by URL
+     */
+    getByUrl(url: string): TypeSchema | null;
+    /**
+     * Check if a schema exists in cache
+     */
+    has(identifier: Identifier): boolean;
+    /**
+     * Check if a schema exists by URL
+     */
+    hasByUrl(url: string): boolean;
+    /**
+     * Delete a schema from cache
+     */
+    delete(identifier: Identifier): boolean;
+    /**
+     * Delete a schema by URL
+     */
+    deleteByUrl(url: string): boolean;
+    /**
+     * Get schemas by package
+     */
+    getByPackage(packageName: string): TypeSchema[];
+    /**
+     * Get schemas by kind
+     */
+    getByKind(kind: string): TypeSchema[];
+    /**
+     * Store multiple schemas
+     */
+    setMany(schemas: TypeSchema[]): void;
+    /**
+     * Clear all cached schemas
+     */
+    clear(): void;
+    /**
+     * Generate cache key for identifier
+     */
+    private generateKey;
+    /**
+     * Initialize cache directory if persistence is enabled
+     */
+    initialize(): Promise<void>;
+    /**
+     * Load all cached schemas from disk
+     */
+    private loadFromDisk;
+    /**
+     * Persist a schema to disk
+     */
+    private persistSchema;
+    /**
+     * Clear cache directory
+     */
+    clearDisk(): Promise<void>;
+}
+
+/**
+ * TypeSchema Generator
  *
- * ```typescript
- * import { APIBuilder } from '@atomic-ehr/codegen';
+ * Generates TypeSchema documents from FHIR packages using fhrischema.
+ * Provides high-level API for converting FHIR Structure Definitions to TypeSchema format.
+ */
+
+/**
+ * TypeSchema Generator class
  *
- * // High-level API for common workflows
- * const api = new APIBuilder();
+ * Main class for generating TypeSchema documents from FHIR packages.
+ * Leverages fhrischema for FHIR parsing and canonical manager for dependency resolution.
+ */
+declare class TypeSchemaGenerator {
+    private manager;
+    private options;
+    private cacheConfig?;
+    private cache?;
+    private logger;
+    constructor(options?: TypeschemaGeneratorOptions, cacheConfig?: TypeSchemaConfig);
+    private initializeCache;
+    registerFromPackageMetas(packageMetas: PackageMeta[]): Promise<Register>;
+    generateFhirSchemas(structureDefinitions: StructureDefinition[]): FHIRSchema[];
+    generateValueSetSchemas(valueSets: RichValueSet[]): Promise<TypeSchema[]>;
+    generateFromPackage(packageName: string, packageVersion?: string): Promise<TypeSchema[]>;
+    /**
+     * Apply treeshaking to StructureDefinitions before FHIR schema transformation
+     * This is more efficient and includes smart reference handling
+     */
+    private applyStructureDefinitionTreeshaking;
+    private extractStructureDefinitionDependenciesWithReferences;
+    private extractResourceNameFromUrl;
+}
+
+/**
+ * TypeSchema Parser
  *
- * // Generate FHIR types from packages
- * await api
- *   .fromFHIRPackages(['hl7.fhir.r4.core@4.0.1', 'hl7.fhir.us.core@6.1.0'])
- *   .typescript('./src/types/fhir')
- *   .withValidation()
- *   .generate();
- * ```
+ * Parser for reading and manipulating TypeSchema documents from various formats.
+ * Supports both NDJSON and JSON formats with automatic format detection.
+ */
+
+/**
+ * TypeSchema Parser class
  *
- * ## Architecture
+ * Provides functionality to read, parse, and manipulate TypeSchema documents
+ * from files or strings in various formats.
+ */
+declare class TypeSchemaParser {
+    private options;
+    constructor(options?: TypeschemaParserOptions);
+    /**
+     * Parse TypeSchema from file
+     */
+    parseFromFile(filePath: string): Promise<TypeSchema[]>;
+    /**
+     * Parse TypeSchema from string content
+     */
+    parseFromString(content: string, format?: "ndjson" | "json"): Promise<TypeSchema[]>;
+    /**
+     * Parse multiple TypeSchema files
+     */
+    parseFromFiles(filePaths: string[]): Promise<TypeSchema[]>;
+    /**
+     * Parse a single TypeSchema object
+     */
+    parseSchema(schemaData: any): TypeSchema;
+    /**
+     * Find schemas by identifier
+     */
+    findByIdentifier(schemas: TypeSchema[], identifier: Partial<Identifier>): TypeSchema[];
+    /**
+     * Find schema by URL
+     */
+    findByUrl(schemas: TypeSchema[], url: string): TypeSchema | undefined;
+    /**
+     * Find schemas by kind
+     */
+    findByKind(schemas: TypeSchema[], kind: Identifier["kind"]): TypeSchema[];
+    /**
+     * Find schemas by package
+     */
+    findByPackage(schemas: TypeSchema[], packageName: string): TypeSchema[];
+    /**
+     * Get all dependencies from a schema
+     */
+    /**
+     * Resolve schema dependencies
+     */
+    /**
+     * Detect format from content or filename
+     */
+    private detectFormat;
+    /**
+     * Parse NDJSON format
+     */
+    private parseNDJSON;
+    /**
+     * Parse JSON format
+     */
+    private parseJSON;
+    /**
+     * Validate schemas
+     */
+    private validateSchemas;
+    /**
+     * Validate identifier structure
+     */
+    private isValidIdentifier;
+    /**
+     * Check if identifier matches criteria
+     */
+    private matchesIdentifier;
+}
+
+interface WriterOptions {
+    outputDir: string;
+    tabSize: number;
+    withDebugComment?: boolean;
+    commentLinePrefix: string;
+    logger?: CodegenLogger;
+}
+
+/**
+ * High-Level API Builder
  *
- * The library follows a three-stage architecture:
+ * Provides a fluent, chainable API for common codegen use cases with pre-built generators.
+ * This builder pattern allows users to configure generation in a declarative way.
+ */
+
+/**
+ * Configuration options for the API builder
+ */
+interface APIBuilderOptions {
+    outputDir?: string;
+    verbose?: boolean;
+    overwrite?: boolean;
+    cache?: boolean;
+    typeSchemaConfig?: TypeSchemaConfig;
+    logger?: CodegenLogger;
+    manager?: ReturnType<typeof CanonicalManager> | null;
+    throwException?: boolean;
+}
+/**
+ * Progress callback for long-running operations
+ */
+type ProgressCallback$1 = (phase: string, current: number, total: number, message?: string) => void;
+/**
+ * Generation result information
+ */
+interface GenerationResult {
+    success: boolean;
+    outputDir: string;
+    filesGenerated: string[];
+    errors: string[];
+    warnings: string[];
+    duration: number;
+}
+/**
+ * High-Level API Builder class
  *
- * 1. **Input**: FHIR packages, JSON Schema, or custom schemas
- * 2. **TypeSchema**: Universal intermediate representation
- * 3. **Output**: TypeScript, Python, Go, or custom target languages
+ * Provides a fluent interface for configuring and executing code generation
+ * from FHIR packages or TypeSchema documents.
+ */
+declare class APIBuilder {
+    private schemas;
+    private options;
+    private generators;
+    private cache?;
+    private pendingOperations;
+    private typeSchemaGenerator?;
+    private logger;
+    private packages;
+    progressCallback: any;
+    private typeSchemaConfig?;
+    constructor(options?: APIBuilderOptions);
+    fromPackage(packageName: string, version?: string): APIBuilder;
+    /**
+     * Load TypeSchema from files
+     */
+    fromFiles(...filePaths: string[]): APIBuilder;
+    /**
+     * Load TypeSchema from TypeSchema objects
+     */
+    fromSchemas(schemas: TypeSchema[]): APIBuilder;
+    typescript(options?: {
+        moduleFormat?: "esm" | "cjs";
+        generateIndex?: boolean;
+        includeDocuments?: boolean;
+        namingConvention?: "PascalCase" | "camelCase";
+        includeExtensions?: boolean;
+        includeProfiles?: boolean;
+        generateValueSets?: boolean;
+        includeValueSetHelpers?: boolean;
+        valueSetStrengths?: ("required" | "preferred" | "extensible" | "example")[];
+        valueSetMode?: "all" | "required-only" | "custom";
+        valueSetDirectory?: string;
+    }): APIBuilder;
+    typescript2(opts: Partial<WriterOptions>): this;
+    /**
+     * Set a progress callback for monitoring generation
+     */
+    onProgress(callback: ProgressCallback$1): APIBuilder;
+    /**
+     * Set the output directory for all generators
+     */
+    outputTo(directory: string): APIBuilder;
+    verbose(enabled?: boolean): APIBuilder;
+    throwException(enabled?: boolean): APIBuilder;
+    generate(): Promise<GenerationResult>;
+    /**
+     * Generate and return the results without writing to files
+     */
+    build(): Promise<{
+        typescript?: {
+            content: string;
+            filename: string;
+        }[];
+    }>;
+    /**
+     * Clear all configuration and start fresh
+     */
+    reset(): APIBuilder;
+    /**
+     * Get loaded schemas (for inspection)
+     */
+    getSchemas(): TypeSchema[];
+    /**
+     * Get configured generators (for inspection)
+     */
+    getGenerators(): string[];
+    private loadFromFiles;
+    private executeGenerators;
+}
+/**
+ * Create a new API builder instance
+ */
+declare function createAPI(options?: APIBuilderOptions): APIBuilder;
+/**
+ * Create an API builder instance from a configuration object
+ */
+declare function createAPIFromConfig(config: Config): APIBuilder;
+/**
+ * Convenience function for quick TypeScript generation from a package
+ */
+declare function generateTypesFromPackage(packageName: string, outputDir: string, options?: {
+    version?: string;
+    verbose?: boolean;
+    validate?: boolean;
+}): Promise<GenerationResult>;
+/**
+ * Convenience function for quick TypeScript generation from files
+ */
+declare function generateTypesFromFiles(inputFiles: string[], outputDir: string, options?: {
+    verbose?: boolean;
+    validate?: boolean;
+}): Promise<GenerationResult>;
+
+/**
+ * Core types and interfaces for the base generator system
  *
- * ## Examples
+ * This module provides the foundational type definitions that all generators
+ * build upon, ensuring consistency and type safety across the system.
+ */
+
+/**
+ * Base configuration options that all generators must support
+ * These options provide the minimum required configuration for any generator
+ */
+interface BaseGeneratorOptions {
+    /** Output directory where generated files will be written */
+    outputDir: string;
+    /** Logger instance for tracking generation progress and errors */
+    logger?: CodegenLogger;
+    /** Whether to overwrite existing files (default: true) */
+    overwrite?: boolean;
+    /** Whether to validate schemas and generated content (default: true) */
+    validate?: boolean;
+    /** Enable detailed logging for debugging (default: false) */
+    verbose?: boolean;
+    /** Enable beginner-friendly error messages and guidance (default: false) */
+    beginnerMode?: boolean;
+    /** Format for error output: console, json, or structured (default: 'console') */
+    errorFormat?: "console" | "json" | "structured";
+}
+/**
+ * Language-specific type representation
+ * This interface standardizes how FHIR types are mapped to target languages
+ */
+interface LanguageType {
+    /** The type string in the target language (e.g., "string", "number", "Patient") */
+    name: string;
+    /** Whether this is a primitive type that doesn't need imports */
+    isPrimitive: boolean;
+    /** Import path if this type needs to be imported from another module */
+    importPath?: string;
+    /** Generic parameters if this is a generic type (e.g., ["T", "K"] for Map<T,K>) */
+    generics?: string[];
+    /** Whether this type is nullable/optional in the target language */
+    nullable?: boolean;
+    /** Additional metadata specific to the target language */
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Generated file metadata and content
+ * Represents a single generated file with all its associated information
+ */
+interface GeneratedFile {
+    /** Full file system path where the file was/will be written */
+    path: string;
+    /** Filename only (without directory path) */
+    filename: string;
+    /** The generated content of the file */
+    content: string;
+    /** List of symbols exported from this file */
+    exports: string[];
+    /** File size in bytes */
+    size: number;
+    /** When this file was generated */
+    timestamp: Date;
+    /** Additional metadata about the generation process */
+    metadata?: {
+        /** Time taken to generate this file in milliseconds */
+        generationTime?: number;
+        /** Number of schemas processed for this file */
+        schemaCount?: number;
+        /** Template used to generate this file */
+        templateName?: string;
+        /** Any warnings generated during processing */
+        warnings?: string[];
+    };
+}
+/**
+ * Template context provided to template engines
+ * Contains all the data needed to render templates for code generation
+ */
+interface TemplateContext {
+    /** The schema being processed */
+    schema: TypeSchema;
+    /** Type mapper for the target language */
+    typeMapper: TypeMapper;
+    /** Current file being generated */
+    filename: string;
+    /** Target language name (e.g., "TypeScript", "Python") */
+    language: string;
+    /** Generation timestamp in ISO format */
+    timestamp: string;
+    /** Import map for the current file */
+    imports?: Map<string, string>;
+    /** Export set for the current file */
+    exports?: Set<string>;
+    /** Additional context data that templates can use */
+    [key: string]: unknown;
+}
+/**
+ * File builder context passed to lifecycle hooks
+ * Provides access to file generation state during the build process
+ */
+interface FileContext {
+    /** Name of the file being generated */
+    filename: string;
+    /** Current file content */
+    content: string;
+    /** Map of imports (symbol name -> import path) */
+    imports: Map<string, string>;
+    /** Set of exported symbols */
+    exports: Set<string>;
+    /** Additional metadata about the file */
+    metadata: Record<string, unknown>;
+    /** The schema that generated this file (if applicable) */
+    schema?: TypeSchema;
+    /** Template name used to generate this file (if applicable) */
+    templateName?: string;
+}
+/**
+ * Statistics about file operations
+ * Used for performance monitoring and optimization
+ */
+interface FileStats {
+    /** File size in bytes */
+    size: number;
+    /** Time taken to generate content in milliseconds */
+    generationTime: number;
+    /** Time taken to write to disk in milliseconds */
+    writeTime: number;
+    /** Memory used during generation in bytes */
+    memoryUsed?: number;
+    /** Number of template renders performed */
+    templateRenders?: number;
+}
+/**
+ * Progress callback signature for monitoring generation
+ * Allows consumers to track progress of long-running operations
+ */
+type ProgressCallback = (
+/** Current phase of generation */
+phase: "validation" | "generation" | "writing" | "complete", 
+/** Current item number being processed */
+current: number, 
+/** Total number of items to process */
+total: number, 
+/** Optional message describing current operation */
+message?: string, 
+/** Schema being processed (if applicable) */
+schema?: TypeSchema) => void;
+/**
+ * Lifecycle hook signatures for file operations
+ * These hooks allow customization of the file generation process
+ */
+/** Hook called before saving a file - can modify content or abort save */
+type BeforeSaveHook = (context: FileContext) => void | Promise<void>;
+/** Hook called after successfully saving a file */
+type AfterSaveHook = (filePath: string, stats: FileStats) => void | Promise<void>;
+/** Hook called when an error occurs during file operations */
+type ErrorHook = (error: Error, context: FileContext) => void | Promise<void>;
+/**
+ * File builder configuration options
+ * Controls how files are generated and processed
+ */
+interface FileBuilderOptions {
+    /** Template name to use for content generation */
+    template?: string;
+    /** Strategy for resolving import paths */
+    importStrategy?: "auto" | "manual" | "none";
+    /** Level of content validation to perform */
+    validation?: "strict" | "loose" | "none";
+    /** Enable pretty printing of generated content */
+    prettify?: boolean;
+    /** Custom formatting options */
+    formatting?: {
+        /** Number of spaces for indentation (default: 2) */
+        indentSize?: number;
+        /** Use tabs instead of spaces (default: false) */
+        useTabs?: boolean;
+        /** Maximum line length before wrapping (default: 100) */
+        maxLineLength?: number;
+    };
+    /** File encoding (default: 'utf-8') */
+    encoding?: BufferEncoding;
+}
+/**
+ * Abstract base class for type mapping between FHIR and target languages
+ * Each language-specific generator must implement this interface
+ */
+declare abstract class TypeMapper {
+    /**
+     * Map a FHIR primitive type to the target language
+     * @param fhirType - FHIR primitive type name (e.g., "string", "integer")
+     * @returns Language-specific type representation
+     */
+    abstract mapPrimitive(fhirType: string): LanguageType;
+    /**
+     * Map a FHIR reference to the target language
+     * @param targets - Array of possible reference targets
+     * @returns Language-specific reference type
+     */
+    abstract mapReference(targets: Identifier[]): LanguageType;
+    /**
+     * Map an array type in the target language
+     * @param elementType - The element type name
+     * @returns Language-specific array type
+     */
+    abstract mapArray(elementType: string): LanguageType;
+    /**
+     * Map optional/nullable types
+     * @param type - The base type
+     * @param required - Whether the field is required
+     * @returns Language-specific optional type
+     */
+    abstract mapOptional(type: string, required: boolean): LanguageType;
+    /**
+     * Map enumerated values to the target language
+     * @param values - Array of possible values
+     * @param name - Optional name for the enum type
+     * @returns Language-specific enum type
+     */
+    abstract mapEnum(values: string[], name?: string): LanguageType;
+    /**
+     * Format a FHIR type name according to target language conventions
+     * @param name - FHIR type name
+     * @returns Formatted type name
+     */
+    abstract formatTypeName(name: string): string;
+    /**
+     * Format a field name according to target language conventions
+     * @param name - FHIR field name
+     * @returns Formatted field name
+     */
+    abstract formatFieldName(name: string): string;
+    /**
+     * Format a filename according to target language conventions
+     * @param name - Base filename
+     * @returns Formatted filename (without extension)
+     */
+    abstract formatFileName(name: string): string;
+    /**
+     * Map a complete TypeSchema identifier to target language type
+     * @param identifier - FHIR type identifier
+     * @returns Language-specific type representation
+     */
+    abstract mapType(identifier: Identifier): LanguageType;
+    /**
+     * Get import statement format for the target language
+     * @param symbols - Symbols to import
+     * @param from - Module to import from
+     * @returns Formatted import statement
+     */
+    formatImport?(symbols: string[], from: string): string;
+    /**
+     * Get export statement format for the target language
+     * @param symbols - Symbols to export
+     * @returns Formatted export statement
+     */
+    formatExport?(symbols: string[]): string;
+}
+/**
+ * Template engine interface
+ * Abstraction for different template engines (Handlebars, etc.)
+ */
+interface TemplateEngine {
+    /**
+     * Render a template with the given context
+     * @param templateName - Name of the template to render
+     * @param context - Data to pass to the template
+     * @returns Rendered content
+     */
+    render(templateName: string, context: Record<string, unknown>): string;
+    /**
+     * Register a template
+     * @param name - Template name
+     * @param template - Template content or compiled template
+     */
+    registerTemplate(name: string, template: string | ((...args: any[]) => any)): void;
+    /**
+     * Register a helper function
+     * @param name - Helper name
+     * @param helper - Helper function
+     */
+    registerHelper(name: string, helper: (...args: any[]) => any): void;
+    /**
+     * Check if a template exists
+     * @param name - Template name
+     * @returns True if template exists
+     */
+    hasTemplate(name: string): boolean;
+    /**
+     * Get list of available templates
+     * @returns Array of template names
+     */
+    getAvailableTemplates(): string[];
+}
+/**
+ * Generator capabilities interface
+ * Describes what a generator can do - used for introspection
+ */
+interface GeneratorCapabilities {
+    /** Programming language this generator targets */
+    language: string;
+    /** File extensions this generator produces */
+    fileExtensions: string[];
+    /** Whether this generator supports templates */
+    supportsTemplates: boolean;
+    /** Whether this generator supports custom type mapping */
+    supportsCustomTypeMapping: boolean;
+    /** Whether this generator supports incremental generation */
+    supportsIncrementalGeneration: boolean;
+    /** Whether this generator supports validation */
+    supportsValidation: boolean;
+    /** Supported schema kinds */
+    supportedSchemaKinds: Array<"resource" | "complex-type" | "profile" | "primitive-type" | "logical">;
+    /** Version of the generator */
+    version: string;
+    /** Additional metadata about capabilities */
+    metadata?: Record<string, unknown>;
+}
+
+/**
+ * Core file management system with batching and performance optimizations
  *
- * ### FHIR Patient with US Core Extensions
+ * This replaces scattered writeFile calls with a comprehensive file management
+ * system that provides better error handling, performance, and maintainability.
+ */
+
+interface FileManagerOptions {
+    outputDir: string;
+    logger: CodegenLogger;
+    overwrite?: boolean;
+    batchSize?: number;
+}
+interface WriteFileResult {
+    path: string;
+    size: number;
+    writeTime: number;
+}
+/**
+ * High-performance file manager with batching and error recovery
  *
- * ```typescript
- * import { USCorePatient, USCoreRaceExtension } from './types/fhir';
- *
- * const patient: USCorePatient = {
- *   resourceType: 'Patient',
- *   identifier: [{ value: 'MRN-123' }],
- *   name: [{ family: 'Johnson', given: ['Maria'] }],
- *   gender: 'female',
- *   extension: [{
- *     url: 'http://hl7.org/fhir/us/core/StructureDefinition/us-core-race',
- *     extension: [{ url: 'text', valueString: 'Hispanic or Latino' }]
- *   } as USCoreRaceExtension]
- * };
- * ```
+ * Features:
+ * - Automatic directory creation
+ * - Batch operations for better performance
+ * - Comprehensive error handling with recovery suggestions
+ * - Import path resolution
+ * - File existence checks
+ */
+declare class FileManager {
+    private readonly options;
+    private readonly logger;
+    constructor(options: FileManagerOptions);
+    /**
+     * Write a file with automatic directory creation
+     * @param relativePath Path relative to output directory
+     * @param content File content
+     * @param options Write options
+     */
+    writeFile(relativePath: string, content: string, options?: {
+        encoding?: BufferEncoding;
+        overwrite?: boolean;
+    }): Promise<WriteFileResult>;
+    /**
+     * Write multiple files in batch for better performance
+     * @param files Map of relative path to content
+     */
+    writeBatch(files: Map<string, string>): Promise<WriteFileResult[]>;
+    /**
+     * Ensure directory exists, creating parent directories as needed
+     * @param dirPath Full directory path
+     */
+    ensureDirectory(dirPath: string): Promise<void>;
+    /**
+     * Clean directory by removing all contents
+     * @param relativePath Path relative to output directory
+     */
+    cleanDirectory(relativePath?: string): Promise<void>;
+    /**
+     * Get relative import path between two files
+     * @param fromFile Source file path
+     * @param toFile Target file path
+     */
+    getRelativeImportPath(fromFile: string, toFile: string): string;
+    /**
+     * Check if a file would be overwritten
+     * @param relativePath Path relative to output directory
+     */
+    wouldOverwrite(relativePath: string): Promise<boolean>;
+    /**
+     * Get file statistics
+     * @param relativePath Path relative to output directory
+     */
+    getFileStats(relativePath: string): Promise<FileStats | null>;
+    /**
+     * Get output directory
+     */
+    getOutputDirectory(): string;
+    /**
+     * Set batch size for operations
+     * @param size Batch size
+     */
+    setBatchSize(size: number): void;
+    /**
+     * Get current batch size
+     */
+    getBatchSize(): number;
+}
+
+/**
+ * Index file builder for automated exports
  *
- * ### Runtime Validation
+ * Automatically generates index files that export all types and functions
+ * from a directory, with support for grouping and namespaces.
+ */
+
+interface IndexBuilderConfig {
+    directory: string;
+    fileManager: FileManager;
+    templateEngine?: TemplateEngine;
+    logger: CodegenLogger;
+}
+/**
+ * Builder for index files with intelligent export management
  *
- * ```typescript
- * import { isUSCorePatient, validateFHIRResource } from './types/fhir/guards';
+ * Features:
+ * - Automatic export detection
+ * - Namespace support
+ * - Export grouping
+ * - Custom headers
+ * - Template support
+ */
+declare class IndexBuilder {
+    private readonly config;
+    private readonly exports;
+    private readonly namespaces;
+    private readonly reExports;
+    private header;
+    private footer;
+    private groupingFunction?;
+    private sortFunction?;
+    constructor(config: IndexBuilderConfig);
+    /**
+     * Add exports from a specific file
+     * @param exportNames Export names
+     * @param fromPath Path to file (without extension)
+     */
+    withExports(exportNames: string[], fromPath: string): IndexBuilder;
+    /**
+     * Add a single export
+     * @param exportName Export name
+     * @param fromPath Path to file
+     */
+    withExport(exportName: string, fromPath: string): IndexBuilder;
+    /**
+     * Add namespace exports
+     * @param namespaces Map of namespace to path
+     */
+    withNamespaces(namespaces: Record<string, string>): IndexBuilder;
+    /**
+     * Add namespace export
+     * @param namespace Namespace name
+     * @param path Path to export as namespace
+     */
+    withNamespace(namespace: string, path: string): IndexBuilder;
+    /**
+     * Re-export all from paths
+     * @param paths Paths to re-export all from
+     */
+    withReExports(paths: string[]): IndexBuilder;
+    /**
+     * Add re-export
+     * @param path Path to re-export all from
+     */
+    withReExport(path: string): IndexBuilder;
+    /**
+     * Set header content
+     * @param header Header content
+     */
+    withHeader(header: string): IndexBuilder;
+    /**
+     * Set footer content
+     * @param footer Footer content
+     */
+    withFooter(footer: string): IndexBuilder;
+    /**
+     * Group exports by function
+     * @param fn Function that returns group name for export
+     */
+    groupBy(fn: (exportName: string) => string): IndexBuilder;
+    /**
+     * Sort exports by function
+     * @param fn Sort function for [exportName, fromPath] tuples
+     */
+    sortBy(fn: (a: [string, string], b: [string, string]) => number): IndexBuilder;
+    /**
+     * Auto-discover exports from directory
+     * @param filePattern Pattern to match files (e.g., "*.ts")
+     */
+    autoDiscover(_filePattern?: string): Promise<IndexBuilder>;
+    /**
+     * Save the index file
+     */
+    save(): Promise<string>;
+    /**
+     * Build content without saving (for preview)
+     */
+    build(): string;
+    /**
+     * Generate the index file content
+     */
+    private generateContent;
+    /**
+     * Generate simple exports without grouping
+     */
+    private generateSimpleExports;
+    /**
+     * Generate grouped exports
+     */
+    private generateGroupedExports;
+    /**
+     * Get current exports (for testing/debugging)
+     */
+    getExports(): Map<string, string>;
+    /**
+     * Get current namespaces (for testing/debugging)
+     */
+    getNamespaces(): Map<string, string>;
+    /**
+     * Get current re-exports (for testing/debugging)
+     */
+    getReExports(): Map<string, string>;
+}
+
+/**
+ * Fluent file builder with lifecycle hooks and validation
  *
- * if (isUSCorePatient(someData)) {
- *   // TypeScript knows this is a USCorePatient
- *   const validation = await validateFHIRResource(someData);
- *   if (validation.valid) {
- *     console.log('Valid US Core Patient!');
- *   }
- * }
- * ```
+ * This provides a clean, chainable API for building files with imports,
+ * exports, content generation, and lifecycle hooks for customization.
+ */
+
+interface FileBuilderConfig {
+    filename: string;
+    fileManager: FileManager;
+    templateEngine?: TemplateEngine;
+    typeMapper: TypeMapper;
+    logger: CodegenLogger;
+}
+/**
+ * Fluent builder for creating files with lifecycle hooks
+ *
+ * Features:
+ * - Fluent API for content building
+ * - Template integration
+ * - Import/export management
+ * - Lifecycle hooks (before/after save, error handling)
+ * - Content validation
+ * - Automatic import path resolution
+ */
+declare class FileBuilder {
+    private readonly config;
+    private content;
+    private readonly imports;
+    private readonly exports;
+    private readonly metadata;
+    private beforeSaveHooks;
+    private afterSaveHooks;
+    private errorHooks;
+    private options;
+    constructor(config: FileBuilderConfig);
+    /**
+     * Set content directly
+     * @param content File content
+     */
+    withContent(content: string | (() => string)): FileBuilder;
+    /**
+     * Generate content from template
+     * @param templateName Template to use
+     * @param context Template context
+     */
+    withTemplate(templateName: string, context: Record<string, unknown>): FileBuilder;
+    /**
+     * Append content to existing content
+     * @param content Content to append
+     */
+    appendContent(content: string): FileBuilder;
+    /**
+     * Prepend content to existing content
+     * @param content Content to prepend
+     */
+    prependContent(content: string): FileBuilder;
+    /**
+     * Set all imports at once
+     * @param imports Map of symbol name to import path
+     */
+    withImports(imports: Map<string, string>): FileBuilder;
+    /**
+     * Add a single import
+     * @param symbol Symbol to import
+     * @param from Import path
+     */
+    addImport(symbol: string, from: string): FileBuilder;
+    /**
+     * Add multiple imports from the same path
+     * @param symbols Symbols to import
+     * @param from Import path
+     */
+    addImports(symbols: string[], from: string): FileBuilder;
+    /**
+     * Set all exports at once
+     * @param exports Array of export names
+     */
+    withExports(exports: string[]): FileBuilder;
+    /**
+     * Add a single export
+     * @param name Export name
+     */
+    addExport(name: string): FileBuilder;
+    /**
+     * Add multiple exports
+     * @param names Export names
+     */
+    addExports(names: string[]): FileBuilder;
+    /**
+     * Set metadata for the file
+     * @param key Metadata key
+     * @param value Metadata value
+     */
+    withMetadata(key: string, value: unknown): FileBuilder;
+    /**
+     * Set file builder options
+     * @param options Options to set
+     */
+    withOptions(options: Partial<FileBuilderOptions>): FileBuilder;
+    /**
+     * Add hook to run before saving
+     * @param hook Hook function
+     */
+    onBeforeSave(hook: BeforeSaveHook): FileBuilder;
+    /**
+     * Add hook to run after successful save
+     * @param hook Hook function
+     */
+    onAfterSave(hook: AfterSaveHook): FileBuilder;
+    /**
+     * Add hook to run when error occurs
+     * @param hook Hook function
+     */
+    onError(hook: ErrorHook): FileBuilder;
+    /**
+     * Build final content without saving
+     * @returns File context with final content
+     */
+    build(): FileContext;
+    /**
+     * Save the file
+     * @returns Promise resolving to file path
+     */
+    save(): Promise<string>;
+    /**
+     * Build final content with imports and exports
+     */
+    private buildFinalContent;
+    /**
+     * Generate import statements
+     */
+    private generateImportStatements;
+    /**
+     * Generate export statements
+     */
+    private generateExportStatements;
+    /**
+     * Prettify content (basic implementation)
+     */
+    private prettifyContent;
+    /**
+     * Validate generated content
+     */
+    private validateContent;
+    /**
+     * Get current content (for testing/debugging)
+     */
+    getContent(): string;
+    /**
+     * Get current imports (for testing/debugging)
+     */
+    getImports(): Map<string, string>;
+    /**
+     * Get current exports (for testing/debugging)
+     */
+    getExports(): Set<string>;
+}
+
+/**
+ * Directory builder for batch file operations
+ *
+ * Provides a fluent API for managing entire directories of files,
+ * including subdirectories, index files, and batch operations.
+ */
+
+interface DirectoryBuilderConfig {
+    path: string;
+    fileManager: FileManager;
+    logger: CodegenLogger;
+}
+/**
+ * Fluent builder for directory operations
+ *
+ * Features:
+ * - Subdirectory management
+ * - Batch file operations
+ * - Index file generation
+ * - Directory cleaning
+ * - File listing for preview
+ */
+declare class DirectoryBuilder {
+    private readonly config;
+    private readonly files;
+    private readonly subdirectories;
+    private indexBuilder?;
+    private shouldClean;
+    constructor(config: DirectoryBuilderConfig);
+    /**
+     * Add a subdirectory
+     * @param name Subdirectory name
+     */
+    withSubdirectory(name: string): DirectoryBuilder;
+    /**
+     * Add files to this directory
+     * @param files Map of filename to FileBuilder
+     */
+    withFiles(files: Record<string, FileBuilder>): DirectoryBuilder;
+    /**
+     * Add a single file
+     * @param filename File name
+     * @param builder File builder
+     */
+    withFile(filename: string, builder: FileBuilder): DirectoryBuilder;
+    /**
+     * Set index builder for this directory
+     * @param builder Index builder
+     */
+    withIndex(builder: IndexBuilder): DirectoryBuilder;
+    /**
+     * Clean directory before creating files
+     */
+    clean(): DirectoryBuilder;
+    /**
+     * Ensure directory exists
+     */
+    ensure(): Promise<DirectoryBuilder>;
+    /**
+     * Save all files in this directory
+     */
+    save(): Promise<string[]>;
+    /**
+     * Get all files that would be generated (for preview)
+     */
+    getFileList(): string[];
+    /**
+     * Get statistics about this directory
+     */
+    getStats(): {
+        fileCount: number;
+        subdirectoryCount: number;
+        hasIndex: boolean;
+        totalFiles: number;
+    };
+    /**
+     * Check if directory would overwrite existing files
+     */
+    wouldOverwrite(): Promise<string[]>;
+    /**
+     * Get the path of this directory
+     */
+    getPath(): string;
+    /**
+     * Get all file builders (for testing/debugging)
+     */
+    getFiles(): Map<string, FileBuilder>;
+    /**
+     * Get all subdirectories (for testing/debugging)
+     */
+    getSubdirectories(): Map<string, DirectoryBuilder>;
+    /**
+     * Get index builder (for testing/debugging)
+     */
+    getIndexBuilder(): IndexBuilder | undefined;
+}
+
+/**
+ * Centralized error handling and reporting system
+ *
+ * This module provides a comprehensive error handling solution that:
+ * - Handles both generator-specific and unknown errors gracefully
+ * - Provides rich, context-aware error reporting
+ * - Supports multiple output formats (console, JSON, structured)
+ * - Includes batch error handling for multiple failures
+ * - Offers smart error recovery suggestions
+ */
+
+interface ErrorHandlerOptions {
+    logger: CodegenLogger;
+    verbose?: boolean;
+    beginnerMode?: boolean;
+    outputFormat?: "console" | "json" | "structured";
+}
+/**
+ * Centralized error handler with smart reporting
+ */
+declare class ErrorHandler {
+    private options;
+    constructor(options: ErrorHandlerOptions);
+    /**
+     * Handle a single error with appropriate reporting
+     */
+    handleError(error: Error, context?: {
+        schema?: TypeSchema;
+        filename?: string;
+    }): void;
+    /**
+     * Handle multiple errors in batch
+     */
+    handleBatchErrors(errors: Error[]): void;
+    /**
+     * Handle generator-specific errors with rich context
+     */
+    private handleGeneratorError;
+    /**
+     * Handle unknown errors gracefully
+     */
+    private handleUnknownError;
+    /**
+     * Report error to console with formatting
+     */
+    private reportErrorToConsole;
+    /**
+     * Report error as JSON for programmatic consumption
+     */
+    private reportErrorAsJson;
+    /**
+     * Report error in structured format
+     */
+    private reportErrorStructured;
+    /**
+     * Report multiple errors efficiently
+     */
+    private reportBatchErrors;
+    /**
+     * Get common suggestions across similar errors
+     */
+    private getCommonSuggestions;
+    /**
+     * Get recovery actions for an error
+     */
+    private getRecoveryActions;
+}
+/**
+ * Error boundary for catching and handling all generator errors
+ */
+declare class GeneratorErrorBoundary {
+    private errorHandler;
+    constructor(errorHandler: ErrorHandler);
+    /**
+     * Wrap an async operation with error boundary
+     */
+    withErrorBoundary<T>(operation: () => Promise<T>, context?: {
+        schema?: TypeSchema;
+        filename?: string;
+        operationName?: string;
+    }): Promise<T>;
+    /**
+     * Wrap a batch operation with error boundary
+     */
+    withBatchErrorBoundary<T>(operations: Array<() => Promise<T>>, _context?: {
+        operationName?: string;
+    }): Promise<T[]>;
+}
+
+/**
+ * Abstract base generator class with comprehensive functionality
+ *
+ * Provides common functionality for all generators including:
+ * - Schema validation and processing
+ * - File management with fluent API
+ * - Template processing
+ * - Error handling and recovery
+ * - Progress monitoring
+ * - Performance optimization
+ */
+declare abstract class BaseGenerator<TOptions extends BaseGeneratorOptions = BaseGeneratorOptions, TResult extends GeneratedFile[] = GeneratedFile[]> {
+    /** Validated and merged options */
+    protected options: Required<TOptions>;
+    /** Logger instance for this generator */
+    protected readonly logger: CodegenLogger;
+    /** File manager for all file operations */
+    protected readonly fileManager: FileManager;
+    /** Template engine for content generation (optional) */
+    protected readonly templateEngine?: TemplateEngine;
+    /** Language-specific type mapper */
+    protected readonly typeMapper: TypeMapper;
+    /** Enhanced error handler for comprehensive error reporting */
+    protected readonly errorHandler: ErrorHandler;
+    /** Error boundary for catching and handling all generator errors */
+    protected readonly errorBoundary: GeneratorErrorBoundary;
+    /** Progress callback if provided */
+    private progressCallback?;
+    /** Generated files tracking */
+    private generatedFiles;
+    /** Generation start time for performance metrics */
+    private generationStartTime;
+    /** Cache for expensive operations */
+    private readonly cache;
+    constructor(options: TOptions);
+    /**
+     * Get the name of the target language (e.g., "TypeScript", "Python", "Rust")
+     */
+    protected abstract getLanguageName(): string;
+    /**
+     * Get the file extension for the target language (e.g., ".ts", ".py", ".rs")
+     */
+    protected abstract getFileExtension(): string;
+    /**
+     * Create a language-specific type mapper
+     */
+    protected abstract createTypeMapper(): TypeMapper;
+    /**
+     * Generate content for a single schema
+     * @param schema - The TypeSchema to generate code for
+     * @param context - Additional context for generation
+     */
+    protected abstract generateSchemaContent(schema: TypeSchema, context: TemplateContext): Promise<string>;
+    /**
+     * Validate generated content before writing
+     * @param content - The generated content
+     * @param context - The generation context
+     */
+    protected abstract validateContent(content: string, context: TemplateContext): Promise<void>;
+    /**
+     * Filter and sort schemas with language-specific logic
+     * @param schemas - Input schemas
+     */
+    protected abstract filterAndSortSchemas(schemas: TypeSchema[]): TypeSchema[];
+    /**
+     * Get generator capabilities - can be overridden for introspection
+     */
+    getCapabilities(): GeneratorCapabilities;
+    /**
+     * Create file manager instance - can be overridden for custom file handling
+     */
+    protected createFileManager(): FileManager;
+    /**
+     * Create template engine instance - can be overridden for custom templates
+     * Returns undefined if template engine is not needed
+     */
+    protected createTemplateEngine(): TemplateEngine | undefined;
+    /**
+     * Generate code from TypeSchema documents
+     * This is the main method that orchestrates the entire generation process
+     * @param schemas - Array of TypeSchema documents
+     */
+    generate(schemas: TypeSchema[]): Promise<TResult>;
+    /**
+     * Generate and return content without writing files (useful for testing)
+     * @param schemas - Array of TypeSchema documents
+     */
+    build(schemas: TypeSchema[]): Promise<TResult>;
+    /**
+     * Create a file builder for fluent file generation
+     * @param filename - Name of the file to create
+     */
+    file(filename: string): FileBuilder;
+    /**
+     * Create a directory builder for batch operations
+     * @param path - Directory path relative to output directory
+     */
+    directory(path: string): DirectoryBuilder;
+    /**
+     * Create an index file builder
+     * @param directory - Directory to create index for
+     */
+    index(directory?: string): IndexBuilder;
+    /**
+     * Set progress callback for monitoring generation
+     * @param callback - Progress callback function
+     */
+    onProgress(callback: ProgressCallback): this;
+    /**
+     * Validate generator configuration
+     */
+    private validateConfiguration;
+    /**
+     * Merge options with defaults
+     */
+    private mergeWithDefaults;
+    /**
+     * Validate schemas before processing
+     */
+    private validateSchemas;
+    /**
+     * Validate individual schema
+     */
+    protected validateSchema(schema: TypeSchema): Promise<void>;
+    /**
+     * Detect circular references in schema dependencies
+     */
+    private detectCircularReferences;
+    /**
+     * Generate files from processed schemas
+     */
+    private generateFiles;
+    /**
+     * Generate a single file from a schema
+     */
+    private generateFileForSchema;
+    /**
+     * Ensure filename has correct extension
+     */
+    private ensureFileExtension;
+    /**
+     * Extract exported symbols from generated content
+     * Can be overridden by language-specific implementations
+     */
+    protected extractExports(content: string): string[];
+    /**
+     * Report progress to callback if provided
+     */
+    protected reportProgress(phase: "validation" | "generation" | "writing" | "complete", current: number, total: number, message?: string, schema?: TypeSchema): void;
+    /**
+     * Run post-generation hooks
+     * Can be overridden to add custom post-processing
+     */
+    protected runPostGenerationHooks(): Promise<void>;
+    /**
+     * Get cached value or compute and cache it
+     */
+    protected getCachedOrCompute<T>(key: string, computeFn: () => T | Promise<T>): T | Promise<T>;
+    /**
+     * Clear internal cache
+     */
+    protected clearCache(): void;
+    /**
+     * Get generation statistics
+     */
+    getGenerationStats(): {
+        filesGenerated: number;
+        totalSize: number;
+        averageFileSize: number;
+        generationTime: number;
+        averageTimePerFile: number;
+        cacheHitRate: number;
+    };
+}
+
+/**
+ * Abstract base class for language-specific type mapping
+ *
+ * This provides the interface that all language generators must implement
+ * to convert FHIR TypeSchema types into their target language types.
+ */
+
+/**
+ * Configuration for type mapping behavior
+ */
+interface TypeMapperOptions {
+    /** Whether to generate nullable types (e.g., T | null) */
+    generateNullable?: boolean;
+    /** Whether to use strict type checking */
+    strictTypes?: boolean;
+    /** Custom type mappings */
+    customMappings?: Record<string, string>;
+    /** Whether to generate array types or use generic collections */
+    preferArraySyntax?: boolean;
+    /** Naming convention strategy */
+    namingConvention?: "camelCase" | "PascalCase" | "snake_case" | "kebab-case";
+}
+
+/**
+ * TypeScript-specific type mapper implementation
+ */
+
+/**
+ * TypeScript-specific options
+ */
+interface TypeScriptTypeMapperOptions extends TypeMapperOptions {
+    /** Whether to use 'unknown' or 'any' for unmapped types */
+    preferUnknown?: boolean;
+    /** Whether to generate branded types for primitives */
+    useBrandedTypes?: boolean;
+    /** Whether to use 'undefined' or 'null' for optional types */
+    preferUndefined?: boolean;
+    /** Module format for imports */
+    moduleFormat?: "esm" | "commonjs";
+}
+
+/**
+ * Modern TypeScript Generator built on BaseGenerator
+ *
+ * This is the new, clean implementation that replaces the monolithic typescript.ts generator.
+ * Built using the BaseGenerator architecture with TypeMapper, TemplateEngine, and FileManager.
+ */
+
+/**
+ * TypeScript-specific generator options
+ */
+interface TypeScriptGeneratorOptions extends BaseGeneratorOptions {
+    /** Module format for imports/exports */
+    moduleFormat?: "esm" | "cjs";
+    /** Whether to generate index files */
+    generateIndex?: boolean;
+    /** Include JSDoc documentation */
+    includeDocuments?: boolean;
+    /** Naming convention for types */
+    namingConvention?: "PascalCase" | "camelCase";
+    /** Include FHIR extensions */
+    includeExtensions?: boolean;
+    /** Include FHIR profiles */
+    includeProfiles?: boolean;
+    /** Generate value set files (default: false) */
+    generateValueSets?: boolean;
+    /** Include helper validation functions (default: false) */
+    includeValueSetHelpers?: boolean;
+    /**
+     * Which binding strengths to generate value sets for
+     * Only used when valueSetMode is 'custom'
+     * @default ['required']
+     */
+    valueSetStrengths?: ("required" | "preferred" | "extensible" | "example")[];
+    /**
+     * Directory name for value set files (relative to outputDir)
+     * @default 'valuesets'
+     */
+    valueSetDirectory?: string;
+    /**
+     * Value set generation mode
+     * - 'all': Generate for all binding strengths with enums
+     * - 'required-only': Generate only for required bindings (safe default)
+     * - 'custom': Use valueSetStrengths array to control
+     * @default 'required-only'
+     */
+    valueSetMode?: "all" | "required-only" | "custom";
+    /** Type mapper options */
+    typeMapperOptions?: TypeScriptTypeMapperOptions;
+}
+/**
+ * Result of generating a single TypeScript file
+ */
+interface GeneratedTypeScript {
+    content: string;
+    imports: Map<string, string>;
+    exports: string[];
+    filename: string;
+}
+/**
+ * Modern TypeScript Generator
  *
- * @packageDocumentation
- * @module @atomic-ehr/codegen
- * @version 0.0.1
- * @author Atomic EHR Team
- * @since 0.0.1
+ * Generates clean, type-safe TypeScript interfaces from FHIR TypeSchema documents.
+ * Uses the new BaseGenerator architecture for maintainability and extensibility.
  */
-export * from "./api/index";
-export * from "./config";
+declare class TypeScriptGenerator extends BaseGenerator<TypeScriptGeneratorOptions, GeneratedFile[]> {
+    private readonly resourceTypes;
+    private collectedValueSets;
+    private get tsOptions();
+    protected getLanguageName(): string;
+    protected getFileExtension(): string;
+    protected createTypeMapper(): TypeMapper;
+    protected generateSchemaContent(schema: TypeSchema, _context: TemplateContext): Promise<string>;
+    protected filterAndSortSchemas(schemas: TypeSchema[]): TypeSchema[];
+    protected validateContent(content: string, context: TemplateContext): Promise<void>;
+    /**
+     * Transform multiple schemas into TypeScript
+     */
+    transformSchemas(schemas: TypeSchema[]): Promise<GeneratedTypeScript[]>;
+    /**
+     * Transform a single schema into TypeScript
+     */
+    transformSchema(schema: TypeSchema): Promise<GeneratedTypeScript | undefined>;
+    /**
+     * Check if a binding schema should generate a value set file
+     */
+    private shouldGenerateValueSet;
+    /**
+     * Collect value sets from schemas that should generate value set files
+     */
+    private collectValueSets;
+    /**
+     * Check if a field binding should use a value set type
+     */
+    private shouldUseValueSetType;
+    /**
+     * Get the TypeScript type name for a binding
+     */
+    private getValueSetTypeName;
+    /**
+     * Check if a field has enum values that should be inlined
+     */
+    private shouldUseInlineEnum;
+    /**
+     * Generate inline enum type from field enum values
+     */
+    private generateInlineEnumType;
+    private shouldSkipSchema;
+    private getFilenameForSchema;
+    private extractImportsFromContent;
+    private extractExportsFromContent;
+    /**
+     * Generate special Reference interface with generics
+     */
+    private generateReferenceInterface;
+    /**
+     * Generate TypeScript interface directly without templates
+     */
+    private generateTypeScriptInterface;
+    /**
+     * Collect import dependencies from a field
+     */
+    private collectFieldImports;
+    /**
+     * Extract resource types from reference field constraints
+     */
+    private extractReferenceTypes;
+    /**
+     * Generate nested type interface
+     */
+    private generateNestedTypeInterface;
+    /**
+     * Capitalize first letter of string
+     */
+    private capitalizeFirst;
+    /**
+     * Generate field lines (handles polymorphic fields by expanding them)
+     */
+    private generateFieldLines;
+    /**
+     * Generate a single field line
+     */
+    private generateFieldLine;
+    /**
+     * Extract exported symbols from TypeScript content
+     */
+    protected extractExports(content: string): string[];
+    /**
+     * Set output directory for compatibility with API builder
+     */
+    setOutputDir(directory: string): void;
+    /**
+     * Update generator options for compatibility with API builder
+     */
+    setOptions(options: Partial<TypeScriptGeneratorOptions>): void;
+    /**
+     * Get current options for compatibility with API builder
+     */
+    getOptions(): TypeScriptGeneratorOptions;
+    /**
+     * Override generate to clean directory first
+     */
+    generate(schemas: TypeSchema[]): Promise<GeneratedFile[]>;
+    /**
+     * Run post-generation hooks - generate utility files
+     */
+    protected runPostGenerationHooks(): Promise<void>;
+    /**
+     * Generate utilities.ts file with ResourceType union
+     */
+    private generateUtilitiesFile;
+    /**
+     * Generate a complete value set TypeScript file
+     */
+    private generateValueSetFile;
+    /**
+     * Create valuesets directory and generate all value set files
+     */
+    private generateValueSetFiles;
+    /**
+     * Generate index.ts file that re-exports all value sets
+     */
+    private generateValueSetIndexFile;
+    /**
+     * Generate main types/index.ts file that exports all types and value sets
+     */
+    private generateMainIndexFile;
+}
+
+export { APIBuilder, type APIBuilderOptions, CONFIG_FILE_NAMES, type Config, ConfigLoader, type ConfigValidationError, type ConfigValidationResult, ConfigValidator, DEFAULT_CONFIG, type GeneratedFile, type GenerationResult, type PackageMeta as PackageInfo, type ProgressCallback$1 as ProgressCallback, type TypeSchema, TypeSchemaCache, type TypeSchemaConfig, type Field as TypeSchemaField, TypeSchemaGenerator, type Identifier as TypeSchemaIdentifier, TypeSchemaParser, TypeScriptGenerator, type TypeScriptGeneratorConfig, type TypeScriptGeneratorOptions, configLoader, createAPI, createAPIFromConfig, defineConfig, generateTypesFromFiles, generateTypesFromPackage, isConfig, loadConfig };