@atomic-ehr/codegen 0.0.15 → 0.0.16

package/dist/index.js

@@ -110,8 +110,9 @@ function mkLogger(opts = {}) {
 var mkCodegenLogger = (opts = {}) => mkLogger(opts);
 
 // src/api/writer-generator/utils.ts
+var WORD_SPLIT_RE = /(?<=[a-z])(?=[A-Z])|[-_.\s]/;
 var words = (s) => {
-  return s.split(/(?<=[a-z])(?=[A-Z])|[-_.\s]/).filter(Boolean);
+  return s.split(WORD_SPLIT_RE).filter(Boolean);
 };
 var kebabCase = (s) => {
   return words(s).map((s2) => s2.toLowerCase()).join("-");
@@ -294,9 +295,8 @@ var Writer = class extends FileSystemWriter {
       tokens = tokens.map((token) => {
         if (typeof token === "string") {
           return token;
-        } else {
-          return JSON.stringify(token, null, 2);
         }
+        return JSON.stringify(token, null, 2);
       });
       this.comment(...tokens);
     }
@@ -334,6 +334,7 @@ var Writer = class extends FileSystemWriter {
     this.line(`]${endTokens?.filter(Boolean).join(" ") ?? ""}`);
   }
 };
+var LEADING_DIGIT_RE = /^\d/;
 var extractNameFromCanonical = (canonical, dropFragment = true) => {
   let localName = canonical.split("/").pop();
   if (!localName) return void 0;
@@ -341,7 +342,7 @@ var extractNameFromCanonical = (canonical, dropFragment = true) => {
     localName = localName.split("#")[0];
   }
   if (!localName) return void 0;
-  if (/^\d/.test(localName)) {
+  if (LEADING_DIGIT_RE.test(localName)) {
     localName = `number_${localName}`;
   }
   return localName;
@@ -505,9 +506,8 @@ var resolveCSharpAssets = (fn) => {
   const __dirname = Path5__default.dirname(__filename);
   if (__filename.endsWith("dist/index.js")) {
     return Path5__default.resolve(__dirname, "..", "assets", "api", "writer-generator", "csharp", fn);
-  } else {
-    return Path5__default.resolve(__dirname, "../../../..", "assets", "api", "writer-generator", "csharp", fn);
   }
+  return Path5__default.resolve(__dirname, "../../../..", "assets", "api", "writer-generator", "csharp", fn);
 };
 var PRIMITIVE_TYPE_MAP = {
   boolean: "bool",
@@ -543,13 +543,14 @@ var formatClassName = (schema) => {
 var formatBaseClass = (schema) => {
   return schema.base ? `: ${schema.base.name}` : "";
 };
+var LEADING_DIGIT_RE2 = /^\d/;
 var canonicalToName = (canonical, dropFragment = true) => {
   if (!canonical) return void 0;
   let localName = canonical.split("/").pop();
   if (!localName) return void 0;
   if (dropFragment && localName.includes("#")) localName = localName.split("#")[0];
   if (!localName) return void 0;
-  if (/^\d/.test(localName)) {
+  if (LEADING_DIGIT_RE2.test(localName)) {
     localName = `number_${localName}`;
   }
   return formatName(localName);
@@ -781,6 +782,116 @@ var CSharp = class extends Writer {
     fs__default.copyFileSync(sourceFile, destFile);
   }
 };
+
+// src/api/writer-generator/python/naming-utils.ts
+var PRIMITIVE_TYPE_MAP2 = {
+  boolean: "bool",
+  instant: "str",
+  time: "str",
+  date: "str",
+  dateTime: "str",
+  decimal: "float",
+  integer: "int",
+  unsignedInt: "int",
+  positiveInt: "PositiveInt",
+  integer64: "int",
+  base64Binary: "str",
+  uri: "str",
+  url: "str",
+  canonical: "str",
+  oid: "str",
+  uuid: "str",
+  string: "str",
+  code: "str",
+  markdown: "str",
+  id: "str",
+  xhtml: "str"
+};
+var PYTHON_KEYWORDS = /* @__PURE__ */ new Set([
+  "False",
+  "None",
+  "True",
+  "and",
+  "as",
+  "assert",
+  "async",
+  "await",
+  "break",
+  "class",
+  "continue",
+  "def",
+  "del",
+  "elif",
+  "else",
+  "except",
+  "finally",
+  "for",
+  "from",
+  "global",
+  "if",
+  "import",
+  "in",
+  "is",
+  "lambda",
+  "nonlocal",
+  "not",
+  "or",
+  "pass",
+  "raise",
+  "return",
+  "try",
+  "while",
+  "with",
+  "yield"
+]);
+var fixReservedWords = (name) => {
+  return PYTHON_KEYWORDS.has(name) ? `${name}_` : name;
+};
+var canonicalToName2 = (canonical, dropFragment = true) => {
+  if (!canonical) return void 0;
+  let localName = canonical.split("/").pop();
+  if (!localName) return void 0;
+  if (dropFragment && localName.includes("#")) {
+    localName = localName.split("#")[0];
+  }
+  if (!localName) return void 0;
+  if (/^\d/.test(localName)) {
+    localName = `number_${localName}`;
+  }
+  return snakeCase(localName);
+};
+var deriveResourceName = (id) => {
+  if (id.kind === "nested") {
+    const url = id.url;
+    const path = canonicalToName2(url, false);
+    if (!path) return "";
+    const [resourceName, fragment] = path.split("#");
+    const name = uppercaseFirstLetterOfEach((fragment ?? "").split(".")).join("");
+    return pascalCase([resourceName, name].join(""));
+  }
+  return pascalCase(id.name);
+};
+var buildPyPackageName = (packageName) => {
+  const parts = packageName ? [snakeCase(packageName)] : [""];
+  return parts.join(".");
+};
+var pyFhirPackageByName = (rootPackageName, name) => [rootPackageName, buildPyPackageName(name)].join(".");
+var pyFhirPackage = (rootPackageName, identifier) => pyFhirPackageByName(rootPackageName, identifier.package);
+var pyPackage = (rootPackageName, identifier) => {
+  if (identifier.kind === "complex-type") {
+    return `${pyFhirPackage(rootPackageName, identifier)}.base`;
+  }
+  if (identifier.kind === "resource") {
+    return [pyFhirPackage(rootPackageName, identifier), snakeCase(identifier.name)].join(".");
+  }
+  return pyFhirPackage(rootPackageName, identifier);
+};
+var pyTypeFromIdentifier = (id) => {
+  if (isPrimitiveIdentifier(id)) return PRIMITIVE_TYPE_MAP2[id.name] ?? "str";
+  const prim = PRIMITIVE_TYPE_MAP2[id.name];
+  if (prim !== void 0) return prim;
+  return deriveResourceName(id);
+};
 var groupByPackages = (typeSchemas) => {
   const grouped = {};
   for (const ts of typeSchemas) {
@@ -1202,180 +1313,1193 @@ var mkTypeSchemaIndex = (schemas, {
         allChoiceNames: field.choices
       };
     }
-    return void 0;
-  };
-  const isWithMetaField = (profile) => {
-    const genealogy = tryHierarchy(profile);
-    if (!genealogy) return false;
-    return genealogy.filter(isSpecializationTypeSchema).some((schema) => {
-      return schema.fields?.meta !== void 0;
+    return void 0;
+  };
+  const isWithMetaField = (profile) => {
+    const genealogy = tryHierarchy(profile);
+    if (!genealogy) return false;
+    return genealogy.filter(isSpecializationTypeSchema).some((schema) => {
+      return schema.fields?.meta !== void 0;
+    });
+  };
+  const entityTree = () => {
+    const tree = {};
+    for (const [pkgId, shemas] of Object.entries(groupByPackages(schemas))) {
+      tree[pkgId] = {
+        "primitive-type": {},
+        "complex-type": {},
+        resource: {},
+        "value-set": {},
+        nested: {},
+        binding: {},
+        profile: {},
+        "profile-snapshot": {},
+        logical: {}
+      };
+      for (const schema of shemas) {
+        tree[pkgId][schema.identifier.kind][schema.identifier.url] = {};
+      }
+    }
+    return tree;
+  };
+  const exportTree = async (filename) => {
+    const tree = entityTree();
+    const raw = filename.endsWith(".yaml") ? YAML.stringify(tree) : JSON.stringify(tree, void 0, 2);
+    await fsPromises.mkdir(Path5.dirname(filename), { recursive: true });
+    await fsPromises.writeFile(filename, raw);
+  };
+  return {
+    _schemaIndex: index,
+    schemas,
+    schemasByPackage: groupByPackages(schemas),
+    register,
+    collectComplexTypes: () => schemas.filter(isComplexTypeTypeSchema),
+    collectResources: () => schemas.filter(isResourceTypeSchema),
+    collectLogicalModels: () => schemas.filter(isLogicalTypeSchema),
+    collectProfiles: () => schemas.filter(isProfileTypeSchema),
+    collectSnapshotProfiles,
+    resolve: resolve6,
+    resolveType,
+    resolveByUrl,
+    tryHierarchy,
+    hierarchy,
+    findLastSpecialization,
+    findLastSpecializationByIdentifier,
+    flatProfile,
+    constrainedChoice,
+    isWithMetaField,
+    entityTree,
+    exportTree,
+    irReport: () => irReport,
+    replaceSchemas: (newSchemas) => mkTypeSchemaIndex(newSchemas, { register, logger, irReport: { ...irReport } })
+  };
+};
+
+// src/api/writer-generator/python/profile-naming.ts
+var normalizePyName = (n) => {
+  let out = n.replace(/\[x\]/g, "_x_").replace(/[- :./]/g, "_");
+  if (PYTHON_KEYWORDS.has(out)) out = `${out}_`;
+  if (/^\d/.test(out)) out = `_${out}`;
+  return out;
+};
+var pySnakeName = (name) => {
+  if (!name) return "";
+  const cleaned = name.replace(/\[x\]/g, "").replace(/[:./]/g, "_");
+  return snakeCase(cleaned);
+};
+var pyFieldName = (n, formatName2 = snakeCase) => {
+  const cleaned = n.replace(/\[x\]/g, "").replace(/[:./]/g, "_");
+  const out = formatName2(cleaned);
+  return PYTHON_KEYWORDS.has(out) ? `${out}_` : out;
+};
+var pyProfileClassName = (schema) => {
+  const name = pascalCase(normalizePyName(schema.identifier.name));
+  if (schema.base.name === "Extension") {
+    return name.endsWith("Extension") ? name : `${name}Extension`;
+  }
+  return name.endsWith("Profile") ? name : `${name}Profile`;
+};
+var pyProfileModuleName = (tsIndex, schema) => {
+  const baseSchema = tsIndex.findLastSpecialization(schema);
+  const baseName = snakeCase(normalizePyName(baseSchema.identifier.name));
+  const profileName = snakeCase(normalizePyName(schema.identifier.name));
+  return `${baseName}_${profileName}`;
+};
+var pySliceStaticName = (name) => {
+  const cleaned = name.replace(/\[x]/g, "").replace(/[^a-zA-Z0-9_]/g, "_");
+  return `_${snakeCase(cleaned)}_slice_match`;
+};
+var pyValueFieldName = (id, formatName2 = snakeCase) => formatName2(`value${pascalCase(normalizePyName(id.name))}`);
+var resolveProfileMethodBaseNames = (extensions, sliceDefs) => {
+  const extensionsRecord = {};
+  for (const ext of extensions) {
+    if (!ext.url) continue;
+    extensionsRecord[`${ext.url}:${ext.path}`] = snakeCase(ext.nameCandidates.recommended);
+  }
+  const slicesRecord = {};
+  for (const s of sliceDefs) {
+    slicesRecord[`${s.fieldName}:${s.sliceName}`] = snakeCase(s.nameCandidates.recommended);
+  }
+  const allBaseNames = /* @__PURE__ */ new Set([...Object.values(extensionsRecord), ...Object.values(slicesRecord)]);
+  return { extensions: extensionsRecord, slices: slicesRecord, allBaseNames };
+};
+
+// src/api/writer-generator/python/profile-extensions.ts
+var resolveExtensionProfile = (tsIndex, pkgName, ext) => {
+  if (ext.profile) {
+    const schema2 = tsIndex.resolve(ext.profile);
+    if (schema2) {
+      return {
+        className: pyProfileClassName(schema2),
+        moduleName: pyProfileModuleName(tsIndex, schema2)
+      };
+    }
+  }
+  if (!ext.url) return void 0;
+  const schema = tsIndex.resolveByUrl(pkgName, ext.url);
+  if (!schema || !isProfileTypeSchema(schema)) return void 0;
+  if (schema.identifier.package !== pkgName) return void 0;
+  return {
+    className: pyProfileClassName(schema),
+    moduleName: pyProfileModuleName(tsIndex, schema)
+  };
+};
+var generateExtensionMethods = (w, tsIndex, flatProfile, className, extensionBaseNames) => {
+  const pkgName = flatProfile.identifier.package;
+  for (const ext of flatProfile.extensions ?? []) {
+    if (!ext.url) continue;
+    const baseName = extensionBaseNames[`${ext.url}:${ext.path}`] ?? snakeCase(ext.nameCandidates.recommended);
+    const targetPath = ext.path.split(".").filter((segment) => segment !== "extension");
+    const extProfileInfo = resolveExtensionProfile(tsIndex, pkgName, ext);
+    if (ext.isComplex && ext.subExtensions) {
+      generateComplexExtensionGetter(w, ext, baseName, targetPath, extProfileInfo);
+      generateComplexExtensionSetter(w, ext, className, baseName, targetPath, extProfileInfo);
+    } else if (ext.valueFieldTypes?.length === 1 && ext.valueFieldTypes[0]) {
+      const valueType = ext.valueFieldTypes[0];
+      const valueField = pyValueFieldName(valueType, w.nameFormatFunction);
+      const pyType = pyTypeFromIdentifier(valueType);
+      generateSingleValueExtensionGetter(w, ext, baseName, targetPath, valueField, pyType, extProfileInfo);
+      generateSingleValueExtensionSetter(w, ext, className, baseName, targetPath, valueField, extProfileInfo);
+    } else {
+      generateGenericExtensionGetter(w, ext, baseName, targetPath, extProfileInfo);
+      generateGenericExtensionSetter(w, ext, className, baseName, targetPath, extProfileInfo);
+    }
+  }
+};
+var emitExtLookup = (w, ext, targetPath) => {
+  if (targetPath.length === 0) {
+    w.line(`exts = getattr(self._resource, "extension", None) or []`);
+  } else {
+    w.line(
+      `target = ensure_path(self._resource.model_dump(by_alias=True, exclude_none=True) if hasattr(self._resource, "model_dump") else self._resource, ${JSON.stringify(targetPath)})`
+    );
+    w.line(`exts = target.get("extension", []) if isinstance(target, dict) else []`);
+  }
+  w.line(`ext = next((e for e in exts if is_extension(e, ${JSON.stringify(ext.url)})), None)`);
+};
+var emitExtPush = (w, targetPath, extExpr) => {
+  if (targetPath.length === 0) {
+    w.line(`push_extension(self._resource, ${extExpr})`);
+  } else {
+    w.line(`target = ensure_path(self._resource, ${JSON.stringify(targetPath)})`);
+    w.line(`push_extension(target, ${extExpr})`);
+  }
+};
+var emitGetterOverloads = (w, methodName, flatPyType, extProfileInfo) => {
+  const profileClass = extProfileInfo?.className;
+  w.line("@overload");
+  w.line(`def ${methodName}(self) -> ${flatPyType} | None: ...`);
+  w.line("@overload");
+  w.line(`def ${methodName}(self, mode: Literal["raw"]) -> Extension | None: ...`);
+  if (profileClass) {
+    w.line("@overload");
+    w.line(`def ${methodName}(self, mode: Literal["profile"]) -> ${profileClass} | None: ...`);
+  }
+  const modeType = profileClass ? `Literal["raw", "profile"] | None` : `Literal["raw"] | None`;
+  const returnUnion = profileClass ? `${flatPyType} | Extension | ${profileClass} | None` : `${flatPyType} | Extension | None`;
+  w.line(`def ${methodName}(self, mode: ${modeType} = None) -> ${returnUnion}:`);
+};
+var emitGetterModeDispatch = (w, extProfileInfo) => {
+  w.line("ext_obj = ext if not isinstance(ext, dict) else Extension(**ext)");
+  w.line(`if mode == "raw":`);
+  w.indentBlock(() => w.line("return ext_obj"));
+  if (extProfileInfo) {
+    w.line(`if mode == "profile":`);
+    w.indentBlock(() => w.line(`return ${extProfileInfo.className}.apply(ext_obj)`));
+  }
+};
+var emitSetterDispatchPreamble = (w, ext, targetPath, extProfileInfo) => {
+  let startedChain = false;
+  if (extProfileInfo) {
+    w.line(`if isinstance(value, ${extProfileInfo.className}):`);
+    w.indentBlock(() => emitExtPush(w, targetPath, "value.to_resource()"));
+    startedChain = true;
+  }
+  const keyword = startedChain ? "elif" : "if";
+  w.line(`${keyword} is_extension(value):`);
+  w.indentBlock(() => {
+    w.line(`if _get_key(value, "url") != ${JSON.stringify(ext.url)}:`);
+    w.indentBlock(
+      () => w.line(`raise ValueError(f"Expected extension url '${ext.url}', got {_get_key(value, 'url')!r}")`)
+    );
+    emitExtPush(w, targetPath, "value");
+  });
+};
+var buildSetterParamType = (flatType, extProfileInfo) => {
+  const parts = [];
+  if (extProfileInfo) parts.push(extProfileInfo.className);
+  parts.push("Extension", flatType);
+  return `"${parts.join(" | ")}"`;
+};
+var generateExtensionGetter = (w, ext, baseName, flatPyType, targetPath, extProfileInfo, emitFlatReturn) => {
+  emitGetterOverloads(w, `get_${baseName}`, flatPyType, extProfileInfo);
+  w.indentBlock(() => {
+    emitExtLookup(w, ext, targetPath);
+    w.line("if ext is None:");
+    w.indentBlock(() => w.line("return None"));
+    emitGetterModeDispatch(w, extProfileInfo);
+    emitFlatReturn();
+  });
+  w.line();
+};
+var generateComplexExtensionGetter = (w, ext, baseName, targetPath, extProfileInfo) => {
+  generateExtensionGetter(w, ext, baseName, "dict[str, Any]", targetPath, extProfileInfo, () => {
+    const configItems = (ext.subExtensions ?? []).map((sub) => {
+      const valueField = sub.valueFieldType ? pyValueFieldName(sub.valueFieldType, w.nameFormatFunction) : "value";
+      const isArray = sub.max === "*";
+      return `{"name": ${JSON.stringify(sub.url)}, "valueField": ${JSON.stringify(valueField)}, "isArray": ${isArray ? "True" : "False"}}`;
+    });
+    w.line(`config = [${configItems.join(", ")}]`);
+    w.line("return extract_complex_extension(ext, config)");
+  });
+};
+var generateExtensionSetter = (w, ext, className, baseName, flatParamType, targetPath, extProfileInfo, emitElseBody) => {
+  const paramType = buildSetterParamType(flatParamType, extProfileInfo);
+  w.line(`def set_${baseName}(self, value: ${paramType}) -> "${className}":`);
+  w.indentBlock(() => {
+    emitSetterDispatchPreamble(w, ext, targetPath, extProfileInfo);
+    w.line("else:");
+    w.indentBlock(emitElseBody);
+    w.line("return self");
+  });
+  w.line();
+};
+var generateComplexExtensionSetter = (w, ext, className, baseName, targetPath, extProfileInfo) => {
+  generateExtensionSetter(w, ext, className, baseName, "dict[str, Any]", targetPath, extProfileInfo, () => {
+    w.line("sub_extensions = []");
+    for (const sub of ext.subExtensions ?? []) {
+      const valueField = sub.valueFieldType ? pyValueFieldName(sub.valueFieldType, w.nameFormatFunction) : "value";
+      if (sub.max === "*") {
+        w.line(`for item in value.get(${JSON.stringify(sub.url)}, []):`);
+        w.indentBlock(() => {
+          w.line(
+            `sub_extensions.append({"url": ${JSON.stringify(sub.url)}, ${JSON.stringify(valueField)}: item})`
+          );
+        });
+      } else {
+        w.line(`if value.get(${JSON.stringify(sub.url)}) is not None:`);
+        w.indentBlock(() => {
+          w.line(
+            `sub_extensions.append({"url": ${JSON.stringify(sub.url)}, ${JSON.stringify(valueField)}: value[${JSON.stringify(sub.url)}]})`
+          );
+        });
+      }
+    }
+    const extObj = `Extension(url=${JSON.stringify(ext.url)}, extension=sub_extensions)`;
+    emitExtPush(w, targetPath, extObj);
+  });
+};
+var generateSingleValueExtensionGetter = (w, ext, baseName, targetPath, valueField, pyType, extProfileInfo) => {
+  generateExtensionGetter(w, ext, baseName, pyType, targetPath, extProfileInfo, () => {
+    w.line(`return cast('${pyType} | None', get_extension_value(ext, ${JSON.stringify(valueField)}))`);
+  });
+};
+var generateSingleValueExtensionSetter = (w, ext, className, baseName, targetPath, valueField, extProfileInfo) => {
+  generateExtensionSetter(w, ext, className, baseName, "Any", targetPath, extProfileInfo, () => {
+    emitExtPush(w, targetPath, `Extension(url=${JSON.stringify(ext.url)}, ${valueField}=value)`);
+  });
+};
+var generateGenericExtensionGetter = (w, ext, baseName, targetPath, extProfileInfo) => {
+  generateExtensionGetter(w, ext, baseName, "dict[str, Any]", targetPath, extProfileInfo, () => {
+    w.line(
+      'return cast("dict[str, Any] | None", ext if isinstance(ext, dict) else ext.model_dump(by_alias=True, exclude_none=True))'
+    );
+  });
+};
+var generateGenericExtensionSetter = (w, ext, className, baseName, targetPath, extProfileInfo) => {
+  generateExtensionSetter(w, ext, className, baseName, "dict[str, Any]", targetPath, extProfileInfo, () => {
+    emitExtPush(w, targetPath, `{"url": ${JSON.stringify(ext.url)}, **value}`);
+  });
+};
+
+// src/api/writer-generator/python/profile-slices.ts
+var collectRequiredSliceNames = (field) => {
+  if (!field.array || !field.slicing?.slices) return void 0;
+  if (field.slicing.discriminator?.some((d) => d.type === "type")) 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);
+  return names.length > 0 ? names : void 0;
+};
+var generateStaticSliceFields = (w, sliceDefs) => {
+  for (const sliceDef of sliceDefs) {
+    const staticName = pySliceStaticName(sliceDef.sliceName);
+    w.line(`${staticName}: dict[str, Any] = ${JSON.stringify(sliceDef.match)}`);
+  }
+  if (sliceDefs.length > 0) w.line();
+};
+var normalizeMatchForPython = (tsIndex, match, schema) => {
+  if (!schema || !("fields" in schema) || !schema.fields) return match;
+  const result = {};
+  for (const [key, value] of Object.entries(match)) {
+    const fieldDef = schema.fields[key];
+    if (!fieldDef || !isNotChoiceDeclarationField(fieldDef)) {
+      result[key] = value;
+      continue;
+    }
+    const nestedSchema = fieldDef.type ? tsIndex.resolveType(fieldDef.type) : void 0;
+    const normalizeOne = (v) => v !== null && typeof v === "object" && !Array.isArray(v) ? normalizeMatchForPython(tsIndex, v, nestedSchema) : v;
+    if (Array.isArray(value)) {
+      result[key] = value.map(normalizeOne);
+    } else if (value !== null && typeof value === "object") {
+      const normalized = normalizeOne(value);
+      result[key] = fieldDef.array ? [normalized] : normalized;
+    } else {
+      result[key] = value;
+    }
+  }
+  return result;
+};
+var extractTypeDiscriminatorResource = (isTypeDiscriminated, rawMatch) => {
+  if (!isTypeDiscriminated || !rawMatch) return void 0;
+  for (const val of Object.values(rawMatch)) {
+    if (val !== null && typeof val === "object" && !Array.isArray(val)) {
+      const rt = val.resourceType;
+      if (typeof rt === "string") return rt;
+    }
+  }
+  return void 0;
+};
+var collectSliceDefs = (tsIndex, flatProfile) => {
+  const pkgName = flatProfile.identifier.package;
+  return Object.entries(flatProfile.fields).flatMap(([fieldName, field]) => {
+    if (!isNotChoiceDeclarationField(field) || !field.slicing?.slices || !field.type) return [];
+    const choiceBaseNames = /* @__PURE__ */ new Set();
+    const baseSchema = tsIndex.resolveType(field.type);
+    if (baseSchema && "fields" in baseSchema && baseSchema.fields) {
+      for (const [n, f] of Object.entries(baseSchema.fields)) {
+        if (isChoiceDeclarationField(f)) choiceBaseNames.add(n);
+      }
+    }
+    return Object.entries(field.slicing.slices).filter(([_, slice]) => Object.keys(slice.match ?? {}).length > 0).map(([sliceName, slice]) => {
+      const matchFields = Object.keys(slice.match ?? {});
+      const required = (slice.required ?? []).filter(
+        (name) => !matchFields.includes(name) && !choiceBaseNames.has(name)
+      );
+      const cc = slice.elements ? tsIndex.constrainedChoice(pkgName, field.type, slice.elements) : void 0;
+      const constrainedChoice = cc && !isPrimitiveIdentifier(cc.variantType) ? cc : void 0;
+      const isTypeDiscriminated = field.slicing?.discriminator?.some((d) => d.type === "type") ?? false;
+      const typeDiscriminatorResource = extractTypeDiscriminatorResource(
+        isTypeDiscriminated,
+        slice.match
+      );
+      return {
+        fieldName,
+        sliceName,
+        match: normalizeMatchForPython(tsIndex, slice.match ?? {}, baseSchema),
+        required,
+        array: Boolean(field.array),
+        max: slice.max ?? 0,
+        constrainedChoice,
+        elementTypeName: field.type && !isPrimitiveIdentifier(field.type) ? pyTypeFromIdentifier(field.type) : void 0,
+        elementTypeId: field.type && !isPrimitiveIdentifier(field.type) ? field.type : void 0,
+        isTypeDiscriminated,
+        typeDiscriminatorResource,
+        nameCandidates: slice.nameCandidates
+      };
+    });
+  });
+};
+var sliceElementRetType = (sliceDef) => sliceDef.elementTypeName && sliceDef.typeDiscriminatorResource ? `${sliceDef.elementTypeName}[${sliceDef.typeDiscriminatorResource}]` : sliceDef.elementTypeName ?? "Any";
+var generateSliceGetters = (w, sliceDefs, sliceBaseNames) => {
+  for (const sliceDef of sliceDefs) {
+    const baseName = sliceBaseNames[`${sliceDef.fieldName}:${sliceDef.sliceName}`] ?? sliceDef.nameCandidates.recommended;
+    const staticName = pySliceStaticName(sliceDef.sliceName);
+    const fieldName = pyFieldName(sliceDef.fieldName, w.nameFormatFunction);
+    const matchKeys = JSON.stringify(Object.keys(sliceDef.match));
+    if (sliceDef.isTypeDiscriminated) {
+      const retType = sliceElementRetType(sliceDef);
+      const isUnbounded = sliceDef.array && sliceDef.max === 0;
+      if (isUnbounded) {
+        w.line(`def get_${baseName}(self, mode: str | None = None) -> list[${retType}] | None:`);
+        w.indentBlock(() => {
+          w.line(`match = self.__class__.${staticName}`);
+          w.line(
+            `result = get_array_slices(getattr(self._resource, ${JSON.stringify(fieldName)}, None), match)`
+          );
+          w.line(`return cast('list[${retType}] | None', result or None)`);
+        });
+      } else {
+        w.line(`def get_${baseName}(self, mode: str | None = None) -> ${retType} | None:`);
+        w.indentBlock(() => {
+          w.line(`match = self.__class__.${staticName}`);
+          w.line(
+            `return cast('${retType} | None', get_array_slice(getattr(self._resource, ${JSON.stringify(fieldName)}, None), match))`
+          );
+        });
+      }
+    } else {
+      const flatRetType = "dict[str, Any]";
+      const rawRetType = sliceDef.elementTypeName ?? "Any";
+      w.line("@overload");
+      w.line(`def get_${baseName}(self) -> ${flatRetType} | None: ...`);
+      w.line("@overload");
+      w.line(`def get_${baseName}(self, mode: Literal["raw"]) -> ${rawRetType} | None: ...`);
+      w.line(
+        `def get_${baseName}(self, mode: Literal["raw"] | None = None) -> ${flatRetType} | ${rawRetType} | None:`
+      );
+      w.indentBlock(() => {
+        w.line(`match = self.__class__.${staticName}`);
+        if (sliceDef.array) {
+          w.line(
+            `item = get_array_slice(getattr(self._resource, ${JSON.stringify(fieldName)}, None), match)`
+          );
+        } else {
+          w.line(`item = getattr(self._resource, ${JSON.stringify(fieldName)}, None)`);
+          w.line("if item is None or not matches_value(item, match):");
+          w.indentBlock(() => {
+            w.line("return None");
+          });
+        }
+        w.line('if mode == "raw":');
+        w.indentBlock(() => {
+          w.line(`return cast('${rawRetType} | None', item)`);
+        });
+        w.line(
+          "item_dict = item if isinstance(item, dict) else item.model_dump(by_alias=True, exclude_none=True)"
+        );
+        if (sliceDef.constrainedChoice) {
+          const variant = JSON.stringify(sliceDef.constrainedChoice.variant);
+          w.line(`return unwrap_slice_choice(item_dict, ${matchKeys}, ${variant})`);
+        } else {
+          w.line(`return strip_match_keys(item_dict, ${matchKeys})`);
+        }
+      });
+    }
+    w.line();
+  }
+};
+var generateSliceSetters = (w, className, sliceDefs, sliceBaseNames) => {
+  for (const sliceDef of sliceDefs) {
+    const baseName = sliceBaseNames[`${sliceDef.fieldName}:${sliceDef.sliceName}`] ?? sliceDef.nameCandidates.recommended;
+    const staticName = pySliceStaticName(sliceDef.sliceName);
+    const fieldName = pyFieldName(sliceDef.fieldName, w.nameFormatFunction);
+    if (sliceDef.isTypeDiscriminated) {
+      const retType = sliceElementRetType(sliceDef);
+      const isUnbounded = sliceDef.array && sliceDef.max === 0;
+      if (isUnbounded) {
+        w.line(`def set_${baseName}(self, values: list[${retType}]) -> "${className}":`);
+        w.indentBlock(() => {
+          w.line(`match = self.__class__.${staticName}`);
+          w.line(`items = list(getattr(self._resource, ${JSON.stringify(fieldName)}, None) or [])`);
+          w.line("set_array_slices(items, match, values)");
+          w.line(`setattr(self._resource, ${JSON.stringify(fieldName)}, items)`);
+          w.line("return self");
+        });
+      } else {
+        w.line(`def set_${baseName}(self, value: ${retType} | None = None) -> "${className}":`);
+        w.indentBlock(() => {
+          w.line(`match = self.__class__.${staticName}`);
+          w.line(`items = getattr(self._resource, ${JSON.stringify(fieldName)}, None) or []`);
+          w.line("set_array_slice(items, match, value)");
+          w.line(`setattr(self._resource, ${JSON.stringify(fieldName)}, items)`);
+          w.line("return self");
+        });
+      }
+    } else {
+      const inputOptional = sliceDef.required.length === 0;
+      const sig = inputOptional ? `def set_${baseName}(self, value: dict[str, Any] | None = None) -> "${className}":` : `def set_${baseName}(self, value: dict[str, Any]) -> "${className}":`;
+      w.line(sig);
+      w.indentBlock(() => {
+        w.line(`match = self.__class__.${staticName}`);
+        const inputExpr = inputOptional ? "(value or {})" : "value";
+        if (sliceDef.constrainedChoice) {
+          const variant = JSON.stringify(sliceDef.constrainedChoice.variant);
+          w.line(`wrapped = wrap_slice_choice(${inputExpr}, ${variant})`);
+          w.line("merged = apply_slice_match(wrapped, match)");
+        } else {
+          w.line(`merged = apply_slice_match(${inputExpr}, match)`);
+        }
+        if (sliceDef.elementTypeName) {
+          w.line(`merged = ${sliceDef.elementTypeName}(**merged)`);
+        }
+        if (sliceDef.array) {
+          w.line(`items = getattr(self._resource, ${JSON.stringify(fieldName)}, None) or []`);
+          w.line("set_array_slice(items, match, merged)");
+          w.line(`setattr(self._resource, ${JSON.stringify(fieldName)}, items)`);
+        } else {
+          w.line(`setattr(self._resource, ${JSON.stringify(fieldName)}, merged)`);
+        }
+        w.line("return self");
+      });
+    }
+    w.line();
+  }
+};
+
+// src/api/writer-generator/python/profile-factory.ts
+var fieldPyType = (field, resolveRef) => {
+  const resolved = resolveRef ? resolveRef(field.type) : field.type;
+  const base = pyTypeFromIdentifier(resolved);
+  if (base === "str" && field.enum && !field.enum.isOpen && field.enum.values.length > 0) {
+    const literal = `Literal[${field.enum.values.map((v) => JSON.stringify(v)).join(", ")}]`;
+    return field.array ? `list[${literal}]` : literal;
+  }
+  return field.array ? `list[${base}]` : base;
+};
+var tryPromoteChoice = (field, fields, params, promotedChoices) => {
+  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 pyType = pyTypeFromIdentifier(choiceField.type) + (choiceField.array ? "[]" : "");
+  params.push({ name: choiceName, pyType, typeId: choiceField.type });
+  promotedChoices.add(choiceName);
+};
+var collectBaseRequiredParams = (tsIndex, flatProfile, resolveRef, params, coveredNames) => {
+  const covered = new Set(coveredNames);
+  const baseSchema = tsIndex.resolveType(flatProfile.base);
+  if (!baseSchema || !("fields" in baseSchema) || !baseSchema.fields) return;
+  for (const [name, field] of Object.entries(baseSchema.fields)) {
+    if (covered.has(name)) continue;
+    if (!field.required) continue;
+    if (isChoiceInstanceField(field)) continue;
+    if (isChoiceDeclarationField(field)) continue;
+    if (isNotChoiceDeclarationField(field) && field.type) {
+      const pyType = fieldPyType(field, resolveRef);
+      params.push({ name, pyType, typeId: field.type });
+    }
+  }
+};
+var collectProfileFactoryInfo = (tsIndex, flatProfile) => {
+  const autoFields = [];
+  const sliceAutoFields = [];
+  const params = [];
+  const autoAccessors = [];
+  const pendingChoiceInstances = [];
+  const fields = flatProfile.fields;
+  const promotedChoices = /* @__PURE__ */ new Set();
+  const resolveRef = tsIndex.findLastSpecializationByIdentifier;
+  const choiceGroups = /* @__PURE__ */ new Map();
+  for (const [, field] of Object.entries(fields)) {
+    if (isChoiceDeclarationField(field)) {
+      for (const choice of field.choices) choiceGroups.set(choice, field.choices);
+    }
+  }
+  if (isResourceIdentifier(flatProfile.base)) {
+    autoFields.push({ name: "resourceType", value: JSON.stringify(flatProfile.base.name) });
+  }
+  for (const [name, field] of Object.entries(fields)) {
+    if (field.excluded) continue;
+    if (isChoiceInstanceField(field)) {
+      pendingChoiceInstances.push([name, field]);
+      continue;
+    }
+    if (isChoiceDeclarationField(field)) {
+      tryPromoteChoice(field, fields, params, promotedChoices);
+      continue;
+    }
+    if (field.valueConstraint) {
+      const value = JSON.stringify(field.valueConstraint.value);
+      autoFields.push({ name, value: field.array ? `[${value}]` : value });
+      if (isNotChoiceDeclarationField(field) && field.type) {
+        const pyType = fieldPyType(field, resolveRef);
+        autoAccessors.push({ name, pyType, typeId: field.type });
+      }
+      continue;
+    }
+    if (isNotChoiceDeclarationField(field)) {
+      const sliceNames = collectRequiredSliceNames(field);
+      if (sliceNames) {
+        if (field.type) {
+          const pyType = fieldPyType(field, resolveRef);
+          sliceAutoFields.push({ name, pyType, typeId: field.type, sliceNames });
+          autoAccessors.push({ name, pyType, typeId: field.type });
+        }
+        continue;
+      }
+    }
+    if (field.required) {
+      const pyType = fieldPyType(field, resolveRef);
+      params.push({ name, pyType, typeId: field.type });
+    }
+  }
+  collectBaseRequiredParams(tsIndex, flatProfile, resolveRef, params, [
+    ...autoFields.map((f) => f.name),
+    ...sliceAutoFields.map((f) => f.name),
+    ...params.map((f) => f.name),
+    ...promotedChoices
+  ]);
+  const choiceAccessors = [];
+  for (const [name, field] of pendingChoiceInstances) {
+    if (promotedChoices.has(name)) continue;
+    const pyType = pyTypeFromIdentifier(field.type) + (field.array ? "[]" : "");
+    const choiceSiblings = (choiceGroups.get(name) ?? []).filter((s) => s !== name && !promotedChoices.has(s));
+    choiceAccessors.push({ name, pyType, typeId: field.type, choiceSiblings });
+  }
+  return { autoFields, sliceAutoFields, params, accessors: [...autoAccessors, ...choiceAccessors] };
+};
+var buildParamSignature = (factoryInfo, formatName2) => {
+  const parts = [];
+  for (const f of factoryInfo.sliceAutoFields) {
+    parts.push(`${pyFieldName(f.name, formatName2)}: ${f.pyType} | None = None`);
+  }
+  for (const p of factoryInfo.params) {
+    parts.push(`${pyFieldName(p.name, formatName2)}: ${p.pyType}`);
+  }
+  if (parts.length === 0) return "";
+  return `*, ${parts.join(", ")}`;
+};
+var buildCallArgs = (factoryInfo, formatName2) => {
+  const parts = [];
+  for (const f of factoryInfo.sliceAutoFields) {
+    const name = pyFieldName(f.name, formatName2);
+    parts.push(`${name}=${name}`);
+  }
+  for (const p of factoryInfo.params) {
+    const name = pyFieldName(p.name, formatName2);
+    parts.push(`${name}=${name}`);
+  }
+  return parts.join(", ");
+};
+var generateCreateResource = (w, baseTypeName, annotatedBaseTypeName, isResourceBase, hasParams, factoryInfo) => {
+  const fmt = w.nameFormatFunction;
+  w.line("@classmethod");
+  if (hasParams) {
+    w.line(`def create_resource(cls, ${buildParamSignature(factoryInfo, fmt)}) -> ${annotatedBaseTypeName}:`);
+  } else {
+    w.line(`def create_resource(cls) -> ${annotatedBaseTypeName}:`);
+  }
+  w.indentBlock(() => {
+    for (const f of factoryInfo.sliceAutoFields) {
+      const fieldName = pyFieldName(f.name, fmt);
+      const matchRefs = f.sliceNames.map((s) => `cls.${pySliceStaticName(s)}`);
+      if (matchRefs.length === 1) {
+        w.line(`${fieldName}_with_defaults = ensure_slice_defaults(list(${fieldName} or []), ${matchRefs[0]})`);
+      } else {
+        w.line(`${fieldName}_with_defaults = ensure_slice_defaults(`);
+        w.indentBlock(() => {
+          w.line(`list(${fieldName} or []),`);
+          for (const ref of matchRefs) w.line(`${ref},`);
+        });
+        w.line(")");
+      }
+    }
+    if (factoryInfo.sliceAutoFields.length > 0) w.line();
+    const buildArgs = [];
+    for (const f of factoryInfo.autoFields) {
+      buildArgs.push(`${pyFieldName(f.name, fmt)}=${f.value}`);
+    }
+    for (const f of factoryInfo.sliceAutoFields) {
+      buildArgs.push(`${pyFieldName(f.name, fmt)}=${pyFieldName(f.name, fmt)}_with_defaults`);
+    }
+    for (const p of factoryInfo.params) {
+      buildArgs.push(`${pyFieldName(p.name, fmt)}=${pyFieldName(p.name, fmt)}`);
+    }
+    if (isResourceBase) {
+      buildArgs.push(`meta={"profile": [cls.canonical_url]}`);
+    }
+    if (buildArgs.length <= 2) {
+      w.line(`return build_resource(${baseTypeName}, ${buildArgs.join(", ")})`);
+    } else {
+      w.line(`return build_resource(`);
+      w.indentBlock(() => {
+        w.line(`${baseTypeName},`);
+        for (const arg of buildArgs) {
+          w.line(`${arg},`);
+        }
+      });
+      w.line(")");
+    }
+  });
+};
+var generateFieldAccessors = (w, className, factoryInfo, extSliceMethodBaseNames) => {
+  const fmt = w.nameFormatFunction;
+  for (const p of factoryInfo.params) {
+    const fieldName = pyFieldName(p.name, fmt);
+    const methodSuffix = pySnakeName(p.name);
+    w.line(`def get_${methodSuffix}(self) -> ${p.pyType} | None:`);
+    w.indentBlock(() => {
+      w.line(`return cast('${p.pyType} | None', getattr(self._resource, ${JSON.stringify(fieldName)}, None))`);
+    });
+    w.line();
+    w.line(`def set_${methodSuffix}(self, value: ${p.pyType}) -> "${className}":`);
+    w.indentBlock(() => {
+      w.line(`setattr(self._resource, ${JSON.stringify(fieldName)}, value)`);
+      w.line("return self");
+    });
+    w.line();
+  }
+  for (const a of factoryInfo.accessors) {
+    const methodSuffix = pySnakeName(a.name);
+    if (extSliceMethodBaseNames.has(methodSuffix)) continue;
+    const fieldName = pyFieldName(a.name, fmt);
+    w.line(`def get_${methodSuffix}(self) -> ${a.pyType} | None:`);
+    w.indentBlock(() => {
+      w.line(`return cast('${a.pyType} | None', getattr(self._resource, ${JSON.stringify(fieldName)}, None))`);
+    });
+    w.line();
+    w.line(`def set_${methodSuffix}(self, value: ${a.pyType}) -> "${className}":`);
+    w.indentBlock(() => {
+      if (a.choiceSiblings?.length) {
+        for (const sibling of a.choiceSiblings) {
+          w.line(`setattr(self._resource, ${JSON.stringify(pyFieldName(sibling, fmt))}, None)`);
+        }
+      }
+      w.line(`setattr(self._resource, ${JSON.stringify(fieldName)}, value)`);
+      w.line("return self");
+    });
+    w.line();
+  }
+};
+
+// src/api/writer-generator/python/profile-validation.ts
+var collectValidateBody = (flatProfile, resolveRef, errorLines, warningLines, formatName2) => {
+  const helpers = /* @__PURE__ */ new Set();
+  const fields = flatProfile.fields;
+  for (const [name, field] of Object.entries(fields)) {
+    const pyName = pyFieldName(name, formatName2);
+    if (isChoiceInstanceField(field)) {
+      collectProhibitedChoiceValidation(fields, name, pyName, helpers, errorLines);
+      continue;
+    }
+    if (isChoiceDeclarationField(field)) {
+      if (field.required) {
+        helpers.add("validate_choice_required");
+        const pyChoices = field.choices.map((c) => pyFieldName(c, formatName2));
+        errorLines.push(
+          `errors.extend(validate_choice_required(self._resource, profile_name, ${JSON.stringify(pyChoices)}))`
+        );
+      }
+      continue;
+    }
+    if (field.excluded) {
+      helpers.add("validate_excluded");
+      errorLines.push(
+        `errors.extend(validate_excluded(self._resource, profile_name, ${JSON.stringify(pyName)}))`
+      );
+      continue;
+    }
+    if (field.required) {
+      helpers.add("validate_required");
+      errorLines.push(
+        `errors.extend(validate_required(self._resource, profile_name, ${JSON.stringify(pyName)}))`
+      );
+    }
+    if (field.valueConstraint) {
+      helpers.add("validate_fixed_value");
+      const value = JSON.stringify(field.valueConstraint.value);
+      errorLines.push(
+        `errors.extend(validate_fixed_value(self._resource, profile_name, ${JSON.stringify(pyName)}, ${value}))`
+      );
+    }
+    if (isNotChoiceDeclarationField(field)) {
+      if (field.enum) {
+        helpers.add("validate_enum");
+        const target = field.enum.isOpen ? warningLines : errorLines;
+        const listName = field.enum.isOpen ? "warnings" : "errors";
+        target.push(
+          `${listName}.extend(validate_enum(self._resource, profile_name, ${JSON.stringify(pyName)}, ${JSON.stringify(field.enum.values)}))`
+        );
+      }
+      if (field.mustSupport && !field.required) {
+        helpers.add("validate_must_support");
+        warningLines.push(
+          `warnings.extend(validate_must_support(self._resource, profile_name, ${JSON.stringify(pyName)}))`
+        );
+      }
+      if (field.reference && field.reference.length > 0) {
+        helpers.add("validate_reference");
+        const allowed = field.reference.map((ref) => resolveRef(ref).name);
+        errorLines.push(
+          `errors.extend(validate_reference(self._resource, profile_name, ${JSON.stringify(pyName)}, ${JSON.stringify(allowed)}))`
+        );
+      }
+      if (field.slicing?.slices) {
+        collectSliceCardinalityValidation(field, pyName, helpers, errorLines);
+      }
+    }
+  }
+  return helpers;
+};
+var collectProhibitedChoiceValidation = (fields, name, pyName, helpers, errorLines) => {
+  const field = fields[name];
+  if (!field || !isChoiceInstanceField(field)) return;
+  const decl = fields[field.choiceOf];
+  if (!decl || !isChoiceDeclarationField(decl) || !decl.prohibited?.includes(name)) return;
+  helpers.add("validate_excluded");
+  errorLines.push(`errors.extend(validate_excluded(self._resource, profile_name, ${JSON.stringify(pyName)}))`);
+};
+var collectSliceCardinalityValidation = (field, name, helpers, errorLines) => {
+  if (!field.slicing?.slices) return;
+  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;
+    helpers.add("validate_slice_cardinality");
+    errorLines.push(
+      `errors.extend(validate_slice_cardinality(self._resource, profile_name, ${JSON.stringify(name)}, ${JSON.stringify(match)}, ${JSON.stringify(sliceName)}, ${min}, ${max}))`
+    );
+  }
+};
+
+// src/api/writer-generator/python/profile.ts
+var modulePathForTypeId = (rootPackageName, typeId) => {
+  const pkg = pyFhirPackageByName(rootPackageName, typeId.package);
+  if (isResourceIdentifier(typeId)) return `${pkg}.${snakeCase(typeId.name)}`;
+  if (isNestedIdentifier(typeId)) {
+    const path = canonicalToName2(typeId.url, false);
+    const parentName = path?.split("#")[0];
+    return parentName ? `${pkg}.${snakeCase(parentName)}` : `${pkg}.base`;
+  }
+  return `${pkg}.base`;
+};
+var addExactTypeImport = (typeImports, rootPackageName, skipName, typeId) => {
+  if (isPrimitiveIdentifier(typeId) || PRIMITIVE_TYPE_MAP2[typeId.name] !== void 0) return;
+  const name = deriveResourceName(typeId);
+  if (!name || name === skipName) return;
+  const modulePath = modulePathForTypeId(rootPackageName, typeId);
+  const names = typeImports.get(modulePath) ?? /* @__PURE__ */ new Set();
+  names.add(name);
+  typeImports.set(modulePath, names);
+};
+var addTypeImport = (typeImports, rootPackageName, skipName, resolveRef, typeId) => {
+  const ids = [typeId];
+  const resolved = resolveRef(typeId);
+  if (resolved !== typeId) ids.push(resolved);
+  for (const id of ids) {
+    if (isPrimitiveIdentifier(id) || PRIMITIVE_TYPE_MAP2[id.name] !== void 0) continue;
+    const name = deriveResourceName(id);
+    if (name === skipName) continue;
+    const modulePath = modulePathForTypeId(rootPackageName, id);
+    let names = typeImports.get(modulePath);
+    if (!names) {
+      names = /* @__PURE__ */ new Set();
+      typeImports.set(modulePath, names);
+    }
+    names.add(name);
+  }
+};
+var collectHelperImports = (isResourceBase, factoryInfo, sliceDefs, extensions, validationHelpers) => {
+  const imports = ["build_resource"];
+  if (isResourceBase) imports.push("ensure_profile");
+  if (factoryInfo.sliceAutoFields.length > 0) imports.push("ensure_slice_defaults");
+  if (sliceDefs.length > 0) {
+    const hasNonTyped = sliceDefs.some((s) => !s.isTypeDiscriminated);
+    const hasTypedBounded = sliceDefs.some((s) => s.isTypeDiscriminated && !(s.array && s.max === 0));
+    const hasTypedUnbounded = sliceDefs.some((s) => s.isTypeDiscriminated && s.array && s.max === 0);
+    if (hasNonTyped) imports.push("apply_slice_match", "matches_value", "strip_match_keys");
+    if (hasTypedBounded || hasNonTyped) imports.push("get_array_slice", "set_array_slice");
+    if (hasTypedUnbounded) imports.push("get_array_slices", "set_array_slices");
+    if (sliceDefs.some((s) => s.constrainedChoice)) imports.push("wrap_slice_choice", "unwrap_slice_choice");
+  }
+  if (extensions.length > 0) {
+    imports.push("_get_key", "is_extension", "get_extension_value", "push_extension");
+    if (extensions.some((ext) => ext.isComplex && ext.subExtensions)) imports.push("extract_complex_extension");
+    if (extensions.some((ext) => ext.path.split(".").some((s) => s !== "extension"))) imports.push("ensure_path");
+  }
+  imports.push(...validationHelpers);
+  imports.sort();
+  return imports;
+};
+var collectTypeImports = (rootPackageName, baseTypeName, resolveRef, factoryInfo, sliceDefs, extensions, schemas) => {
+  const typeImports = /* @__PURE__ */ new Map();
+  for (const p of factoryInfo.params) addTypeImport(typeImports, rootPackageName, baseTypeName, resolveRef, p.typeId);
+  for (const f of factoryInfo.sliceAutoFields)
+    addTypeImport(typeImports, rootPackageName, baseTypeName, resolveRef, f.typeId);
+  for (const a of factoryInfo.accessors)
+    addTypeImport(typeImports, rootPackageName, baseTypeName, resolveRef, a.typeId);
+  for (const s of sliceDefs) {
+    if (s.elementTypeId) addExactTypeImport(typeImports, rootPackageName, baseTypeName, s.elementTypeId);
+    if (!s.isTypeDiscriminated) continue;
+    if (!s.typeDiscriminatorResource) continue;
+    const resourceId = schemas.find(
+      (schema) => schema.identifier.kind === "resource" && schema.identifier.name === s.typeDiscriminatorResource
+    )?.identifier;
+    if (resourceId) addTypeImport(typeImports, rootPackageName, baseTypeName, resolveRef, resourceId);
+  }
+  for (const ext of extensions) {
+    if (ext.isComplex && ext.subExtensions) continue;
+    if (ext.valueFieldTypes?.length === 1 && ext.valueFieldTypes[0])
+      addExactTypeImport(typeImports, rootPackageName, baseTypeName, ext.valueFieldTypes[0]);
+  }
+  return typeImports;
+};
+var collectExtProfileImports = (tsIndex, flatProfile, extensions) => {
+  const extProfileImports = /* @__PURE__ */ new Map();
+  for (const ext of extensions) {
+    if (!ext.url) continue;
+    const info = resolveExtensionProfile(tsIndex, flatProfile.identifier.package, ext);
+    if (info && !extProfileImports.has(info.className)) extProfileImports.set(info.className, info);
+  }
+  return extProfileImports;
+};
+var emitModuleImports = (w, flatProfile, isResourceBase, extensions, factoryInfo, typeImports, extProfileImports, helperImports, sliceDefs) => {
+  w.line("from __future__ import annotations");
+  w.line();
+  const usesLiteral = [...factoryInfo.params, ...factoryInfo.accessors, ...factoryInfo.sliceAutoFields].some(
+    (f) => f.pyType.includes("Literal[")
+  );
+  const hasNonTypedSlice = sliceDefs.some((s) => !s.isTypeDiscriminated);
+  const needsOverload = extensions.length > 0 || hasNonTypedSlice;
+  const needsAny = extensions.length > 0 || sliceDefs.length > 0;
+  const needsCast = factoryInfo.params.length > 0 || factoryInfo.accessors.length > 0 || sliceDefs.length > 0 || extensions.length > 0;
+  const typingNames = [];
+  if (needsAny) typingNames.push("Any");
+  if (needsCast) typingNames.push("cast");
+  if (needsOverload || usesLiteral) typingNames.push("Literal");
+  if (needsOverload) typingNames.push("overload");
+  if (typingNames.length > 0) {
+    w.pyImportFrom("typing", ...[...typingNames].sort());
+    w.line();
+  }
+  const baseTypeName = flatProfile.base.name;
+  const basePkg = pyFhirPackageByName(w.opts.rootPackageName, flatProfile.base.package);
+  if (isResourceBase) {
+    w.pyImportFrom(`${basePkg}.${snakeCase(baseTypeName)}`, baseTypeName);
+  } else {
+    w.pyImportFrom(`${basePkg}.base`, baseTypeName);
+  }
+  if (extensions.length > 0) w.pyImportFrom(`${basePkg}.base`, "Extension");
+  for (const [modulePath, names] of [...typeImports.entries()].sort(([a], [b]) => a.localeCompare(b))) {
+    w.pyImportFrom(modulePath, ...[...names].sort());
+  }
+  for (const [extClassName, info] of [...extProfileImports.entries()].sort(([a], [b]) => a.localeCompare(b))) {
+    w.pyImportFrom(`.${info.moduleName}`, extClassName);
+  }
+  w.pyImportFrom(`${w.opts.rootPackageName}.profile_helpers`, ...helperImports);
+  w.line();
+  w.line();
+};
+var generateFromResourceMethod = (w, annotatedBaseTypeName, className, isResourceBase) => {
+  w.line("@classmethod");
+  w.line(`def from_resource(cls, resource: ${annotatedBaseTypeName}) -> "${className}":`);
+  w.indentBlock(() => {
+    if (isResourceBase) {
+      w.line('meta = getattr(resource, "meta", None)');
+      w.line('profiles = getattr(meta, "profile", None) if meta is not None else None');
+      w.line("if profiles is None or cls.canonical_url not in profiles:");
+      w.indentBlock(() => {
+        w.line(`raise ValueError(f"${className}: meta.profile must include {cls.canonical_url}")`);
+      });
+    }
+    w.line("profile = cls(resource)");
+    w.line("result = profile.validate()");
+    w.line('if result["errors"]:');
+    w.indentBlock(() => w.line('raise ValueError("; ".join(result["errors"]))'));
+    w.line("return profile");
+  });
+  w.line();
+};
+var generateApplyMethod = (w, annotatedBaseTypeName, className, isResourceBase) => {
+  w.line("@classmethod");
+  w.line(`def apply(cls, resource: ${annotatedBaseTypeName}) -> "${className}":`);
+  w.indentBlock(() => {
+    if (isResourceBase) w.line("ensure_profile(resource, cls.canonical_url)");
+    w.line("return cls(resource)");
+  });
+  w.line();
+};
+var generateCreateMethod = (w, className, hasParams, factoryInfo) => {
+  w.line("@classmethod");
+  if (hasParams) {
+    w.line(`def create(cls, ${buildParamSignature(factoryInfo, w.nameFormatFunction)}) -> "${className}":`);
+    w.indentBlock(
+      () => w.line(`return cls.apply(cls.create_resource(${buildCallArgs(factoryInfo, w.nameFormatFunction)}))`)
+    );
+  } else {
+    w.line(`def create(cls) -> "${className}":`);
+    w.indentBlock(() => w.line("return cls.apply(cls.create_resource())"));
+  }
+  w.line();
+};
+var generateValidateMethod = (w, className, errorLines, warningLines) => {
+  w.line("def validate(self) -> dict[str, list[str]]:");
+  w.indentBlock(() => {
+    w.line(`profile_name = "${className}"`);
+    w.line("errors: list[str] = []");
+    w.line("warnings: list[str] = []");
+    for (const expr of errorLines) w.line(expr);
+    for (const expr of warningLines) w.line(expr);
+    w.line('return {"errors": errors, "warnings": warnings}');
+  });
+};
+var generateClassBody = (ctx) => {
+  const {
+    w,
+    tsIndex,
+    flatProfile,
+    baseTypeName,
+    annotatedBaseTypeName,
+    className,
+    isResourceBase,
+    errorLines,
+    warningLines,
+    factoryInfo,
+    sliceDefs,
+    resolvedNames
+  } = ctx;
+  const hasParams = factoryInfo.params.length > 0 || factoryInfo.sliceAutoFields.length > 0;
+  w.line(`def __init__(self, resource: ${annotatedBaseTypeName}) -> None:`);
+  w.indentBlock(() => w.line("self._resource = resource"));
+  w.line();
+  generateFromResourceMethod(w, annotatedBaseTypeName, className, isResourceBase);
+  generateApplyMethod(w, annotatedBaseTypeName, className, isResourceBase);
+  generateCreateResource(w, baseTypeName, annotatedBaseTypeName, isResourceBase, hasParams, factoryInfo);
+  w.line();
+  generateCreateMethod(w, className, hasParams, factoryInfo);
+  w.line(`def to_resource(self) -> ${annotatedBaseTypeName}:`);
+  w.indentBlock(() => w.line("return self._resource"));
+  w.line();
+  if (factoryInfo.params.length > 0 || factoryInfo.accessors.length > 0)
+    generateFieldAccessors(w, className, factoryInfo, resolvedNames.allBaseNames);
+  const extensions = flatProfile.extensions ?? [];
+  if (extensions.length > 0) generateExtensionMethods(w, tsIndex, flatProfile, className, resolvedNames.extensions);
+  if (sliceDefs.length > 0) {
+    generateSliceGetters(w, sliceDefs, resolvedNames.slices);
+    generateSliceSetters(w, className, sliceDefs, resolvedNames.slices);
+  }
+  generateValidateMethod(w, className, errorLines, warningLines);
+};
+var generateProfileModule = (w, tsIndex, flatProfile) => {
+  const className = pyProfileClassName(flatProfile);
+  const baseTypeName = flatProfile.base.name;
+  const isResourceBase = isResourceIdentifier(flatProfile.base);
+  const canonicalUrl = flatProfile.identifier.url ?? "";
+  const factoryInfo = collectProfileFactoryInfo(tsIndex, flatProfile);
+  const sliceDefs = collectSliceDefs(tsIndex, flatProfile);
+  const typedResources = [
+    ...new Set(
+      sliceDefs.filter((s) => s.isTypeDiscriminated && s.typeDiscriminatorResource).map((s) => s.typeDiscriminatorResource)
+    )
+  ];
+  const annotatedBaseTypeName = typedResources.length > 0 ? `${baseTypeName}[${typedResources.join(" | ")}, Resource]` : baseTypeName;
+  const extensions = flatProfile.extensions ?? [];
+  const resolvedNames = resolveProfileMethodBaseNames(extensions, sliceDefs);
+  const errorLines = [];
+  const warningLines = [];
+  const validationHelpers = collectValidateBody(
+    flatProfile,
+    tsIndex.findLastSpecializationByIdentifier,
+    errorLines,
+    warningLines,
+    w.nameFormatFunction
+  );
+  const helperImports = collectHelperImports(isResourceBase, factoryInfo, sliceDefs, extensions, validationHelpers);
+  const typeImports = collectTypeImports(
+    w.opts.rootPackageName,
+    baseTypeName,
+    tsIndex.findLastSpecializationByIdentifier,
+    factoryInfo,
+    sliceDefs,
+    extensions,
+    tsIndex.schemas
+  );
+  const extProfileImports = collectExtProfileImports(tsIndex, flatProfile, extensions);
+  if (typedResources.length > 0) {
+    const basePkg = pyFhirPackageByName(w.opts.rootPackageName, flatProfile.base.package);
+    const resourceModule = `${basePkg}.resource`;
+    const names = typeImports.get(resourceModule) ?? /* @__PURE__ */ new Set();
+    names.add("Resource");
+    typeImports.set(resourceModule, names);
+  }
+  emitModuleImports(
+    w,
+    flatProfile,
+    isResourceBase,
+    extensions,
+    factoryInfo,
+    typeImports,
+    extProfileImports,
+    helperImports,
+    sliceDefs
+  );
+  w.line(`class ${className}:`);
+  w.indentBlock(() => {
+    if (flatProfile.description) {
+      w.line(`"""${flatProfile.description}`);
+      w.line();
+      w.line(`CanonicalURL: ${canonicalUrl}`);
+      w.line(`"""`);
+      w.line();
+    }
+    w.line(`canonical_url: str = ${JSON.stringify(canonicalUrl)}`);
+    w.line();
+    generateStaticSliceFields(w, sliceDefs);
+    generateClassBody({
+      w,
+      tsIndex,
+      flatProfile,
+      baseTypeName,
+      annotatedBaseTypeName,
+      className,
+      isResourceBase,
+      factoryInfo,
+      sliceDefs,
+      resolvedNames,
+      errorLines,
+      warningLines
+    });
+  });
+  w.line();
+};
+var generateProfilesInit = (w, tsIndex, profiles) => {
+  w.cat("__init__.py", () => {
+    w.generateDisclaimer();
+    const seen = /* @__PURE__ */ new Set();
+    for (const profile of profiles) {
+      const className = pyProfileClassName(profile);
+      const moduleName = pyProfileModuleName(tsIndex, profile);
+      if (seen.has(className)) continue;
+      seen.add(className);
+      w.pyImportFrom(`.${moduleName}`, className);
+    }
+    w.line();
+    w.squareBlock(["__all__", "="], () => {
+      for (const className of [...seen].sort()) w.line(`'${className}',`);
     });
-  };
-  const entityTree = () => {
-    const tree = {};
-    for (const [pkgId, shemas] of Object.entries(groupByPackages(schemas))) {
-      tree[pkgId] = {
-        "primitive-type": {},
-        "complex-type": {},
-        resource: {},
-        "value-set": {},
-        nested: {},
-        binding: {},
-        profile: {},
-        "profile-snapshot": {},
-        logical: {}
-      };
-      for (const schema of shemas) {
-        tree[pkgId][schema.identifier.kind][schema.identifier.url] = {};
-      }
+  });
+};
+var generateNewProfiles = (w, tsIndex, profiles) => {
+  if (profiles.length === 0) return;
+  w.cd("profiles", () => {
+    for (const profile of profiles) {
+      const moduleName = pyProfileModuleName(tsIndex, profile);
+      w.cat(`${moduleName}.py`, () => {
+        w.generateDisclaimer();
+        generateProfileModule(w, tsIndex, profile);
+      });
     }
-    return tree;
-  };
-  const exportTree = async (filename) => {
-    const tree = entityTree();
-    const raw = filename.endsWith(".yaml") ? YAML.stringify(tree) : JSON.stringify(tree, void 0, 2);
-    await fsPromises.mkdir(Path5.dirname(filename), { recursive: true });
-    await fsPromises.writeFile(filename, raw);
-  };
-  return {
-    _schemaIndex: index,
-    schemas,
-    schemasByPackage: groupByPackages(schemas),
-    register,
-    collectComplexTypes: () => schemas.filter(isComplexTypeTypeSchema),
-    collectResources: () => schemas.filter(isResourceTypeSchema),
-    collectLogicalModels: () => schemas.filter(isLogicalTypeSchema),
-    collectProfiles: () => schemas.filter(isProfileTypeSchema),
-    collectSnapshotProfiles,
-    resolve: resolve6,
-    resolveType,
-    resolveByUrl,
-    tryHierarchy,
-    hierarchy,
-    findLastSpecialization,
-    findLastSpecializationByIdentifier,
-    flatProfile,
-    constrainedChoice,
-    isWithMetaField,
-    entityTree,
-    exportTree,
-    irReport: () => irReport,
-    replaceSchemas: (newSchemas) => mkTypeSchemaIndex(newSchemas, { register, logger, irReport: { ...irReport } })
-  };
+    generateProfilesInit(w, tsIndex, profiles);
+  });
 };
 
-// src/api/writer-generator/python.ts
-var PRIMITIVE_TYPE_MAP2 = {
-  boolean: "bool",
-  instant: "str",
-  time: "str",
-  date: "str",
-  dateTime: "str",
-  decimal: "float",
-  integer: "int",
-  unsignedInt: "int",
-  positiveInt: "PositiveInt",
-  integer64: "int",
-  base64Binary: "str",
-  uri: "str",
-  url: "str",
-  canonical: "str",
-  oid: "str",
-  uuid: "str",
-  string: "str",
-  code: "str",
-  markdown: "str",
-  id: "str",
-  xhtml: "str"
+// src/api/writer-generator/python/writer.ts
+var resolvePyAssets = (fn) => {
+  const __dirname = Path5.dirname(fileURLToPath(import.meta.url));
+  const __filename = fileURLToPath(import.meta.url);
+  if (__filename.endsWith("dist/index.js")) {
+    return Path5.resolve(__dirname, "..", "assets", "api", "writer-generator", "python", fn);
+  }
+  return Path5.resolve(__dirname, "../../../..", "assets", "api", "writer-generator", "python", fn);
 };
 var AVAILABLE_STRING_FORMATS = {
   snake_case: snakeCase,
   PascalCase: pascalCase,
   camelCase
 };
-var PYTHON_KEYWORDS = /* @__PURE__ */ new Set([
-  "False",
-  "None",
-  "True",
-  "and",
-  "as",
-  "assert",
-  "async",
-  "await",
-  "break",
-  "class",
-  "continue",
-  "def",
-  "del",
-  "elif",
-  "else",
-  "except",
-  "finally",
-  "for",
-  "from",
-  "global",
-  "if",
-  "import",
-  "in",
-  "is",
-  "lambda",
-  "nonlocal",
-  "not",
-  "or",
-  "pass",
-  "raise",
-  "return",
-  "try",
-  "while",
-  "with",
-  "yield",
-  "List"
-]);
 var MAX_IMPORT_LINE_LENGTH = 100;
 var GENERIC_FIELD_REWRITES = {
   Coding: { code: "T" },
   CodeableConcept: { coding: "Coding[T]" }
 };
+var leafOf2 = (path) => path[path.length - 1] ?? "";
+var collectResourceGenericTypeVars = (schema) => {
+  const all = /* @__PURE__ */ new Map();
+  const addParams = (s) => {
+    for (const p of s.generic?.params ?? []) {
+      if (!all.has(p.typeVar)) all.set(p.typeVar, p.constraint.name);
+    }
+  };
+  addParams(schema);
+  for (const nested of schema.nested ?? []) addParams(nested);
+  return Array.from(all.entries()).sort(([a], [b]) => a.localeCompare(b)).map(([typeVar, constraint]) => ({ typeVar, constraint }));
+};
 var pyEnumType = (enumDef) => {
   const values = enumDef.values.map((e) => `"${e}"`).join(", ");
   return enumDef.isOpen ? `Literal[${values}] | str` : `Literal[${values}]`;
 };
-var fixReservedWords = (name) => {
-  return PYTHON_KEYWORDS.has(name) ? `${name}_` : name;
-};
-var canonicalToName2 = (canonical, dropFragment = true) => {
-  if (!canonical) return void 0;
-  let localName = canonical.split("/").pop();
-  if (!localName) return void 0;
-  if (dropFragment && localName.includes("#")) {
-    localName = localName.split("#")[0];
-  }
-  if (!localName) return void 0;
-  if (/^\d/.test(localName)) {
-    localName = `number_${localName}`;
-  }
-  return snakeCase(localName);
-};
-var deriveResourceName = (id) => {
-  if (id.kind === "nested") {
-    const url = id.url;
-    const path = canonicalToName2(url, false);
-    if (!path) return "";
-    const [resourceName, fragment] = path.split("#");
-    const name = uppercaseFirstLetterOfEach((fragment ?? "").split(".")).join("");
-    return pascalCase([resourceName, name].join(""));
-  }
-  return pascalCase(id.name);
-};
-var resolvePyAssets = (fn) => {
-  const __dirname = Path5.dirname(fileURLToPath(import.meta.url));
-  const __filename = fileURLToPath(import.meta.url);
-  if (__filename.endsWith("dist/index.js")) {
-    return Path5.resolve(__dirname, "..", "assets", "api", "writer-generator", "python", fn);
-  } else {
-    return Path5.resolve(__dirname, "../../..", "assets", "api", "writer-generator", "python", fn);
-  }
-};
 var Python = class extends Writer {
   nameFormatFunction;
   tsIndex;
@@ -1384,19 +2508,29 @@ var Python = class extends Writer {
   constructor(options) {
     super({ ...options, resolveAssets: options.resolveAssets ?? resolvePyAssets });
     this.nameFormatFunction = this.getFieldFormatFunction(options.fieldFormat);
-    this.forFhirpyClient = options.fhirpyClient ?? false;
+    this.forFhirpyClient = this.resolveClient(options);
     this.fieldFormat = options.fieldFormat;
   }
+  /** Resolve which client integration to emit. `client` wins; `fhirpyClient` is the deprecated fallback; default is fhirpy. */
+  resolveClient(options) {
+    if (options.client !== void 0) return options.client === "fhirpy";
+    if (options.fhirpyClient !== void 0) {
+      this.logger()?.warn('python: `fhirpyClient` is deprecated; use `client: "fhirpy" | "none"` instead.');
+      return options.fhirpyClient;
+    }
+    return true;
+  }
   async generate(tsIndex) {
     this.tsIndex = tsIndex;
     const groups = {
       groupedComplexTypes: groupByPackages(tsIndex.collectComplexTypes()),
       groupedResources: groupByPackages(tsIndex.collectResources())
     };
-    this.generateRootPackages(groups);
-    this.generateSDKPackages(groups);
+    const hasProfiles = (this.opts.generateProfile ?? false) && tsIndex.collectSnapshotProfiles().length > 0;
+    this.generateRootPackages(groups, hasProfiles);
+    this.generateSDKPackages(tsIndex, groups);
   }
-  generateRootPackages(groups) {
+  generateRootPackages(groups, hasProfiles) {
     this.generateRootInitFile(groups);
     if (this.forFhirpyClient) {
       if (this.fieldFormat === "camelCase") {
@@ -1405,20 +2539,24 @@ var Python = class extends Writer {
         this.copyAssets(resolvePyAssets("fhirpy_base_model.py"), "fhirpy_base_model.py");
       }
     }
+    if (hasProfiles) {
+      this.copyAssets(resolvePyAssets("profile_helpers.py"), "profile_helpers.py");
+    }
     this.copyAssets(resolvePyAssets("requirements.txt"), "requirements.txt");
   }
-  generateSDKPackages(groups) {
+  generateSDKPackages(tsIndex, groups) {
     this.generateComplexTypesPackages(groups.groupedComplexTypes);
-    this.generateResourcePackages(groups);
+    this.generateResourcePackages(tsIndex, groups);
   }
   generateComplexTypesPackages(groupedComplexTypes) {
     for (const [packageName, packageComplexTypes] of Object.entries(groupedComplexTypes)) {
       this.cd(`/${snakeCase(packageName)}`, () => {
-        this.generateBasePy(packageComplexTypes);
+        this.generateBasePy(packageName, packageComplexTypes);
       });
     }
   }
-  generateResourcePackages(groups) {
+  generateResourcePackages(tsIndex, groups) {
+    const profilesByPackage = this.opts.generateProfile ? groupByPackages(tsIndex.collectSnapshotProfiles()) : {};
     for (const [packageName, packageResources] of Object.entries(groups.groupedResources)) {
       this.cd(`/${snakeCase(packageName)}`, () => {
         this.generateResourcePackageContent(
@@ -1426,13 +2564,27 @@ var Python = class extends Writer {
           packageResources,
           groups.groupedComplexTypes[packageName] || []
         );
+        const packageProfiles = profilesByPackage[packageName];
+        if (packageProfiles && packageProfiles.length > 0) {
+          generateNewProfiles(this, tsIndex, packageProfiles);
+        }
+      });
+    }
+    for (const [packageName, packageProfiles] of Object.entries(profilesByPackage)) {
+      if (groups.groupedResources[packageName]) continue;
+      if (!packageProfiles || packageProfiles.length === 0) continue;
+      this.cd(`/${snakeCase(packageName)}`, () => {
+        generateNewProfiles(this, tsIndex, packageProfiles);
       });
     }
   }
   generateResourcePackageContent(packageName, packageResources, packageComplexTypes) {
-    const pyPackageName = this.pyFhirPackageByName(packageName);
+    const pyPackageName = pyFhirPackageByName(this.opts.rootPackageName, packageName);
     this.generateResourcePackageInit(pyPackageName, packageResources, packageComplexTypes);
-    this.generateResourceFamilies(packageResources);
+    const hasAnyResourceGenericParams = packageResources.some((s) => collectResourceGenericTypeVars(s).length > 0);
+    if (hasAnyResourceGenericParams) {
+      this.copyAssets(resolvePyAssets("resource_preprocessor.py"), "resource_preprocessor.py");
+    }
     for (const schema of packageResources) {
       this.generateResourceModule(schema);
     }
@@ -1443,13 +2595,14 @@ var Python = class extends Writer {
         this.generateDisclaimer();
         const pydanticModels = this.collectAndImportAllModels(groups);
         this.generateModelRebuilds(pydanticModels);
+        this.importProfileRegistrations(groups);
       });
     });
   }
   collectAndImportAllModels(groups) {
     const models = [];
     for (const packageName of Object.keys(groups.groupedResources)) {
-      const fullPyPackageName = this.pyFhirPackageByName(packageName);
+      const fullPyPackageName = pyFhirPackageByName(this.opts.rootPackageName, packageName);
       models.push(...this.importComplexTypes(fullPyPackageName, groups.groupedComplexTypes[packageName]));
       models.push(...this.importResources(fullPyPackageName, false, groups.groupedResources[packageName]));
     }
@@ -1461,7 +2614,15 @@ var Python = class extends Writer {
       this.line(`${modelName}.model_rebuild()`);
     }
   }
-  generateBasePy(packageComplexTypes) {
+  importProfileRegistrations(groups) {
+    if (!this.opts.generateProfile) return;
+    this.line();
+    for (const packageName of Object.keys(groups.groupedResources)) {
+      const profilesPackage = `${pyFhirPackageByName(this.opts.rootPackageName, packageName)}.profiles`;
+      this.line(`import ${profilesPackage}  # noqa: F401`);
+    }
+  }
+  generateBasePy(_packageName, packageComplexTypes) {
     const hasGenericTypes = packageComplexTypes.some((s) => s.identifier.name in GENERIC_FIELD_REWRITES);
     this.cat("base.py", () => {
       this.generateDisclaimer();
@@ -1498,20 +2659,16 @@ var Python = class extends Writer {
     this.line();
     return baseTypes;
   }
-  buildImportLine(remaining, maxImportLineLength) {
+  buildImportLine(entities, start, maxLen) {
     let line = "";
-    while (remaining.length > 0 && line.length < maxImportLineLength) {
-      const entity = remaining.shift();
-      if (!entity) throw new Error("Unexpected empty entity");
-      if (line.length > 0) {
-        line += ", ";
-      }
-      line += entity;
-    }
-    if (remaining.length > 0) {
-      line += ", \\";
+    let i = start;
+    while (i < entities.length && line.length < maxLen) {
+      if (line.length > 0) line += ", ";
+      line += entities[i];
+      i++;
     }
-    return line;
+    if (i < entities.length) line += ", \\";
+    return { line, next: i };
   }
   importResources(fullPyPackageName, importEmptyResources, packageResources) {
     if (!packageResources || packageResources.length === 0) return [];
@@ -1527,12 +2684,7 @@ var Python = class extends Writer {
     const moduleName = `${fullPyPackageName}.${snakeCase(resource.identifier.name)}`;
     const importNames = this.collectResourceImportNames(resource);
     this.pyImportFrom(moduleName, ...importNames);
-    const names = [...importNames];
-    if (this.shouldImportResourceFamily(resource)) {
-      const familyName = `${resource.identifier.name}Family`;
-      this.pyImportFrom(`${fullPyPackageName}.resource_families`, familyName);
-    }
-    return names;
+    return [...importNames];
   }
   collectResourceImportNames(resource) {
     const names = [deriveResourceName(resource.identifier)];
@@ -1542,9 +2694,6 @@ var Python = class extends Writer {
     }
     return names;
   }
-  shouldImportResourceFamily(resource) {
-    return resource.identifier.kind === "resource" && (resource.typeFamily?.resources?.length ?? 0) > 0;
-  }
   generateExportsDeclaration(packageComplexTypes, allResourceNames) {
     this.squareBlock(["__all__", "="], () => {
       const allExports = [
@@ -1557,12 +2706,22 @@ var Python = class extends Writer {
     });
   }
   generateResourceModule(schema) {
+    const typeVars = collectResourceGenericTypeVars(schema);
+    const hasResourceGenericParams = typeVars.length > 0;
     this.cat(`${snakeCase(schema.identifier.name)}.py`, () => {
       this.generateDisclaimer();
-      this.generateDefaultImports(false);
+      this.generateDefaultImports(false, hasResourceGenericParams, true);
       this.generateFhirBaseModelImport();
       this.line();
       this.generateDependenciesImports(schema);
+      if (hasResourceGenericParams) {
+        const pyFhirPackage2 = pyFhirPackageByName(this.opts.rootPackageName, schema.identifier.package);
+        this.pyImportFrom(`${pyFhirPackage2}.resource_preprocessor`, "preprocess_resource_fields");
+        this.line();
+        for (const { typeVar, constraint } of typeVars) {
+          this.line(`${typeVar} = TypeVar('${typeVar}', bound=${constraint}, default=${constraint})`);
+        }
+      }
       this.line();
       this.generateNestedTypes(schema);
       this.line();
@@ -1587,6 +2746,11 @@ var Python = class extends Writer {
     if (schema.base) bases.push(schema.base.name);
     bases.push(...this.injectSuperClasses(schema.identifier.url));
     if (schema.identifier.name in GENERIC_FIELD_REWRITES) bases.push("Generic[T]");
+    const params = schema.generic?.params ?? [];
+    if (params.length > 0) {
+      const typeVars = params.map((p) => p.typeVar).join(", ");
+      bases.push(`Generic[${typeVars}]`);
+    }
     return bases;
   }
   generateClassBody(schema) {
@@ -1598,10 +2762,26 @@ var Python = class extends Writer {
     if (isResourceTypeSchema(schema)) {
       this.generateResourceTypeField(schema);
     }
-    this.generateFields(schema, schema.identifier.name);
+    this.generateFields(schema);
+    if (this.opts.generateProfile && schema.identifier.name === "Extension") {
+      this.generateExtensionEqualityMethods();
+    }
     if (isResourceTypeSchema(schema)) {
       this.generateResourceMethods(schema);
     }
+    if ((schema.generic?.params?.length ?? 0) > 0) {
+      this.generateResourcePreprocessorMethod(schema);
+    }
+  }
+  generateResourcePreprocessorMethod(schema) {
+    const pyFhirPackage2 = pyFhirPackageByName(this.opts.rootPackageName, schema.identifier.package);
+    this.line();
+    this.line("@model_validator(mode='before')");
+    this.line("@classmethod");
+    this.line("def _preprocess_resources(cls, data: Any) -> Any:");
+    this.line("    if isinstance(data, dict):");
+    this.line(`        return preprocess_resource_fields(data, "${pyFhirPackage2}")`);
+    this.line("    return data");
   }
   generateModelConfig() {
     const extraMode = this.opts.allowExtraFields ? "allow" : "forbid";
@@ -1625,12 +2805,12 @@ var Python = class extends Writer {
     });
     this.line(")");
   }
-  generateFields(schema, schemaName) {
+  generateFields(schema) {
     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);
+      const fieldInfo = this.buildFieldInfo(fieldName, field, schema);
       this.line(`${fieldInfo.name}: ${fieldInfo.type}${fieldInfo.defaultValue}`);
       if (withExtensions && "type" in field && isPrimitiveIdentifier(field.type)) {
         this.addPrimitiveExtensionField(fieldName, field.array ?? false);
@@ -1647,23 +2827,24 @@ var Python = class extends Writer {
     return false;
   }
   addPrimitiveExtensionField(fieldName, isArray) {
-    const pyFieldName = this.nameFormatFunction(`${fieldName}Extension`);
+    const pyFieldName2 = 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})`);
+    this.line(`${pyFieldName2}: ${typeExpr} = Field(None, ${aliasSpec})`);
   }
-  buildFieldInfo(fieldName, field, schemaName) {
-    const pyFieldName = fixReservedWords(this.nameFormatFunction(fieldName));
-    const fieldType = this.determineFieldType(field, fieldName, schemaName);
+  buildFieldInfo(fieldName, field, schema) {
+    const pyFieldName2 = fixReservedWords(this.nameFormatFunction(fieldName));
+    const fieldType = this.determineFieldType(field, fieldName, schema);
     const defaultValue = this.getFieldDefaultValue(field, fieldName);
     return {
-      name: pyFieldName,
+      name: pyFieldName2,
       type: fieldType,
       defaultValue
     };
   }
-  determineFieldType(field, fieldName, schemaName) {
+  determineFieldType(field, fieldName, schema) {
+    const schemaName = schema.identifier.name;
     let fieldType = field ? this.getBaseFieldType(field) : "";
     const rewrite = GENERIC_FIELD_REWRITES[schemaName]?.[fieldName];
     if (rewrite) {
@@ -1672,6 +2853,27 @@ var Python = class extends Writer {
       if (!field.required) fieldType = `${fieldType} | None`;
       return fieldType;
     }
+    const params = schema.generic?.params ?? [];
+    const directParam = params.find((p) => leafOf2(p.path) === fieldName);
+    if (directParam) {
+      fieldType = directParam.typeVar;
+      if (field.array) fieldType = `PyList[${fieldType}]`;
+      if (!field.required) fieldType = `${fieldType} | None`;
+      return fieldType;
+    }
+    if ("type" in field && field.type && params.length > 0) {
+      assert4(this.tsIndex !== void 0);
+      const target = this.tsIndex.resolveType(field.type);
+      if (target && (isNestedTypeSchema(target) || isSpecializationTypeSchema(target))) {
+        const nestedParams = target.generic?.params ?? [];
+        if (nestedParams.length > 0) {
+          const args = nestedParams.map(
+            (np) => params.find((p) => leafOf2(p.path) === leafOf2(np.path))?.typeVar ?? np.typeVar
+          );
+          fieldType = `${fieldType}[${args.join(", ")}]`;
+        }
+      }
+    }
     if ("enum" in field && field.enum) {
       const baseTypeName = "type" in field ? field.type.name : "";
       if (baseTypeName in GENERIC_FIELD_REWRITES) {
@@ -1703,19 +2905,30 @@ var Python = class extends Writer {
     }
     return ` = Field(${aliasSpec})`;
   }
-  generateResourceMethods(schema) {
-    const className = schema.identifier.name.toString();
+  generateResourceMethods(_schema) {
     this.line();
     this.line("def model_post_init(self, __context: Any) -> None:");
-    this.line('    self.__pydantic_fields_set__.add("resource_type")');
+    this.line(`    self.__pydantic_fields_set__.add("${this.nameFormatFunction("resourceType")}")`);
     this.line();
     this.line("def to_json(self, indent: int | None = None) -> str:");
     this.line("    return self.model_dump_json(exclude_unset=True, exclude_none=True, indent=indent)");
     this.line();
     this.line("@classmethod");
-    this.line(`def from_json(cls, json: str) -> ${className}:`);
+    this.line("def from_json(cls, json: str) -> Self:");
     this.line("    return cls.model_validate_json(json)");
   }
+  generateExtensionEqualityMethods() {
+    this.line();
+    this.line("def __eq__(self, other: object) -> bool:");
+    this.line("    if not isinstance(other, Extension):");
+    this.line("        return NotImplemented");
+    this.line(
+      "    return self.model_dump(by_alias=True, exclude_none=True) == other.model_dump(by_alias=True, exclude_none=True)"
+    );
+    this.line();
+    this.line("def __hash__(self) -> int:");
+    this.line("    return hash(self.url)");
+  }
   generateNestedTypes(schema) {
     if (!schema.nested) return;
     this.line();
@@ -1723,17 +2936,20 @@ var Python = class extends Writer {
       this.generateType(subtype);
     }
   }
-  generateDefaultImports(includeGenericImports) {
+  generateDefaultImports(includeGenericImports, includeResourceGenericImports = false, includeResourceMethods = false) {
     this.pyImportFrom("__future__", "annotations");
-    this.pyImportFrom("pydantic", "BaseModel", "ConfigDict", "Field", "PositiveInt");
+    const pydanticImports = ["BaseModel", "ConfigDict", "Field", "PositiveInt"];
+    if (includeResourceGenericImports) pydanticImports.push("model_validator");
+    this.pyImportFrom("pydantic", ...pydanticImports.sort());
     const typingImports = ["Any", "List as PyList", "Literal"];
-    if (includeGenericImports) {
+    if (includeGenericImports || includeResourceGenericImports) {
       typingImports.push("Generic");
     }
     this.pyImportFrom("typing", ...typingImports.sort());
-    if (includeGenericImports) {
-      this.pyImportFrom("typing_extensions", "TypeVar");
-    }
+    const typingExtImports = [];
+    if (includeGenericImports || includeResourceGenericImports) typingExtImports.push("TypeVar");
+    if (includeResourceMethods) typingExtImports.push("Self");
+    if (typingExtImports.length > 0) this.pyImportFrom("typing_extensions", ...typingExtImports.sort());
   }
   generateDependenciesImports(schema) {
     if (!schema.dependencies || schema.dependencies.length === 0) return;
@@ -1749,134 +2965,58 @@ var Python = class extends Writer {
     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");
+    const pyPkg = pyPackage(this.opts.rootPackageName, element.identifier);
+    this.pyImportFrom(pyPkg, "Element");
   }
   importComplexTypeDependencies(dependencies) {
     const complexTypeDeps = dependencies.filter((dep) => dep.kind === "complex-type");
     const depsByPackage = this.groupDependenciesByPackage(complexTypeDeps);
-    for (const [pyPackage, names] of Object.entries(depsByPackage)) {
-      this.pyImportFrom(pyPackage, ...names.sort());
+    for (const [pyPackage2, names] of Object.entries(depsByPackage)) {
+      this.pyImportFrom(pyPackage2, ...names.sort());
     }
   }
   importResourceDependencies(dependencies) {
     const resourceDeps = dependencies.filter((dep) => dep.kind === "resource");
     for (const dep of resourceDeps) {
       this.pyImportType(dep);
-      const familyName = `${pascalCase(dep.name)}Family`;
-      const familyPackage = `${this.pyFhirPackage(dep)}.resource_families`;
-      this.pyImportFrom(familyPackage, familyName);
     }
   }
   groupDependenciesByPackage(dependencies) {
     const grouped = {};
     for (const dep of dependencies) {
-      const pyPackage = this.pyPackage(dep);
-      if (!grouped[pyPackage]) {
-        grouped[pyPackage] = [];
+      const pyPkg = pyPackage(this.opts.rootPackageName, dep);
+      if (!grouped[pyPkg]) {
+        grouped[pyPkg] = [];
       }
-      grouped[pyPackage].push(dep.name);
+      grouped[pyPkg].push(dep.name);
     }
     return grouped;
   }
-  pyImportFrom(pyPackage, ...entities) {
-    const oneLine = `from ${pyPackage} import ${entities.join(", ")}`;
+  pyImportFrom(pyPackage2, ...entities) {
+    const oneLine = `from ${pyPackage2} import ${entities.join(", ")}`;
     if (this.shouldUseSingleLineImport(oneLine, entities)) {
       this.line(oneLine);
     } else {
-      this.writeMultiLineImport(pyPackage, entities);
+      this.writeMultiLineImport(pyPackage2, entities);
     }
   }
   shouldUseSingleLineImport(oneLine, entities) {
     return oneLine.length <= MAX_IMPORT_LINE_LENGTH || entities.length === 1;
   }
-  writeMultiLineImport(pyPackage, entities) {
-    this.line(`from ${pyPackage} import (\\`);
+  writeMultiLineImport(pyPackage2, entities) {
+    this.line(`from ${pyPackage2} import (`);
     this.indentBlock(() => {
-      const remaining = [...entities];
-      while (remaining.length > 0) {
-        const line = this.buildImportLine(remaining, MAX_IMPORT_LINE_LENGTH);
+      let i = 0;
+      while (i < entities.length) {
+        const { line, next } = this.buildImportLine(entities, i, MAX_IMPORT_LINE_LENGTH);
         this.line(line);
+        i = next;
       }
     });
     this.line(")");
   }
   pyImportType(identifier) {
-    this.pyImportFrom(this.pyPackage(identifier), pascalCase(identifier.name));
-  }
-  generateResourceFamilies(packageResources) {
-    assert4(this.tsIndex !== void 0);
-    const packages = (
-      //this.helper.getPackages(packageResources, this.opts.rootPackageName);
-      Object.keys(groupByPackages(packageResources)).map(
-        (pkgName) => `${this.opts.rootPackageName}.${pkgName.replaceAll(".", "_")}`
-      )
-    );
-    const families = {};
-    for (const resource of this.tsIndex.collectResources()) {
-      const children = (resource.typeFamily?.resources ?? []).map((c) => c.name);
-      if (children.length > 0) {
-        const familyName = `${resource.identifier.name}Family`;
-        families[familyName] = children;
-      }
-    }
-    const exportList = Object.keys(families);
-    if (exportList.length === 0) return;
-    this.buildResourceFamiliesFile(packages, families, exportList);
-  }
-  buildResourceFamiliesFile(packages, families, exportList) {
-    this.cat("resource_families.py", () => {
-      this.generateDisclaimer();
-      this.includeResourceFamilyValidator();
-      this.line();
-      this.generateFamilyDefinitions(packages, families);
-      this.generateFamilyExports(exportList);
-    });
-  }
-  includeResourceFamilyValidator() {
-    const content = fs__default.readFileSync(resolvePyAssets("resource_family_validator.py"), "utf-8");
-    this.line(content);
-  }
-  generateFamilyDefinitions(packages, families) {
-    this.line(`packages = [${packages.map((p) => `'${p}'`).join(", ")}]`);
-    this.line();
-    for (const [familyName, resources] of Object.entries(families)) {
-      this.generateFamilyDefinition(familyName, resources);
-    }
-  }
-  generateFamilyDefinition(familyName, resources) {
-    const listName = `${familyName}_resources`;
-    this.line(
-      `${listName} = [${resources.map((r) => `'${r}'`).sort().join(", ")}]`
-    );
-    this.line();
-    this.line(`def validate_and_downcast_${familyName}(v: Any) -> Any:`);
-    this.line(`   return validate_and_downcast(v, packages, ${listName})`);
-    this.line();
-    this.line(`type ${familyName} = Annotated[Any, BeforeValidator(validate_and_downcast_${familyName})]`);
-    this.line();
-  }
-  generateFamilyExports(exportList) {
-    this.line(`__all__ = [${exportList.map((e) => `'${e}'`).join(", ")}]`);
-  }
-  buildPyPackageName(packageName) {
-    const parts = packageName ? [snakeCase(packageName)] : [""];
-    return parts.join(".");
-  }
-  pyFhirPackage(identifier) {
-    return this.pyFhirPackageByName(identifier.package);
-  }
-  pyFhirPackageByName(name) {
-    return [this.opts.rootPackageName, this.buildPyPackageName(name)].join(".");
-  }
-  pyPackage(identifier) {
-    if (identifier.kind === "complex-type") {
-      return `${this.pyFhirPackage(identifier)}.base`;
-    }
-    if (identifier.kind === "resource") {
-      return [this.pyFhirPackage(identifier), snakeCase(identifier.name)].join(".");
-    }
-    return this.pyFhirPackage(identifier);
+    this.pyImportFrom(pyPackage(this.opts.rootPackageName, identifier), pascalCase(identifier.name));
   }
   getFieldFormatFunction(format2) {
     if (!AVAILABLE_STRING_FORMATS[format2]) {
@@ -1950,11 +3090,13 @@ function mkIdentifier(fhirSchema) {
   if (fhirSchema.kind === "logical") return { kind: "logical", ...fields };
   return { kind: "resource", ...fields };
 }
+var VALUE_SET_NAME_SPLIT_RE = /[-_]/;
+var OPAQUE_VALUE_SET_ID_RE = /^[a-zA-Z0-9_-]{20,}$/;
 var getValueSetName = (url) => {
   const urlParts = url.split("/");
   const lastSegment = urlParts[urlParts.length - 1];
   if (lastSegment && lastSegment.length > 0) {
-    return lastSegment.split(/[-_]/).map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase()).join("");
+    return lastSegment.split(VALUE_SET_NAME_SPLIT_RE).map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase()).join("");
   }
   return url;
 };
@@ -1968,7 +3110,7 @@ function mkValueSetIdentifierByUrl(register, pkg, fullValueSetUrl) {
     },
     id: fullValueSetUrl};
   const valueSet = register.resolveVs(pkg, valueSetUrl) || valuesSetFallback;
-  const valueSetName = valueSet?.id && !/^[a-zA-Z0-9_-]{20,}$/.test(valueSet.id) ? valueSet.id : valueSetNameFallback;
+  const valueSetName = valueSet?.id && !OPAQUE_VALUE_SET_ID_RE.test(valueSet.id) ? valueSet.id : valueSetNameFallback;
   return {
     kind: "value-set",
     package: valueSet.package_meta.name,
@@ -2240,6 +3382,7 @@ var isValueSet = (resource) => {
 };
 
 // src/typeschema/register.ts
+var BARE_RESOURCE_NAME_RE = /^[a-zA-Z0-9]+$/;
 var readPackageDependencies = async (manager, packageMeta2) => {
   const packageJSON = await manager.packageJson(packageMeta2.name);
   if (!packageJSON) return [];
@@ -2264,6 +3407,7 @@ var mkPackageAwareResolver = async (manager, pkg, deep, acc, logger) => {
   logger?.info(`${" ".repeat(deep * 2)}+ ${pkgId}`);
   if (acc[pkgId]) return acc[pkgId];
   const index = mkEmptyPkgIndex(pkg);
+  acc[pkgId] = index;
   for (const resource of await manager.search({ package: pkg })) {
     const rawUrl = resource.url;
     if (!rawUrl) continue;
@@ -2284,7 +3428,6 @@ var mkPackageAwareResolver = async (manager, pkg, deep, acc, logger) => {
   for (const resolutionOptions of Object.values(index.canonicalResolution)) {
     resolutionOptions.sort((a, b) => a.deep - b.deep);
   }
-  acc[pkgId] = index;
   return index;
 };
 var enrichResolver = (resolver, logger) => {
@@ -2299,8 +3442,8 @@ var enrichResolver = (resolver, logger) => {
       const resource = resolition.resource;
       const resourcePkg = resolition.pkg;
       if (isStructureDefinition(resource)) {
-        const fs7 = fhirschema.translate(resource);
-        const rfs = enrichFHIRSchema(fs7, resourcePkg);
+        const fs6 = fhirschema.translate(resource);
+        const rfs = enrichFHIRSchema(fs6, resourcePkg);
         counter++;
         resolver[pkgId].fhirSchemas[rfs.url] = rfs;
       }
@@ -2333,12 +3476,12 @@ var registerFromManager = async (manager, { logger, focusedPackages }) => {
       }
     }
     for (const idx of Object.values(resolver)) {
-      const fs7 = idx.fhirSchemas[canonicalUrl];
-      if (fs7 && fs7.package_meta.name === pkg.name) return fs7;
+      const fs6 = idx.fhirSchemas[canonicalUrl];
+      if (fs6 && fs6.package_meta.name === pkg.name) return fs6;
     }
     for (const idx of Object.values(resolver)) {
-      const fs7 = idx.fhirSchemas[canonicalUrl];
-      if (fs7) return fs7;
+      const fs6 = idx.fhirSchemas[canonicalUrl];
+      if (fs6) return fs6;
     }
     return void 0;
   };
@@ -2362,29 +3505,29 @@ var registerFromManager = async (manager, { logger, focusedPackages }) => {
   };
   const ensureSpecializationCanonicalUrl = (name) => {
     if (name.includes("|")) name = name.split("|")[0];
-    if (name.match(/^[a-zA-Z0-9]+$/)) {
+    if (BARE_RESOURCE_NAME_RE.test(name)) {
       return `http://hl7.org/fhir/StructureDefinition/${name}`;
     }
     return name;
   };
   const resolveFsGenealogy = (pkg, canonicalUrl) => {
-    let fs7 = resolveFs(pkg, canonicalUrl);
-    if (fs7 === void 0) throw new Error(`Failed to resolve FHIR Schema: '${canonicalUrl}'`);
-    const genealogy = [fs7];
-    while (fs7?.base) {
-      const pkg2 = fs7.package_meta;
-      const baseUrl = ensureSpecializationCanonicalUrl(fs7.base);
-      fs7 = resolveFs(pkg2, baseUrl);
-      if (fs7 === void 0)
+    let fs6 = resolveFs(pkg, canonicalUrl);
+    if (fs6 === void 0) throw new Error(`Failed to resolve FHIR Schema: '${canonicalUrl}'`);
+    const genealogy = [fs6];
+    while (fs6?.base) {
+      const pkg2 = fs6.package_meta;
+      const baseUrl = ensureSpecializationCanonicalUrl(fs6.base);
+      fs6 = resolveFs(pkg2, baseUrl);
+      if (fs6 === void 0)
         throw new Error(
           `Failed to resolve FHIR Schema base for '${canonicalUrl}'. Problem: '${baseUrl}' from '${packageMetaToFhir(pkg2)}'`
         );
-      genealogy.push(fs7);
+      genealogy.push(fs6);
     }
     return genealogy;
   };
   const resolveFsSpecializations = (pkg, canonicalUrl) => {
-    return resolveFsGenealogy(pkg, canonicalUrl).filter((fs7) => fs7.derivation === "specialization");
+    return resolveFsGenealogy(pkg, canonicalUrl).filter((fs6) => fs6.derivation === "specialization");
   };
   const resolveElementSnapshot = (fhirSchema, path) => {
     const geneology = resolveFsGenealogy(fhirSchema.package_meta, fhirSchema.url);
@@ -2479,9 +3622,9 @@ var registerFromPackageMetas = async (packageMetas, conf) => {
 var resolveFsElementGenealogy = (genealogy, path) => {
   const [top, ...rest] = path;
   if (top === void 0) return [];
-  return genealogy.map((fs7) => {
-    if (!fs7.elements) return void 0;
-    let elem = fs7.elements?.[top];
+  return genealogy.map((fs6) => {
+    if (!fs6.elements) return void 0;
+    let elem = fs6.elements?.[top];
     for (const k of rest) {
       elem = elem?.elements?.[k];
     }
@@ -2504,7 +3647,7 @@ var hasStructuralElements = (register, fhirSchema, path) => {
   if (elemType) {
     const typeUrl = register.ensureSpecializationCanonicalUrl(elemType);
     const typeGenealogy = register.resolveFsGenealogy(fhirSchema.package_meta, typeUrl);
-    const keys = typeGenealogy.flatMap((fs7) => Object.keys(fs7.elements ?? {}));
+    const keys = typeGenealogy.flatMap((fs6) => Object.keys(fs6.elements ?? {}));
     if (keys.length > 0) typeKeys = new Set(keys);
   }
   for (const elem of elemGens) {
@@ -2519,19 +3662,19 @@ var isNestedElement = (register, fhirSchema, path, snapshot, raw) => {
   if (!raw?.elements || raw.choiceOf !== void 0) return false;
   return hasStructuralElements(register, fhirSchema, path);
 };
-var collectNestedPaths = (fs7) => {
-  if (!fs7.elements) return /* @__PURE__ */ new Set();
+var collectNestedPaths = (fs6) => {
+  if (!fs6.elements) return /* @__PURE__ */ new Set();
   return new Set(
-    collectNestedElements(fs7, [], fs7.elements).filter(([_, el]) => el.elements && Object.keys(el.elements).length > 0).map(([path]) => path.join("."))
+    collectNestedElements(fs6, [], fs6.elements).filter(([_, el]) => el.elements && Object.keys(el.elements).length > 0).map(([path]) => path.join("."))
   );
 };
 function mkNestedIdentifier(register, fhirSchema, path) {
   const nestedTypeOrigins = {};
   const genealogy = fhirSchema.derivation === "constraint" ? register.resolveFsSpecializations(fhirSchema.package_meta, fhirSchema.url) : register.resolveFsGenealogy(fhirSchema.package_meta, fhirSchema.url);
-  for (const fs7 of [...genealogy].reverse()) {
-    const paths = collectNestedPaths(fs7);
+  for (const fs6 of [...genealogy].reverse()) {
+    const paths = collectNestedPaths(fs6);
     for (const p of paths) {
-      nestedTypeOrigins[p] = `${fs7.url}#${p}`;
+      nestedTypeOrigins[p] = `${fs6.url}#${p}`;
     }
   }
   const nestedName = path.join(".");
@@ -2666,10 +3809,10 @@ function isRequired(register, fhirSchema, path) {
   const fieldName = path[path.length - 1];
   if (!fieldName) throw new Error(`Internal error: fieldName is missing for path ${path.join("/")}`);
   const parentPath = path.slice(0, -1);
-  const requires = register.resolveFsGenealogy(fhirSchema.package_meta, fhirSchema.url).flatMap((fs7) => {
-    if (parentPath.length === 0) return fs7.required || [];
-    if (!fs7.elements) return [];
-    let elem = fs7;
+  const requires = register.resolveFsGenealogy(fhirSchema.package_meta, fhirSchema.url).flatMap((fs6) => {
+    if (parentPath.length === 0) return fs6.required || [];
+    if (!fs6.elements) return [];
+    let elem = fs6;
     for (const k of parentPath) {
       elem = elem?.elements?.[k];
     }
@@ -2681,10 +3824,10 @@ function isExcluded(register, fhirSchema, path) {
   const fieldName = path[path.length - 1];
   if (!fieldName) throw new Error(`Internal error: fieldName is missing for path ${path.join("/")}`);
   const parentPath = path.slice(0, -1);
-  const requires = register.resolveFsGenealogy(fhirSchema.package_meta, fhirSchema.url).flatMap((fs7) => {
-    if (parentPath.length === 0) return fs7.excluded || [];
-    if (!fs7.elements) return [];
-    let elem = fs7;
+  const requires = register.resolveFsGenealogy(fhirSchema.package_meta, fhirSchema.url).flatMap((fs6) => {
+    if (parentPath.length === 0) return fs6.excluded || [];
+    if (!fs6.elements) return [];
+    let elem = fs6;
     for (const k of parentPath) {
       elem = elem?.elements?.[k];
     }
@@ -2696,9 +3839,9 @@ var buildReferences = (register, fhirSchema, element) => {
   if (!element.refers) return void 0;
   return element.refers.map((ref) => {
     const curl = register.ensureSpecializationCanonicalUrl(ref);
-    const fs7 = register.resolveFs(fhirSchema.package_meta, curl);
-    if (!fs7) throw new Error(`Failed to resolve fs for ${curl}`);
-    return mkIdentifier(fs7);
+    const fs6 = register.resolveFs(fhirSchema.package_meta, curl);
+    if (!fs6) throw new Error(`Failed to resolve fs for ${curl}`);
+    return mkIdentifier(fs6);
   });
 };
 var extractSliceFieldNames = (schema) => {
@@ -2848,7 +3991,8 @@ function buildFieldType(register, fhirSchema, path, element, logger) {
   if (element.elementReference) {
     const refPath = element.elementReference.slice(1).filter((_, i) => i % 2 === 1);
     return mkNestedIdentifier(register, fhirSchema, refPath);
-  } else if (element.type) {
+  }
+  if (element.type) {
     const url = register.ensureSpecializationCanonicalUrl(element.type);
     const fieldFs = register.resolveFs(fhirSchema.package_meta, url);
     if (!fieldFs) {
@@ -2864,17 +4008,18 @@ function buildFieldType(register, fhirSchema, path, element, logger) {
       );
     }
     return mkIdentifier(fieldFs);
-  } else if (element.choices) {
-    return void 0;
-  } else if (fhirSchema.derivation === "constraint") {
+  }
+  if (element.choices) {
     return void 0;
-  } else {
-    logger?.dryWarn(
-      "#fieldTypeNotFound",
-      `Can't recognize element type: <${fhirSchema.url}>.${path.join(".")} (pkg: '${packageMetaToFhir(fhirSchema.package_meta)}'): missing type info`
-    );
+  }
+  if (fhirSchema.derivation === "constraint") {
     return void 0;
   }
+  logger?.dryWarn(
+    "#fieldTypeNotFound",
+    `Can't recognize element type: <${fhirSchema.url}>.${path.join(".")} (pkg: '${packageMetaToFhir(fhirSchema.package_meta)}'): missing type info`
+  );
+  return void 0;
 }
 var mkField = (register, fhirSchema, path, element, logger, rawElement) => {
   let binding;
@@ -3526,13 +4671,13 @@ var typeSchemaToJson = (ts, pretty) => {
     genContent: () => JSON.stringify(ts, null, pretty ? 2 : void 0)
   };
 };
-var fhirSchemaToJson = (fs7, pretty) => {
-  const pkgPath = normalizeFileName(fs7.package_meta.name);
-  const name = normalizeFileName(`${fs7.name}(${extractNameFromCanonical(fs7.url)})`);
+var fhirSchemaToJson = (fs6, pretty) => {
+  const pkgPath = normalizeFileName(fs6.package_meta.name);
+  const name = normalizeFileName(`${fs6.name}(${extractNameFromCanonical(fs6.url)})`);
   const baseName = Path5.join(pkgPath, name);
   return {
     filename: baseName,
-    genContent: () => JSON.stringify(fs7, null, pretty ? 2 : void 0)
+    genContent: () => JSON.stringify(fs6, null, pretty ? 2 : void 0)
   };
 };
 var structureDefinitionToJson = (sd, pretty) => {
@@ -3554,7 +4699,7 @@ var IntrospectionWriter = class extends FileSystemWriter {
     }
     if (this.opts.typeSchemas) {
       if (Path5.extname(this.opts.typeSchemas) === ".ndjson") {
-        this.writeNdjson(tsIndex.schemas, this.opts.typeSchemas, typeSchemaToJson);
+        await this.writeNdjson(tsIndex.schemas, this.opts.typeSchemas, typeSchemaToJson);
       } else {
         const items = tsIndex.schemas.map((ts) => typeSchemaToJson(ts, true));
         const seenFilenames = /* @__PURE__ */ new Set();
@@ -3602,16 +4747,16 @@ var IntrospectionWriter = class extends FileSystemWriter {
       const outputPath = this.opts.fhirSchemas;
       const allFs = tsIndex.register.allFs();
       const seenUrls = /* @__PURE__ */ new Set();
-      const fhirSchemas = allFs.filter((fs7) => {
-        if (seenUrls.has(fs7.url)) return false;
-        seenUrls.add(fs7.url);
+      const fhirSchemas = allFs.filter((fs6) => {
+        if (seenUrls.has(fs6.url)) return false;
+        seenUrls.add(fs6.url);
         return true;
       });
       if (Path5.extname(outputPath) === ".ndjson") {
-        this.writeNdjson(fhirSchemas, outputPath, fhirSchemaToJson);
+        await this.writeNdjson(fhirSchemas, outputPath, fhirSchemaToJson);
       } else {
-        this.writeJsonFiles(
-          fhirSchemas.map((fs7) => fhirSchemaToJson(fs7, true)),
+        await this.writeJsonFiles(
+          fhirSchemas.map((fs6) => fhirSchemaToJson(fs6, true)),
           outputPath
         );
       }
@@ -3627,9 +4772,9 @@ var IntrospectionWriter = class extends FileSystemWriter {
         return true;
       });
       if (Path5.extname(outputPath) === ".ndjson") {
-        this.writeNdjson(structureDefinitions, outputPath, structureDefinitionToJson);
+        await this.writeNdjson(structureDefinitions, outputPath, structureDefinitionToJson);
       } else {
-        this.writeJsonFiles(
+        await this.writeJsonFiles(
           structureDefinitions.map((sd) => structureDefinitionToJson(sd, true)),
           outputPath
         );
@@ -3680,7 +4825,7 @@ var IntrospectionWriter = class extends FileSystemWriter {
 // src/typeschema/ir/report.ts
 var generateSkippedPackagesSection = (lines, skippedPackages) => {
   lines.push("## Skipped Packages", "");
-  for (const pkg of skippedPackages) {
+  for (const pkg of [...skippedPackages].sort()) {
     lines.push(`- ${pkg}`);
   }
   lines.push("");
@@ -3741,7 +4886,7 @@ var generateCollisionVersionLines = (versions) => {
     const sourceList = v.entries.map((e) => {
       const name = extractNameFromCanonical(e.sourceCanonical) ?? e.sourceCanonical;
       return `${name} (${e.sourcePackage})`;
-    }).join(", ");
+    }).sort().join(", ");
     const mark = v.mark ? versionMarkLabel[v.mark] : "";
     return `  - Version ${version++}${mark}: ${sourceList}`;
   });
@@ -3843,6 +4988,7 @@ var DebugMixinProvider = class {
   constructor(mode) {
     this.mode = mode;
   }
+  mode;
   apply(target) {
     return this._addDebug(target);
   }
@@ -3880,6 +5026,7 @@ var LambdaMixinProvider = class {
       upperCase: () => (text, render) => render(text).toUpperCase()
     };
   }
+  nameGenerator;
   lambda;
   apply(target) {
     return {
@@ -3897,6 +5044,10 @@ var NameGenerator = class {
     this.nameTransformations = nameTransformations;
     this.unsaveCharacterPattern = unsaveCharacterPattern;
   }
+  keywords;
+  typeMap;
+  nameTransformations;
+  unsaveCharacterPattern;
   _replaceUnsaveChars(name) {
     const pattern = this.unsaveCharacterPattern instanceof RegExp ? this.unsaveCharacterPattern : new RegExp(this.unsaveCharacterPattern, "g");
     return name.replace(pattern, "_");
@@ -4066,6 +5217,9 @@ var ViewModelFactory = class {
     this.nameGenerator = nameGenerator;
     this.filterPred = filterPred;
   }
+  tsIndex;
+  nameGenerator;
+  filterPred;
   arrayMixinProvider = new ListElementInformationMixinProvider();
   createUtility() {
     return this._createForRoot();
@@ -4329,7 +5483,7 @@ function loadMustacheGeneratorConfig(templatePath, logger) {
     if (parsed && typeof parsed === "object") {
       return parsed;
     }
-  } catch (_e) {
+  } catch {
   }
   return {};
 }
@@ -4638,8 +5792,9 @@ var extractValueField = (elements) => {
   if (!elements) return void 0;
   return elements.find((e) => e.startsWith("value") && e !== "value");
 };
+var VALUE_PREFIX_RE = /^value/;
 var valueFieldToTsType = (valueField) => {
-  const fhirName = valueField.replace(/^value/, "");
+  const fhirName = valueField.replace(VALUE_PREFIX_RE, "");
   const primitives = {
     String: "string",
     Boolean: "boolean",
@@ -4684,7 +5839,7 @@ var collectSubExtensionSlices = (extProfile) => {
   }
   return result;
 };
-var resolveExtensionProfile = (tsIndex, pkgName, url) => {
+var resolveExtensionProfile2 = (tsIndex, pkgName, url) => {
   const schema = tsIndex.resolveByUrl(pkgName, url);
   if (!schema || !isProfileTypeSchema(schema)) return void 0;
   if (schema.identifier.package !== pkgName) return void 0;
@@ -4757,7 +5912,7 @@ var generateExtensionGetterOverloads = (w, ext, targetPath, methodName, inputTyp
     }
   );
 };
-var generateComplexExtensionSetter = (w, info) => {
+var generateComplexExtensionSetter2 = (w, info) => {
   const { ext, snapshot, setMethodName, targetPath, extProfileInfo } = info;
   const tsProfileName = tsResourceName(snapshot.identifier);
   const inputTypeName = tsExtensionFlatTypeName(tsProfileName, ext.name);
@@ -4820,7 +5975,7 @@ var generateComplexExtensionSetter = (w, info) => {
     });
   }
 };
-var generateComplexExtensionGetter = (w, info) => {
+var generateComplexExtensionGetter2 = (w, info) => {
   const { ext, snapshot, getMethodName, targetPath, extProfileInfo } = info;
   const tsProfileName = tsResourceName(snapshot.identifier);
   const inputTypeName = tsExtensionFlatTypeName(tsProfileName, ext.name);
@@ -4836,7 +5991,7 @@ var generateComplexExtensionGetter = (w, info) => {
     w.line(`return extractComplexExtension<${inputType}>(ext, config)`);
   });
 };
-var generateSingleValueExtensionSetter = (w, tsIndex, info) => {
+var generateSingleValueExtensionSetter2 = (w, tsIndex, info) => {
   const { ext, setMethodName, targetPath, extProfileInfo } = info;
   const firstValueType = ext.valueFieldTypes?.[0];
   if (!firstValueType) return;
@@ -4844,7 +5999,7 @@ var generateSingleValueExtensionSetter = (w, tsIndex, info) => {
   const valueField = tsValueFieldName(firstValueType);
   const useUpsert = ext.max === "1";
   if (extProfileInfo) {
-    const extFactoryInfo = collectProfileFactoryInfo(tsIndex, extProfileInfo.snapshot);
+    const extFactoryInfo = collectProfileFactoryInfo2(tsIndex, extProfileInfo.snapshot);
     const extValueParam = extFactoryInfo.params.find((p) => p.name === valueField);
     const resolvedValueType = extValueParam?.tsType ?? valueType;
     const paramType = `${extProfileInfo.className} | Extension | ${resolvedValueType}`;
@@ -4873,7 +6028,7 @@ var generateSingleValueExtensionSetter = (w, tsIndex, info) => {
     });
   }
 };
-var generateSingleValueExtensionGetter = (w, info) => {
+var generateSingleValueExtensionGetter2 = (w, info) => {
   const { ext, getMethodName, targetPath, extProfileInfo } = info;
   const firstValueType = ext.valueFieldTypes?.[0];
   if (!firstValueType) return;
@@ -4883,7 +6038,7 @@ var generateSingleValueExtensionGetter = (w, info) => {
     w.line(`return getExtensionValue<${valueType}>(ext, "${valueField}")`);
   });
 };
-var generateGenericExtensionSetter = (w, info) => {
+var generateGenericExtensionSetter2 = (w, info) => {
   const { ext, setMethodName, targetPath } = info;
   const useUpsert = ext.max === "1";
   w.curlyBlock(["public", setMethodName, `(value: Omit<Extension, "url"> | Extension): this`], () => {
@@ -4899,7 +6054,7 @@ var generateGenericExtensionSetter = (w, info) => {
     w.line("return this");
   });
 };
-var generateGenericExtensionGetter = (w, info) => {
+var generateGenericExtensionGetter2 = (w, info) => {
   const { ext, getMethodName, targetPath } = info;
   w.curlyBlock(["public", getMethodName, "(): Extension | undefined"], () => {
     if (targetPath.length === 0) {
@@ -4912,12 +6067,12 @@ var generateGenericExtensionGetter = (w, info) => {
     }
   });
 };
-var generateExtensionMethods = (w, tsIndex, snapshot) => {
+var generateExtensionMethods2 = (w, tsIndex, snapshot) => {
   for (const ext of snapshot.extensions ?? []) {
     if (!ext.url) continue;
     const baseName = ext.nameCandidates.recommended;
     const targetPath = ext.path.split(".").filter((segment) => segment !== "extension");
-    const extProfileInfo = resolveExtensionProfile(tsIndex, snapshot.identifier.package, ext.url);
+    const extProfileInfo = resolveExtensionProfile2(tsIndex, snapshot.identifier.package, ext.url);
     const info = {
       ext,
       snapshot,
@@ -4927,17 +6082,17 @@ var generateExtensionMethods = (w, tsIndex, snapshot) => {
       extProfileInfo
     };
     if (ext.isComplex && ext.subExtensions) {
-      generateComplexExtensionSetter(w, info);
+      generateComplexExtensionSetter2(w, info);
       w.line();
-      generateComplexExtensionGetter(w, info);
+      generateComplexExtensionGetter2(w, info);
     } else if (ext.valueFieldTypes?.length === 1 && ext.valueFieldTypes[0]) {
-      generateSingleValueExtensionSetter(w, tsIndex, info);
+      generateSingleValueExtensionSetter2(w, tsIndex, info);
       w.line();
-      generateSingleValueExtensionGetter(w, info);
+      generateSingleValueExtensionGetter2(w, info);
     } else {
-      generateGenericExtensionSetter(w, info);
+      generateGenericExtensionSetter2(w, info);
       w.line();
-      generateGenericExtensionGetter(w, info);
+      generateGenericExtensionGetter2(w, info);
     }
     w.line();
   }
@@ -5026,7 +6181,7 @@ var collectTypesFromSlices = (tsIndex, snapshot, addType) => {
     }
   }
 };
-var collectRequiredSliceNames = (field) => {
+var collectRequiredSliceNames2 = (field) => {
   if (!field.array || !field.slicing?.slices) return void 0;
   const isTypeDisc = field.slicing.discriminator?.some((d) => d.type === "type") ?? false;
   if (isTypeDisc) return void 0;
@@ -5038,7 +6193,7 @@ var collectRequiredSliceNames = (field) => {
   }).map(([name]) => name);
   return names.length > 0 ? names : void 0;
 };
-var collectSliceDefs = (tsIndex, snapshot) => Object.entries(snapshot.fields).filter(([_, field]) => isNotChoiceDeclarationField(field) && field.slicing?.slices).flatMap(([fieldName, field]) => {
+var collectSliceDefs2 = (tsIndex, snapshot) => Object.entries(snapshot.fields).filter(([_, field]) => isNotChoiceDeclarationField(field) && field.slicing?.slices).flatMap(([fieldName, field]) => {
   if (!isNotChoiceDeclarationField(field) || !field.slicing?.slices || !field.type) return [];
   const baseType = tsTypeFromIdentifier(field.type);
   const pkgName = snapshot.identifier.package;
@@ -5069,7 +6224,7 @@ var collectSliceDefs = (tsIndex, snapshot) => Object.entries(snapshot.fields).fi
     };
   });
 });
-var generateSliceSetters = (w, sliceDefs, snapshot) => {
+var generateSliceSetters2 = (w, sliceDefs, snapshot) => {
   const profileClassName = tsProfileClassName(snapshot);
   const tsProfileName = tsResourceName(snapshot.identifier);
   for (const sliceDef of sliceDefs) {
@@ -5133,7 +6288,7 @@ var generateSliceSetters = (w, sliceDefs, snapshot) => {
     w.line();
   }
 };
-var generateSliceGetters = (w, sliceDefs, snapshot) => {
+var generateSliceGetters2 = (w, sliceDefs, snapshot) => {
   const profileClassName = tsProfileClassName(snapshot);
   const tsProfileName = tsResourceName(snapshot.identifier);
   const defaultMode = w.opts.sliceGetterDefault ?? "flat";
@@ -5266,7 +6421,7 @@ var collectRegularFieldValidation = (errors, warnings, name, field, resolveRef,
     }
   }
 };
-var generateValidateMethod = (w, tsIndex, snapshot) => {
+var generateValidateMethod2 = (w, tsIndex, snapshot) => {
   const fields = snapshot.fields;
   const profileName = snapshot.identifier.name;
   const canonicalUrl = snapshot.identifier.url;
@@ -5343,7 +6498,7 @@ var collectChoiceAccessors = (snapshot, promotedChoices) => {
   }));
   return { accessors, choiceClearMethods };
 };
-var tryPromoteChoice = (field, fields, params, promotedChoices, resolveRef, isFamilyType) => {
+var tryPromoteChoice2 = (field, fields, params, promotedChoices, resolveRef, isFamilyType) => {
   if (!isChoiceDeclarationField(field) || !field.required || field.choices.length !== 1) return;
   const choiceName = field.choices[0];
   if (!choiceName) return;
@@ -5358,7 +6513,7 @@ var mkIsFamilyType = (tsIndex) => (ref) => {
   if (!schema || !("typeFamily" in schema)) return false;
   return (schema.typeFamily?.resources?.length ?? 0) > 0;
 };
-var collectProfileFactoryInfo = (tsIndex, snapshot) => {
+var collectProfileFactoryInfo2 = (tsIndex, snapshot) => {
   const autoFields = [];
   const sliceAutoFields = [];
   const params = [];
@@ -5375,7 +6530,7 @@ var collectProfileFactoryInfo = (tsIndex, snapshot) => {
     if (field.excluded) continue;
     if (isChoiceInstanceField(field)) continue;
     if (isChoiceDeclarationField(field)) {
-      tryPromoteChoice(field, fields, params, promotedChoices, resolveRef, isFamilyType);
+      tryPromoteChoice2(field, fields, params, promotedChoices, resolveRef, isFamilyType);
       continue;
     }
     if (field.valueConstraint) {
@@ -5389,7 +6544,7 @@ var collectProfileFactoryInfo = (tsIndex, snapshot) => {
       continue;
     }
     if (isNotChoiceDeclarationField(field)) {
-      const sliceNames = collectRequiredSliceNames(field);
+      const sliceNames = collectRequiredSliceNames2(field);
       if (sliceNames) {
         if (field.type) {
           const tsType = fieldTsType(field, resolveRef, isFamilyType);
@@ -5409,7 +6564,7 @@ var collectProfileFactoryInfo = (tsIndex, snapshot) => {
       params.push({ name, tsType, typeId: field.type });
     }
   }
-  collectBaseRequiredParams(
+  collectBaseRequiredParams2(
     tsIndex,
     snapshot,
     resolveRef,
@@ -5426,7 +6581,7 @@ var collectProfileFactoryInfo = (tsIndex, snapshot) => {
   const accessors = [...autoAccessors, ...choiceAccessors];
   return { autoFields, sliceAutoFields, params, accessors, choiceClearMethods, fixedFields };
 };
-var collectBaseRequiredParams = (tsIndex, snapshot, resolveRef, params, coveredNames, isFamilyType) => {
+var collectBaseRequiredParams2 = (tsIndex, snapshot, resolveRef, params, coveredNames, isFamilyType) => {
   const covered = new Set(coveredNames);
   const baseSchema = tsIndex.resolveType(snapshot.base);
   if (!baseSchema || !("fields" in baseSchema) || !baseSchema.fields) return;
@@ -5516,7 +6671,7 @@ var generateProfileImports = (w, tsIndex, snapshot) => {
   collectTypesFromSlices(tsIndex, snapshot, addType);
   const needsExtensionType = collectTypesFromExtensions(tsIndex, snapshot, addType);
   collectTypesFromFlatInput(tsIndex, snapshot, addType);
-  const factoryInfo = collectProfileFactoryInfo(tsIndex, snapshot);
+  const factoryInfo = collectProfileFactoryInfo2(tsIndex, snapshot);
   for (const param of factoryInfo.params) addType(param.typeId);
   for (const f of factoryInfo.sliceAutoFields) addType(f.typeId);
   for (const accessor of factoryInfo.accessors) addType(accessor.typeId);
@@ -5542,7 +6697,7 @@ var generateProfileImports = (w, tsIndex, snapshot) => {
   const extProfileImports = /* @__PURE__ */ new Map();
   for (const ext of snapshot.extensions ?? []) {
     if (!ext.url) continue;
-    const info = resolveExtensionProfile(tsIndex, snapshot.identifier.package, ext.url);
+    const info = resolveExtensionProfile2(tsIndex, snapshot.identifier.package, ext.url);
     if (!info) continue;
     if (!extProfileImports.has(info.className)) {
       const hasFlatInput = collectSubExtensionSlices(info.snapshot).length > 0;
@@ -5557,7 +6712,7 @@ var generateProfileImports = (w, tsIndex, snapshot) => {
   }
   if (extProfileImports.size > 0) w.line();
 };
-var generateStaticSliceFields = (w, sliceDefs) => {
+var generateStaticSliceFields2 = (w, sliceDefs) => {
   for (const sliceDef of sliceDefs) {
     const staticName = `${tsSliceStaticName(sliceDef.sliceName)}SliceMatch`;
     const json = JSON.stringify(sliceDef.match);
@@ -5779,7 +6934,7 @@ var generateFactoryMethods = (w, tsIndex, snapshot, factoryInfo) => {
   });
   w.line();
 };
-var generateFieldAccessors = (w, factoryInfo) => {
+var generateFieldAccessors2 = (w, factoryInfo) => {
   w.line("// Field accessors");
   for (const p of factoryInfo.params) {
     const methodBaseName = uppercaseFirstLetter(p.name);
@@ -5821,7 +6976,7 @@ var generateInlineExtensionInputTypes = (w, tsIndex, snapshot) => {
   const complexExtensions = (snapshot.extensions ?? []).filter((ext) => ext.isComplex && ext.subExtensions);
   for (const ext of complexExtensions) {
     if (!ext.url) continue;
-    const extProfileInfo = resolveExtensionProfile(tsIndex, snapshot.identifier.package, ext.url);
+    const extProfileInfo = resolveExtensionProfile2(tsIndex, snapshot.identifier.package, ext.url);
     const hasFlatInput = extProfileInfo ? collectSubExtensionSlices(extProfileInfo.snapshot).length > 0 : false;
     if (hasFlatInput) continue;
     const typeName = tsExtensionFlatTypeName(tsProfileName, ext.name);
@@ -5927,8 +7082,8 @@ var generateFlatInputType = (w, snapshot) => {
 var generateProfileClass = (w, tsIndex, snapshot) => {
   const tsBaseResourceName = tsTypeFromIdentifier(snapshot.base);
   const profileClassName = tsProfileClassName(snapshot);
-  const sliceDefs = collectSliceDefs(tsIndex, snapshot);
-  const factoryInfo = collectProfileFactoryInfo(tsIndex, snapshot);
+  const sliceDefs = collectSliceDefs2(tsIndex, snapshot);
+  const factoryInfo = collectProfileFactoryInfo2(tsIndex, snapshot);
   generateInlineExtensionInputTypes(w, tsIndex, snapshot);
   generateSliceInputTypes(w, snapshot, sliceDefs);
   generateProfileHelpersImport(w, tsIndex, snapshot, sliceDefs, factoryInfo);
@@ -5939,18 +7094,18 @@ var generateProfileClass = (w, tsIndex, snapshot) => {
   w.curlyBlock(["export", "class", profileClassName], () => {
     w.lineSM(`static readonly canonicalUrl = ${JSON.stringify(canonicalUrl)}`);
     w.line();
-    generateStaticSliceFields(w, sliceDefs);
+    generateStaticSliceFields2(w, sliceDefs);
     w.lineSM(`private resource: ${tsBaseResourceName}`);
     w.line();
     generateFactoryMethods(w, tsIndex, snapshot, factoryInfo);
-    generateFieldAccessors(w, factoryInfo);
+    generateFieldAccessors2(w, factoryInfo);
     w.line("// Extensions");
-    generateExtensionMethods(w, tsIndex, snapshot);
+    generateExtensionMethods2(w, tsIndex, snapshot);
     w.line("// Slices");
-    generateSliceSetters(w, sliceDefs, snapshot);
-    generateSliceGetters(w, sliceDefs, snapshot);
+    generateSliceSetters2(w, sliceDefs, snapshot);
+    generateSliceGetters2(w, sliceDefs, snapshot);
     w.line("// Validation");
-    generateValidateMethod(w, tsIndex, snapshot);
+    generateValidateMethod2(w, tsIndex, snapshot);
   });
   w.line();
 };
@@ -5964,7 +7119,7 @@ var resolveTsAssets = (fn) => {
   }
   return Path5.resolve(__dirname, "../../../..", "assets", "api", "writer-generator", "typescript", fn);
 };
-var leafOf2 = (path) => path[path.length - 1] ?? "";
+var leafOf3 = (path) => path[path.length - 1] ?? "";
 var TS_HARDCODED_GENERIC_NAMES = /* @__PURE__ */ new Set(["Reference", "Coding", "CodeableConcept"]);
 var TypeScript = class extends Writer {
   constructor(options) {
@@ -6107,11 +7262,11 @@ var TypeScript = class extends Writer {
         const targetParams = isNestedTypeSchema(target) || isSpecializationTypeSchema(target) ? target.generic?.params : void 0;
         if (targetParams?.length) {
           const args = targetParams.map(
-            (tp) => params.find((q) => leafOf2(q.path) === leafOf2(tp.path))?.typeVar ?? tp.typeVar
+            (tp) => params.find((q) => leafOf3(q.path) === leafOf3(tp.path))?.typeVar ?? tp.typeVar
           );
           nestedArgsByField[tsName] = `<${args.join(", ")}>`;
         } else if (isSpecializationTypeSchema(target) && (target.typeFamily?.resources?.length ?? 0) > 0) {
-          const p = params.find((q) => leafOf2(q.path) === fieldName);
+          const p = params.find((q) => leafOf3(q.path) === fieldName);
           if (p) fieldMap[tsName] = p.typeVar;
         }
       }
@@ -6432,7 +7587,7 @@ var APIBuilder = class {
     const defaultPyOpts = {
       ...defaultWriterOpts,
       rootPackageName: "fhir_types",
-      fieldFormat: "snake_case",
+      fieldFormat: "camelCase",
       primitiveTypeExtension: false
     };
     const opts = {
@@ -6550,7 +7705,7 @@ var APIBuilder = class {
     };
     this.logger.debug(`Starting generation with ${this.generators.length} generators`);
     try {
-      if (this.options.cleanOutput) cleanup(this.options, this.logger);
+      if (this.options.cleanOutput) await cleanup(this.options, this.logger);
       let register;
       if (this.prebuiltRegister) {
         this.logger.info("Using prebuilt register");