TypeScript generator does not emit SimpleQuantity (constrained Quantity)

[bkaney]

Summary

The TypeScript generator is not emitting a type for SimpleQuantity. This appears to be because SimpleQuantity is represented as a constraint on Quantity rather than as a full standalone type in the same way other specializations are.

Other datatype specializations (e.g., Count) are generated correctly, but SimpleQuantity is missing from the TypeScript output.

Background / Context

For illustration:

SimpleQuantity

Is a constraint of the Quantity type (e.g., limitation of comparator, UCUM focus, etc.), and is defined in FHIR as a profile/specialization of Quantity.

Count

Declares a Count type (specialization of Quantity) and is treated as a proper structure so code is emitted for it.

In general, the generator processes profiles and specializations correctly for many target languages. However, the TypeScript generator appears to skip these constrained profiles because “it has nothing useful to say” in its current logic, so no SimpleQuantity type gets generated.

The result is that any FHIR definition that references SimpleQuantity has no corresponding TypeScript type emitted.

Steps to Reproduce

Run the TypeScript generator on the R4 core spec using fhir-codegen. Inspect the output for datatype definitions.

Note that:

• Quantity and Count are generated.
• SimpleQuantity is not generated.

Expected Behavior

The TypeScript generator should emit a SimpleQuantity type that corresponds to the FHIR SimpleQuantity definition, analogous to how it emits Count as a specialization of Quantity. This allows downstream TypeScript projects to reference SimpleQuantity where it appears in the FHIR spec.

For example, we’d expect something like a SimpleQuantity interface or type alias that reflects the constraints applied to Quantity for elements that specifically reference SimpleQuantity.

Actual Behavior

SimpleQuantity is not generated at all in the TypeScript output.

References to SimpleQuantity in FHIR resources end up effectively pointing to Quantity (or nothing explicit), losing the semantic distinction and constraints.

[bkaney]

Hi @quotentiroler - you might be interested in this issue.

[quotentiroler]

Additional Finding: MoneyQuantity Also Missing

While investigating this issue, I discovered that MoneyQuantity is also missing from @types/fhir for the same reason as SimpleQuantity. Both have derivation: "constraint" in their StructureDefinitions.

Verification

# Checked against @types/fhir R4 definitions
SimpleQuantity   MISSING  # derivation: constraint
MoneyQuantity    MISSING  # derivation: constraint
Age              FOUND    # derivation: specialization
Distance         FOUND    # derivation: specialization
Duration         FOUND    # derivation: specialization
Count            FOUND    # derivation: specialization

The types with derivation: specialization are generated correctly; only those with derivation: constraint are skipped.

---

Root Cause Analysis

Looking at the fhir-codegen source, I found that CSharpFirely2.cs already handles constrained Quantity types but TypeScript.cs does not:

CSharpFirely2.cs (has the fix)

• Lines 1871-1896: Detects cgBaseTypeName == "Quantity" and calls WriteConstrainedQuantity()
• Lines 2517-2538: WriteConstrainedQuantity() implementation generates proper constraint type

TypeScript.cs (missing the fix)

• WriteTsInterface() at lines 627-700 has no equivalent check for constrained Quantity profiles
• Profiles with derivation: constraint that don't add new elements get skipped entirely

---

Proposed Solutions

Option A: Simple Type Aliases (Quick Fix)

Add type aliases to the TypeScript output:

export type SimpleQuantity = Quantity;
export type MoneyQuantity = Quantity;

This ensures the types exist for TypeScript consumers. While it doesn't encode the constraints at the type level, TypeScript's structural typing means this is semantically correct - both are valid Quantity instances.

Note: Omit<Quantity, 'comparator'> would work for SimpleQuantity (where comparator is forbidden with max: "0"), but NOT for MoneyQuantity (which only adds a FHIRPath constraint mqty-1 requiring ISO 4217 system - comparator is still allowed).

Option C: Root Cause Fix in TypeScript.cs

Port the pattern from CSharpFirely2.cs to TypeScript.cs:

1. In WriteTsInterface() or WriteStructures(), add a check similar to:

   if (complex.cgBaseTypeName(_info, false) == "Quantity" && 
       complex.cgDerivation(_info) == "constraint")
   {
       WriteConstrainedQuantity(complex, writer);
       return;
   }

2. Implement WriteConstrainedQuantity() for TypeScript that emits:

   export type SimpleQuantity = Quantity;
   export type MoneyQuantity = Quantity;

This would ensure all constrained Quantity profiles are properly exported going forward.

---

Happy to help with a PR if this direction looks good!