@atomic-ehr/codegen 0.0.1-canary.20251006070905.fb6ed98 → 0.0.1-canary.20251006094042.7f0be72

package/dist/api/generators/typescript.js

@@ -1,819 +0,0 @@
-/**
- * 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.
- */
-import { isBindingSchema } from "@typeschema/types";
-import { BaseGenerator } from "./base/BaseGenerator";
-import { TypeScriptTypeMapper } from "./base/TypeScriptTypeMapper";
-/**
- * Modern TypeScript Generator
- *
- * Generates clean, type-safe TypeScript interfaces from FHIR TypeSchema documents.
- * Uses the new BaseGenerator architecture for maintainability and extensibility.
- */
-export class TypeScriptGenerator extends BaseGenerator {
-    resourceTypes = new Set();
-    collectedValueSets = new Map();
-    get tsOptions() {
-        return this.options;
-    }
-    getLanguageName() {
-        return "TypeScript";
-    }
-    getFileExtension() {
-        return ".ts";
-    }
-    createTypeMapper() {
-        const options = this.options;
-        return new TypeScriptTypeMapper({
-            namingConvention: (options.namingConvention ?? "PascalCase") === "PascalCase" ? "PascalCase" : "camelCase",
-            moduleFormat: options.moduleFormat === "cjs" ? "commonjs" : "esm",
-            preferUndefined: true,
-            ...options.typeMapperOptions,
-        });
-    }
-    async generateSchemaContent(schema, _context) {
-        // Skip unsupported schema types
-        if (this.shouldSkipSchema(schema)) {
-            return "";
-        }
-        // Collect resource types for Reference generic
-        if (schema.identifier.kind === "resource") {
-            this.resourceTypes.add(this.typeMapper.formatTypeName(schema.identifier.name));
-        }
-        // Update filename for profiles to include proper directory structure
-        // if (false) {
-        // 	// Profile support removed - not in core schema
-        // 	const sanitizedPackage = this.sanitizePackageName(
-        // 		schema.identifier.package || "unknown",
-        // 	);
-        // 	const profileFileName = this.typeMapper.formatFileName(
-        // 		schema.identifier.name,
-        // 	);
-        // 	context.filename = `profiles/${sanitizedPackage}/${profileFileName}`;
-        // 	// Track profile for index generation
-        // 	if (!this.profilesByPackage.has(schema.identifier.package || "unknown")) {
-        // 		this.profilesByPackage.set(schema.identifier.package || "unknown", []);
-        // 	}
-        // 	this.profilesByPackage.get(schema.identifier.package || "unknown")?.push({
-        // 		filename: profileFileName,
-        // 		interfaceName: this.typeMapper.formatTypeName(schema.identifier.name),
-        // 	});
-        // }
-        // Handle Reference type specially
-        if (schema.identifier.name === "Reference") {
-            return this.generateReferenceInterface(schema);
-        }
-        // Generate TypeScript content directly (no templates for simplicity)
-        const mainInterface = this.generateTypeScriptInterface(schema);
-        // Generate nested types if present
-        let nestedInterfaces = "";
-        if ("nested" in schema && schema.nested && Array.isArray(schema.nested)) {
-            const nestedInterfaceStrings = schema.nested.map((nestedType) => this.generateNestedTypeInterface(schema.identifier.name, nestedType));
-            nestedInterfaces = nestedInterfaceStrings.join("\n\n");
-        }
-        // Combine main interface with nested interfaces
-        if (nestedInterfaces) {
-            return `${mainInterface}\n\n${nestedInterfaces}`;
-        }
-        return mainInterface;
-    }
-    filterAndSortSchemas(schemas) {
-        // Collect value sets from ALL schemas before filtering
-        this.collectedValueSets = this.collectValueSets(schemas);
-        return schemas.filter((schema) => !this.shouldSkipSchema(schema));
-    }
-    async validateContent(content, context) {
-        const hasValidExport = /export\s+(interface|class|type|enum)\s+\w+/.test(content);
-        const hasValidSyntax = content.includes("{") && content.includes("}");
-        if (!hasValidExport) {
-            throw new Error(`Generated content for ${context.schema.identifier.name} does not contain valid export statements`);
-        }
-        if (!hasValidSyntax) {
-            throw new Error(`Generated content for ${context.schema.identifier.name} has invalid syntax (missing braces)`);
-        }
-    }
-    /**
-     * Transform multiple schemas into TypeScript
-     */
-    async transformSchemas(schemas) {
-        const results = [];
-        for (const schema of schemas) {
-            const result = await this.transformSchema(schema);
-            if (result) {
-                results.push(result);
-            }
-        }
-        return results;
-    }
-    /**
-     * Transform a single schema into TypeScript
-     */
-    async transformSchema(schema) {
-        if (this.shouldSkipSchema(schema)) {
-            return undefined;
-        }
-        // Create template context
-        const context = {
-            schema,
-            typeMapper: this.typeMapper,
-            filename: this.getFilenameForSchema(schema),
-            language: "TypeScript",
-            timestamp: new Date().toISOString(),
-        };
-        // Generate content using template engine
-        const content = await this.generateSchemaContent(schema, context);
-        if (!content.trim()) {
-            return undefined;
-        }
-        // Extract imports and exports from generated content
-        const imports = this.extractImportsFromContent(content, schema);
-        const exports = this.extractExportsFromContent(content, schema);
-        const filename = this.getFilenameForSchema(schema);
-        return {
-            content,
-            imports,
-            exports: Array.from(exports),
-            filename,
-        };
-    }
-    /**
-     * Check if a binding schema should generate a value set file
-     */
-    shouldGenerateValueSet(schema) {
-        if (!isBindingSchema(schema) || !schema.enum || !Array.isArray(schema.enum) || schema.enum.length === 0) {
-            return false;
-        }
-        // Handle different value set modes
-        const mode = this.options.valueSetMode || "required-only";
-        switch (mode) {
-            case "all":
-                return true; // Generate for all binding strengths
-            case "required-only":
-                return schema.strength === "required";
-            case "custom": {
-                const strengths = this.options.valueSetStrengths || ["required"];
-                return strengths.includes(schema.strength);
-            }
-            default:
-                return schema.strength === "required";
-        }
-    }
-    /**
-     * Collect value sets from schemas that should generate value set files
-     */
-    collectValueSets(schemas) {
-        const valueSets = new Map();
-        for (const schema of schemas) {
-            if (this.shouldGenerateValueSet(schema) && isBindingSchema(schema)) {
-                const name = this.typeMapper.formatTypeName(schema.identifier.name);
-                valueSets.set(name, schema);
-            }
-        }
-        return valueSets;
-    }
-    /**
-     * Check if a field binding should use a value set type
-     */
-    shouldUseValueSetType(binding) {
-        if (!binding) {
-            return false;
-        }
-        // If generateValueSets is false, never use value set types
-        if (!this.tsOptions.generateValueSets) {
-            return false;
-        }
-        const valueSetTypeName = this.typeMapper.formatTypeName(binding.name);
-        return this.collectedValueSets.has(valueSetTypeName);
-    }
-    /**
-     * Get the TypeScript type name for a binding
-     */
-    getValueSetTypeName(binding) {
-        return this.typeMapper.formatTypeName(binding.name);
-    }
-    /**
-     * Check if a field has enum values that should be inlined
-     */
-    shouldUseInlineEnum(field) {
-        if (!field) {
-            return false;
-        }
-        // Only use inline enums when generateValueSets is false
-        if (this.tsOptions.generateValueSets) {
-            return false;
-        }
-        // Check if field has enum values directly on the field
-        return field.enum && Array.isArray(field.enum) && field.enum.length > 0;
-    }
-    /**
-     * Generate inline enum type from field enum values
-     */
-    generateInlineEnumType(field) {
-        if (!field.enum || !Array.isArray(field.enum)) {
-            return "string"; // fallback
-        }
-        // Create union type from enum values
-        const enumValues = field.enum.map((value) => `'${value}'`).join(" | ");
-        return enumValues;
-    }
-    shouldSkipSchema(schema) {
-        if (schema.identifier.kind === "value-set" ||
-            schema.identifier.kind === "binding" ||
-            schema.identifier.kind === "primitive-type") {
-            return true;
-        }
-        // Profile support removed - not in core schema specification
-        // Skip FHIR extensions when includeExtensions is false
-        if (!this.tsOptions.includeExtensions) {
-            // Check if this is a FHIR extension by looking at the URL pattern
-            const url = schema.identifier.url;
-            if (url?.includes("StructureDefinition/")) {
-                // Extensions typically have URLs like:
-                // http://hl7.org/fhir/StructureDefinition/extension-name
-                // http://hl7.org/fhir/StructureDefinition/resource-extension
-                // Get the part after StructureDefinition/
-                const structDefPart = url.split("StructureDefinition/")[1];
-                if (structDefPart) {
-                    // Check if it contains a hyphen (indicating extension pattern)
-                    // FHIR extensions are profiles with hyphenated names
-                    const hasHyphenPattern = structDefPart.includes("-");
-                    const isProfileKind = schema.identifier.kind === "profile";
-                    // Extensions are profiles with hyphenated StructureDefinition names
-                    // But we need to exclude core resources that also have hyphens
-                    if (hasHyphenPattern && isProfileKind) {
-                        return true;
-                    }
-                }
-            }
-        }
-        return false;
-    }
-    getFilenameForSchema(schema) {
-        const baseName = this.typeMapper.formatFileName(schema.identifier.name);
-        return `${baseName}${this.getFileExtension()}`;
-    }
-    extractImportsFromContent(content, _schema) {
-        const imports = new Map();
-        const importRegex = /import\s+(?:type\s+)?{\s*([^}]+)\s*}\s+from\s+['"]([^'"]+)['"];?/g;
-        let match;
-        while ((match = importRegex.exec(content)) !== null) {
-            const symbolsStr = match[1];
-            const path = match[2];
-            if (!symbolsStr || !path)
-                continue;
-            const symbols = symbolsStr.split(",").map((s) => s.trim());
-            for (const symbol of symbols) {
-                imports.set(symbol, path);
-            }
-        }
-        return imports;
-    }
-    extractExportsFromContent(content, schema) {
-        const exports = new Set();
-        const exportRegex = /export\s+(?:interface|class|enum|type)\s+([A-Za-z_$][A-Za-z0-9_$]*)/g;
-        let match;
-        while ((match = exportRegex.exec(content)) !== null) {
-            if (match[1])
-                exports.add(match[1]);
-        }
-        exports.add(this.typeMapper.formatTypeName(schema.identifier.name));
-        return exports;
-    }
-    /**
-     * Generate special Reference interface with generics
-     */
-    generateReferenceInterface(schema) {
-        const lines = [];
-        const imports = new Set();
-        if ("fields" in schema && schema.fields) {
-            for (const [, field] of Object.entries(schema.fields)) {
-                const importDeps = this.collectFieldImports(field);
-                importDeps.forEach((imp) => imports.add(imp));
-            }
-        }
-        lines.push("import type { ResourceType } from './utilities.js';");
-        if (imports.size > 0) {
-            const sortedImports = Array.from(imports).sort();
-            for (const importName of sortedImports) {
-                lines.push(`import type { ${importName} } from './${importName}.js';`);
-            }
-        }
-        lines.push(""); // Add blank line after imports
-        // Add JSDoc comment
-        if (this.tsOptions.includeDocuments && schema.description) {
-            lines.push("/**");
-            lines.push(` * ${schema.description}`);
-            if (schema.identifier.url) {
-                lines.push(` * @see ${schema.identifier.url}`);
-            }
-            if (schema.identifier.package) {
-                lines.push(` * @package ${schema.identifier.package}`);
-            }
-            lines.push(" * @template T - The resource type being referenced");
-            lines.push(" */");
-        }
-        // Generate generic interface declaration
-        lines.push("export interface Reference<T extends ResourceType = ResourceType> {");
-        if ("fields" in schema && schema.fields) {
-            for (const [fieldName, field] of Object.entries(schema.fields)) {
-                if (fieldName === "type") {
-                    // Special handling for the type field to use the generic parameter
-                    lines.push("  type?: T;");
-                }
-                else {
-                    const fieldLines = this.generateFieldLines(fieldName, field);
-                    for (const fieldLine of fieldLines) {
-                        if (fieldLine) {
-                            lines.push(`  ${fieldLine}`);
-                        }
-                    }
-                }
-            }
-        }
-        lines.push("}");
-        return lines.join("\n");
-    }
-    /**
-     * Generate TypeScript interface directly without templates
-     */
-    generateTypeScriptInterface(schema) {
-        const lines = [];
-        const interfaceName = this.typeMapper.formatTypeName(schema.identifier.name);
-        const imports = new Set();
-        const valueSetImports = new Set();
-        // Collect imports from fields
-        if ("fields" in schema && schema.fields) {
-            for (const [, field] of Object.entries(schema.fields)) {
-                const fieldImports = this.collectFieldImports(field);
-                for (const imp of fieldImports) {
-                    // Check if this is a value set import
-                    if (this.collectedValueSets.has(imp)) {
-                        valueSetImports.add(imp);
-                    }
-                    else {
-                        imports.add(imp);
-                    }
-                }
-            }
-        }
-        // Collect imports from nested types
-        if ("nested" in schema && schema.nested && Array.isArray(schema.nested)) {
-            for (const nestedType of schema.nested) {
-                if (nestedType.fields) {
-                    for (const [, field] of Object.entries(nestedType.fields)) {
-                        const fieldImports = this.collectFieldImports(field);
-                        for (const imp of fieldImports) {
-                            // Check if this is a value set import
-                            if (this.collectedValueSets.has(imp)) {
-                                valueSetImports.add(imp);
-                            }
-                            else {
-                                imports.add(imp);
-                            }
-                        }
-                    }
-                }
-            }
-        }
-        // Generate regular type imports
-        if (imports.size > 0) {
-            const sortedImports = Array.from(imports).sort();
-            for (const importName of sortedImports) {
-                lines.push(`import type { ${importName} } from './${importName}.js';`);
-            }
-        }
-        // Generate value set imports
-        if (valueSetImports.size > 0) {
-            const sortedValueSetImports = Array.from(valueSetImports).sort();
-            const importList = sortedValueSetImports.join(", ");
-            lines.push(`import type { ${importList} } from './valuesets/index.js';`);
-        }
-        if (imports.size > 0 || valueSetImports.size > 0) {
-            lines.push(""); // Add blank line after imports
-        }
-        // Add JSDoc comment if enabled
-        if (this.tsOptions.includeDocuments && schema.description) {
-            lines.push("/**");
-            lines.push(` * ${schema.description}`);
-            if (schema.identifier.url) {
-                lines.push(` * @see ${schema.identifier.url}`);
-            }
-            if (schema.identifier.package) {
-                lines.push(` * @package ${schema.identifier.package}`);
-            }
-            lines.push(" */");
-        }
-        // Generate interface declaration
-        lines.push(`export interface ${interfaceName} {`);
-        // Add resourceType for FHIR resources
-        if (schema.identifier.kind === "resource") {
-            lines.push(`  resourceType: '${interfaceName}';`);
-        }
-        // Generate fields (if any)
-        if ("fields" in schema && schema.fields) {
-            for (const [fieldName, field] of Object.entries(schema.fields)) {
-                const fieldLines = this.generateFieldLines(fieldName, field);
-                for (const fieldLine of fieldLines) {
-                    if (fieldLine) {
-                        lines.push(`  ${fieldLine}`);
-                    }
-                }
-            }
-        }
-        lines.push("}");
-        return lines.join("\n");
-    }
-    /**
-     * Collect import dependencies from a field
-     */
-    collectFieldImports(field) {
-        const imports = [];
-        // Skip polymorphic declaration fields (they don't have types to import)
-        if ("choices" in field && field.choices && Array.isArray(field.choices)) {
-            return imports;
-        }
-        // Handle value set imports (only when generateValueSets is true)
-        if (field.binding && this.shouldUseValueSetType(field.binding)) {
-            const valueSetTypeName = this.getValueSetTypeName(field.binding);
-            imports.push(valueSetTypeName);
-            return imports;
-        }
-        // Handle all other fields (regular fields and polymorphic instance fields)
-        if ("type" in field && field.type) {
-            // Handle nested types - they don't need imports as they're in the same file
-            if (field.type.kind === "nested") {
-                // Nested types are generated in the same file, no import needed
-                return imports;
-            }
-            const languageType = this.typeMapper.mapType(field.type);
-            // Only import non-primitive types that are not built-in
-            if (!languageType.isPrimitive && languageType.name !== "any") {
-                const builtInTypes = ["string", "number", "boolean", "Date", "object", "unknown", "any"];
-                if (!builtInTypes.includes(languageType.name)) {
-                    imports.push(languageType.name);
-                }
-            }
-        }
-        return [...new Set(imports)]; // Remove duplicates
-    }
-    /**
-     * Extract resource types from reference field constraints
-     */
-    extractReferenceTypes(referenceConstraints) {
-        const resourceTypes = [];
-        if (!Array.isArray(referenceConstraints)) {
-            return resourceTypes;
-        }
-        for (const constraint of referenceConstraints) {
-            if (!constraint || typeof constraint !== "object") {
-                continue;
-            }
-            if (constraint.kind === "resource" && constraint.name) {
-                const resourceType = this.typeMapper.formatTypeName(constraint.name);
-                resourceTypes.push(resourceType);
-            }
-        }
-        return [...new Set(resourceTypes)]; // Remove duplicates
-    }
-    /**
-     * Generate nested type interface
-     */
-    generateNestedTypeInterface(parentTypeName, nestedType) {
-        const lines = [];
-        const nestedTypeName = this.typeMapper.formatTypeName(`${parentTypeName}${this.capitalizeFirst(nestedType.identifier.name)}`);
-        // Add JSDoc comment if enabled
-        if (this.tsOptions.includeDocuments && nestedType.description) {
-            lines.push("/**");
-            lines.push(` * ${nestedType.description}`);
-            if (nestedType.identifier.url) {
-                lines.push(` * @see ${nestedType.identifier.url}`);
-            }
-            lines.push(" */");
-        }
-        // Generate interface declaration
-        lines.push(`export interface ${nestedTypeName} {`);
-        // Generate fields
-        if (nestedType.fields) {
-            for (const [fieldName, field] of Object.entries(nestedType.fields)) {
-                const fieldLines = this.generateFieldLines(fieldName, field);
-                for (const fieldLine of fieldLines) {
-                    if (fieldLine) {
-                        lines.push(`  ${fieldLine}`);
-                    }
-                }
-            }
-        }
-        lines.push("}");
-        return lines.join("\n");
-    }
-    /**
-     * Capitalize first letter of string
-     */
-    capitalizeFirst(str) {
-        return str.charAt(0).toUpperCase() + str.slice(1);
-    }
-    /**
-     * Generate field lines (handles polymorphic fields by expanding them)
-     */
-    generateFieldLines(fieldName, field) {
-        // Check if this field has choices (polymorphic declaration field)
-        if ("choices" in field && field.choices && Array.isArray(field.choices)) {
-            // Skip declaration fields - the actual instance fields are generated separately
-            // Declaration fields like `{"choices": ["deceasedBoolean", "deceasedDateTime"]}`
-            // are just metadata and shouldn't be rendered as actual TypeScript fields
-            return [];
-        }
-        // For all other fields (including polymorphic instance fields with choiceOf), generate normally
-        const fieldLine = this.generateFieldLine(fieldName, field);
-        return fieldLine ? [fieldLine] : [];
-    }
-    /**
-     * Generate a single field line
-     */
-    generateFieldLine(fieldName, field) {
-        let typeString = "any";
-        let required = false;
-        let isArray = false;
-        if ("type" in field && field.type) {
-            // Check if field has a binding that we generated a value set for
-            if (field.binding && this.shouldUseValueSetType(field.binding)) {
-                const valueSetTypeName = this.getValueSetTypeName(field.binding);
-                typeString = valueSetTypeName;
-            }
-            else if (field.binding && this.shouldUseInlineEnum(field)) {
-                // Generate inline enum union type when generateValueSets is false
-                typeString = this.generateInlineEnumType(field);
-            }
-            else {
-                // Existing type mapping logic
-                const languageType = this.typeMapper.mapType(field.type);
-                typeString = languageType.name;
-                // Handle nested types specially
-                if (field.type.kind === "nested") {
-                    // Extract parent name from URL like "http://hl7.org/fhir/StructureDefinition/Patient#contact"
-                    const urlParts = field.type.url?.split("#") || [];
-                    if (urlParts.length === 2) {
-                        const parentName = urlParts[0].split("/").pop() || "";
-                        const nestedName = field.type.name;
-                        typeString = this.typeMapper.formatTypeName(`${parentName}${this.capitalizeFirst(nestedName)}`);
-                    }
-                    else {
-                        typeString = this.typeMapper.formatTypeName(field.type.name);
-                    }
-                }
-                else if (typeString === "Reference" && field.reference && Array.isArray(field.reference)) {
-                    const referenceTypes = this.extractReferenceTypes(field.reference);
-                    if (referenceTypes.length > 0) {
-                        referenceTypes.forEach((type) => this.resourceTypes.add(type));
-                        const unionType = referenceTypes.map((type) => `'${type}'`).join(" | ");
-                        typeString = `Reference<${unionType}>`;
-                    }
-                }
-            }
-        }
-        if ("required" in field) {
-            required = field.required;
-        }
-        if ("array" in field) {
-            isArray = field.array;
-        }
-        const optional = required ? "" : "?";
-        const arrayType = isArray ? "[]" : "";
-        return `${fieldName}${optional}: ${typeString}${arrayType};`;
-    }
-    // ==========================================
-    /**
-     * Extract exported symbols from TypeScript content
-     */
-    extractExports(content) {
-        const exports = [];
-        const exportListPattern = /export\s*\{\s*([^}]+)\s*\}/g;
-        let match;
-        while ((match = exportListPattern.exec(content)) !== null) {
-            if (match[1]) {
-                const names = match[1]
-                    .split(",")
-                    .map((name) => name.trim())
-                    .filter(Boolean);
-                exports.push(...names);
-            }
-        }
-        const directExportPatterns = [
-            /export\s+interface\s+(\w+)/g, // export interface Name
-            /export\s+type\s+(\w+)/g, // export type Name
-            /export\s+class\s+(\w+)/g, // export class Name
-            /export\s+enum\s+(\w+)/g, // export enum Name
-            /export\s+const\s+(\w+)/g, // export const name
-            /export\s+function\s+(\w+)/g, // export function name
-        ];
-        for (const pattern of directExportPatterns) {
-            let match;
-            while ((match = pattern.exec(content)) !== null) {
-                if (match[1]) {
-                    exports.push(match[1]);
-                }
-            }
-        }
-        return [...new Set(exports)];
-    }
-    /**
-     * Set output directory for compatibility with API builder
-     */
-    setOutputDir(directory) {
-        this.options.outputDir = directory;
-    }
-    /**
-     * Update generator options for compatibility with API builder
-     */
-    setOptions(options) {
-        this.options = { ...this.options, ...options };
-    }
-    /**
-     * Get current options for compatibility with API builder
-     */
-    getOptions() {
-        return { ...this.options };
-    }
-    /**
-     * Override generate to clean directory first
-     */
-    async generate(schemas) {
-        // Clean output directory before generation
-        await this.fileManager.cleanDirectory();
-        this.logger.debug("Cleaned output directory before generation");
-        // Call parent implementation
-        return super.generate(schemas);
-    }
-    /**
-     * Run post-generation hooks - generate utility files
-     */
-    async runPostGenerationHooks() {
-        await super.runPostGenerationHooks();
-        await this.generateValueSetFiles();
-        await this.generateUtilitiesFile();
-        await this.generateMainIndexFile();
-    }
-    /**
-     * Generate utilities.ts file with ResourceType union
-     */
-    async generateUtilitiesFile() {
-        if (this.resourceTypes.size === 0) {
-            this.logger.warn("No resource types found, skipping utilities.ts generation");
-            return;
-        }
-        const lines = [];
-        // Add file header comment
-        lines.push("/**");
-        lines.push(" * FHIR Resource Type Utilities");
-        lines.push(" * This file contains utility types for FHIR resources.");
-        lines.push(" * ");
-        lines.push(" * @generated This file is auto-generated. Do not edit manually.");
-        lines.push(" */");
-        lines.push("");
-        // Generate ResourceType union
-        const sortedResourceTypes = Array.from(this.resourceTypes).sort();
-        lines.push("/**");
-        lines.push(" * Union of all FHIR resource types in this package");
-        lines.push(" */");
-        lines.push("export type ResourceType =");
-        for (let i = 0; i < sortedResourceTypes.length; i++) {
-            const isLast = i === sortedResourceTypes.length - 1;
-            const separator = isLast ? ";" : "";
-            lines.push(`  | '${sortedResourceTypes[i]}'${separator}`);
-        }
-        lines.push("");
-        // Generate helper type for Resource references
-        lines.push("/**");
-        lines.push(" * Helper type for creating typed References");
-        lines.push(" * @example Reference<'Patient' | 'Practitioner'> - Reference that can point to Patient or Practitioner");
-        lines.push(" */");
-        lines.push("export type TypedReference<T extends ResourceType> = {");
-        lines.push("  reference?: string;");
-        lines.push("  type?: T;");
-        lines.push("  identifier?: any; // Simplified for utility");
-        lines.push("  display?: string;");
-        lines.push("};");
-        const content = lines.join("\n");
-        // Write the utilities file
-        await this.fileManager.writeFile("utilities.ts", content);
-        this.logger.info(`Generated utilities.ts with ${this.resourceTypes.size} resource types`);
-    }
-    /**
-     * Generate a complete value set TypeScript file
-     */
-    generateValueSetFile(binding) {
-        const name = this.typeMapper.formatTypeName(binding.identifier.name);
-        const values = binding.enum?.map((v) => `  '${v}'`).join(",\n") || "";
-        const lines = [];
-        // Add file header comment
-        if (this.options.includeDocuments) {
-            lines.push("/**");
-            lines.push(` * ${binding.identifier.name} value set`);
-            if (binding.description) {
-                lines.push(` * ${binding.description}`);
-            }
-            if (binding.valueset?.url) {
-                lines.push(` * @see ${binding.valueset.url}`);
-            }
-            if (binding.identifier.package) {
-                lines.push(` * @package ${binding.identifier.package}`);
-            }
-            lines.push(" * @generated This file is auto-generated. Do not edit manually.");
-            lines.push(" */");
-            lines.push("");
-        }
-        // Add values array
-        lines.push(`export const ${name}Values = [`);
-        if (values) {
-            lines.push(values);
-        }
-        lines.push("] as const;");
-        lines.push("");
-        // Add union type
-        lines.push(`export type ${name} = typeof ${name}Values[number];`);
-        // Add helper function if enabled
-        if (this.tsOptions.includeValueSetHelpers) {
-            lines.push("");
-            lines.push(`export const isValid${name} = (value: string): value is ${name} =>`);
-            lines.push(`  ${name}Values.includes(value as ${name});`);
-        }
-        return lines.join("\n");
-    }
-    /**
-     * Create valuesets directory and generate all value set files
-     */
-    async generateValueSetFiles() {
-        if (!this.tsOptions.generateValueSets || this.collectedValueSets.size === 0) {
-            return;
-        }
-        // Generate individual value set files in valuesets/
-        for (const [name, binding] of this.collectedValueSets) {
-            const content = this.generateValueSetFile(binding);
-            const fileName = `valuesets/${name}.ts`;
-            await this.fileManager.writeFile(fileName, content);
-            this.logger.info(`Generated value set: ${fileName}`);
-        }
-        // Generate index file in valuesets/
-        await this.generateValueSetIndexFile();
-    }
-    /**
-     * Generate index.ts file that re-exports all value sets
-     */
-    async generateValueSetIndexFile() {
-        const lines = [];
-        if (this.tsOptions.includeDocuments) {
-            lines.push("/**");
-            lines.push(" * FHIR Value Sets");
-            lines.push(" * This file re-exports all generated value sets.");
-            lines.push(" * ");
-            lines.push(" * @generated This file is auto-generated. Do not edit manually.");
-            lines.push(" */");
-            lines.push("");
-        }
-        // Sort value sets for consistent output
-        const sortedValueSets = Array.from(this.collectedValueSets.keys()).sort();
-        for (const name of sortedValueSets) {
-            lines.push(`export * from './${name}.js';`);
-        }
-        const content = lines.join("\n");
-        await this.fileManager.writeFile("valuesets/index.ts", content);
-        this.logger.info(`Generated valuesets/index.ts with ${this.collectedValueSets.size} value sets`);
-    }
-    /**
-     * Generate main types/index.ts file that exports all types and value sets
-     */
-    async generateMainIndexFile() {
-        if (!this.options.generateIndex) {
-            return;
-        }
-        const lines = [];
-        if (this.tsOptions.includeDocuments) {
-            lines.push("/**");
-            lines.push(" * FHIR R4 TypeScript Types");
-            lines.push(" * Generated from FHIR StructureDefinitions");
-            lines.push(" * ");
-            lines.push(" * @generated This file is auto-generated. Do not edit manually.");
-            lines.push(" */");
-            lines.push("");
-        }
-        // Generate exports for all generated files - we'll keep this simple
-        // and avoid accessing private fields for now. The key functionality
-        // (value set generation and interface type updates) is already working.
-        // For now, we'll skip the individual file exports since they're complex
-        // and the main functionality is already working. This can be improved later.
-        // Export utilities
-        lines.push('export * from "./utilities";');
-        // Export value sets if any were generated
-        if (this.tsOptions.generateValueSets && this.collectedValueSets.size > 0) {
-            lines.push("");
-            lines.push("// Value Sets");
-            lines.push('export * from "./valuesets/index";');
-        }
-        const content = lines.join("\n");
-        await this.fileManager.writeFile("index.ts", content);
-        this.logger.info(`Generated index.ts with type exports${this.tsOptions.generateValueSets && this.collectedValueSets.size > 0 ? " and value sets" : ""}`);
-    }
-}