@atomic-ehr/codegen 0.0.10 → 0.0.11-canary.20260408122114.4af415a

package/dist/index.js

@@ -1482,11 +1482,31 @@ var Python = class extends Writer {
   }
   generateFields(schema, schemaName) {
     const sortedFields = Object.entries(schema.fields ?? []).sort(([a], [b]) => a.localeCompare(b));
+    const withExtensions = this.shouldAddPrimitiveExtensions(schema);
     for (const [fieldName, field] of sortedFields) {
       if ("choices" in field && field.choices) continue;
       const fieldInfo = this.buildFieldInfo(fieldName, field, schemaName);
       this.line(`${fieldInfo.name}: ${fieldInfo.type}${fieldInfo.defaultValue}`);
+      if (withExtensions && "type" in field && isPrimitiveIdentifier(field.type)) {
+        this.addPrimitiveExtensionField(fieldName, field.array ?? false);
+      }
+    }
+  }
+  shouldAddPrimitiveExtensions(schema) {
+    if (!this.opts.primitiveTypeExtension) return false;
+    if (!isSpecializationTypeSchema(schema)) return false;
+    for (const field of Object.values(schema.fields ?? {})) {
+      if ("choices" in field && field.choices) continue;
+      if ("type" in field && isPrimitiveIdentifier(field.type)) return true;
     }
+    return false;
+  }
+  addPrimitiveExtensionField(fieldName, isArray) {
+    const pyFieldName = this.nameFormatFunction(`${fieldName}Extension`);
+    const alias = `_${fieldName}`;
+    const typeExpr = isArray ? "PyList[Element | None] | None" : "Element | None";
+    const aliasSpec = `alias="${alias}", serialization_alias="${alias}"`;
+    this.line(`${pyFieldName}: ${typeExpr} = Field(None, ${aliasSpec})`);
   }
   buildFieldInfo(fieldName, field, schemaName) {
     const pyFieldName = fixReservedWords(this.nameFormatFunction(fieldName));
@@ -1571,6 +1591,18 @@ var Python = class extends Writer {
     if (!schema.dependencies || schema.dependencies.length === 0) return;
     this.importComplexTypeDependencies(schema.dependencies);
     this.importResourceDependencies(schema.dependencies);
+    this.importElementIfNeeded(schema);
+  }
+  importElementIfNeeded(schema) {
+    if (!this.shouldAddPrimitiveExtensions(schema)) return;
+    if (schema.identifier.name === "Element") return;
+    if (schema.dependencies?.find((d) => d.name === "Element")) return;
+    assert4(this.tsIndex !== void 0);
+    const elementUrl = "http://hl7.org/fhir/StructureDefinition/Element";
+    const element = this.tsIndex.resolveByUrl(schema.identifier.package, elementUrl);
+    if (!element) return;
+    const pyPackage = this.pyPackage(element.identifier);
+    this.pyImportFrom(pyPackage, "Element");
   }
   importComplexTypeDependencies(dependencies) {
     const complexTypeDeps = dependencies.filter((dep) => dep.kind === "complex-type");
@@ -2450,7 +2482,7 @@ var navigateMatch = (match, remainingPath) => {
   }
   return value;
 };
-var collectDiscriminatorValue = (schema, segments, index, result) => {
+var collectDiscriminatorValue = (schema, segments, index, result, arrayPaths) => {
   if (index >= segments.length || !schema.elements) return;
   const segment = segments[index];
   const element = schema.elements[segment];
@@ -2460,6 +2492,7 @@ var collectDiscriminatorValue = (schema, segments, index, result) => {
     return;
   }
   if (element.slicing?.slices) {
+    arrayPaths.add(segments.slice(0, index + 1).join("."));
     const remainingSegments = segments.slice(index + 1);
     for (const subSlice of Object.values(element.slicing.slices)) {
       if (!subSlice.min || subSlice.min < 1 || !subSlice.match || typeof subSlice.match !== "object") continue;
@@ -2474,7 +2507,7 @@ var collectDiscriminatorValue = (schema, segments, index, result) => {
     }
     return;
   }
-  collectDiscriminatorValue(element, segments, index + 1, result);
+  collectDiscriminatorValue(element, segments, index + 1, result, arrayPaths);
 };
 var computeTypeDiscriminatorMatch = (path, schema, result) => {
   if (path === "$this") return;
@@ -2491,16 +2524,31 @@ var computeTypeDiscriminatorMatch = (path, schema, result) => {
 var computeMatchFromSchema = (discriminators, schema) => {
   if (!schema || !discriminators || discriminators.length === 0) return void 0;
   const result = {};
+  const arrayPaths = /* @__PURE__ */ new Set();
   for (const disc of discriminators) {
     if (disc.type === "type") {
       computeTypeDiscriminatorMatch(disc.path, schema, result);
     } else {
       if (!schema.elements) continue;
       const segments = disc.path.split(".");
-      collectDiscriminatorValue(schema, segments, 0, result);
+      collectDiscriminatorValue(schema, segments, 0, result, arrayPaths);
     }
   }
-  return Object.keys(result).length > 0 ? result : void 0;
+  if (Object.keys(result).length === 0) return void 0;
+  for (const path of arrayPaths) {
+    const segments = path.split(".");
+    let target = result;
+    for (let i = 0; i < segments.length - 1; i++) {
+      const v = target[segments[i]];
+      if (!v || typeof v !== "object" || Array.isArray(v)) break;
+      target = v;
+    }
+    const key = segments[segments.length - 1];
+    if (target[key] && typeof target[key] === "object" && !Array.isArray(target[key])) {
+      target[key] = [target[key]];
+    }
+  }
+  return result;
 };
 var buildSlicing = (element) => {
   const slicing = element.slicing;
@@ -4221,6 +4269,9 @@ var tsProfileClassName = (schema) => {
 var tsSliceFlatTypeName = (profileName, fieldName, sliceName) => {
   return `${uppercaseFirstLetter(profileName)}_${uppercaseFirstLetter(normalizeTsName(fieldName))}_${uppercaseFirstLetter(normalizeTsName(sliceName))}SliceFlat`;
 };
+var tsSliceFlatAllTypeName = (profileName, fieldName, sliceName) => {
+  return `${uppercaseFirstLetter(profileName)}_${uppercaseFirstLetter(normalizeTsName(fieldName))}_${uppercaseFirstLetter(normalizeTsName(sliceName))}SliceFlatAll`;
+};
 var tsExtensionFlatTypeName = (profileName, extensionName) => {
   return `${uppercaseFirstLetter(profileName)}_${uppercaseFirstLetter(normalizeTsName(extensionName))}Flat`;
 };
@@ -4284,7 +4335,7 @@ var rewriteFieldTypeDefs = {
   Reference: { reference: () => "`${T}/${string}`" },
   CodeableConcept: { coding: () => "Coding<T>" }
 };
-var resolveFieldTsType = (schemaName, tsName, field, resolveRef, genericFieldMap) => {
+var resolveFieldTsType = (schemaName, tsName, field, resolveRef, genericFieldMap, isFamilyType) => {
   if (genericFieldMap?.[tsName]) return genericFieldMap[tsName];
   const rewriteFieldType = rewriteFieldTypeDefs[schemaName]?.[tsName];
   if (rewriteFieldType) return rewriteFieldType();
@@ -4294,14 +4345,15 @@ var resolveFieldTsType = (schemaName, tsName, field, resolveRef, genericFieldMap
     return tsEnumType(field.enum);
   }
   if (field.reference && field.reference.length > 0) {
-    const references = field.reference.map((ref) => resolveRef ? resolveRef(ref) : ref).map((ref) => `"${ref.name}"`).join(" | ");
+    const resolved = field.reference.map((ref) => resolveRef ? resolveRef(ref) : ref);
+    const references = resolved.map((ref) => isFamilyType?.(ref) ? `string /* ${ref.name} */` : `"${ref.name}"`).join(" | ");
     return `Reference<${references}>`;
   }
   if (isPrimitiveIdentifier(field.type)) return resolvePrimitiveType(field.type.name);
   if (isNestedIdentifier(field.type)) return tsResourceName(field.type);
   return field.type.name;
 };
-var fieldTsType = (field, resolveRef) => resolveFieldTsType("", "", field, resolveRef) + (field.array ? "[]" : "");
+var fieldTsType = (field, resolveRef, isFamilyType) => resolveFieldTsType("", "", field, resolveRef, void 0, isFamilyType) + (field.array ? "[]" : "");
 var tsTypeFromIdentifier = (id) => {
   if (isNestedIdentifier(id)) return tsResourceName(id);
   if (isPrimitiveIdentifier(id)) return resolvePrimitiveType(id.name);
@@ -4370,21 +4422,22 @@ var resolveExtensionProfile = (tsIndex, pkgName, url) => {
   const flatProfile = tsIndex.flatProfile(schema);
   return { className, modulePath, flatProfile };
 };
-var generateRawExtensionBody = (w, ext, targetPath, paramName = "input") => {
+var generateRawExtensionBody = (w, ext, targetPath, paramName = "input", useUpsert = false) => {
   w.line(
     `if (${paramName}.url !== ${JSON.stringify(ext.url)}) throw new Error(\`Expected extension url '${ext.url}', got '\${${paramName}.url}'\`)`
   );
-  generateExtensionPush(w, targetPath, paramName);
+  generateExtensionPush(w, targetPath, paramName, useUpsert);
 };
-var generateExtensionPush = (w, targetPath, extExpr) => {
+var generateExtensionPush = (w, targetPath, extExpr, useUpsert = false) => {
+  const fn = useUpsert ? "upsertExtension" : "pushExtension";
   if (targetPath.length === 0) {
-    w.line(`pushExtension(this.resource, ${extExpr})`);
+    w.line(`${fn}(this.resource, ${extExpr})`);
   } else {
     w.line(
       `const target = ensurePath(this.resource as unknown as Record<string, unknown>, ${JSON.stringify(targetPath)})`
     );
     w.line("if (!Array.isArray(target.extension)) target.extension = [] as Extension[]");
-    w.line(`pushExtension(target as unknown as { extension?: Extension[] }, ${extExpr})`);
+    w.line(`${fn}(target as unknown as { extension?: Extension[] }, ${extExpr})`);
   }
 };
 var generateExtLookup = (w, ext, targetPath) => {
@@ -4437,6 +4490,7 @@ var generateComplexExtensionSetter = (w, info) => {
   const tsProfileName = tsResourceName(flatProfile.identifier);
   const inputTypeName = tsExtensionFlatTypeName(tsProfileName, ext.name);
   const extProfileHasFlatInput = extProfileInfo ? collectSubExtensionSlices(extProfileInfo.flatProfile).length > 0 : false;
+  const useUpsert = ext.max === "1";
   if (extProfileInfo && extProfileHasFlatInput) {
     const paramType = `${extProfileInfo.className}Flat | ${extProfileInfo.className} | Extension`;
     w.curlyBlock(["public", setMethodName, `(input: ${paramType}): this`], () => {
@@ -4444,14 +4498,19 @@ var generateComplexExtensionSetter = (w, info) => {
         [
           {
             cond: `input instanceof ${extProfileInfo.className}`,
-            body: () => generateExtensionPush(w, targetPath, "input.toResource()")
+            body: () => generateExtensionPush(w, targetPath, "input.toResource()", useUpsert)
           },
           {
             cond: "isExtension<Extension>(input)",
-            body: () => generateRawExtensionBody(w, ext, targetPath)
+            body: () => generateRawExtensionBody(w, ext, targetPath, "input", useUpsert)
           }
         ],
-        () => generateExtensionPush(w, targetPath, `${extProfileInfo.className}.createResource(input)`)
+        () => generateExtensionPush(
+          w,
+          targetPath,
+          `${extProfileInfo.className}.createResource(input)`,
+          useUpsert
+        )
       );
       w.line("return this");
     });
@@ -4474,15 +4533,16 @@ var generateComplexExtensionSetter = (w, info) => {
           });
         }
       }
+      const extLiteral = `{ url: "${ext.url}", extension: subExtensions }`;
+      const fn = useUpsert ? "upsertExtension" : "pushExtension";
       if (targetPath.length === 0) {
-        w.line("const list = (this.resource.extension ??= [])");
-        w.line(`list.push({ url: "${ext.url}", extension: subExtensions })`);
+        w.line(`${fn}(this.resource, ${extLiteral})`);
       } else {
         w.line(
           `const target = ensurePath(this.resource as unknown as Record<string, unknown>, ${JSON.stringify(targetPath)})`
         );
         w.line("if (!Array.isArray(target.extension)) target.extension = [] as Extension[]");
-        w.line(`(target.extension as Extension[]).push({ url: "${ext.url}", extension: subExtensions })`);
+        w.line(`${fn}(target as unknown as { extension?: Extension[] }, ${extLiteral})`);
       }
       w.line("return this");
     });
@@ -4510,32 +4570,33 @@ var generateSingleValueExtensionSetter = (w, tsIndex, info) => {
   if (!firstValueType) return;
   const valueType = tsTypeFromIdentifier(firstValueType);
   const valueField = tsValueFieldName(firstValueType);
+  const useUpsert = ext.max === "1";
   if (extProfileInfo) {
-    const paramType = `${extProfileInfo.className} | Extension | ${valueType}`;
-    const extHasValueParam = collectProfileFactoryInfo(tsIndex, extProfileInfo.flatProfile).params.some(
-      (p) => p.name === valueField
-    );
-    const elseExpr = extHasValueParam ? `${extProfileInfo.className}.createResource({ ${valueField}: value as ${valueType} })` : `{ url: "${ext.url}", ${valueField}: value as ${valueType} } as Extension`;
+    const extFactoryInfo = collectProfileFactoryInfo(tsIndex, extProfileInfo.flatProfile);
+    const extValueParam = extFactoryInfo.params.find((p) => p.name === valueField);
+    const resolvedValueType = extValueParam?.tsType ?? valueType;
+    const paramType = `${extProfileInfo.className} | Extension | ${resolvedValueType}`;
+    const elseExpr = extValueParam ? `${extProfileInfo.className}.createResource({ ${valueField}: value as ${resolvedValueType} })` : `{ url: "${ext.url}", ${valueField}: value as ${valueType} } as Extension`;
     w.curlyBlock(["public", setMethodName, `(value: ${paramType}): this`], () => {
       w.ifElseChain(
         [
           {
             cond: `value instanceof ${extProfileInfo.className}`,
-            body: () => generateExtensionPush(w, targetPath, "value.toResource()")
+            body: () => generateExtensionPush(w, targetPath, "value.toResource()", useUpsert)
           },
           {
             cond: "isExtension(value)",
-            body: () => generateRawExtensionBody(w, ext, targetPath, "value")
+            body: () => generateRawExtensionBody(w, ext, targetPath, "value", useUpsert)
           }
         ],
-        () => generateExtensionPush(w, targetPath, elseExpr)
+        () => generateExtensionPush(w, targetPath, elseExpr, useUpsert)
       );
       w.line("return this");
     });
   } else {
     w.curlyBlock(["public", setMethodName, `(value: ${valueType}): this`], () => {
       const extLiteral = `{ url: "${ext.url}", ${valueField}: value } as Extension`;
-      generateExtensionPush(w, targetPath, extLiteral);
+      generateExtensionPush(w, targetPath, extLiteral, useUpsert);
       w.line("return this");
     });
   }
@@ -4552,15 +4613,16 @@ var generateSingleValueExtensionGetter = (w, info) => {
 };
 var generateGenericExtensionSetter = (w, info) => {
   const { ext, setMethodName, targetPath } = info;
+  const useUpsert = ext.max === "1";
   w.curlyBlock(["public", setMethodName, `(value: Omit<Extension, "url"> | Extension): this`], () => {
     w.ifElseChain(
       [
         {
           cond: "isExtension(value)",
-          body: () => generateRawExtensionBody(w, ext, targetPath, "value")
+          body: () => generateRawExtensionBody(w, ext, targetPath, "value", useUpsert)
         }
       ],
-      () => generateExtensionPush(w, targetPath, `{ url: "${ext.url}", ...value } as Extension`)
+      () => generateExtensionPush(w, targetPath, `{ url: "${ext.url}", ...value } as Extension`, useUpsert)
     );
     w.line("return this");
   });
@@ -4694,7 +4756,14 @@ var collectTypesFromSlices = (tsIndex, flatProfile, addType) => {
 };
 var collectRequiredSliceNames = (field) => {
   if (!field.array || !field.slicing?.slices) return void 0;
-  const names = Object.entries(field.slicing.slices).filter(([_, s]) => s.min !== void 0 && s.min >= 1 && s.match && Object.keys(s.match).length > 0).map(([name]) => name);
+  const isTypeDisc = field.slicing.discriminator?.some((d) => d.type === "type") ?? false;
+  if (isTypeDisc) return void 0;
+  const names = Object.entries(field.slicing.slices).filter(([_, s]) => {
+    if (s.min === void 0 || s.min < 1 || !s.match || Object.keys(s.match).length === 0) return false;
+    const matchKeys = new Set(Object.keys(s.match));
+    const requiredBeyondMatch = (s.required ?? []).filter((name) => !matchKeys.has(name));
+    return requiredBeyondMatch.length === 0;
+  }).map(([name]) => name);
   return names.length > 0 ? names : void 0;
 };
 var collectSliceDefs = (tsIndex, flatProfile) => Object.entries(flatProfile.fields ?? {}).filter(([_, field]) => isNotChoiceDeclarationField(field) && field.slicing?.slices).flatMap(([fieldName, field]) => {
@@ -4722,7 +4791,8 @@ var collectSliceDefs = (tsIndex, flatProfile) => Object.entries(flatProfile.fiel
       excluded: slice.excluded ?? [],
       array: Boolean(field.array),
       constrainedChoice,
-      typeDiscriminator: isTypeDisc
+      typeDiscriminator: isTypeDisc,
+      max: slice.max ?? 0
     };
   });
 });
@@ -4732,39 +4802,61 @@ var generateSliceSetters = (w, sliceDefs, flatProfile, sliceBaseNames) => {
   for (const sliceDef of sliceDefs) {
     const baseName = tsResolvedSliceBaseName(sliceBaseNames, sliceDef.fieldName, sliceDef.sliceName);
     const methodName = `set${baseName}`;
-    const typeName = tsSliceFlatTypeName(tsProfileName, sliceDef.fieldName, sliceDef.sliceName);
+    const inputTypeName = tsSliceFlatTypeName(tsProfileName, sliceDef.fieldName, sliceDef.sliceName);
     const matchRef = `${profileClassName}.${tsSliceStaticName(sliceDef.sliceName)}SliceMatch`;
     const tsField = tsFieldName(sliceDef.fieldName);
     const fieldAccess = tsGet("this.resource", tsField);
     const baseType = sliceDef.typedBaseType;
-    const inputOptional = sliceDef.required.length === 0;
-    const unionType = `${typeName} | ${baseType}`;
-    const paramSignature = inputOptional ? `(input?: ${unionType}): this` : `(input: ${unionType}): this`;
-    w.curlyBlock(["public", methodName, paramSignature], () => {
-      w.line(`const match = ${matchRef}`);
-      w.curlyBlock(["if", "(input && matchesValue(input, match))"], () => {
+    const isUnbounded = sliceDef.array && (sliceDef.max === 0 || sliceDef.max === void 0);
+    if (isUnbounded) {
+      const unionType = `(${inputTypeName} | ${baseType})[]`;
+      const paramSignature = `(input: ${unionType}): this`;
+      w.curlyBlock(["public", methodName, paramSignature], () => {
+        w.line(`const match = ${matchRef}`);
+        w.line(`const arr = ${fieldAccess} ??= []`);
+        if (sliceDef.constrainedChoice) {
+          const cc = sliceDef.constrainedChoice;
+          w.line(
+            `const values = input.map(item => matchesValue(item, match) ? item as ${baseType} : applySliceMatch<${baseType}>(wrapSliceChoice<${baseType}>(item, ${JSON.stringify(cc.variant)}), match))`
+          );
+        } else {
+          w.line(
+            `const values = input.map(item => matchesValue(item, match) ? item as ${baseType} : applySliceMatch<${baseType}>(item, match))`
+          );
+        }
+        w.line("setArraySliceAll(arr, match, values)");
+        w.line("return this");
+      });
+    } else {
+      const inputOptional = sliceDef.required.length === 0;
+      const unionType = `${inputTypeName} | ${baseType}`;
+      const paramSignature = inputOptional ? `(input?: ${unionType}): this` : `(input: ${unionType}): this`;
+      w.curlyBlock(["public", methodName, paramSignature], () => {
+        w.line(`const match = ${matchRef}`);
+        w.curlyBlock(["if", "(input && matchesValue(input, match))"], () => {
+          if (sliceDef.array) {
+            w.line(`setArraySlice(${fieldAccess} ??= [], match, input as ${baseType})`);
+          } else {
+            w.line(`${fieldAccess} = input as ${baseType}`);
+          }
+          w.line("return this");
+        });
+        const inputExpr = inputOptional ? "input ?? {}" : "input";
+        if (sliceDef.constrainedChoice) {
+          const cc = sliceDef.constrainedChoice;
+          w.line(`const wrapped = wrapSliceChoice<${baseType}>(${inputExpr}, ${JSON.stringify(cc.variant)})`);
+          w.line(`const value = applySliceMatch<${baseType}>(wrapped, match)`);
+        } else {
+          w.line(`const value = applySliceMatch<${baseType}>(${inputExpr}, match)`);
+        }
         if (sliceDef.array) {
-          w.line(`setArraySlice(${fieldAccess} ??= [], match, input as ${baseType})`);
+          w.line(`setArraySlice(${fieldAccess} ??= [], match, value)`);
         } else {
-          w.line(`${fieldAccess} = input as ${baseType}`);
+          w.line(`${fieldAccess} = value`);
         }
         w.line("return this");
       });
-      const inputExpr = inputOptional ? "input ?? {}" : "input";
-      if (sliceDef.constrainedChoice) {
-        const cc = sliceDef.constrainedChoice;
-        w.line(`const wrapped = wrapSliceChoice<${baseType}>(${inputExpr}, ${JSON.stringify(cc.variant)})`);
-        w.line(`const value = applySliceMatch<${baseType}>(wrapped, match)`);
-      } else {
-        w.line(`const value = applySliceMatch<${baseType}>(${inputExpr}, match)`);
-      }
-      if (sliceDef.array) {
-        w.line(`setArraySlice(${fieldAccess} ??= [], match, value)`);
-      } else {
-        w.line(`${fieldAccess} = value`);
-      }
-      w.line("return this");
-    });
+    }
     w.line();
   }
 };
@@ -4775,52 +4867,85 @@ var generateSliceGetters = (w, sliceDefs, flatProfile, sliceBaseNames) => {
   for (const sliceDef of sliceDefs) {
     const baseName = tsResolvedSliceBaseName(sliceBaseNames, sliceDef.fieldName, sliceDef.sliceName);
     const getMethodName = `get${baseName}`;
-    const typeName = tsSliceFlatTypeName(tsProfileName, sliceDef.fieldName, sliceDef.sliceName);
+    const flatTypeName = tsSliceFlatAllTypeName(tsProfileName, sliceDef.fieldName, sliceDef.sliceName);
     const matchRef = `${profileClassName}.${tsSliceStaticName(sliceDef.sliceName)}SliceMatch`;
     const matchKeys = JSON.stringify(Object.keys(sliceDef.match));
     const tsField = tsFieldName(sliceDef.fieldName);
     const fieldAccess = tsGet("this.resource", tsField);
     const baseType = sliceDef.typedBaseType;
-    const defaultReturn = defaultMode === "raw" ? baseType : typeName;
-    w.lineSM(`public ${getMethodName}(mode: 'flat'): ${typeName} | undefined`);
-    w.lineSM(`public ${getMethodName}(mode: 'raw'): ${baseType} | undefined`);
-    w.lineSM(`public ${getMethodName}(): ${defaultReturn} | undefined`);
-    w.curlyBlock(
-      [
-        "public",
-        getMethodName,
-        `(mode: 'flat' | 'raw' = '${defaultMode}'): ${typeName} | ${baseType} | undefined`
-      ],
-      () => {
-        w.line(`const match = ${matchRef}`);
-        if (sliceDef.array) {
-          w.line(`const item = getArraySlice(${fieldAccess}, match)`);
-          w.line("if (!item) return undefined");
-        } else {
-          w.line(`const item = ${fieldAccess}`);
-          w.line("if (!item || !matchesValue(item, match)) return undefined");
-        }
-        if (sliceDef.typeDiscriminator) {
-          w.line(`if (mode === 'raw') return item as ${baseType}`);
-        } else {
-          w.line("if (mode === 'raw') return item");
+    const isUnbounded = sliceDef.array && (sliceDef.max === 0 || sliceDef.max === void 0);
+    if (isUnbounded) {
+      const defaultReturn = defaultMode === "raw" ? `${baseType}[]` : `${flatTypeName}[]`;
+      w.lineSM(`public ${getMethodName}(mode: 'flat'): ${flatTypeName}[] | undefined`);
+      w.lineSM(`public ${getMethodName}(mode: 'raw'): ${baseType}[] | undefined`);
+      w.lineSM(`public ${getMethodName}(): ${defaultReturn} | undefined`);
+      w.curlyBlock(
+        [
+          "public",
+          getMethodName,
+          `(mode: 'flat' | 'raw' = '${defaultMode}'): (${flatTypeName} | ${baseType})[] | undefined`
+        ],
+        () => {
+          w.line(`const match = ${matchRef}`);
+          w.line(`const items = getArraySliceAll(${fieldAccess}, match)`);
+          w.line("if (items.length === 0) return undefined");
+          if (sliceDef.typeDiscriminator) {
+            w.line(`if (mode === 'raw') return items as ${baseType}[]`);
+          } else {
+            w.line("if (mode === 'raw') return items");
+          }
+          if (sliceDef.constrainedChoice) {
+            const cc = sliceDef.constrainedChoice;
+            w.line(
+              `return items.map(item => unwrapSliceChoice<${flatTypeName}>(item, ${matchKeys}, ${JSON.stringify(cc.variant)}))`
+            );
+          } else {
+            w.line(`return items as unknown as ${flatTypeName}[]`);
+          }
         }
-        if (sliceDef.typeDiscriminator) {
-          w.line(`return item as ${typeName}`);
-        } else if (sliceDef.constrainedChoice) {
-          const cc = sliceDef.constrainedChoice;
-          w.line(`return unwrapSliceChoice<${typeName}>(item, ${matchKeys}, ${JSON.stringify(cc.variant)})`);
-        } else {
-          w.line(`return stripMatchKeys<${typeName}>(item, ${matchKeys})`);
+      );
+    } else {
+      const defaultReturn = defaultMode === "raw" ? baseType : flatTypeName;
+      w.lineSM(`public ${getMethodName}(mode: 'flat'): ${flatTypeName} | undefined`);
+      w.lineSM(`public ${getMethodName}(mode: 'raw'): ${baseType} | undefined`);
+      w.lineSM(`public ${getMethodName}(): ${defaultReturn} | undefined`);
+      w.curlyBlock(
+        [
+          "public",
+          getMethodName,
+          `(mode: 'flat' | 'raw' = '${defaultMode}'): ${flatTypeName} | ${baseType} | undefined`
+        ],
+        () => {
+          w.line(`const match = ${matchRef}`);
+          if (sliceDef.array) {
+            w.line(`const item = getArraySlice(${fieldAccess}, match)`);
+            w.line("if (!item) return undefined");
+          } else {
+            w.line(`const item = ${fieldAccess}`);
+            w.line("if (!item || !matchesValue(item, match)) return undefined");
+          }
+          if (sliceDef.typeDiscriminator) {
+            w.line(`if (mode === 'raw') return item as ${baseType}`);
+          } else {
+            w.line("if (mode === 'raw') return item");
+          }
+          if (sliceDef.constrainedChoice) {
+            const cc = sliceDef.constrainedChoice;
+            w.line(
+              `return unwrapSliceChoice<${flatTypeName}>(item, ${matchKeys}, ${JSON.stringify(cc.variant)})`
+            );
+          } else {
+            w.line(`return item as unknown as ${flatTypeName}`);
+          }
         }
-      }
-    );
+      );
+    }
     w.line();
   }
 };
 
 // src/api/writer-generator/typescript/profile-validation.ts
-var collectRegularFieldValidation = (errors, warnings, name, field, resolveRef, canonicalUrlExpr) => {
+var collectRegularFieldValidation = (errors, warnings, name, field, resolveRef, canonicalUrlExpr, tsIndex) => {
   if (field.excluded) {
     errors.push(`...validateExcluded(res, profileName, ${JSON.stringify(name)})`);
     return;
@@ -4842,14 +4967,29 @@ var collectRegularFieldValidation = (errors, warnings, name, field, resolveRef,
     );
   if (field.slicing?.slices) {
     for (const [sliceName, slice] of Object.entries(field.slicing.slices)) {
-      if (slice.min === void 0 && slice.max === void 0) continue;
       const match = slice.match ?? {};
       if (Object.keys(match).length === 0) continue;
-      const min = slice.min ?? 0;
-      const max = slice.max ?? 0;
-      errors.push(
-        `...validateSliceCardinality(res, profileName, ${JSON.stringify(name)}, ${JSON.stringify(match)}, ${JSON.stringify(sliceName)}, ${min}, ${max})`
-      );
+      if (slice.min !== void 0 || slice.max !== void 0) {
+        const min = slice.min ?? 0;
+        const max = slice.max ?? 0;
+        errors.push(
+          `...validateSliceCardinality(res, profileName, ${JSON.stringify(name)}, ${JSON.stringify(match)}, ${JSON.stringify(sliceName)}, ${min}, ${max})`
+        );
+      }
+      const sliceRequiredFields = [];
+      const matchKeys = new Set(Object.keys(match));
+      for (const rf of slice.required ?? []) {
+        if (!matchKeys.has(rf)) sliceRequiredFields.push(rf);
+      }
+      if (tsIndex && field.type && slice.elements) {
+        const cc = tsIndex.constrainedChoice(field.type.package, field.type, slice.elements);
+        if (cc) sliceRequiredFields.push(cc.variant);
+      }
+      if (sliceRequiredFields.length > 0) {
+        errors.push(
+          `...validateSliceFields(res, profileName, ${JSON.stringify(name)}, ${JSON.stringify(match)}, ${JSON.stringify(sliceName)}, ${JSON.stringify(sliceRequiredFields)})`
+        );
+      }
     }
   }
 };
@@ -4881,7 +5021,8 @@ var generateValidateMethod = (w, tsIndex, flatProfile) => {
         name,
         field,
         tsIndex.findLastSpecializationByIdentifier,
-        canonicalUrlExpr
+        canonicalUrlExpr,
+        tsIndex
       );
     }
     const emitArray = (label, exprs) => {
@@ -4913,24 +5054,31 @@ var collectChoiceAccessors = (flatProfile, promotedChoices) => {
   }
   return accessors;
 };
-var tryPromoteChoice = (field, fields, params, promotedChoices) => {
+var tryPromoteChoice = (field, fields, params, promotedChoices, resolveRef, isFamilyType) => {
   if (!isChoiceDeclarationField(field) || !field.required || field.choices.length !== 1) return;
   const choiceName = field.choices[0];
   if (!choiceName) return;
   const choiceField = fields[choiceName];
   if (!choiceField || !isChoiceInstanceField(choiceField)) return;
-  const tsType = tsTypeFromIdentifier(choiceField.type) + (choiceField.array ? "[]" : "");
+  const tsType = fieldTsType(choiceField, resolveRef, isFamilyType);
   params.push({ name: choiceName, tsType, typeId: choiceField.type });
   promotedChoices.add(choiceName);
 };
+var mkIsFamilyType = (tsIndex) => (ref) => {
+  const schema = tsIndex.resolveType(ref);
+  if (!schema || !("typeFamily" in schema)) return false;
+  return (schema.typeFamily?.resources?.length ?? 0) > 0;
+};
 var collectProfileFactoryInfo = (tsIndex, flatProfile) => {
   const autoFields = [];
   const sliceAutoFields = [];
   const params = [];
   const autoAccessors = [];
+  const fixedFields = /* @__PURE__ */ new Set();
   const fields = flatProfile.fields ?? {};
   const promotedChoices = /* @__PURE__ */ new Set();
   const resolveRef = tsIndex.findLastSpecializationByIdentifier;
+  const isFamilyType = mkIsFamilyType(tsIndex);
   if (isResourceIdentifier(flatProfile.base)) {
     autoFields.push({ name: "resourceType", value: JSON.stringify(flatProfile.base.name) });
   }
@@ -4938,14 +5086,15 @@ var collectProfileFactoryInfo = (tsIndex, flatProfile) => {
     if (field.excluded) continue;
     if (isChoiceInstanceField(field)) continue;
     if (isChoiceDeclarationField(field)) {
-      tryPromoteChoice(field, fields, params, promotedChoices);
+      tryPromoteChoice(field, fields, params, promotedChoices, resolveRef, isFamilyType);
       continue;
     }
     if (field.valueConstraint) {
       const value = JSON.stringify(field.valueConstraint.value);
       autoFields.push({ name, value: field.array ? `[${value}]` : value });
+      fixedFields.add(name);
       if (isNotChoiceDeclarationField(field) && field.type) {
-        const tsType = fieldTsType(field, resolveRef);
+        const tsType = fieldTsType(field, resolveRef, isFamilyType);
         autoAccessors.push({ name, tsType, typeId: field.type });
       }
       continue;
@@ -4954,7 +5103,7 @@ var collectProfileFactoryInfo = (tsIndex, flatProfile) => {
       const sliceNames = collectRequiredSliceNames(field);
       if (sliceNames) {
         if (field.type) {
-          const tsType = fieldTsType(field, resolveRef);
+          const tsType = fieldTsType(field, resolveRef, isFamilyType);
           sliceAutoFields.push({
             name,
             tsType,
@@ -4967,20 +5116,27 @@ var collectProfileFactoryInfo = (tsIndex, flatProfile) => {
       }
     }
     if (field.required) {
-      const tsType = fieldTsType(field, resolveRef);
+      const tsType = fieldTsType(field, resolveRef, isFamilyType);
       params.push({ name, tsType, typeId: field.type });
     }
   }
-  collectBaseRequiredParams(tsIndex, flatProfile, resolveRef, params, [
-    ...autoFields.map((f) => f.name),
-    ...sliceAutoFields.map((f) => f.name),
-    ...params.map((f) => f.name),
-    ...promotedChoices
-  ]);
+  collectBaseRequiredParams(
+    tsIndex,
+    flatProfile,
+    resolveRef,
+    params,
+    [
+      ...autoFields.map((f) => f.name),
+      ...sliceAutoFields.map((f) => f.name),
+      ...params.map((f) => f.name),
+      ...promotedChoices
+    ],
+    isFamilyType
+  );
   const accessors = [...autoAccessors, ...collectChoiceAccessors(flatProfile, promotedChoices)];
-  return { autoFields, sliceAutoFields, params, accessors };
+  return { autoFields, sliceAutoFields, params, accessors, fixedFields };
 };
-var collectBaseRequiredParams = (tsIndex, flatProfile, resolveRef, params, coveredNames) => {
+var collectBaseRequiredParams = (tsIndex, flatProfile, resolveRef, params, coveredNames, isFamilyType) => {
   const covered = new Set(coveredNames);
   const baseSchema = tsIndex.resolveType(flatProfile.base);
   if (!baseSchema || !("fields" in baseSchema) || !baseSchema.fields) return;
@@ -4990,7 +5146,7 @@ var collectBaseRequiredParams = (tsIndex, flatProfile, resolveRef, params, cover
     if (isChoiceInstanceField(field)) continue;
     if (isChoiceDeclarationField(field)) continue;
     if (isNotChoiceDeclarationField(field) && field.type) {
-      const tsType = fieldTsType(field, resolveRef);
+      const tsType = fieldTsType(field, resolveRef, isFamilyType);
       params.push({ name, tsType, typeId: field.type });
     }
   }
@@ -5018,23 +5174,27 @@ var generateProfileHelpersImport = (w, tsIndex, flatProfile, sliceDefs, factoryI
   const hasMeta = tsIndex.isWithMetaField(flatProfile);
   const canonicalUrl = flatProfile.identifier.url;
   const imports = [];
-  if (!isPrimitiveIdentifier(flatProfile.base)) imports.push("buildResource");
   if (flatProfile.base.name === "Extension" && !!canonicalUrl && collectSubExtensionSlices(flatProfile).length > 0)
     imports.push("isRawExtensionInput");
   if (canonicalUrl && hasMeta) imports.push("ensureProfile");
   if (sliceDefs.length > 0 || factoryInfo.sliceAutoFields.length > 0)
     imports.push("applySliceMatch", "matchesValue", "setArraySlice", "getArraySlice", "ensureSliceDefaults");
+  const hasUnboundedSlice = sliceDefs.some((s) => s.array && (s.max === 0 || s.max === void 0));
+  if (hasUnboundedSlice) imports.push("setArraySliceAll", "getArraySliceAll");
   if (extensions.some((ext) => ext.path.split(".").some((s) => s !== "extension"))) imports.push("ensurePath");
   if (extensions.some((ext) => ext.isComplex && ext.subExtensions)) imports.push("extractComplexExtension");
-  if (sliceDefs.some((s) => !s.typeDiscriminator)) imports.push("stripMatchKeys");
   if (sliceDefs.some((s) => s.constrainedChoice)) imports.push("wrapSliceChoice", "unwrapSliceChoice");
-  if (extensions.some((ext) => ext.url)) imports.push("isExtension", "getExtensionValue", "pushExtension");
+  if (extensions.some((ext) => ext.url)) {
+    imports.push("isExtension", "getExtensionValue", "pushExtension");
+    if (extensions.some((ext) => ext.url && ext.max === "1")) imports.push("upsertExtension");
+  }
   if (Object.keys(flatProfile.fields ?? {}).length > 0)
     imports.push(
       "validateRequired",
       "validateExcluded",
       "validateFixedValue",
       "validateSliceCardinality",
+      "validateSliceFields",
       "validateEnum",
       "validateReference",
       "validateChoiceRequired",
@@ -5109,7 +5269,17 @@ var generateProfileImports = (w, tsIndex, flatProfile) => {
 var generateStaticSliceFields = (w, sliceDefs) => {
   for (const sliceDef of sliceDefs) {
     const staticName = `${tsSliceStaticName(sliceDef.sliceName)}SliceMatch`;
-    w.lineSM(`private static readonly ${staticName}: Record<string, unknown> = ${JSON.stringify(sliceDef.match)}`);
+    const json = JSON.stringify(sliceDef.match);
+    const prefix = `private static readonly ${staticName}: Record<string, unknown> = `;
+    if (prefix.length + json.length <= (w.opts.lineWidth ?? 120)) {
+      w.lineSM(`${prefix}${json}`);
+    } else {
+      w.curlyBlock([prefix.trimEnd()], () => {
+        for (const [key, value] of Object.entries(sliceDef.match)) {
+          w.line(`${JSON.stringify(key)}: ${JSON.stringify(value)},`);
+        }
+      });
+    }
   }
   if (sliceDefs.length > 0) w.line();
 };
@@ -5147,6 +5317,28 @@ var generateFactoryMethods = (w, tsIndex, flatProfile, factoryInfo) => {
     if (hasMeta) {
       w.lineSM(`ensureProfile(resource, ${profileClassName}.canonicalUrl)`);
     }
+    if (flatProfile.base.name === "Extension" && flatProfile.identifier.url) {
+      w.lineSM(`resource.url = ${profileClassName}.canonicalUrl`);
+    }
+    const applyAutoFields = factoryInfo.autoFields.filter((f) => f.name !== "resourceType");
+    if (applyAutoFields.length > 0) {
+      w.curlyBlock(["Object.assign(resource,"], () => {
+        for (const f of applyAutoFields) {
+          w.line(`${f.name}: ${f.value},`);
+        }
+      }, [")"]);
+    }
+    for (const f of factoryInfo.sliceAutoFields) {
+      const matchRefs = f.sliceNames.map((s) => `${profileClassName}.${tsSliceStaticName(s)}SliceMatch`);
+      w.line(`resource.${f.name} = ensureSliceDefaults(`);
+      w.indentBlock(() => {
+        w.line(`[...(resource.${f.name} ?? [])],`);
+        for (const ref of matchRefs) {
+          w.line(`${ref},`);
+        }
+      });
+      w.lineSM(")");
+    }
     w.lineSM(`return new ${profileClassName}(resource)`);
   });
   w.line();
@@ -5209,7 +5401,7 @@ var generateFactoryMethods = (w, tsIndex, flatProfile, factoryInfo) => {
       }
       w.line();
       const extensionVar = extSliceField ? "extensionWithDefaults" : "resolvedExtensions";
-      w.curlyBlock([`const resource = buildResource<${tsBaseResourceName}>(`], () => {
+      w.curlyBlock([`const resource: ${tsBaseResourceName} =`], () => {
         for (const f of allFields) {
           if (f.name === "extension") continue;
           w.line(`${f.name}: ${f.value},`);
@@ -5218,7 +5410,7 @@ var generateFactoryMethods = (w, tsIndex, flatProfile, factoryInfo) => {
         if (hasMeta) {
           w.line(`meta: { profile: [${profileClassName}.canonicalUrl] },`);
         }
-      }, [")"]);
+      });
       w.lineSM("return resource");
     });
     w.line();
@@ -5245,22 +5437,21 @@ var generateFactoryMethods = (w, tsIndex, flatProfile, factoryInfo) => {
       if (isPrimitiveIdentifier(flatProfile.base)) {
         w.lineSM(`const resource = undefined as unknown as ${tsBaseResourceName}`);
       } else {
-        w.curlyBlock([`const resource = buildResource<${tsBaseResourceName}>(`], () => {
+        w.curlyBlock([`const resource: ${tsBaseResourceName} =`], () => {
           for (const f of allFields) {
             w.line(`${f.name}: ${f.value},`);
           }
           if (hasMeta) {
             w.line(`meta: { profile: [${profileClassName}.canonicalUrl] },`);
           }
-        }, [")"]);
+        });
       }
       w.lineSM("return resource");
     });
     w.line();
     w.curlyBlock(["static", "create", `(${paramSignature})`, `: ${profileClassName}`], () => {
-      w.lineSM(
-        `return ${profileClassName}.apply(${profileClassName}.createResource(${hasParams ? "args" : ""}))`
-      );
+      w.lineSM(`const resource = ${profileClassName}.createResource(${hasParams ? "args" : ""})`);
+      w.lineSM(`return ${profileClassName}.apply(resource)`);
     });
   }
   w.line();
@@ -5291,11 +5482,13 @@ var generateFieldAccessors = (w, factoryInfo, extSliceMethodBaseNames) => {
       w.lineSM(`return ${tsGet("this.resource", fieldAccess)} as ${a.tsType} | undefined`);
     });
     w.line();
-    w.curlyBlock([`set${methodBaseName}`, `(value: ${a.tsType})`, ": this"], () => {
-      w.lineSM(`Object.assign(this.resource, { ${fieldAccess}: value })`);
-      w.lineSM("return this");
-    });
-    w.line();
+    if (!factoryInfo.fixedFields.has(a.name)) {
+      w.curlyBlock([`set${methodBaseName}`, `(value: ${a.tsType})`, ": this"], () => {
+        w.lineSM(`Object.assign(this.resource, { ${fieldAccess}: value })`);
+        w.lineSM("return this");
+      });
+      w.line();
+    }
   }
 };
 var generateInlineExtensionInputTypes = (w, tsIndex, flatProfile) => {
@@ -5318,11 +5511,23 @@ var generateInlineExtensionInputTypes = (w, tsIndex, flatProfile) => {
     w.line();
   }
 };
+var valueToTypeLiteral = (value) => {
+  if (value === null || value === void 0) return "undefined";
+  if (typeof value === "string") return JSON.stringify(value);
+  if (typeof value === "number" || typeof value === "boolean") return String(value);
+  if (Array.isArray(value)) return `[${value.map(valueToTypeLiteral).join(", ")}]`;
+  if (typeof value === "object") {
+    const entries = Object.entries(value).map(([k, v]) => `${k}: ${valueToTypeLiteral(v)}`).join("; ");
+    return `{ ${entries} }`;
+  }
+  return "unknown";
+};
 var generateSliceInputTypes = (w, flatProfile, sliceDefs) => {
   if (sliceDefs.length === 0) return;
   const tsProfileName = tsResourceName(flatProfile.identifier);
   for (const sliceDef of sliceDefs) {
-    const typeName = tsSliceFlatTypeName(tsProfileName, sliceDef.fieldName, sliceDef.sliceName);
+    const inputTypeName = tsSliceFlatTypeName(tsProfileName, sliceDef.fieldName, sliceDef.sliceName);
+    const flatTypeName = tsSliceFlatAllTypeName(tsProfileName, sliceDef.fieldName, sliceDef.sliceName);
     const matchFields = sliceDef.typeDiscriminator ? [] : Object.keys(sliceDef.match);
     const allExcluded = [.../* @__PURE__ */ new Set([...sliceDef.excluded, ...matchFields])];
     if (sliceDef.constrainedChoice) {
@@ -5335,19 +5540,32 @@ var generateSliceInputTypes = (w, flatProfile, sliceDefs) => {
     const excludedNames = allExcluded.map((name) => JSON.stringify(name));
     const requiredNames = sliceDef.required.map((name) => JSON.stringify(name));
     const baseType = sliceDef.typedBaseType;
-    let typeExpr = baseType;
+    let inputTypeExpr = baseType;
     if (excludedNames.length > 0) {
-      typeExpr = `Omit<${typeExpr}, ${excludedNames.join(" | ")}>`;
+      inputTypeExpr = `Omit<${inputTypeExpr}, ${excludedNames.join(" | ")}>`;
     }
     if (requiredNames.length > 0) {
-      typeExpr = `${typeExpr} & Required<Pick<${baseType}, ${requiredNames.join(" | ")}>>`;
+      inputTypeExpr = `${inputTypeExpr} & Required<Pick<${baseType}, ${requiredNames.join(" | ")}>>`;
     }
     if (sliceDef.constrainedChoice) {
-      typeExpr = `${typeExpr} & ${tsTypeFromIdentifier(sliceDef.constrainedChoice.variantType)}`;
+      inputTypeExpr = `${inputTypeExpr} & ${tsTypeFromIdentifier(sliceDef.constrainedChoice.variantType)}`;
+    }
+    w.lineSM(`export type ${inputTypeName} = ${inputTypeExpr}`);
+    const safeMatchEntries = matchFields.length > 0 && !sliceDef.constrainedChoice ? matchFields.filter((key) => {
+      const v = sliceDef.match[key];
+      return Array.isArray(v) || typeof v !== "object" || v === null;
+    }).map((key) => ({ key, typeLiteral: valueToTypeLiteral(sliceDef.match[key]) })) : [];
+    if (safeMatchEntries.length > 0) {
+      w.curlyBlock([`export type ${flatTypeName} = ${inputTypeName} &`], () => {
+        for (const entry of safeMatchEntries) {
+          w.lineSM(`readonly ${entry.key}: ${entry.typeLiteral}`);
+        }
+      });
+    } else {
+      w.lineSM(`export type ${flatTypeName} = ${inputTypeName}`);
     }
-    w.lineSM(`export type ${typeName} = ${typeExpr}`);
+    w.line();
   }
-  w.line();
 };
 var generateRawType = (w, flatProfile, factoryInfo) => {
   const hasParams = factoryInfo.params.length > 0 || factoryInfo.sliceAutoFields.length > 0;
@@ -5585,7 +5803,7 @@ var TypeScript = class extends Writer {
     const typeExpr = isArray ? "(Element | null)[]" : "Element";
     this.lineSM(`${extFieldName}?: ${typeExpr}`);
   }
-  generateType(tsIndex, schema) {
+  generateType(tsIndex, schema, isFamilyType) {
     let name;
     const genericTypes = ["Reference", "Coding", "CodeableConcept"];
     if (genericTypes.includes(schema.identifier.name)) {
@@ -5639,7 +5857,14 @@ var TypeScript = class extends Writer {
         if (!field.type) continue;
         this.debugComment(fieldName, ":", field);
         const tsName = tsFieldName(fieldName);
-        const tsType = resolveFieldTsType(schema.identifier.name, tsName, field, void 0, genericFieldMap);
+        const tsType = resolveFieldTsType(
+          schema.identifier.name,
+          tsName,
+          field,
+          void 0,
+          genericFieldMap,
+          isFamilyType
+        );
         const optionalSymbol = field.required ? "" : "?";
         const arraySymbol = field.array ? "[]" : "";
         this.lineSM(`${tsName}${optionalSymbol}: ${tsType}${arraySymbol}`);
@@ -5669,10 +5894,10 @@ var TypeScript = class extends Writer {
       );
     });
   }
-  generateNestedTypes(tsIndex, schema) {
+  generateNestedTypes(tsIndex, schema, isFamilyType) {
     if (schema.nested) {
       for (const subtype of schema.nested) {
-        this.generateType(tsIndex, subtype);
+        this.generateType(tsIndex, subtype, isFamilyType);
         this.line();
       }
     }
@@ -5688,17 +5913,18 @@ var TypeScript = class extends Writer {
         });
       });
     } else if (isSpecializationTypeSchema(schema)) {
+      const isFamilyType = mkIsFamilyType(tsIndex);
       this.cat(`${tsModuleFileName(schema.identifier)}`, () => {
         this.generateDisclaimer();
         this.generateDependenciesImports(tsIndex, schema);
         this.generateComplexTypeReexports(schema);
-        this.generateNestedTypes(tsIndex, schema);
+        this.generateNestedTypes(tsIndex, schema, isFamilyType);
         this.comment(
           "CanonicalURL:",
           schema.identifier.url,
           `(pkg: ${packageMetaToFhir(packageMeta(schema))})`
         );
-        this.generateType(tsIndex, schema);
+        this.generateType(tsIndex, schema, isFamilyType);
         this.generateResourceTypePredicate(schema);
       });
     } else {
@@ -5881,7 +6107,8 @@ var APIBuilder = class {
     const defaultPyOpts = {
       ...defaultWriterOpts,
       rootPackageName: "fhir_types",
-      fieldFormat: "snake_case"
+      fieldFormat: "snake_case",
+      primitiveTypeExtension: false
     };
     const opts = {
       ...defaultPyOpts,