babelfhir-ts 1.5.19 → 1.5.21

package/out/src/cli/updateCommand.js

@@ -114,21 +114,28 @@ async function promptInstallRedirect(packageFilter, confirm) {
         return { redirectInstall: packageFilter };
     return {};
 }
-/** Default Y/N prompt reading from stdin. */
-function defaultConfirm(question) {
-    return new Promise((resolve) => {
-        process.stdout.write(question);
-        const rl = (async () => {
-            const { createInterface } = await import('readline');
-            return createInterface({ input: process.stdin, output: process.stdout });
-        })();
-        rl.then(r => {
-            r.question('', (answer) => {
-                r.close();
+/**
+ * Default Y/N prompt reading from stdin.
+ *
+ * The readline import is awaited rather than `.then`-ed inside a `new Promise`:
+ * that form dropped a rejection on the floor, and since nothing ever called
+ * `resolve`, a failed import left the caller awaiting a promise that could not
+ * settle. Declining is the safe answer when the prompt cannot be shown.
+ */
+async function defaultConfirm(question) {
+    process.stdout.write(question);
+    const { createInterface } = await import('readline');
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    try {
+        return await new Promise((resolve) => {
+            rl.question('', (answer) => {
                 resolve(!answer || answer.toLowerCase().startsWith('y'));
             });
         });
-    });
+    }
+    finally {
+        rl.close();
+    }
 }
 // ── Discovery ───────────────────────────────────────────────────────────────
 /** Find all lib/ directories starting from startDir. Non-recursive returns only startDir/lib. */

package/out/src/generator/core/constants.js

@@ -57,6 +57,25 @@ export const FETCH_TIMEOUT_MS = 15_000;
 export const TX_TIMEOUT_MS = 30_000;
 /** Max filename length for terminology expansion cache files */
 export const MAX_CACHE_FILENAME_LENGTH = 200;
+/**
+ * FHIR package registries in priority order.
+ *
+ * packages.fhir.org is the canonical source; packages.simplifier.net is the
+ * fallback and carries some national IGs the canonical registry does not mirror.
+ * Both speak the npm metadata shape, so `GET <registry>/<packageId>` returns
+ * `dist-tags` and `versions`.
+ */
+/**
+ * Attempts per registry when downloading a package tarball.
+ *
+ * Registry blips are the single largest cause of spurious parity failures: a run
+ * pulls ~30 packages and a lone `fetch failed` aborted the whole generation.
+ */
+export const PACKAGE_DOWNLOAD_ATTEMPTS = 3;
+export const FHIR_REGISTRIES = [
+    'https://packages.fhir.org',
+    'https://packages.simplifier.net',
+];
 // ─── FHIR StructureDefinition URL prefixes ───────────────────────────────────
 export const FHIR_SD_URL_PREFIX = 'http://hl7.org/fhir/StructureDefinition/';
 export const FHIR_SD_URL_PREFIX_HTTPS = 'https://hl7.org/fhir/StructureDefinition/';

package/out/src/generator/core/extensionSdReader.js

@@ -0,0 +1,99 @@
+/**
+ * Reading what an Extension StructureDefinition declares about its own contents.
+ *
+ * A complex extension carries its requirements in its own SD. A profile that
+ * references one re-declares the sub-extension paths as mustSupport markers but
+ * copies none of the constraints, so anything read only from the profile's field
+ * model misses them entirely — KBV_PR_ERP_PracticeSupply's
+ * `extension:Kostentraeger.extension:Kostentraegertyp.value[x]:valueCoding` has no
+ * binding, while KBV_EX_ERP_PracticeSupply_Payor binds it required to
+ * KBV_VS_FOR_Payor_type.
+ */
+/** `Extension.extension:<name>` with no further path below it. */
+const SUB_SLICE_ID = /^Extension\.extension:([^.:]+)$/;
+/**
+ * The elements to read constraints from.
+ *
+ * Prefer the snapshot, but fall back to the differential: several published
+ * extension SDs ship without one (KBV_EX_ERP_PracticeSupply_Payor among them), and
+ * requiring a snapshot meant they resolved to no metadata at all.
+ */
+export function extensionElements(sd) {
+    const els = sd?.snapshot?.element ?? sd?.differential?.element;
+    return els?.length ? els : undefined;
+}
+/** Read a binding off an element, normalising the ValueSet reference to a bare uri. */
+export function readBinding(el) {
+    const binding = el?.binding;
+    if (!binding?.strength || !binding.valueSet)
+        return undefined;
+    const raw = typeof binding.valueSet === 'string'
+        ? binding.valueSet
+        : binding.valueSet?.reference;
+    if (!raw)
+        return undefined;
+    return { strength: binding.strength, uri: raw.split('|')[0] };
+}
+/** Type codes declared on an element. */
+function typeCodes(el) {
+    return (el?.type ?? []).map(t => t.code).filter((c) => !!c);
+}
+/**
+ * `min` on the unsliced `Extension.extension` element.
+ *
+ * This is what HL7 reports as "Extension.extension: minimum required = N", and it is
+ * not the sum of the slice minimums — the SD states it directly.
+ */
+export function readSubExtensionMin(els) {
+    const el = els.find(e => (e.id ?? e.path) === 'Extension.extension' && !e.sliceName);
+    return typeof el?.min === 'number' ? el.min : undefined;
+}
+/**
+ * Collect the sub-extension slices a complex extension declares.
+ *
+ * A slice with no resolvable `url` is dropped rather than reported under its slice
+ * name: the url is how a member is recognised at runtime, and without it any check
+ * would be guessing which member to apply itself to.
+ */
+export function collectSubExtensionSlices(els) {
+    const byId = new Map();
+    for (const el of els) {
+        const id = el.id ?? el.path;
+        if (id)
+            byId.set(id, el);
+    }
+    const out = [];
+    for (const el of els) {
+        const id = el.id ?? el.path;
+        const match = id ? SUB_SLICE_ID.exec(id) : null;
+        if (!match)
+            continue;
+        const sliceName = el.sliceName ?? match[1];
+        const urlEl = byId.get(`Extension.extension:${sliceName}.url`);
+        const url = typeof urlEl?.fixedUri === 'string' ? urlEl.fixedUri : undefined;
+        if (!url)
+            continue;
+        const valueEl = byId.get(`Extension.extension:${sliceName}.value[x]`);
+        let valueTypes = typeCodes(valueEl);
+        let binding = readBinding(valueEl);
+        // The binding usually sits on the typed slice (…value[x]:valueCoding) rather than
+        // on value[x] itself, which is where the Payor extension puts it.
+        for (const code of valueTypes.length ? valueTypes : ['']) {
+            const suffix = code ? code.charAt(0).toUpperCase() + code.slice(1) : '';
+            const typedEl = suffix ? byId.get(`Extension.extension:${sliceName}.value[x]:value${suffix}`) : undefined;
+            if (!typedEl)
+                continue;
+            binding = binding ?? readBinding(typedEl);
+            if (valueTypes.length === 0)
+                valueTypes = typeCodes(typedEl);
+        }
+        out.push({
+            sliceName,
+            url,
+            min: typeof el.min === 'number' ? el.min : 0,
+            valueTypes,
+            binding,
+        });
+    }
+    return out;
+}

package/out/src/generator/core/utils.js

@@ -24,6 +24,38 @@ export function capitalize(str) {
         return str;
     return str.charAt(0).toUpperCase() + str.slice(1);
 }
+/**
+ * The property name a choice element takes for one of its permitted types.
+ *
+ * A choice element has no property of its own: FHIR declares one property per
+ * permitted type, named for the type code capitalized (`value[x]` as a
+ * SampledData is `valueSampledData`, as a `code` primitive it is `valueCode`).
+ *
+ * Pass the *type code*, never a profile name. R4 declares
+ * `Coverage.costToBeneficiary.value[x]` as a Quantity profiled to SimpleQuantity,
+ * and the property is `valueQuantity` — `valueSimpleQuantity` does not exist on
+ * any resource, so emitting it produces data every validator rejects.
+ *
+ * @param baseName the choice element's name with `[x]` already removed
+ */
+export function choicePropertyName(baseName, typeCode) {
+    return baseName + capitalize(typeCode);
+}
+/**
+ * The single type a choice element has been narrowed to, or undefined while it
+ * still permits more than one.
+ *
+ * A still-open choice has no one property name, so callers must leave the base
+ * definition's expanded properties in force rather than pick a type.
+ */
+export function narrowedChoiceType(field) {
+    if (field.typeOptions && field.typeOptions.length > 1)
+        return undefined;
+    const type = field.typeOptions?.[0]?.code || field.type;
+    if (!type || type === 'any' || type === 'unknown')
+        return undefined;
+    return type;
+}
 /**
  * Extract base FHIR types from all interface declarations in a file.
  * Handles:
@@ -149,6 +181,48 @@ export function alignFields(newFields, oldFields) {
     // Return the original oldFields and the aligned newFields
     return { alignedNewFields, oldFields };
 }
+/** A type the parser could not pin down from the element itself. */
+function isUnstatedType(type) {
+    return !type || type === 'any';
+}
+/**
+ * Carry forward what a differential element left unstated.
+ *
+ * A differential says only what it changes, so an element that constrains
+ * cardinality alone carries no `type` and an element that constrains `min` alone
+ * carries no `max`. Both are inherited rather than defaulted away.
+ */
+function inheritUnstatedFromBase(field, base) {
+    if (!base)
+        return field;
+    const merged = { ...field };
+    if (isUnstatedType(merged.type) && !isUnstatedType(base.type)) {
+        merged.type = base.type;
+    }
+    if (!merged.baseTypeCode && base.baseTypeCode) {
+        merged.baseTypeCode = base.baseTypeCode;
+    }
+    // `max` absent means the differential did not narrow the upper bound, so the
+    // base's bound — and with it whether the element repeats — still holds.
+    if (merged.max === undefined && base.max !== undefined) {
+        merged.max = base.max;
+        merged.isArray = base.isArray;
+    }
+    if (!merged.typeOptions?.length && base.typeOptions?.length) {
+        merged.typeOptions = base.typeOptions;
+    }
+    // An extension slice is recognised at runtime by the canonical its profile
+    // names. A derived profile that only tightens cardinality does not restate it —
+    // KBV_PR_ERP_Medication_PZN redeclares extension:Kategorie and extension:Normgroesse
+    // with no type.profile, while KBV_PR_Base_Medication gives them
+    // KBV_EX_Base_Medication_Type and .../normgroesse. Dropping the base's left two
+    // of four slices unidentifiable, so the closed-slicing check on
+    // Medication.extension could not build its allowed set and stayed silent.
+    if (!merged.profileUrls?.length && base.profileUrls?.length) {
+        merged.profileUrls = base.profileUrls;
+    }
+    return merged;
+}
 export function mergeFields(newFields, oldFields) {
     const fieldMap = new Map();
     // Create unique key for field - use elementId if available (includes slice names for child elements)
@@ -176,9 +250,22 @@ export function mergeFields(newFields, oldFields) {
         }
         fieldMap.set(key, field);
     }
-    // Overwrite or add newFields to the map
+    // Overwrite or add newFields to the map.
+    //
+    // A differential element states only what it *changes*. Replacing the base
+    // field wholesale therefore threw away everything it stayed silent about:
+    // KBV constrains Medication.amount.numerator.value to max=0 and says nothing
+    // about its type, so the merged field read `any` and every type-aware check
+    // skipped it — HL7 reported "The value 'Example value' is not a valid decimal"
+    // where we said nothing. The same silence on `max` left Medication.ingredient
+    // with isArray=false despite being 0..* in the base, so paths beneath it were
+    // never walked.
+    //
+    // Only genuinely absent properties are filled in; anything the differential
+    // states still wins.
     for (const field of newFields) {
-        fieldMap.set(getFieldKey(field), field);
+        const key = getFieldKey(field);
+        fieldMap.set(key, inheritUnstatedFromBase(field, fieldMap.get(key)));
     }
     // Return the merged fields as an array
     return Array.from(fieldMap.values());
@@ -220,9 +307,16 @@ function caseAwareWriteFile(filePath, content) {
 }
 /**
  * Extracts the base resource name from a baseDefinition URL.
+ *
+ * The version suffix has to go first. A canonical may be pinned
+ * (`http://hl7.org/fhir/StructureDefinition/Base|4.0.1`, as IPS 2.0.1's logical
+ * models write it), and keeping it yielded the base name `Base_4_0_1` after
+ * sanitising. That defeated the `baseResource === 'Base'` check that suppresses
+ * extending the abstract root, so the emitter produced
+ * `export type Document = Base_4_0_1` plus an import of a type nothing generates.
  */
 export function getBaseResource(baseDefinition) {
-    return baseDefinition?.split("/").pop() || "Resource";
+    return stripVersionFromCanonicalUrl(baseDefinition ?? '').split('/').pop() || 'Resource';
 }
 /**
  * Sanitizes a string so it can be used as a valid TypeScript identifier.

package/out/src/generator/emitters/class/classTemplate.js

@@ -26,7 +26,7 @@ export function renderClassTemplate(params) {
     const helperImportList = Array.from(helperImports).join(', ');
     const hasVsBindings = Object.keys(valueSetBindings).length > 0;
     return `
-import { validate${interfaceName}, ${interfaceName} } from "./${interfaceName}.js";
+import { validate${interfaceName}, type ${interfaceName} } from "./${interfaceName}.js";
 import type { ValidatorOptions } from "./ValidatorOptions.js";
 // Only import helpers actually referenced below (dynamic based on required fields)
 import { ${helperImportList} } from "./random/index.js";
@@ -55,7 +55,13 @@ function safeClone<T>(value: T): T {
 
 export class ${className} {
 ${generatePatternMetadata(fieldPatterns, forbiddenFields, valueSetBindings, fieldOrder, codeableConceptBindings)}
-  constructor(private resource: ${interfaceName}) {
+  private resource: ${interfaceName};
+
+  // Declared and assigned rather than written as a parameter property, which
+  // erasableSyntaxOnly bans: it emits real assignment code from what reads as a
+  // type annotation. Generated output is held to the same strictness as src/.
+  constructor(resource: ${interfaceName}) {
+    this.resource = resource;
     ${constructorMetaProfile}
   }
   /** Validate current resource instance. */

package/out/src/generator/emitters/class/sliceElementDefaults.js

@@ -221,7 +221,9 @@ export function buildNestedRequirementsObject(nestedRequirements) {
     if (!nestedRequirements || nestedRequirements.length === 0) {
         return null;
     }
-    // Collect all array segments from all requirements to know which paths need array wrapping
+    // Relative paths that are arrays, so nesting knows where to wrap. Keyed by the
+    // full relative path rather than by segment name: `name.part` is 0..* while the
+    // `part` string inside it is 1..1, and one shared verdict wrapped the string too.
     const allArraySegments = new Set();
     for (const req of nestedRequirements) {
         if (req.arraySegments) {
@@ -250,7 +252,7 @@ export function buildNestedRequirementsObject(nestedRequirements) {
         // Navigate/create nested objects for all but the last part
         for (let i = 0; i < parts.length - 1; i++) {
             const part = parts[i];
-            const isArraySegment = allArraySegments.has(part);
+            const isArraySegment = allArraySegments.has(parts.slice(0, i + 1).join('.'));
             if (!(part in current)) {
                 // Create either an array with one object or a plain object
                 if (isArraySegment) {
@@ -346,7 +348,7 @@ export function buildNestedRequirementsObject(nestedRequirements) {
         }
         // If the final segment is an array segment, wrap the value in an array.
         // Also wrap if the field is inherently an array in FHIR base types
-        const shouldWrap = (allArraySegments.has(lastPart) || FHIR_BASE_ARRAY_FIELDS.has(lastPart))
+        const shouldWrap = (allArraySegments.has(req.path) || FHIR_BASE_ARRAY_FIELDS.has(lastPart))
             && !Array.isArray(value);
         if (shouldWrap) {
             current[lastPart] = [value];

package/out/src/generator/emitters/client/clientGenerator.js

@@ -176,11 +176,16 @@ export type FetchFn = typeof globalThis.fetch;
 export class FhirResourceReader<T, S extends SearchParams = SearchParams> implements FhirResourceSearcher<T, S> {
   private readonly fetchFn: FetchFn;
 
+  public readonly baseUrl: string;
+  public readonly resourceType: string;
+
   constructor(
-    public readonly baseUrl: string,
-    public readonly resourceType: string,
+    baseUrl: string,
+    resourceType: string,
     fetchFn?: FetchFn,
   ) {
+    this.baseUrl = baseUrl;
+    this.resourceType = resourceType;
     this.fetchFn = fetchFn ?? globalThis.fetch.bind(globalThis);
   }
 
@@ -321,11 +326,16 @@ import type { FetchFn } from "./resource-reader.js";
 export class FhirResourceWriterImpl<T> implements FhirResourceWriter<T> {
   private readonly fetchFn: FetchFn;
 
+  public readonly baseUrl: string;
+  public readonly resourceType: string;
+
   constructor(
-    public readonly baseUrl: string,
-    public readonly resourceType: string,
+    baseUrl: string,
+    resourceType: string,
     fetchFn?: FetchFn,
   ) {
+    this.baseUrl = baseUrl;
+    this.resourceType = resourceType;
     this.fetchFn = fetchFn ?? globalThis.fetch.bind(globalThis);
   }
 
@@ -451,7 +461,11 @@ export type BundleEntry<T extends FhirResource = FhirResource> = {
  * FHIR Bundle Parser - provides type-safe parsing and filtering of FHIR Bundles
  */
 export class BundleParser {
-  constructor(private readonly bundle: Bundle<FhirResource>) {}
+  private readonly bundle: Bundle<FhirResource>;
+
+  constructor(bundle: Bundle<FhirResource>) {
+    this.bundle = bundle;
+  }
 
   /**
    * Get all resources from the bundle
@@ -659,11 +673,13 @@ ${writerMethods}
 export class FhirClient {
   private readonly readClient: FhirReadClient;
   private readonly writeClient: FhirWriteClient;
+  public readonly baseUrl: string;
 
   constructor(
-    public readonly baseUrl: string,
+    baseUrl: string,
     fetchFn?: FetchFn,
   ) {
+    this.baseUrl = baseUrl;
     this.readClient = new FhirReadClient(baseUrl, fetchFn);
     this.writeClient = new FhirWriteClient(baseUrl, fetchFn);
   }

package/out/src/generator/emitters/client/smartAuthGenerator.js

@@ -167,7 +167,10 @@ export class SmartAuth {
   private readonly storage: Storage;
   private readonly keys: ReturnType<typeof storageKeys>;
 
-  constructor(public readonly config: SmartConfig) {
+  public readonly config: SmartConfig;
+
+  constructor(config: SmartConfig) {
+    this.config = config;
     this.storage = config.storage ?? sessionStorage;
     this.keys = storageKeys(config.storagePrefix ?? "smart_");
   }

package/out/src/generator/emitters/interface/backboneSliceTyping.js

@@ -18,7 +18,7 @@
  * }
  * ```
  */
-import { capitalize, sanitizeIdentifier } from '../../core/utils.js';
+import { capitalize, choicePropertyName, narrowedChoiceType, sanitizeIdentifier } from '../../core/utils.js';
 import { getRules } from '../../fhir/versionContext.js';
 import { logger } from '../../../logger.js';
 const log = logger.withTag('backbone-slices');
@@ -135,7 +135,7 @@ function collectSliceGroups(fields, baseFields, baseResource) {
         if (!isEligibleBackbonePath(field.baseTypeCode || field.type || '', path, baseResource))
             continue;
         const childFields = gatherChildFields(fields, path);
-        const slicingRules = field.slicingRules || 'open';
+        const slicingRules = field.slicingRules ?? 'open';
         seenPaths.add(path);
         groups.push({ parentField: field, sliceFields, childFields, slicingRules });
     }
@@ -160,7 +160,7 @@ function collectSliceGroups(fields, baseFields, baseResource) {
         if (sliceFields.length === 0)
             continue;
         const childFields = gatherChildFields(fields, path);
-        const slicingRules = parentField.slicingRules || 'open';
+        const slicingRules = parentField.slicingRules ?? 'open';
         seenPaths.add(path);
         groups.push({ parentField, sliceFields, childFields, slicingRules });
     }
@@ -263,7 +263,18 @@ function buildSliceInterfaceBody(sliceField, sliceChildren, sliceElementId, _bac
         // metadata and their inherited type (e.g. Quantity) is misleading
         if (choiceTypeParents.has(relativePath))
             continue;
-        const propName = relativePath.replace(/\[x\]$/, '');
+        // A choice element has no property of its own, so it is named for the single
+        // type the slice narrowed it to. Stripping `[x]` produced `value`, `effective`
+        // and the like — properties no resource carries, so the slice demanded a
+        // property FHIR has no such thing as while leaving the real `valueSampledData`
+        // unconstrained. A choice still open here names nothing and is skipped.
+        let propName = relativePath;
+        if (propName.endsWith('[x]')) {
+            const narrowedTo = narrowedChoiceType(child);
+            if (!narrowedTo)
+                continue;
+            propName = choicePropertyName(propName.slice(0, -'[x]'.length), narrowedTo);
+        }
         if (child.fixedValue !== undefined) {
             // Fixed value constraint
             const fixedLiteral = JSON.stringify(child.fixedValue);

package/out/src/generator/emitters/interface/importManager.js

@@ -191,6 +191,33 @@ export class ImportManager {
         }
         return statements.join('\n');
     }
+    /**
+     * Whether `name` is referenced in `body`, counting the profile ids that
+     * resolve to it as references too.
+     *
+     * An external profile can be reached under more than one name: the id taken
+     * from its canonical URL (`AuDosage` from `.../au-dosage`) and the interface
+     * name it is finally generated under (`AUBaseDosage`, from the SD's name).
+     * `generateImportStatements` deduplicates those to the resolved name, but the
+     * interface body is still written with the id at that point — a later pass
+     * rewrites it. Matching only the resolved name therefore pruned an import that
+     * the rewritten body goes on to need, leaving a dangling reference (TS2304 on
+     * `AUBaseDosage` in au-core 2.0.0's AUCoreMedicationStatement, and the same
+     * shape in davinci-pas and davinci-dtr).
+     */
+    isReferencedAllowingAliases(name, body) {
+        if (new RegExp(`\\b${name}\\b`).test(body))
+            return true;
+        if (!this.profileIdToName)
+            return false;
+        for (const [alias, resolved] of this.profileIdToName) {
+            if (resolved !== name || alias === name)
+                continue;
+            if (new RegExp(`\\b${alias}\\b`).test(body))
+                return true;
+        }
+        return false;
+    }
     /**
      * Prunes unused imports from generated code.
      * Removes import statements for types that aren't actually used.
@@ -213,8 +240,7 @@ export class ImportManager {
             const used = [];
             const specifiers = inside.split(',').map((s) => s.trim()).filter(Boolean);
             for (const name of specifiers) {
-                const re = new RegExp(`\\b${name}\\b`);
-                if (re.test(output.replace(full, ''))) {
+                if (this.isReferencedAllowingAliases(name, output.replace(full, ''))) {
                     used.push(name);
                 }
             }

package/out/src/generator/emitters/interface/interfaceFieldProcessor.js

@@ -1,4 +1,4 @@
-import { capitalize, sanitizeIdentifier, toPascalCase, stripVersionFromCanonicalUrl } from '../../core/utils.js';
+import { capitalize, choicePropertyName, narrowedChoiceType, sanitizeIdentifier, toPascalCase, stripVersionFromCanonicalUrl } from '../../core/utils.js';
 import { sanitizeValueSetName } from '../valueset/valueSetGenerator.js';
 import { logger } from '../../../logger.js';
 import { getRules } from '../../fhir/versionContext.js';
@@ -214,25 +214,30 @@ export function processFields(ctx, fields, parentInterfaceName, parentFieldType,
             });
             return;
         }
-        if (fieldName === "value[x]")
-            fieldName = "value";
-        if (fieldName === "event[x]" && field.type === "any" && field.fixedValue === undefined)
-            return;
-        if (fieldName === "event[x]")
-            fieldName = "event";
-        if (fieldName === "deceased[x]")
-            fieldName = "deceased";
+        // `extension[x]` is a parser artifact rather than a FHIR choice — Extension.extension
+        // is a plain repeating element — so it keeps its name.
         if (fieldName === "extension[x]")
             fieldName = "extension";
-        if (fieldName === "multipleBirth[x]")
-            fieldName = "multipleBirth";
         // Helper to retrieve original last segment before local renaming
         function fieldNameOriginal(fullName) { return fullName.split('.').pop() || fullName; }
-        // Generic handling: for choice elements (ending in [x]) that we do NOT explicitly map above,
-        // we skip emitting them so the base resource's expanded choice properties remain intact (e.g., onsetDateTime, onsetAge,...).
-        if (/\[x\]$/.test(fieldNameOriginal(field.name)) && !['value[x]', 'event[x]', 'deceased[x]', 'extension[x]', 'multipleBirth[x]'].includes(fieldNameOriginal(field.name))) {
-            debug('skip choice element to inherit base choice fields', field.name);
-            return;
+        // Choice elements carry no property of their own: FHIR declares one property
+        // per permitted type. A profile that narrows the choice to a single type names
+        // that property, so the constraint lands on the property the resource actually
+        // carries; anything still open is skipped, leaving the base definition's
+        // expanded choice properties in force (onsetDateTime, onsetAge, …).
+        //
+        // value[x], event[x], deceased[x] and multipleBirth[x] used to be renamed to
+        // value/event/deceased/multipleBirth, none of which exist on any resource.
+        // A slice narrowing Observation.component.value[x] to SampledData declared
+        // `value: SampledData`, so a caller writing correct FHIR failed to typecheck
+        // for a missing `value` while `valueSampledData` went unconstrained.
+        if (/\[x\]$/.test(fieldNameOriginal(field.name))) {
+            const narrowedTo = narrowedChoiceType(field);
+            if (!narrowedTo) {
+                debug('skip choice element to inherit base choice fields', field.name);
+                return;
+            }
+            fieldName = choicePropertyName(fieldName.replace(/\[x\]$/, ''), narrowedTo);
         }
         if (isFhirType(capitalize(fieldName)) && field.type === "any" && field.fixedValue === undefined && !(fieldName === 'extension' && hasSamePathExtensionSlices)) {
             if (isAaaCodesContext)

package/out/src/generator/emitters/interface/interfaceFieldUtils.js

@@ -13,6 +13,22 @@ export function canonicalToTypeName(name, profileUrlToName) {
         }
         t = t.split('/').pop() || t;
     }
+    // A bare profile id also has a registered interface name, and it is not
+    // derivable from the id: davinci-pas 2.2.1's `profile-identifier` is generated
+    // as `PASIdentifier` (from the SD's `name`), so PascalCasing the id produced
+    // `ProfileIdentifier` — a type that is referenced and imported but never
+    // emitted (TS2307/TS2304 across seven files). Resolve through the registry by
+    // matching the URL's last segment, and only when it is unambiguous.
+    if (profileUrlToName && !/^https?:\/\//.test(t)) {
+        const matches = new Set();
+        for (const [url, generatedName] of profileUrlToName) {
+            if ((url.split('/').pop() || '').toLowerCase() === t.toLowerCase()) {
+                matches.add(generatedName);
+            }
+        }
+        if (matches.size === 1)
+            return [...matches][0];
+    }
     // if already a valid identifier with capitalization, return as-is
     if (/^[A-Za-z_][A-Za-z0-9_]*$/.test(t) && /[A-Z]/.test(t[0]))
         return t;

package/out/src/generator/emitters/interface/postProcessExtensions.js

@@ -4,6 +4,7 @@
  */
 import { capitalize, sanitizeIdentifier, toPascalCase, stripVersionFromCanonicalUrl } from '../../core/utils.js';
 import { logger } from '../../../logger.js';
+import {} from './importManager.js';
 import { getRules } from '../../fhir/versionContext.js';
 export function postProcessExtensions(params) {
     const { interfaces, interfaceName, baseResource, newFields, baseFieldByLastSegment, importManager, existingProfiles, profileUrlToName, generatedAliasTypes, findInterfaceIndex, inferBackboneType, addTypeImport } = params;