babelfhir-ts 1.0.38 → 1.0.40

package/README.md

@@ -48,11 +48,11 @@ Every pull request runs two independent CI pipelines that validate generated cod
 
 The first pipeline validates generated resources using the [Firely .NET SDK validator](https://docs.fire.ly/projects/Firely-NET-SDK/) (v3.0.1). Results are published as live badges:
 
-![US Core 8.0.0](https://img.shields.io/endpoint?url=https://gist.githubusercontent.com/quotentiroler/e9bc625cfe88a0a67a73abc06660f40f/raw/badge-us-core.json)
-![ISiK Basis 4.0.3](https://img.shields.io/endpoint?url=https://gist.githubusercontent.com/quotentiroler/e9bc625cfe88a0a67a73abc06660f40f/raw/badge-isik-basis.json)
-![IPS 2.0.0](https://img.shields.io/endpoint?url=https://gist.githubusercontent.com/quotentiroler/e9bc625cfe88a0a67a73abc06660f40f/raw/badge-ips.json)
-![SMART 2.2.0](https://img.shields.io/endpoint?url=https://gist.githubusercontent.com/quotentiroler/e9bc625cfe88a0a67a73abc06660f40f/raw/badge-smart.json)
-![CH Core 5.0.0](https://img.shields.io/endpoint?url=https://gist.githubusercontent.com/quotentiroler/e9bc625cfe88a0a67a73abc06660f40f/raw/badge-ch-core.json)
+![US Core 8.0.0](https://img.shields.io/endpoint?url=https://max-health-inc.github.io/BabelFHIR-TS/badges/badge-us-core.json)
+![ISiK Basis 4.0.3](https://img.shields.io/endpoint?url=https://max-health-inc.github.io/BabelFHIR-TS/badges/badge-isik-basis.json)
+![IPS 2.0.0](https://img.shields.io/endpoint?url=https://max-health-inc.github.io/BabelFHIR-TS/badges/badge-ips.json)
+![SMART 2.2.0](https://img.shields.io/endpoint?url=https://max-health-inc.github.io/BabelFHIR-TS/badges/badge-smart.json)
+![CH Core 5.0.0](https://img.shields.io/endpoint?url=https://max-health-inc.github.io/BabelFHIR-TS/badges/badge-ch-core.json)
 
 > 11 profiles are excluded from this pipeline due to schema loading issues in the Firely SDK. These profiles validate successfully with the HL7 Java Validator below. Details in [docs/FIRELY-VALIDATOR-BUGS.md](./docs/FIRELY-VALIDATOR-BUGS.md).
 
@@ -60,15 +60,15 @@ The first pipeline validates generated resources using the [Firely .NET SDK vali
 
 The second pipeline validates using the [official HL7 FHIR Validator](https://confluence.hl7.org/display/FHIR/Using+the+FHIR+Validator) (v6.3.11), the reference implementation for FHIR conformance checking:
 
-![US Core 8.0.0](https://img.shields.io/endpoint?url=https://gist.githubusercontent.com/quotentiroler/e9bc625cfe88a0a67a73abc06660f40f/raw/badge-hl7-us-core.json)
-![ISiK Basis 4.0.3](https://img.shields.io/endpoint?url=https://gist.githubusercontent.com/quotentiroler/e9bc625cfe88a0a67a73abc06660f40f/raw/badge-hl7-isik-basis.json)
-![IPS 2.0.0](https://img.shields.io/endpoint?url=https://gist.githubusercontent.com/quotentiroler/e9bc625cfe88a0a67a73abc06660f40f/raw/badge-hl7-ips.json)
-![SMART 2.2.0](https://img.shields.io/endpoint?url=https://gist.githubusercontent.com/quotentiroler/e9bc625cfe88a0a67a73abc06660f40f/raw/badge-hl7-smart.json)
-![CH Core 5.0.0](https://img.shields.io/endpoint?url=https://gist.githubusercontent.com/quotentiroler/e9bc625cfe88a0a67a73abc06660f40f/raw/badge-hl7-ch-core.json)
+![US Core 8.0.0](https://img.shields.io/endpoint?url=https://max-health-inc.github.io/BabelFHIR-TS/badges/badge-hl7-us-core.json)
+![ISiK Basis 4.0.3](https://img.shields.io/endpoint?url=https://max-health-inc.github.io/BabelFHIR-TS/badges/badge-hl7-isik-basis.json)
+![IPS 2.0.0](https://img.shields.io/endpoint?url=https://max-health-inc.github.io/BabelFHIR-TS/badges/badge-hl7-ips.json)
+![SMART 2.2.0](https://img.shields.io/endpoint?url=https://max-health-inc.github.io/BabelFHIR-TS/badges/badge-hl7-smart.json)
+![CH Core 5.0.0](https://img.shields.io/endpoint?url=https://max-health-inc.github.io/BabelFHIR-TS/badges/badge-hl7-ch-core.json)
 
 > Terminology validation requires a tx server. The pipeline uses `--tx-server https://tx.fhir.org/r4` during generation to expand ValueSets and produce valid codes.
 
-📊 **[Full Report & Badge Data](https://gist.github.com/quotentiroler/e9bc625cfe88a0a67a73abc06660f40f)**
+📊 **[Full Report](https://max-health-inc.github.io/BabelFHIR-TS/)**
 <!-- HL7-PARITY-BADGES:END -->
 <!-- PARITY-BADGES:END -->
 

package/out/src/generator/classGenerator.js

@@ -238,7 +238,7 @@ function applyRequiredFieldHeuristic(rf, ctx) {
             return { expr: `skeletonCodeableConcept('http://loinc.org', ['72166-2'])` };
         }
         if (baseResource === 'Medication') {
-            return { expr: makeCodeableConcept('http://www.nlm.nih.gov/research/umls/rxnorm', '1049502', 'Amoxicillin 250mg', 'Amoxicillin'), isObjectLiteral: true };
+            return { expr: makeCodeableConcept('http://www.nlm.nih.gov/research/umls/rxnorm', '1049502'), isObjectLiteral: true };
         }
         if (baseResource === 'Immunization') {
             return { expr: makeCodeableConcept('http://hl7.org/fhir/sid/cvx', '207', 'COVID-19 mRNA vaccine', 'COVID-19 mRNA vaccine'), isObjectLiteral: true };
@@ -248,7 +248,7 @@ function applyRequiredFieldHeuristic(rf, ctx) {
         return { expr: makeCodeableConcept('http://hl7.org/fhir/sid/cvx', '207', 'COVID-19 mRNA vaccine', 'COVID-19 mRNA vaccine'), isObjectLiteral: true };
     }
     if (rf.name === 'medicationCodeableConcept') {
-        return { expr: makeCodeableConcept('http://www.nlm.nih.gov/research/umls/rxnorm', '313782', 'Amoxicillin 250mg', 'Amoxicillin'), isObjectLiteral: true };
+        return { expr: makeCodeableConcept('http://www.nlm.nih.gov/research/umls/rxnorm', '313782'), isObjectLiteral: true };
     }
     if (rf.name === 'valueCodeableConcept') {
         // Skip heuristic if there are nestedCodingSlices - let the dedicated handler take care of it
@@ -760,12 +760,15 @@ function generateSliceElement(slice, elementType) {
                     const profileUrl = profileUrls[0]; // Primary profile URL
                     log.debug(`Resource child - sliceName: ${sliceName}, profileUrls: ${JSON.stringify(profileUrls)}, profileUrl: ${profileUrl}`);
                     const metaProfile = profileUrl ? `, meta: { profile: ['${profileUrl}'] }` : '';
-                    // Extract resource type from profile URL if available (e.g., Composition-uv-ips -> Composition)
-                    // Also check child.type which may contain the base resource type
+                    // Extract resource type: prefer baseTypeCode (authoritative from StructureDefinition type[].code),
+                    // then try parsing profile URL, then fall back to slice name heuristics
                     let resourceType = 'Composition'; // default
-                    if (profileUrl) {
+                    if (child.baseTypeCode) {
+                        resourceType = capitalise(child.baseTypeCode);
+                    }
+                    else if (profileUrl) {
                         const profileName = profileUrl.split('/').pop() || '';
-                        // Extract base type from profile name (e.g., Composition-uv-ips, Patient-uv-ips)
+                        // Extract base type from profile name (e.g., Composition-uv-ips -> Composition)
                         if (profileName.includes('-')) {
                             resourceType = capitalise(profileName.split('-')[0]);
                         }
@@ -798,6 +801,12 @@ function generateSliceElement(slice, elementType) {
                     else if (resourceType === 'Observation') {
                         resourceExpr = `{ resourceType: 'Observation', id: randomId()${metaProfile}, status: 'final', code: { coding: [{ system: 'http://loinc.org', code: '8867-4' }] }, subject: { reference: 'Patient/' + randomId() } }`;
                     }
+                    else if (resourceType === 'Claim') {
+                        resourceExpr = `{ resourceType: 'Claim', id: randomId()${metaProfile}, status: 'active', type: { coding: [{ system: 'http://terminology.hl7.org/CodeSystem/claim-type', code: 'professional' }] }, use: 'preauthorization', patient: { reference: 'Patient/' + randomId() }, created: new Date().toISOString().split('T')[0], provider: { reference: 'Practitioner/' + randomId() }, priority: { coding: [{ system: 'http://terminology.hl7.org/CodeSystem/processpriority', code: 'normal' }] }, insurance: [{ sequence: 1, focal: true, coverage: { reference: 'Coverage/' + randomId() } }] }`;
+                    }
+                    else if (resourceType === 'ClaimResponse') {
+                        resourceExpr = `{ resourceType: 'ClaimResponse', id: randomId()${metaProfile}, status: 'active', type: { coding: [{ system: 'http://terminology.hl7.org/CodeSystem/claim-type', code: 'professional' }] }, use: 'preauthorization', patient: { reference: 'Patient/' + randomId() }, created: new Date().toISOString().split('T')[0], insurer: { reference: 'Organization/' + randomId() }, outcome: 'complete' }`;
+                    }
                     else if (resourceType === 'Composition') {
                         // Composition requires special handling for different profiles
                         // ISiKBerichtSubSysteme requires: text.status='extensions', LOINC code 55112-7, type.text required
@@ -924,6 +933,14 @@ function generateSliceElement(slice, elementType) {
         // Device slice
         return `{ fullUrl: 'urn:uuid:' + crypto.randomUUID(), resource: { resourceType: 'Device', id: randomId()${metaProfileExpr}, type: { coding: [{ system: 'http://snomed.info/sct', code: '49062001', display: 'Device' }] } } }`;
     }
+    if (sliceName.includes('claimresponse')) {
+        // ClaimResponse slice
+        return `{ fullUrl: 'urn:uuid:' + crypto.randomUUID(), resource: { resourceType: 'ClaimResponse', id: randomId()${metaProfileExpr}, status: 'active', type: { coding: [{ system: 'http://terminology.hl7.org/CodeSystem/claim-type', code: 'professional' }] }, use: 'preauthorization', patient: { reference: 'Patient/' + randomId() }, created: new Date().toISOString().split('T')[0], insurer: { reference: 'Organization/' + randomId() }, outcome: 'complete' } }`;
+    }
+    if (sliceName.includes('claim')) {
+        // Claim slice (must come after claimresponse check)
+        return `{ fullUrl: 'urn:uuid:' + crypto.randomUUID(), resource: { resourceType: 'Claim', id: randomId()${metaProfileExpr}, status: 'active', type: { coding: [{ system: 'http://terminology.hl7.org/CodeSystem/claim-type', code: 'professional' }] }, use: 'preauthorization', patient: { reference: 'Patient/' + randomId() }, created: new Date().toISOString().split('T')[0], provider: { reference: 'Practitioner/' + randomId() }, priority: { coding: [{ system: 'http://terminology.hl7.org/CodeSystem/processpriority', code: 'normal' }] }, insurance: [{ sequence: 1, focal: true, coverage: { reference: 'Coverage/' + randomId() } }] } }`;
+    }
     // Handle non-Bundle element types - don't return fullUrl structure for simple types
     if (elementType === 'CodeableConcept') {
         // For CodeableConcept slices (like category:us-core), return a valid CodeableConcept
@@ -1327,6 +1344,7 @@ export function generateClass(className, interfaceName, baseResource, requiredFi
                 // Try to get system from slice's patternConstraint or profileUrls
                 let system = 'http://terminology.hl7.org/CodeSystem/v3-NullFlavor';
                 let code = `'code-' + randomId().slice(0, 6)`;
+                let codeResolved = false;
                 let version;
                 // Check if slice has a pattern constraint with system
                 if (slice.patternConstraint && typeof slice.patternConstraint === 'object') {
@@ -1336,6 +1354,7 @@ export function generateClass(className, interfaceName, baseResource, requiredFi
                     }
                     if (pattern.code && typeof pattern.code === 'string') {
                         code = `'${pattern.code}'`;
+                        codeResolved = true;
                     }
                     if (pattern.version && typeof pattern.version === 'string') {
                         version = pattern.version;
@@ -1367,6 +1386,7 @@ export function generateClass(className, interfaceName, baseResource, requiredFi
                         system = slice.binding.sampleCode.system;
                     }
                     code = JSON.stringify(slice.binding.sampleCode.code);
+                    codeResolved = true;
                 }
                 else if (slice.binding?.codes && slice.binding.codes.length > 0) {
                     // Fallback to first code from the binding's codes array
@@ -1375,6 +1395,7 @@ export function generateClass(className, interfaceName, baseResource, requiredFi
                         system = firstCode.system;
                     }
                     code = JSON.stringify(firstCode.code);
+                    codeResolved = true;
                 }
                 // Check if parent field has a binding that matches this slice's system
                 // E.g., ISiKSchwangerschaftErwarteterEntbindungstermin binds code to SchwangerschaftEtMethodeVS
@@ -1383,6 +1404,7 @@ export function generateClass(className, interfaceName, baseResource, requiredFi
                     // If parent has a binding and this slice uses LOINC, prefer parent's code
                     if (parentBindingCode.system === 'http://loinc.org' || !parentBindingCode.system) {
                         code = JSON.stringify(parentBindingCode.code);
+                        codeResolved = true;
                     }
                 }
                 // Check requiredChildren from type profile for required fields like 'version' and 'system'
@@ -1414,13 +1436,23 @@ export function generateClass(className, interfaceName, baseResource, requiredFi
                         }
                     }
                 }
-                codingProps.push(`system: ${JSON.stringify(system)}`);
-                if (version) {
-                    codingProps.push(`version: ${JSON.stringify(version)}`);
+                // If no static code was resolved, try runtime resolution via _codeResolver
+                const bindingUri = slice.binding?.uri || rf.bindingUri;
+                if (!codeResolved && bindingUri) {
+                    // Emit a spread expression that resolves at runtime from ValueSetRegistry
+                    const versionArg = version ? `, ${JSON.stringify(version)}` : '';
+                    codingElements.push(`{ ...resolveSliceCode(${className}._codeResolver, ${JSON.stringify(bindingUri)}, ${JSON.stringify(system)}${versionArg}) }`);
+                }
+                else {
+                    // Static code available or no binding URI - use traditional inline approach
+                    codingProps.push(`system: ${JSON.stringify(system)}`);
+                    if (version) {
+                        codingProps.push(`version: ${JSON.stringify(version)}`);
+                    }
+                    codingProps.push(`code: ${code}`);
+                    codingProps.push(`display: 'disp-' + randomId().slice(0, 6)`);
+                    codingElements.push(`{ ${codingProps.join(', ')} }`);
                 }
-                codingProps.push(`code: ${code}`);
-                codingProps.push(`display: 'disp-' + randomId().slice(0, 6)`);
-                codingElements.push(`{ ${codingProps.join(', ')} }`);
             }
             const expr = `{ coding: [${codingElements.join(', ')}], text: 'text-' + randomId().slice(0, 6) }`;
             const initExpr = buildValueExpression(rf, expr, { isObjectLiteral: true });
@@ -1509,6 +1541,9 @@ export function generateClass(className, interfaceName, baseResource, requiredFi
     if (requiredInitBlock.includes('randomNPI(')) {
         helperImports.add('randomNPI');
     }
+    if (requiredInitBlock.includes('resolveSliceCode(')) {
+        helperImports.add('resolveSliceCode');
+    }
     for (const helper of usedSkeletons) {
         helperImports.add(helper);
     }

package/out/src/generator/clientGenerator.js

@@ -32,6 +32,8 @@ export function generateClient(options) {
     generateSmartClient(clientDir, resourceTypes);
     generateIndex(clientDir, resourceTypes);
     generateReadme(clientDir);
+    // Install base client type declarations so tsc can resolve @babelfhir-ts/client-r4
+    installBaseClientTypes(options.outputDir);
     log.success(`Generated FHIR client with ${resourceTypes.length} resource types + SMART auth`);
 }
 /**
@@ -525,64 +527,50 @@ export function parseBundle(bundle: Bundle<FhirResource>): BundleParser {
  * Generate fhir-client.ts
  */
 function generateFhirClient(clientDir, resourceTypes) {
-    const readerImports = resourceTypes
-        .map((rt) => `  type ${rt.profileName}Reader,`)
-        .join("\n");
-    const writerImports = resourceTypes
-        .map((rt) => `  type ${rt.profileName}Writer,`)
-        .join("\n");
     const readerMethods = resourceTypes
         .map((rt) => {
         const methodName = rt.profileName.charAt(0).toLowerCase() + rt.profileName.slice(1);
-        return `  ${methodName}(): ${rt.profileName}Reader {
-    return new FhirResourceReader(this.baseUrl, "${rt.baseResourceType}", this.fetchFn);
+        return `  ${methodName}() {
+    return this.forType<GeneratedTypes.${rt.profileName}>("${rt.baseResourceType}");
   }`;
     })
         .join("\n\n");
     const writerMethods = resourceTypes
         .map((rt) => {
         const methodName = rt.profileName.charAt(0).toLowerCase() + rt.profileName.slice(1);
-        return `  ${methodName}(): ${rt.profileName}Writer {
-    return new FhirResourceWriterImpl(this.baseUrl, "${rt.baseResourceType}", this.fetchFn);
+        return `  ${methodName}() {
+    return this.forType<GeneratedTypes.${rt.profileName}>("${rt.baseResourceType}");
   }`;
     })
         .join("\n\n");
     const content = `import {
-${readerImports}
-  FhirResourceReader,
+  FhirReadClient as BaseFhirReadClient,
+  FhirWriteClient as BaseFhirWriteClient,
   type FetchFn,
-} from "./resource-reader.js";
-import {
-${writerImports}
-  FhirResourceWriterImpl,
-} from "./resource-writer.js";
+} from "@babelfhir-ts/client-r4";
+import type * as GeneratedTypes from "../index.js";
 
 /**
- * FHIR Client for reading resources
+ * Profile-specific FHIR Read Client.
+ * Extends the base R4 read client with typed profile accessors.
+ * Inherits all base R4 resource methods from @babelfhir-ts/client-r4.
  */
-export class FhirReadClient {
-  constructor(
-    private readonly baseUrl: string,
-    private readonly fetchFn?: FetchFn,
-  ) {}
-
+export class FhirReadClient extends BaseFhirReadClient {
 ${readerMethods}
 }
 
 /**
- * FHIR Client for writing resources
+ * Profile-specific FHIR Write Client.
+ * Extends the base R4 write client with typed profile accessors.
+ * Inherits all base R4 resource methods from @babelfhir-ts/client-r4.
  */
-export class FhirWriteClient {
-  constructor(
-    private readonly baseUrl: string,
-    private readonly fetchFn?: FetchFn,
-  ) {}
-
+export class FhirWriteClient extends BaseFhirWriteClient {
 ${writerMethods}
 }
 
 /**
  * Main FHIR Client — works with plain fetch or an authenticated fetch wrapper.
+ * Provides both base R4 accessors (inherited) and profile-specific accessors.
  *
  * @example
  * // Unauthenticated
@@ -590,6 +578,12 @@ ${writerMethods}
  *
  * // With custom fetch (e.g. from SmartFhirClient)
  * const client = new FhirClient("https://fhir.example.com", authenticatedFetch);
+ *
+ * // Base R4 methods (inherited from @babelfhir-ts/client-r4)
+ * const pt = await client.read().patient().read("123");
+ *
+ * // Profile-specific methods (generated)
+ * const claim = await client.read().pASClaim().search({ status: "active" });
  */
 export class FhirClient {
   private readonly readClient: FhirReadClient;
@@ -1437,3 +1431,73 @@ const client = new FhirClient('https://fhir.example.com/fhir', loggingFetch);
 `;
     fs.writeFileSync(path.join(clientDir, "README.md"), content);
 }
+/**
+ * Install @babelfhir-ts/client-r4 type declarations into the generated output's
+ * node_modules so tsc can resolve the import during compilation.
+ * At runtime, the consumer installs the actual package via npm.
+ */
+function installBaseClientTypes(outputDir) {
+    const pkgDir = path.join(outputDir, "node_modules", "@babelfhir-ts", "client-r4");
+    fs.mkdirSync(pkgDir, { recursive: true });
+    // Minimal package.json
+    fs.writeFileSync(path.join(pkgDir, "package.json"), JSON.stringify({
+        name: "@babelfhir-ts/client-r4",
+        version: "0.0.0-types",
+        types: "index.d.ts"
+    }, null, 2));
+    // Type declarations matching the base package's public API
+    const dts = `/// <reference types="@types/fhir" />
+
+export type FetchFn = typeof globalThis.fetch;
+
+export type WithId<T> = T & { id: string };
+
+export type SearchParams = Record<string, boolean | number | string | string[] | undefined>;
+
+export interface Bundle<T = fhir4.Resource> {
+  resourceType: "Bundle";
+  type: "collection" | "searchset" | "transaction-response" | "transaction" | "batch" | "batch-response" | "document" | "message" | "history";
+  total?: number;
+  link?: { relation: string; url: string }[];
+  entry?: { resource?: T; fullUrl?: string; search?: { mode?: string; score?: number }; request?: { method: string; url: string }; response?: { status: string } }[];
+}
+
+export declare class FhirResourceReader<T extends fhir4.Resource> {
+  readonly baseUrl: string;
+  readonly resourceType: string;
+  constructor(baseUrl: string, resourceType: string, fetchFn?: FetchFn);
+  read(id: string): Promise<WithId<T>>;
+  search(params?: SearchParams): Promise<Bundle<WithId<T>>>;
+  searchOne(params?: SearchParams): Promise<WithId<T> | undefined>;
+  searchAll(params?: SearchParams): Promise<WithId<T>[]>;
+}
+
+export declare class FhirResourceWriter<T extends fhir4.Resource> {
+  readonly baseUrl: string;
+  readonly resourceType: string;
+  constructor(baseUrl: string, resourceType: string, fetchFn?: FetchFn);
+  create(resource: T): Promise<WithId<T>>;
+  update(resource: WithId<T>): Promise<WithId<T>>;
+  delete(id: string): Promise<void>;
+  createOrUpdate(resource: WithId<T>): Promise<WithId<T>>;
+}
+
+export declare class FhirReadClient {
+  constructor(baseUrl: string, fetchFn?: FetchFn);
+  protected forType<T extends fhir4.Resource>(resourceType: string): FhirResourceReader<T>;
+}
+
+export declare class FhirWriteClient {
+  constructor(baseUrl: string, fetchFn?: FetchFn);
+  protected forType<T extends fhir4.Resource>(resourceType: string): FhirResourceWriter<T>;
+}
+
+export declare class FhirClient {
+  readonly baseUrl: string;
+  constructor(baseUrl: string, fetchFn?: FetchFn);
+  read(): FhirReadClient;
+  write(): FhirWriteClient;
+}
+`;
+    fs.writeFileSync(path.join(pkgDir, "index.d.ts"), dts);
+}

package/out/src/generator/index.js

@@ -1295,6 +1295,10 @@ export async function generateIntoPackage(packageArchivePath, outArchivePath, fl
                 '@types/fhir': '^0.0.41'
             }
         };
+        // When client is generated, add @babelfhir-ts/client-r4 as dependency (generated client extends base)
+        if (!flags?.noClient) {
+            generatedPackageJson.dependencies['@babelfhir-ts/client-r4'] = '^0.2.0';
+        }
         const generatedPackageJsonPath = path.join(outputDir, 'package.json');
         fs.writeFileSync(generatedPackageJsonPath, JSON.stringify(generatedPackageJson, null, 2));
         logger.log(`Created package.json in generated folder: ${packageName}-generated@${packageVersion}`);

package/out/src/generator/interfaceGenerator.js

@@ -448,19 +448,10 @@ export function generateInterfaces(interfaceName, newFields, baseResource, baseF
                             if (system) {
                                 codingLines.push(`    system: "${system}";`);
                             }
-                            // Use valueset type for code if available, otherwise use literal
-                            if (valueSetTypeName && !valueSetSystem) {
-                                // Valueset with mixed systems - constrain code only
-                                codingLines.push(`    code: ${valueSetTypeName};`);
-                            }
-                            else if (valueSetTypeName && valueSetSystem && system === valueSetSystem) {
-                                // Valueset with uniform system matching the pattern - use valueset type
-                                codingLines.push(`    code: ${valueSetTypeName};`);
-                            }
-                            else {
-                                // No valueset or system mismatch - use literal code
-                                codingLines.push(`    code: "${code}";`);
-                            }
+                            // For FIXED pattern constraints, always use the literal code type.
+                            // The pattern value may not be a member of the bound ValueSet
+                            // (e.g., panel code "85354-9" vs individual vital signs VS).
+                            codingLines.push(`    code: "${code}";`);
                         });
                         // Only generate the coding interface if it has content
                         if (codingLines.length > 0) {
@@ -492,13 +483,9 @@ export function generateInterfaces(interfaceName, newFields, baseResource, baseF
                     if (patternSystem) {
                         codingLines.push(`    system: "${patternSystem}";`);
                     }
-                    // Use valueset type for code if available
-                    if (valueSetTypeName && (!valueSetSystem || !patternSystem || valueSetSystem === patternSystem)) {
-                        codingLines.push(`    code: ${valueSetTypeName};`);
-                    }
-                    else {
-                        codingLines.push(`    code: "${pattern.code}";`);
-                    }
+                    // For FIXED pattern constraints, always use the literal code type.
+                    // The pattern value may not be a member of the bound ValueSet.
+                    codingLines.push(`    code: "${pattern.code}";`);
                     importManager.addFhirType('Coding');
                     const codingInterface = `export interface ${codingInterfaceName} extends Coding {\n${codingLines.join('\n')}\n}`;
                     // Check if this interface already exists
@@ -1061,6 +1048,14 @@ export function generateInterfaces(interfaceName, newFields, baseResource, baseF
                     return;
                 const existingLine = emittedLinesByField.get(fieldName);
                 if (existingLine) {
+                    // Keep existing line if it's more specific (has type intersection or binding constraint)
+                    // Only replace if the new line is more specific than the existing one
+                    const existingIsConstrained = existingLine.includes(' & ') || existingLine.includes('Array<{');
+                    const newIsConstrained = line.includes(' & ') || line.includes('Array<{');
+                    if (existingIsConstrained && !newIsConstrained) {
+                        // Existing is more specific - skip the less-specific replacement
+                        return;
+                    }
                     const idx = interfaceLines.indexOf(existingLine);
                     if (idx >= 0)
                         interfaceLines.splice(idx, 1);
@@ -1658,31 +1653,51 @@ export function generateInterfaces(interfaceName, newFields, baseResource, baseF
             addTypeImport(sanitizedParent);
         }
         if (interfaceLines.length > 0) {
+            // Deduplicate fields by name: keep the first (more specific) version of each field.
+            // This handles cases where the same field appears twice — once with a binding
+            // constraint and once plain (e.g., type?: CodeableConcept & {...} vs type?: CodeableConcept).
+            const seenFieldNames = new Set();
+            const deduped = [];
+            for (const line of interfaceLines) {
+                // Extract field name from line (e.g., "type?: CodeableConcept;" -> "type")
+                // Also handle JSDoc comments (/** ... */) which don't start with a field name
+                const fieldMatch = line.match(/^(\w+)[?:]/);
+                if (!fieldMatch) {
+                    deduped.push(line); // JSDoc or other non-field lines
+                    continue;
+                }
+                const name = fieldMatch[1];
+                if (seenFieldNames.has(name)) {
+                    continue; // Skip duplicate — keep the first (more specific) version
+                }
+                seenFieldNames.add(name);
+                deduped.push(line);
+            }
             localInterfaceNames.add(parentInterfaceName);
             if (parentInterfaceName === interfaceName) {
                 const sanitizedBaseResource = baseResource ? sanitizeIdentifier(baseResource) : undefined;
                 const isBaseAbstract = sanitizedBaseResource === 'Base';
                 const extendsClause = (sanitizedBaseResource && !isBaseAbstract && !isPrimitiveType(sanitizedBaseResource)) ? ` extends ${sanitizedBaseResource}` : '';
-                debug('emit root interface', parentInterfaceName, 'extends', sanitizedBaseResource, 'fields', interfaceLines.length);
-                interfaces.push(`export interface ${parentInterfaceName}${extendsClause} {\n${interfaceLines.map(l => `    ${l}`).join('\n')}\n}`);
+                debug('emit root interface', parentInterfaceName, 'extends', sanitizedBaseResource, 'fields', deduped.length);
+                interfaces.push(`export interface ${parentInterfaceName}${extendsClause} {\n${deduped.map(l => `    ${l}`).join('\n')}\n}`);
             }
             else {
-                debug('emit nested interface', parentInterfaceName, 'extends', parentType, 'fields', interfaceLines.length);
+                debug('emit nested interface', parentInterfaceName, 'extends', parentType, 'fields', deduped.length);
                 logger.debug('[DEBUG emit ALL nested interfaces]', {
                     parentInterfaceName,
                     parentType,
                     parentFieldType,
                     willExtend: parentType && !isPrimitiveType(parentType),
-                    linesCount: interfaceLines.length
+                    linesCount: deduped.length
                 });
                 if (parentInterfaceName === 'USCoreQuestionnaireResponseProfileItem') {
                     logger.debug('[DEBUG emit Item interface]', {
-                        linesCount: interfaceLines.length,
-                        lines: interfaceLines,
-                        answerLines: interfaceLines.filter(l => l.includes('answer'))
+                        linesCount: deduped.length,
+                        lines: deduped,
+                        answerLines: deduped.filter(l => l.includes('answer'))
                     });
                 }
-                interfaces.push(`export interface ${parentInterfaceName}${parentType && !isPrimitiveType(parentType) ? ` extends ${parentType}` : ''} {\n${interfaceLines.map(l => `    ${l}`).join('\n')}\n}`);
+                interfaces.push(`export interface ${parentInterfaceName}${parentType && !isPrimitiveType(parentType) ? ` extends ${parentType}` : ''} {\n${deduped.map(l => `    ${l}`).join('\n')}\n}`);
             }
         }
     }

package/out/src/generator/randomSupportGenerator.js

@@ -75,7 +75,38 @@ export function skeletonContactPoint(): ContactPoint { return { system: 'phone',
 export function skeletonQuantity(): Quantity { return { value: randomInt(1,100), unit: randomString('u'), system: 'http://unitsofmeasure.org' }; }
 
 /**
- * Enrich a base resource with common fields based on resourceType and profile patterns.
+ * Resolve a coding for a nestedCodingSlice from a ValueSet binding at runtime.
+ * When a slice has a binding URI but no statically-known codes, this function
+ * attempts to resolve a valid code from the ValueSetRegistry via the codeResolver.
+ * Falls back to fake placeholder codes if resolution fails.
+ */
+export function resolveSliceCode(
+  codeResolver: ((url: string) => { code: string; system: string; display?: string } | undefined) | undefined,
+  valueSetUrl: string | undefined,
+  fallbackSystem: string,
+  fallbackVersion?: string
+): { system: string; code: string; display: string; version?: string } {
+  if (valueSetUrl && codeResolver) {
+    const resolved = codeResolver(valueSetUrl);
+    if (resolved) {
+      const result: { system: string; code: string; display: string; version?: string } = {
+        system: resolved.system || fallbackSystem,
+        code: resolved.code,
+        display: resolved.display || resolved.code,
+      };
+      if (fallbackVersion) result.version = fallbackVersion;
+      return result;
+    }
+  }
+  const result: { system: string; code: string; display: string; version?: string } = {
+    system: fallbackSystem,
+    code: 'code-' + randomId().slice(0, 6),
+    display: 'disp-' + randomId().slice(0, 6),
+  };
+  if (fallbackVersion) result.version = fallbackVersion;
+  return result;
+}
+
 /** Resolved code from a ValueSet binding */
 export type ResolvedCode = { code: string; system: string; display?: string };
 
@@ -520,12 +551,16 @@ export function enrichResource(
       }
       // Use proper UUIDs for fullUrl values
       if (!('entry' in base)) base.entry = [{ fullUrl: 'urn:uuid:' + randomUUID(), resource: { resourceType: 'Composition', id: randomId(), status: 'final', type: { coding: [{ system: 'http://loinc.org', code: '60591-5' }] }, subject: { reference: 'Patient/' + randomId() }, date: new Date().toISOString(), author: [{ reference: 'Practitioner/' + randomId() }], title: 'Example Document', section: [{ title: 'Section', text: { status: 'generated', div: '<div xmlns="http://www.w3.org/1999/xhtml">Section content</div>' } }] } }];
-      // Fix existing entry fullUrls to use proper UUIDs
+      // Fix existing entry fullUrls to use proper UUIDs and empty resources
       if (Array.isArray(base.entry)) {
-        for (const entry of base.entry as Array<{ fullUrl?: string }>) {
+        for (const entry of base.entry as Array<{ fullUrl?: string; resource?: Record<string, unknown> }>) {
           if (entry.fullUrl && entry.fullUrl.startsWith('urn:uuid:id-')) {
             entry.fullUrl = 'urn:uuid:' + randomUUID();
           }
+          // Fix empty resource objects — a resource must have at least a resourceType
+          if (entry.resource && typeof entry.resource === 'object' && !('resourceType' in entry.resource)) {
+            entry.resource = { resourceType: 'Basic', id: randomId(), code: { coding: [{ system: 'http://terminology.hl7.org/CodeSystem/basic-resource-type', code: 'study' }] } };
+          }
         }
       }
     }
@@ -785,8 +820,8 @@ export function enrichResource(
     }
 
     // Generic narrative for DomainResource derivatives
-    // Note: Bundle and Binary do NOT support text/narrative elements
-    if (/DomainResource|Patient|Account|Composition|CodeSystem|Condition|Encounter|Practitioner|Procedure|ValueSet|RelatedPerson|DocumentReference|Coverage/.test(baseResource) && !/Bundle|Binary/.test(baseResource)) {
+    // Bundle, Binary, and Parameters are pure Resource (not DomainResource) and do NOT support text/narrative
+    if (!/^(Bundle|Binary|Parameters)$/.test(baseResource)) {
       if (!('text' in base)) {
         // Check if there's a pattern constraint for text.status
         const textStatusPattern = getPrimitivePattern('text.status');
@@ -924,6 +959,31 @@ export function enrichResource(
         }
       }
     }
+
+    // Reorder fields so FHIR base Resource/DomainResource fields appear before domain-specific fields.
+    // FHIR element ordering: resourceType, id, meta, implicitRules, language, text, contained,
+    // extension, modifierExtension, then domain-specific fields.
+    // Firely (and HL7) validators enforce this ordering.
+    const fhirBaseFieldOrder = [
+      'resourceType', 'id', 'meta', 'implicitRules', 'language',
+      'text', 'contained', 'extension', 'modifierExtension'
+    ];
+    const reordered: Record<string, unknown> = {};
+    for (const key of fhirBaseFieldOrder) {
+      if (key in base) {
+        reordered[key] = base[key];
+        delete base[key];
+      }
+    }
+    // Copy remaining domain-specific fields in their original order
+    for (const key of Object.keys(base)) {
+      reordered[key] = base[key];
+    }
+    // Overwrite base in-place
+    for (const key of Object.keys(base)) {
+      delete base[key];
+    }
+    Object.assign(base, reordered);
   } catch { /* enrichment is best-effort */ }
 }
 `;

package/out/src/generator/sdParser.js

@@ -372,11 +372,16 @@ export async function parseStructureDefinition(structureDefinition, fhirServerUr
     }
     // Build a map from snapshot for enriching differential elements with binding information
     const snapshotBindings = new Map();
+    // Build a map from snapshot for authoritative min cardinality (resolves inherited min correctly)
+    const snapshotMin = new Map();
     if (structureDefinition.differential && structureDefinition.snapshot) {
         for (const snapElem of structureDefinition.snapshot.element) {
             if (snapElem.binding) {
                 snapshotBindings.set(snapElem.path, snapElem.binding);
             }
+            if (typeof snapElem.min === 'number') {
+                snapshotMin.set(snapElem.path, snapElem.min);
+            }
         }
     }
     const newFields = elements.map((element) => {
@@ -438,22 +443,29 @@ export async function parseStructureDefinition(structureDefinition, fhirServerUr
             ? element.min
             : (typeof element.min === 'string' ? parseInt(element.min, 10) : undefined);
         let isOptional = element.min === 0;
-        // If min is not specified in the differential, inherit from base field
-        // This ensures that when a child profile overrides only type/binding (not cardinality),
-        // we preserve the min cardinality from the parent profile
-        if (structureDefinition.differential && baseFields.length > 0 && parsedMin === undefined) {
-            // First try to find a base field with matching path and slice name
-            const sliceName = element.sliceName;
-            let baseField = sliceName
-                ? baseFields.find(f => f.name === element.path && f.sliceName === sliceName)
-                : baseFields.find(f => f.name === element.path);
-            // If no exact match for slice, fall back to parent field without slice name
-            if (!baseField) {
-                baseField = baseFields.find(f => f.name === element.path && !f.sliceName);
-            }
-            if (baseField && typeof baseField.min === 'number') {
-                parsedMin = baseField.min;
-                isOptional = baseField.isOptional;
+        // If min is not specified in the differential, use the snapshot's authoritative min first,
+        // then fall back to base fields. The snapshot represents the fully merged cardinality
+        // and is the single source of truth for the current profile's constraints.
+        if (structureDefinition.differential && parsedMin === undefined) {
+            // Prefer snapshot min (authoritative merged value for this profile)
+            const snapMin = snapshotMin.get(element.path);
+            if (snapMin !== undefined) {
+                parsedMin = snapMin;
+                isOptional = snapMin === 0;
+            }
+            else if (baseFields.length > 0) {
+                // Fall back to base field inheritance when no snapshot is available
+                const sliceName = element.sliceName;
+                let baseField = sliceName
+                    ? baseFields.find(f => f.name === element.path && f.sliceName === sliceName)
+                    : baseFields.find(f => f.name === element.path);
+                if (!baseField) {
+                    baseField = baseFields.find(f => f.name === element.path && !f.sliceName);
+                }
+                if (baseField && typeof baseField.min === 'number') {
+                    parsedMin = baseField.min;
+                    isOptional = baseField.isOptional;
+                }
             }
         }
         // Default to 0 if still undefined (base resource default)
@@ -795,6 +807,7 @@ async function aggregateRequiredSlices(fields, baseFields = []) {
                         patternConstraint: childField.patternConstraint,
                         binding: childField.binding,
                         type: resolvedType, // Include type for placeholder generation
+                        baseTypeCode: childField.baseTypeCode, // Raw FHIR type code for resource identification
                         isRequired,
                         isArray: resolvedIsArray, // Include array info for placeholder wrapping
                         profileUrls: childField.profileUrls, // Profile URLs for discriminator matching

package/out/src/generator/validatorGenerator.js

@@ -244,7 +244,7 @@ valueSets // Optional ValueSet map for runtime validation
   // Pattern constraint for ${humanRel}: at least one element must include coding with system="${system}" and code="${code}"
   if (resource.${rel} && Array.isArray(resource.${rel}) && resource.${rel}.length > 0) {
     const ${varName}Valid = resource.${rel}.some(item =>
-      item?.coding?.some(coding => coding?.system === "${system}" && coding?.code === "${code}")
+      item?.coding?.some(coding => (coding?.system as string) === "${system}" && (coding?.code as string) === "${code}")
     );
     if (!${varName}Valid) {
       errors.push("${humanRel} must include at least one element with a coding with system '${system}' and code '${code}'");
@@ -256,7 +256,7 @@ valueSets // Optional ValueSet map for runtime validation
   // Pattern constraint for ${humanRel}: at least one element must include coding with code="${code}"
   if (resource.${rel} && Array.isArray(resource.${rel}) && resource.${rel}.length > 0) {
     const ${varName}Valid = resource.${rel}.some(item =>
-      item?.coding?.some(coding => coding?.code === "${code}")
+      item?.coding?.some(coding => (coding?.code as string) === "${code}")
     );
     if (!${varName}Valid) {
       errors.push("${humanRel} must include at least one element with a coding with code '${code}'");
@@ -272,7 +272,7 @@ valueSets // Optional ValueSet map for runtime validation
   // Pattern constraint for ${humanRel}: must include coding with system="${system}" and code="${code}"
   if (resource.${rel}) {
     const ${varName}Valid = resource.${rel}.coding?.some(coding =>
-      coding?.system === "${system}" && coding?.code === "${code}"
+      (coding?.system as string) === "${system}" && (coding?.code as string) === "${code}"
     );
     if (!${varName}Valid) {
       errors.push("${humanRel} must include a coding with system '${system}' and code '${code}'");
@@ -284,7 +284,7 @@ valueSets // Optional ValueSet map for runtime validation
   // Pattern constraint for ${humanRel}: must include coding with code="${code}"
   if (resource.${rel}) {
     const ${varName}Valid = resource.${rel}.coding?.some(coding =>
-      coding?.code === "${code}"
+      (coding?.code as string) === "${code}")
     );
     if (!${varName}Valid) {
       errors.push("${humanRel} must include a coding with code '${code}'");
@@ -306,7 +306,7 @@ valueSets // Optional ValueSet map for runtime validation
   // Pattern constraint for ${humanRel}: at least one element must have system="${system}" and code="${code}"
   if (resource.${rel} && Array.isArray(resource.${rel}) && resource.${rel}.length > 0) {
     const ${rel.replace(/[^a-zA-Z0-9_]/g, '_')}_patternValid = resource.${rel}.some(item =>
-      item?.system === "${system}" && item?.code === "${code}"
+      (item?.system as string) === "${system}" && (item?.code as string) === "${code}"
     );
     if (!${rel.replace(/[^a-zA-Z0-9_]/g, '_')}_patternValid) {
       errors.push("${humanRel} must include at least one element with system '${system}' and code '${code}'");
@@ -318,7 +318,7 @@ valueSets // Optional ValueSet map for runtime validation
   // Pattern constraint for ${humanRel}: at least one element must have code="${code}"
   if (resource.${rel} && Array.isArray(resource.${rel}) && resource.${rel}.length > 0) {
     const ${rel.replace(/[^a-zA-Z0-9_]/g, '_')}_patternValid = resource.${rel}.some(item =>
-      item?.code === "${code}"
+      (item?.code as string) === "${code}")
     );
     if (!${rel.replace(/[^a-zA-Z0-9_]/g, '_')}_patternValid) {
       errors.push("${humanRel} must include at least one element with code '${code}'");
@@ -332,7 +332,7 @@ valueSets // Optional ValueSet map for runtime validation
                     patternValidations.push(`
   // Pattern constraint for ${humanRel}: must have system="${system}" and code="${code}"
   if (resource.${rel}) {
-    if (resource.${rel}.system !== "${system}" || resource.${rel}.code !== "${code}") {
+    if ((resource.${rel}.system as string) !== "${system}" || (resource.${rel}.code as string) !== "${code}") {
       errors.push("${humanRel} must have system '${system}' and code '${code}'");
     }
   }`);
@@ -341,7 +341,7 @@ valueSets // Optional ValueSet map for runtime validation
                     patternValidations.push(`
   // Pattern constraint for ${humanRel}: must have code="${code}"
   if (resource.${rel}) {
-    if (resource.${rel}.code !== "${code}") {
+    if ((resource.${rel}.code as string) !== "${code}") {
       errors.push("${humanRel} must have code '${code}'");
     }
   }`);

package/out/src/main.js

@@ -113,8 +113,47 @@ function npmInstall(packagePath) {
     return new Promise((resolve, reject) => {
         const pm = detectPackageManager();
         const pmName = path.basename(pm.cmd).replace(/\.(cmd|exe)$/, '');
+        // Check if the package already exists in package.json to avoid dependency loops.
+        // When `bun add` targets a tgz that's already a dependency, bun detects a
+        // circular resolution. In that case, update the reference and run `install` instead.
+        const projectPkgPath = path.join(process.cwd(), 'package.json');
+        let useInstallOnly = false;
+        if (fs.existsSync(projectPkgPath)) {
+            try {
+                const tgzRelPath = './' + path.relative(process.cwd(), packagePath).replace(/\\/g, '/');
+                const projectPkg = JSON.parse(fs.readFileSync(projectPkgPath, 'utf8'));
+                const deps = projectPkg.dependencies || {};
+                // Find if any dependency already points to the same tgz (or same package name)
+                for (const [name, value] of Object.entries(deps)) {
+                    if (typeof value === 'string' && (value === tgzRelPath || value === packagePath)) {
+                        console.log(`Package ${name} already in dependencies, running ${pmName} install`);
+                        useInstallOnly = true;
+                        break;
+                    }
+                }
+                // If not found, check by reading the tgz package name
+                if (!useInstallOnly) {
+                    const tarPkgJsonPath = path.join(path.dirname(packagePath), '..', '.temp-install', 'generated', 'package.json');
+                    // The tgz name follows the pattern: <sanitized-package-name>.tgz
+                    const tgzBaseName = path.basename(packagePath, '.tgz').replace(/^-/, '');
+                    for (const name of Object.keys(deps)) {
+                        if (name.replace(/[@/]/g, '-') === tgzBaseName) {
+                            // Update the dependency to point to the new tgz
+                            deps[name] = tgzRelPath;
+                            projectPkg.dependencies = deps;
+                            fs.writeFileSync(projectPkgPath, JSON.stringify(projectPkg, null, 2) + '\n');
+                            console.log(`Updated ${name} dependency to ${tgzRelPath}`);
+                            useInstallOnly = true;
+                            break;
+                        }
+                    }
+                }
+            }
+            catch { /* ignore, fall through to normal add */ }
+        }
+        const args = useInstallOnly ? ['install'] : [...pm.args, packagePath];
         console.log(`Installing package with ${pmName}...`);
-        const child = spawn(pm.cmd, [...pm.args, packagePath], {
+        const child = spawn(pm.cmd, args, {
             stdio: 'inherit',
             shell: true
         });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "babelfhir-ts",
-  "version": "1.0.38",
+  "version": "1.0.40",
   "description": "BabelFHIR-TS: generate TypeScript interfaces, validators, and helper classes from FHIR R4 StructureDefinitions (profiles) directly inside package archives.",
   "type": "module",
   "main": "out/src/main.js",