@atomic-ehr/codegen 0.0.2 → 0.0.3

package/dist/index.d.ts

@@ -1,6 +1,4 @@
 import { CanonicalManager } from '@atomic-ehr/fhir-canonical-manager';
-import * as FS from '@atomic-ehr/fhirschema';
-import { FHIRSchema, StructureDefinition, FHIRSchemaElement } from '@atomic-ehr/fhirschema';
 
 /**
  * CodeGen Logger
@@ -84,16 +82,6 @@ type Name = string & {
 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;
@@ -256,93 +244,18 @@ interface BindingTypeSchema {
     dependencies?: Identifier[];
 }
 type Field = RegularField | ChoiceFieldDeclaration | ChoiceFieldInstance;
-type TypeschemaParserOptions = {
-    format?: "auto" | "ndjson" | "json";
-    validate?: boolean;
-    strict?: boolean;
-};
-type ValueSet = {
-    resourceType: "ValueSet";
-    package_meta?: PackageMeta;
-    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?: {}[];
+        filter?: unknown[];
     }[];
 };
-type CodeSystem = {
-    resourceType: "CodeSystem";
-    url: CanonicalUrl;
-    concept: CodeSystemConcept[];
-};
-type CodeSystemConcept = {
-    concept: CodeSystemConcept[];
-    code: string;
-    display: string;
-};
-type RichValueSet = Omit<ValueSet, "name" | "url"> & {
-    package_meta: PackageMeta;
-    name: Name;
-    url: CanonicalUrl;
-};
-interface TypeschemaGeneratorOptions {
-    verbose?: boolean;
-    logger?: CodegenLogger;
-    treeshake?: string[];
-    manager?: ReturnType<typeof CanonicalManager> | null;
-}
 
-type Register = {
-    testAppendFs(fs: FHIRSchema): void;
-    ensureSpecializationCanonicalUrl(name: string | Name | CanonicalUrl): CanonicalUrl;
-    resolveSd(pkg: PackageMeta, canonicalUrl: CanonicalUrl): StructureDefinition | undefined;
-    resolveFs(pkg: PackageMeta, canonicalUrl: CanonicalUrl): RichFHIRSchema | undefined;
-    resolveFsGenealogy(pkg: PackageMeta, canonicalUrl: CanonicalUrl): RichFHIRSchema[];
-    resolveFsSpecializations(pkg: PackageMeta, canonicalUrl: CanonicalUrl): RichFHIRSchema[];
-    allFs(): RichFHIRSchema[];
-    allVs(): RichValueSet[];
-    resolveVs(_pkg: PackageMeta, canonicalUrl: CanonicalUrl): RichValueSet | undefined;
-    resolveAny(canonicalUrl: CanonicalUrl): any | undefined;
-    resolveElementSnapshot(fhirSchema: RichFHIRSchema, path: string[]): FHIRSchemaElement;
-    getAllElementKeys(elems: Record<string, FHIRSchemaElement>): string[];
-    resolver: PackageAwareResolver;
-} & ReturnType<typeof CanonicalManager>;
-type PkgId = string;
-type FocusedResource = StructureDefinition | ValueSet | CodeSystem;
-type CanonicalResolution<T> = {
-    deep: number;
-    pkg: PackageMeta;
-    pkgId: PkgId;
-    resource: T;
-};
-type PackageIndex = {
-    pkg: PackageMeta;
-    canonicalResolution: Record<CanonicalUrl, CanonicalResolution<FocusedResource>[]>;
-    fhirSchemas: Record<CanonicalUrl, RichFHIRSchema>;
-    valueSets: Record<CanonicalUrl, RichValueSet>;
+type TypeSchemaShakeRule = {
+    ignoreFields?: string[];
 };
-type PackageAwareResolver = Record<PkgId, PackageIndex>;
+type TreeShake = Record<string, Record<string, TypeSchemaShakeRule>>;
 
 /**
  * New Config Schema for High-Level API
@@ -563,236 +476,26 @@ declare function isConfig(obj: unknown): obj is Config;
  */
 declare function defineConfig(config: Config): Config;
 
-/**
- * TypeSchema Cache System
- *
- * 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
- *
- * Generates TypeSchema documents from FHIR packages using fhrischema.
- * Provides high-level API for converting FHIR Structure Definitions to TypeSchema format.
- */
-
-/**
- * TypeSchema Generator class
- *
- * 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[], logger?: CodegenLogger): Promise<TypeSchema[]>;
-    generateFromPackage(packageName: string, packageVersion: string | undefined, logger?: CodegenLogger): 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
- *
- * Parser for reading and manipulating TypeSchema documents from various formats.
- * Supports both NDJSON and JSON formats with automatic format detection.
- */
-
-/**
- * TypeSchema Parser class
- *
- * 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;
-}
-
-type TypeSchemaShakeRule = {
-    ignoreFields?: string[];
-};
-type TreeShake = Record<string, Record<string, TypeSchemaShakeRule>>;
-interface TypeRelation {
-    parent: Identifier;
-    child: Identifier;
-}
-type PackageName = string;
-type TypeSchemaIndex = {
-    _schemaIndex: Record<CanonicalUrl, Record<PackageName, TypeSchema>>;
-    _relations: TypeRelation[];
-    collectComplexTypes: () => RegularTypeSchema[];
-    collectResources: () => RegularTypeSchema[];
-    collectLogicalModels: () => RegularTypeSchema[];
-    collectProfiles: () => ProfileTypeSchema[];
-    resolve: (id: Identifier) => TypeSchema | undefined;
-    resolveByUrl: (pkgName: PackageName, url: CanonicalUrl) => TypeSchema | undefined;
-    resourceChildren: (id: Identifier) => Identifier[];
-    tryHierarchy: (schema: TypeSchema) => TypeSchema[] | undefined;
-    hierarchy: (schema: TypeSchema) => TypeSchema[];
-    findLastSpecialization: (schema: TypeSchema) => TypeSchema;
-    findLastSpecializationByIdentifier: (id: Identifier) => Identifier;
-    flatProfile: (schema: ProfileTypeSchema) => ProfileTypeSchema;
-    isWithMetaField: (profile: ProfileTypeSchema) => boolean;
-    exportTree: (filename: string) => Promise<void>;
-};
-
-interface WriterOptions {
+type FileSystemWriterOptions = {
     outputDir: string;
+    inMemoryOnly?: boolean;
+    logger?: CodegenLogger;
+};
+type WriterOptions = FileSystemWriterOptions & {
     tabSize: number;
     withDebugComment?: boolean;
     commentLinePrefix: string;
     generateProfile?: boolean;
-    logger?: CodegenLogger;
-}
+};
+
+type TypeScriptOptions = {
+    /** openResourceTypeSet -- for resource families (Resource, DomainResource) use open set for resourceType field.
+     *
+     * - when openResourceTypeSet is false: `type Resource = { resourceType: "Resource" | "DomainResource" | "Patient" }`
+     * - when openResourceTypeSet is true: `type Resource = { resourceType: "Resource" | "DomainResource" | "Patient" | string }`
+     */
+    openResourceTypeSet: boolean;
+} & WriterOptions;
 
 /**
  * High-Level API Builder
@@ -821,7 +524,7 @@ interface APIBuilderOptions {
 /**
  * Progress callback for long-running operations
  */
-type ProgressCallback$1 = (phase: string, current: number, total: number, message?: string) => void;
+type ProgressCallback = (phase: string, current: number, total: number, message?: string) => void;
 /**
  * Generation result information
  */
@@ -843,9 +546,6 @@ declare class APIBuilder {
     private schemas;
     private options;
     private generators;
-    private cache?;
-    private pendingOperations;
-    private typeSchemaGenerator?;
     private logger;
     private packages;
     progressCallback: any;
@@ -853,27 +553,13 @@ declare class APIBuilder {
     constructor(options?: APIBuilderOptions);
     fromPackage(packageName: string, version?: string): APIBuilder;
     fromPackageRef(packageRef: string): APIBuilder;
-    fromFiles(...filePaths: string[]): APIBuilder;
     fromSchemas(schemas: TypeSchema[]): APIBuilder;
-    typescriptDepricated(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;
-    typescript(opts: Partial<WriterOptions>): this;
+    typescript(userOpts: Partial<TypeScriptOptions>): this;
     csharp(namespace: string, staticSourceDir?: string | undefined): APIBuilder;
     /**
      * Set a progress callback for monitoring generation
      */
-    onProgress(callback: ProgressCallback$1): APIBuilder;
+    onProgress(callback: ProgressCallback): APIBuilder;
     /**
      * Set the output directory for all generators
      */
@@ -885,15 +571,6 @@ declare class APIBuilder {
     treeShake(tree: TreeShake): this;
     writeTypeSchemas(target: string): this;
     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
      */
@@ -906,1296 +583,13 @@ declare class APIBuilder {
      * Get configured generators (for inspection)
      */
     getGenerators(): string[];
-    private loadFromFiles;
     private executeGenerators;
 }
-/**
- * Create an API builder instance from a configuration object
- */
-declare function createAPIFromConfig(config: Config): APIBuilder;
-
-/**
- * Core types and interfaces for the base generator system
- *
- * 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
- *
- * This replaces scattered writeFile calls with a comprehensive file management
- * system that provides better error handling, performance, and maintainability.
- */
 
-interface FileManagerOptions {
+type CSharpGeneratorOptions = WriterOptions & {
     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
- *
- * 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
- *
- * 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
- *
- * 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
- *
- * 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?: "this.options.logger" | "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[]>;
-}
-
-type GeneratorInput = {
-    schemas: TypeSchema[];
-    index: TypeSchemaIndex;
+    staticSourceDir?: string;
+    targetNamespace: string;
 };
-/**
- * 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 }: GeneratorInput): 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
- *
- * Generates clean, type-safe TypeScript interfaces from FHIR TypeSchema documents.
- * Uses the new BaseGenerator architecture for maintainability and extensibility.
- */
-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(input: GeneratorInput): 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, createAPIFromConfig, defineConfig, isConfig, loadConfig };
+export { APIBuilder, type APIBuilderOptions, CONFIG_FILE_NAMES, type CSharpGeneratorOptions, type Config, ConfigLoader, type ConfigValidationError, type ConfigValidationResult, ConfigValidator, DEFAULT_CONFIG, type TypeSchemaConfig, type TypeScriptGeneratorConfig, type TypeScriptOptions, configLoader, defineConfig, isConfig, loadConfig };