@atomic-ehr/codegen 0.0.4-canary.20251217082407.6dae422 → 0.0.4-canary.20251217132509.d94026d

package/dist/index.js

@@ -3,13 +3,14 @@ import * as fs from 'fs';
 import fs__default, { existsSync } from 'fs';
 import * as afs2 from 'fs/promises';
 import { readFile } from 'fs/promises';
-import * as Path4 from 'path';
-import Path4__default, { resolve } from 'path';
+import * as Path5 from 'path';
+import Path5__default, { resolve } from 'path';
 import { CanonicalManager } from '@atomic-ehr/fhir-canonical-manager';
+import assert2 from 'assert';
+import { fileURLToPath } from 'url';
+import * as YAML from 'yaml';
 import * as fhirschema from '@atomic-ehr/fhirschema';
 import { isStructureDefinition } from '@atomic-ehr/fhirschema';
-import * as YAML from 'yaml';
-import assert from 'assert';
 
 // src/utils/codegen-logger.ts
 var LogLevel = /* @__PURE__ */ ((LogLevel2) => {
@@ -178,6 +179,9 @@ var camelCase = (s) => {
 var pascalCase = (s) => {
   return words(s).map(capitalCase).join("");
 };
+var snakeCase = (s) => {
+  return words(s).map((s2) => s2.toLowerCase()).join("_");
+};
 var uppercaseFirstLetter = (str) => {
   if (!str || str.length === 0) return str;
   return str.charAt(0).toUpperCase() + str.slice(1);
@@ -224,7 +228,7 @@ var FileSystemWriter = class {
   }
   cd(path, gen) {
     const prev = this.currentDir;
-    this.currentDir = path.startsWith("/") ? Path4.join(this.opts.outputDir, path) : Path4.join(this.currentDir ?? this.opts.outputDir, path);
+    this.currentDir = path.startsWith("/") ? Path5.join(this.opts.outputDir, path) : Path5.join(this.currentDir ?? this.opts.outputDir, path);
     this.onDiskMkDir(this.currentDir);
     this.logger()?.debug(`cd '${this.currentDir}'`);
     gen();
@@ -233,12 +237,12 @@ var FileSystemWriter = class {
   cat(fn, gen) {
     if (this.currentFile) throw new Error("Can't open file when another file is open");
     if (fn.includes("/")) throw new Error(`Change file path separatly: ${fn}`);
-    const relPath = Path4.normalize(`${this.currentDir}/${fn}`);
+    const relPath = Path5.normalize(`${this.currentDir}/${fn}`);
     try {
       const descriptor = this.onDiskOpenFile(relPath);
       this.logger()?.debug(`cat > '${relPath}'`);
       this.currentFile = { descriptor, relPath };
-      this.writtenFilesBuffer[this.currentFile.relPath] = { relPath, absPath: Path4.resolve(relPath), tokens: [] };
+      this.writtenFilesBuffer[this.currentFile.relPath] = { relPath, absPath: Path5.resolve(relPath), tokens: [] };
       gen();
     } finally {
       if (this.currentFile) this.onDiskCloseFile(this.currentFile.descriptor);
@@ -726,212 +730,16 @@ var CSharp = class extends Writer {
   }
   copyStaticFiles() {
     if (!this.opts.staticSourceDir) return;
-    const sourcePath = Path4__default.resolve(this.opts.staticSourceDir);
+    const sourcePath = Path5__default.resolve(this.opts.staticSourceDir);
     fs__default.cpSync(sourcePath, this.opts.outputDir, { recursive: true });
   }
   generateHelperFile() {
     const sourceFile = "src/api/writer-generator/csharp/Helper.cs";
-    const destFile = Path4__default.join(this.opts.outputDir, "Helper.cs");
+    const destFile = Path5__default.join(this.opts.outputDir, "Helper.cs");
     fs__default.copyFileSync(sourceFile, destFile);
   }
 };
 
-// src/fhir-types/hl7-fhir-r4-core/CodeSystem.ts
-var isCodeSystem = (resource) => {
-  return resource !== null && typeof resource === "object" && resource.resourceType === "CodeSystem";
-};
-
-// src/fhir-types/hl7-fhir-r4-core/ValueSet.ts
-var isValueSet = (resource) => {
-  return resource !== null && typeof resource === "object" && resource.resourceType === "ValueSet";
-};
-
-// src/typeschema/register.ts
-var readPackageDependencies = async (manager, packageMeta) => {
-  const packageJSON = await manager.packageJson(packageMeta.name);
-  const dependencies = packageJSON.dependencies;
-  if (dependencies !== void 0) {
-    return Object.entries(dependencies).map(([name, version]) => {
-      return { name, version };
-    });
-  }
-  return [];
-};
-var mkEmptyPkgIndex = (pkg) => {
-  return {
-    pkg,
-    canonicalResolution: {},
-    fhirSchemas: {},
-    valueSets: {}
-  };
-};
-var mkPackageAwareResolver = async (manager, pkg, deep, acc, logger) => {
-  const pkgId = packageMetaToFhir(pkg);
-  logger?.info(`${" ".repeat(deep * 2)}+ ${pkgId}`);
-  if (acc[pkgId]) return acc[pkgId];
-  const index = mkEmptyPkgIndex(pkg);
-  for (const resource of await manager.search({ package: pkg })) {
-    const rawUrl = resource.url;
-    if (!rawUrl) continue;
-    if (!(isStructureDefinition(resource) || isValueSet(resource) || isCodeSystem(resource))) continue;
-    const url = rawUrl;
-    if (index.canonicalResolution[url]) logger?.dry_warn(`Duplicate canonical URL: ${url} at ${pkgId}.`);
-    index.canonicalResolution[url] = [{ deep, pkg, pkgId, resource }];
-  }
-  const deps = await readPackageDependencies(manager, pkg);
-  for (const depPkg of deps) {
-    const { canonicalResolution } = await mkPackageAwareResolver(manager, depPkg, deep + 1, acc, logger);
-    for (const [surl, resolutions] of Object.entries(canonicalResolution)) {
-      const url = surl;
-      index.canonicalResolution[url] = [...index.canonicalResolution[url] || [], ...resolutions];
-    }
-  }
-  for (const resolutionOptions of Object.values(index.canonicalResolution)) {
-    resolutionOptions.sort((a, b) => a.deep - b.deep);
-  }
-  acc[pkgId] = index;
-  return index;
-};
-var packageAgnosticResolveCanonical = (resolver, url, _logger) => {
-  const options = Object.values(resolver).flatMap((pkg) => pkg.canonicalResolution[url]);
-  if (!options) throw new Error(`No canonical resolution found for ${url} in any package`);
-  return options[0]?.resource;
-};
-var registerFromManager = async (manager, { logger, fallbackPackageForNameResolution, focusedPackages }) => {
-  const packages = focusedPackages ?? await manager.packages();
-  const resolver = {};
-  for (const pkg of packages) {
-    await mkPackageAwareResolver(manager, pkg, 0, resolver, logger);
-  }
-  for (const { pkg, canonicalResolution } of Object.values(resolver)) {
-    const pkgId = packageMetaToFhir(pkg);
-    if (!resolver[pkgId]) throw new Error(`Package ${pkgId} not found`);
-    let counter = 0;
-    logger?.info(`FHIR Schema conversion for '${packageMetaToFhir(pkg)}' begins...`);
-    for (const [_url, options] of Object.entries(canonicalResolution)) {
-      const resolition = options[0];
-      if (!resolition) throw new Error(`Resource not found`);
-      const resource = resolition.resource;
-      const resourcePkg = resolition.pkg;
-      if (isStructureDefinition(resource)) {
-        const rfs = enrichFHIRSchema(
-          fhirschema.translate(resource),
-          resourcePkg
-        );
-        counter++;
-        resolver[pkgId].fhirSchemas[rfs.url] = rfs;
-      }
-      if (isValueSet(resource)) {
-        const rvs = enrichValueSet(resource, resourcePkg);
-        resolver[pkgId].valueSets[rvs.url] = rvs;
-      }
-    }
-    logger?.info(`FHIR Schema conversion for '${packageMetaToFhir(pkg)}' completed: ${counter} successful`);
-  }
-  const resolveFs = (pkg, canonicalUrl) => {
-    return resolver[packageMetaToFhir(pkg)]?.fhirSchemas[canonicalUrl] || fallbackPackageForNameResolution && resolver[packageMetaToFhir(fallbackPackageForNameResolution)]?.fhirSchemas[canonicalUrl];
-  };
-  const resolveVs = (pkg, canonicalUrl) => {
-    return resolver[packageMetaToFhir(pkg)]?.valueSets[canonicalUrl] || fallbackPackageForNameResolution && resolver[packageMetaToFhir(fallbackPackageForNameResolution)]?.valueSets[canonicalUrl];
-  };
-  const ensureSpecializationCanonicalUrl = (name) => name.match(/^[a-zA-Z0-9]+$/) && `http://hl7.org/fhir/StructureDefinition/${name}` || name;
-  const resolveFsGenealogy = (pkg, canonicalUrl) => {
-    let fs4 = resolveFs(pkg, canonicalUrl);
-    if (fs4 === void 0) throw new Error(`Failed to resolve FHIR Schema: '${canonicalUrl}'`);
-    const genealogy = [fs4];
-    while (fs4?.base) {
-      const pkg2 = fs4.package_meta;
-      const baseUrl = ensureSpecializationCanonicalUrl(fs4.base);
-      fs4 = resolveFs(pkg2, baseUrl);
-      if (fs4 === void 0)
-        throw new Error(
-          `Failed to resolve FHIR Schema base for '${canonicalUrl}'. Problem: '${baseUrl}' from '${packageMetaToFhir(pkg2)}'`
-        );
-      genealogy.push(fs4);
-    }
-    return genealogy;
-  };
-  const resolveFsSpecializations = (pkg, canonicalUrl) => {
-    return resolveFsGenealogy(pkg, canonicalUrl).filter((fs4) => fs4.derivation === "specialization");
-  };
-  const resolveElementSnapshot = (fhirSchema, path) => {
-    const geneology = resolveFsGenealogy(fhirSchema.package_meta, fhirSchema.url);
-    const elemGeneology = resolveFsElementGenealogy(geneology, path);
-    const elemSnapshot = fsElementSnapshot(elemGeneology);
-    return elemSnapshot;
-  };
-  const getAllElementKeys = (elems) => {
-    const keys = /* @__PURE__ */ new Set();
-    for (const [key, elem] of Object.entries(elems)) {
-      keys.add(key);
-      for (const choiceKey of elem?.choices || []) {
-        if (!elems[choiceKey]) {
-          keys.add(choiceKey);
-        }
-      }
-    }
-    return Array.from(keys);
-  };
-  return {
-    ...manager,
-    testAppendFs(fs4) {
-      const rfs = enrichFHIRSchema(fs4);
-      const pkgId = packageMetaToFhir(rfs.package_meta);
-      if (!resolver[pkgId]) resolver[pkgId] = mkEmptyPkgIndex(rfs.package_meta);
-      resolver[pkgId].fhirSchemas[rfs.url] = rfs;
-    },
-    resolveFs,
-    resolveFsGenealogy,
-    resolveFsSpecializations,
-    ensureSpecializationCanonicalUrl,
-    resolveSd: (_pkg, canonicalUrl) => {
-      const res = packageAgnosticResolveCanonical(resolver, canonicalUrl);
-      if (isStructureDefinition(res)) return res;
-      return void 0;
-    },
-    allFs: () => Object.values(resolver).flatMap((pkgIndex) => Object.values(pkgIndex.fhirSchemas)),
-    allVs: () => Object.values(resolver).flatMap((pkgIndex) => Object.values(pkgIndex.valueSets)),
-    resolveVs,
-    resolveAny: (canonicalUrl) => packageAgnosticResolveCanonical(resolver, canonicalUrl),
-    resolveElementSnapshot,
-    getAllElementKeys,
-    resolver,
-    resolutionTree: () => {
-      const res = {};
-      for (const [_pkgId, pkgIndex] of Object.entries(resolver)) {
-        const pkgName = pkgIndex.pkg.name;
-        res[pkgName] = {};
-        for (const [surl, resolutions] of Object.entries(pkgIndex.canonicalResolution)) {
-          const url = surl;
-          res[pkgName][url] = [];
-          for (const resolution of resolutions) {
-            res[pkgName][url].push({ deep: resolution.deep, pkg: resolution.pkg });
-          }
-        }
-      }
-      return res;
-    }
-  };
-};
-var resolveFsElementGenealogy = (genealogy, path) => {
-  const [top, ...rest] = path;
-  if (top === void 0) return [];
-  return genealogy.map((fs4) => {
-    if (!fs4.elements) return void 0;
-    let elem = fs4.elements?.[top];
-    for (const k of rest) {
-      elem = elem?.elements?.[k];
-    }
-    return elem;
-  }).filter((elem) => elem !== void 0);
-};
-function fsElementSnapshot(genealogy) {
-  const revGenealogy = genealogy.reverse();
-  const snapshot = Object.assign({}, ...revGenealogy);
-  snapshot.elements = void 0;
-  return snapshot;
-}
-
 // src/typeschema/core/identifier.ts
 function dropVersionFromUrl(url) {
   const baseUrl = url.split("|")[0];
@@ -1002,7 +810,7 @@ function mkNestedIdentifier(register, fhirSchema, path, logger) {
   const nestedTypeOrigins = {};
   if (fhirSchema.derivation === "constraint") {
     const specializations = register.resolveFsSpecializations(fhirSchema.package_meta, fhirSchema.url);
-    const nestedTypeGenealogy = specializations.map((fs4) => mkNestedTypes(register, fs4, logger)).filter((e) => e !== void 0).flat();
+    const nestedTypeGenealogy = specializations.map((fs5) => mkNestedTypes(register, fs5, logger)).filter((e) => e !== void 0).flat();
     for (const nt of nestedTypeGenealogy.reverse()) {
       nestedTypeOrigins[nt.identifier.name] = nt.identifier.url;
     }
@@ -1101,10 +909,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((fs4) => {
-    if (parentPath.length === 0) return fs4.required || [];
-    if (!fs4.elements) return [];
-    let elem = fs4;
+  const requires = register.resolveFsGenealogy(fhirSchema.package_meta, fhirSchema.url).flatMap((fs5) => {
+    if (parentPath.length === 0) return fs5.required || [];
+    if (!fs5.elements) return [];
+    let elem = fs5;
     for (const k of parentPath) {
       elem = elem?.elements?.[k];
     }
@@ -1116,10 +924,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((fs4) => {
-    if (parentPath.length === 0) return fs4.excluded || [];
-    if (!fs4.elements) return [];
-    let elem = fs4;
+  const requires = register.resolveFsGenealogy(fhirSchema.package_meta, fhirSchema.url).flatMap((fs5) => {
+    if (parentPath.length === 0) return fs5.excluded || [];
+    if (!fs5.elements) return [];
+    let elem = fs5;
     for (const k of parentPath) {
       elem = elem?.elements?.[k];
     }
@@ -1131,9 +939,9 @@ var buildReferences = (register, fhirSchema, element) => {
   if (!element.refers) return void 0;
   return element.refers.map((ref) => {
     const curl = register.ensureSpecializationCanonicalUrl(ref);
-    const fs4 = register.resolveFs(fhirSchema.package_meta, curl);
-    if (!fs4) throw new Error(`Failed to resolve fs for ${curl}`);
-    return mkIdentifier(fs4);
+    const fs5 = register.resolveFs(fhirSchema.package_meta, curl);
+    if (!fs5) throw new Error(`Failed to resolve fs for ${curl}`);
+    return mkIdentifier(fs5);
   });
 };
 function buildFieldType(register, fhirSchema, path, element, logger) {
@@ -1211,7 +1019,7 @@ function extractValueSetConceptsByUrl(register, pkg, valueSetUrl, logger) {
 function extractValueSetConcepts(register, valueSet, _logger) {
   if (valueSet.expansion?.contains) {
     return valueSet.expansion.contains.filter((item) => item.code !== void 0).map((item) => {
-      assert(item.code);
+      assert2(item.code);
       return {
         code: item.code,
         display: item.display,
@@ -1515,6 +1323,54 @@ var treeShake = (tsIndex, treeShake2, { resolutionTree, logger }) => {
   const shaked = collectDeps(focusedSchemas, {});
   return mkTypeSchemaIndex(shaked, { resolutionTree, logger });
 };
+var buildDependencyGraph = (schemas) => {
+  const nameToMap = {};
+  for (const schema of schemas) {
+    nameToMap[schema.identifier.name] = schema;
+  }
+  const graph = {};
+  for (const schema of schemas) {
+    const name = schema.identifier.name;
+    const base = schema.base?.name;
+    if (!graph[name]) {
+      graph[name] = [];
+    }
+    if (base && nameToMap[base]) {
+      graph[name].push(base);
+    }
+  }
+  return graph;
+};
+var topologicalSort = (graph) => {
+  const sorted = [];
+  const visited = {};
+  const temp = {};
+  const visit = (node) => {
+    if (temp[node]) {
+      throw new Error(`Graph has cycles ${node}`);
+    }
+    if (!visited[node]) {
+      temp[node] = true;
+      for (const neighbor of graph[node] ?? []) {
+        visit(neighbor);
+      }
+      temp[node] = false;
+      visited[node] = true;
+      sorted.push(node);
+    }
+  };
+  for (const node in graph) {
+    if (!visited[node]) {
+      visit(node);
+    }
+  }
+  return sorted;
+};
+var sortAsDeclarationSequence = (schemas) => {
+  const graph = buildDependencyGraph(schemas);
+  const sorted = topologicalSort(graph);
+  return sorted.map((name) => schemas.find((schema) => schema.identifier.name === name)).filter(Boolean);
+};
 var resourceRelatives = (schemas) => {
   const regularSchemas = schemas.filter((e) => isResourceTypeSchema(e) || isLogicalTypeSchema(e));
   const directPairs = [];
@@ -1560,7 +1416,7 @@ var mkTypeSchemaIndex = (schemas, { resolutionTree, logger }) => {
     append(schema);
   }
   const relations = resourceRelatives(schemas);
-  const resolve4 = (id) => index[id.url]?.[id.package];
+  const resolve5 = (id) => index[id.url]?.[id.package];
   const resolveByUrl = (pkgName, url) => {
     if (resolutionTree) {
       const resolution = resolutionTree[pkgName]?.[url]?.[0];
@@ -1580,7 +1436,7 @@ var mkTypeSchemaIndex = (schemas, { resolutionTree, logger }) => {
       res.push(cur);
       const base = cur.base;
       if (base === void 0) break;
-      const resolved = resolve4(base);
+      const resolved = resolve5(base);
       if (!resolved) {
         logger?.warn(
           `Failed to resolve base type: ${res.map((e) => `${e.identifier.url} (${e.identifier.kind})`).join(", ")}`
@@ -1606,7 +1462,7 @@ var mkTypeSchemaIndex = (schemas, { resolutionTree, logger }) => {
     return nonConstraintSchema;
   };
   const findLastSpecializationByIdentifier = (id) => {
-    const schema = resolve4(id);
+    const schema = resolve5(id);
     if (!schema) return id;
     return findLastSpecialization(schema).identifier;
   };
@@ -1668,7 +1524,7 @@ var mkTypeSchemaIndex = (schemas, { resolutionTree, logger }) => {
       }
     }
     const raw = filename.endsWith(".yaml") ? YAML.stringify(tree) : JSON.stringify(tree, void 0, 2);
-    await afs2.mkdir(Path4.dirname(filename), { recursive: true });
+    await afs2.mkdir(Path5.dirname(filename), { recursive: true });
     await afs2.writeFile(filename, raw);
   };
   return {
@@ -1678,7 +1534,7 @@ var mkTypeSchemaIndex = (schemas, { resolutionTree, logger }) => {
     collectResources: () => schemas.filter(isResourceTypeSchema),
     collectLogicalModels: () => schemas.filter(isLogicalTypeSchema),
     collectProfiles: () => schemas.filter(isProfileTypeSchema),
-    resolve: resolve4,
+    resolve: resolve5,
     resolveByUrl,
     resourceChildren,
     tryHierarchy,
@@ -1691,46 +1547,773 @@ var mkTypeSchemaIndex = (schemas, { resolutionTree, logger }) => {
   };
 };
 
-// src/typeschema/index.ts
-var codeableReferenceInR4 = "Use CodeableReference which is not provided by FHIR R4.";
-var availabilityInR4 = "Use Availability which is not provided by FHIR R4.";
-var skipMe = {
-  "hl7.fhir.uv.extensions.r4#1.0.0": {
-    "http://hl7.org/fhir/StructureDefinition/extended-contact-availability": availabilityInR4,
-    "http://hl7.org/fhir/StructureDefinition/immunization-procedure": codeableReferenceInR4,
-    "http://hl7.org/fhir/StructureDefinition/specimen-additive": codeableReferenceInR4,
-    "http://hl7.org/fhir/StructureDefinition/workflow-barrier": codeableReferenceInR4,
-    "http://hl7.org/fhir/StructureDefinition/workflow-protectiveFactor": codeableReferenceInR4,
-    "http://hl7.org/fhir/StructureDefinition/workflow-reason": codeableReferenceInR4
-  },
-  "hl7.fhir.r5.core#5.0.0": {
-    "http://hl7.org/fhir/StructureDefinition/shareablecodesystem": "FIXME: CodeSystem.concept.concept defined by ElementReference. FHIR Schema generator output broken value in it, so we just skip it for now."
+// 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"
+};
+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 fixReservedWords = (name) => {
+  return PYTHON_KEYWORDS.has(name) ? `${name}_` : name;
+};
+var injectSuperClasses = (name) => {
+  return name === "Resource" || name === "Element" ? ["BaseModel"] : [];
+};
+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 generateTypeSchemas = async (register, logger) => {
-  const fhirSchemas = [];
-  for (const fhirSchema of register.allFs()) {
-    const pkgId = packageMetaToFhir(fhirSchema.package_meta);
-    if (skipMe[pkgId]?.[fhirSchema.url]) {
-      logger?.dry_warn(`Skip ${fhirSchema.url} from ${pkgId}. Reason: ${skipMe[pkgId]?.[fhirSchema.url]}`);
-      continue;
-    }
-    fhirSchemas.push(...await transformFhirSchema(register, fhirSchema, logger));
+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(""));
   }
-  for (const vsSchema of register.allVs()) {
-    fhirSchemas.push(await transformValueSet(register, vsSchema));
+  return pascalCase(id.name);
+};
+var resolvePyAssets = (fn) => {
+  const __dirname = Path5.dirname(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);
   }
-  return fhirSchemas;
 };
-
-// src/api/writer-generator/typescript.ts
-var primitiveType2tsType = {
-  boolean: "boolean",
-  instant: "string",
-  time: "string",
-  date: "string",
-  dateTime: "string",
-  decimal: "number",
+var Python = class extends Writer {
+  nameFormatFunction;
+  tsIndex;
+  constructor(options) {
+    super(options);
+    this.nameFormatFunction = this.getFieldFormatFunction(options.fieldFormat);
+  }
+  async generate(tsIndex) {
+    this.tsIndex = tsIndex;
+    const groups = {
+      groupedComplexTypes: groupByPackages(tsIndex.collectComplexTypes()),
+      groupedResources: groupByPackages(tsIndex.collectResources())
+    };
+    this.generateRootPackages(groups);
+    this.generateSDKPackages(groups);
+  }
+  generateRootPackages(groups) {
+    this.generateRootInitFile(groups);
+    fs__default.cpSync(resolvePyAssets("requirements.txt"), Path5.resolve(this.opts.outputDir, "requirements.txt"));
+  }
+  generateSDKPackages(groups) {
+    this.generateComplexTypesPackages(groups.groupedComplexTypes);
+    this.generateResourcePackages(groups);
+  }
+  generateComplexTypesPackages(groupedComplexTypes) {
+    for (const [packageName, packageComplexTypes] of Object.entries(groupedComplexTypes)) {
+      this.cd(`/${snakeCase(packageName)}`, () => {
+        this.generateBasePy(packageComplexTypes);
+      });
+    }
+  }
+  generateResourcePackages(groups) {
+    for (const [packageName, packageResources] of Object.entries(groups.groupedResources)) {
+      this.cd(`/${snakeCase(packageName)}`, () => {
+        this.generateResourcePackageContent(
+          packageName,
+          packageResources,
+          groups.groupedComplexTypes[packageName] || []
+        );
+      });
+    }
+  }
+  generateResourcePackageContent(packageName, packageResources, packageComplexTypes) {
+    const pyPackageName = this.pyFhirPackageByName(packageName);
+    this.generateResourcePackageInit(pyPackageName, packageResources, packageComplexTypes);
+    this.generateResourceFamilies(packageResources);
+    for (const schema of packageResources) {
+      this.generateResourceModule(schema);
+    }
+  }
+  generateRootInitFile(groups) {
+    this.cd("/", () => {
+      this.cat("__init__.py", () => {
+        this.generateDisclaimer();
+        const pydanticModels = this.collectAndImportAllModels(groups);
+        this.generateModelRebuilds(pydanticModels);
+      });
+    });
+  }
+  collectAndImportAllModels(groups) {
+    const models = [];
+    for (const packageName of Object.keys(groups.groupedResources)) {
+      const fullPyPackageName = this.pyFhirPackageByName(packageName);
+      models.push(...this.importComplexTypes(fullPyPackageName, groups.groupedComplexTypes[packageName]));
+      models.push(...this.importResources(fullPyPackageName, false, groups.groupedResources[packageName]));
+    }
+    this.line();
+    return models;
+  }
+  generateModelRebuilds(models) {
+    for (const modelName of models.sort()) {
+      this.line(`${modelName}.model_rebuild()`);
+    }
+  }
+  generateBasePy(packageComplexTypes) {
+    this.cat("base.py", () => {
+      this.generateDisclaimer();
+      this.generateDefaultImports();
+      this.line();
+      this.generateComplexTypes(packageComplexTypes);
+      this.line();
+    });
+  }
+  generateComplexTypes(complexTypes) {
+    for (const schema of sortAsDeclarationSequence(complexTypes)) {
+      this.generateNestedTypes(schema);
+      this.line();
+      this.generateType(schema);
+    }
+  }
+  generateResourcePackageInit(fullPyPackageName, packageResources, packageComplexTypes) {
+    this.cat("__init__.py", () => {
+      this.generateDisclaimer();
+      this.importComplexTypes(fullPyPackageName, packageComplexTypes);
+      const allResourceNames = this.importResources(fullPyPackageName, true, packageResources);
+      this.line();
+      this.generateExportsDeclaration(packageComplexTypes, allResourceNames);
+    });
+  }
+  importComplexTypes(fullPyPackageName, packageComplexTypes) {
+    if (!packageComplexTypes || packageComplexTypes.length === 0) return [];
+    const baseTypes = packageComplexTypes.map((t) => t.identifier.name).sort();
+    this.pyImportFrom(`${fullPyPackageName}.base`, ...baseTypes);
+    this.line();
+    return baseTypes;
+  }
+  buildImportLine(remaining, maxImportLineLength) {
+    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 += ", \\";
+    }
+    return line;
+  }
+  importResources(fullPyPackageName, importEmptyResources, packageResources) {
+    if (!packageResources || packageResources.length === 0) return [];
+    const allResourceNames = [];
+    for (const resource of packageResources) {
+      const names = this.importOneResource(resource, fullPyPackageName);
+      if (!importEmptyResources && !resource.fields) continue;
+      allResourceNames.push(...names);
+    }
+    return allResourceNames;
+  }
+  importOneResource(resource, fullPyPackageName) {
+    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;
+  }
+  collectResourceImportNames(resource) {
+    const names = [deriveResourceName(resource.identifier)];
+    for (const nested of resource.nested ?? []) {
+      const nestedName = deriveResourceName(nested.identifier);
+      names.push(nestedName);
+    }
+    return names;
+  }
+  shouldImportResourceFamily(resource) {
+    assert2(this.tsIndex !== void 0);
+    return resource.identifier.kind === "resource" && this.tsIndex.resourceChildren(resource.identifier).length > 0;
+  }
+  generateExportsDeclaration(packageComplexTypes, allResourceNames) {
+    this.squareBlock(["__all__", "="], () => {
+      const allExports = [
+        ...(packageComplexTypes || []).map((t) => t.identifier.name),
+        ...allResourceNames
+      ].sort();
+      for (const schemaName of allExports) {
+        this.line(`'${schemaName}',`);
+      }
+    });
+  }
+  generateResourceModule(schema) {
+    this.cat(`${snakeCase(schema.identifier.name)}.py`, () => {
+      this.generateDisclaimer();
+      this.generateDefaultImports();
+      this.line();
+      this.generateDependenciesImports(schema);
+      this.line();
+      this.generateNestedTypes(schema);
+      this.line();
+      this.generateType(schema);
+    });
+  }
+  generateType(schema) {
+    const className = deriveResourceName(schema.identifier);
+    const superClasses = this.getSuperClasses(schema);
+    this.line(`class ${className}(${superClasses.join(", ")}):`);
+    this.indentBlock(() => {
+      this.generateClassBody(schema);
+    });
+    this.line();
+  }
+  getSuperClasses(schema) {
+    return [...schema.base ? [schema.base.name] : [], ...injectSuperClasses(schema.identifier.name)];
+  }
+  generateClassBody(schema) {
+    this.generateModelConfig();
+    if (!schema.fields) {
+      this.line("pass");
+      return;
+    }
+    if (schema.identifier.kind === "resource") {
+      this.generateResourceTypeField(schema);
+    }
+    this.generateFields(schema);
+    if (schema.identifier.kind === "resource") {
+      this.generateResourceMethods(schema);
+    }
+  }
+  generateModelConfig() {
+    const extraMode = this.opts.allowExtraFields ? "allow" : "forbid";
+    this.line(`model_config = ConfigDict(validate_by_name=True, serialize_by_alias=True, extra="${extraMode}")`);
+  }
+  generateResourceTypeField(schema) {
+    this.line(`${this.nameFormatFunction("resourceType")}: str = Field(`);
+    this.indentBlock(() => {
+      this.line(`default='${schema.identifier.name}',`);
+      this.line(`alias='resourceType',`);
+      this.line(`serialization_alias='resourceType',`);
+      this.line("frozen=True,");
+      this.line(`pattern='${schema.identifier.name}'`);
+    });
+    this.line(")");
+  }
+  generateFields(schema) {
+    const sortedFields = Object.entries(schema.fields ?? []).sort(([a], [b]) => a.localeCompare(b));
+    for (const [fieldName, field] of sortedFields) {
+      if ("choices" in field && field.choices) continue;
+      const fieldInfo = this.buildFieldInfo(fieldName, field);
+      this.line(`${fieldInfo.name}: ${fieldInfo.type}${fieldInfo.defaultValue}`);
+    }
+  }
+  buildFieldInfo(fieldName, field) {
+    const pyFieldName = fixReservedWords(this.nameFormatFunction(fieldName));
+    const fieldType = this.determineFieldType(field);
+    const defaultValue = this.getFieldDefaultValue(field, fieldName);
+    return {
+      name: pyFieldName,
+      type: fieldType,
+      defaultValue
+    };
+  }
+  determineFieldType(field) {
+    let fieldType = field ? this.getBaseFieldType(field) : "";
+    if ("enum" in field && field.enum) {
+      const s = field.enum.map((e) => `"${e}"`).join(", ");
+      fieldType = `Literal[${s}]`;
+    }
+    if (field.array) {
+      fieldType = `PyList[${fieldType}]`;
+    }
+    if (!field.required) {
+      fieldType = `${fieldType} | None`;
+    }
+    return fieldType;
+  }
+  getBaseFieldType(field) {
+    if ("type" in field && field.type.kind === "resource") return `${field.type.name}Family`;
+    if ("type" in field && field.type.kind === "nested") return deriveResourceName(field.type);
+    if ("type" in field && field.type.kind === "primitive-type")
+      return PRIMITIVE_TYPE_MAP2[field.type.name] ?? "str";
+    return "type" in field ? field.type.name : "";
+  }
+  getFieldDefaultValue(field, fieldName) {
+    const aliasSpec = `alias="${fieldName}", serialization_alias="${fieldName}"`;
+    if (!field.required) {
+      return ` = Field(None, ${aliasSpec})`;
+    }
+    return ` = Field(${aliasSpec})`;
+  }
+  generateResourceMethods(schema) {
+    const className = schema.identifier.name.toString();
+    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("    return cls.model_validate_json(json)");
+  }
+  generateNestedTypes(schema) {
+    if (!schema.nested) return;
+    this.line();
+    for (const subtype of schema.nested) {
+      this.generateType(subtype);
+    }
+  }
+  generateDefaultImports() {
+    this.pyImportFrom("__future__", "annotations");
+    this.pyImportFrom("pydantic", "BaseModel", "ConfigDict", "Field", "PositiveInt");
+    this.pyImportFrom("typing", "List as PyList", "Literal");
+  }
+  generateDependenciesImports(schema) {
+    if (!schema.dependencies || schema.dependencies.length === 0) return;
+    this.importComplexTypeDependencies(schema.dependencies);
+    this.importResourceDependencies(schema.dependencies);
+  }
+  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());
+    }
+  }
+  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] = [];
+      }
+      grouped[pyPackage].push(dep.name);
+    }
+    return grouped;
+  }
+  pyImportFrom(pyPackage, ...entities) {
+    const oneLine = `from ${pyPackage} import ${entities.join(", ")}`;
+    if (this.shouldUseSingleLineImport(oneLine, entities)) {
+      this.line(oneLine);
+    } else {
+      this.writeMultiLineImport(pyPackage, entities);
+    }
+  }
+  shouldUseSingleLineImport(oneLine, entities) {
+    return oneLine.length <= MAX_IMPORT_LINE_LENGTH || entities.length === 1;
+  }
+  writeMultiLineImport(pyPackage, entities) {
+    this.line(`from ${pyPackage} import (\\`);
+    this.indentBlock(() => {
+      const remaining = [...entities];
+      while (remaining.length > 0) {
+        const line = this.buildImportLine(remaining, MAX_IMPORT_LINE_LENGTH);
+        this.line(line);
+      }
+    });
+    this.line(")");
+  }
+  pyImportType(identifier) {
+    this.pyImportFrom(this.pyPackage(identifier), pascalCase(identifier.name));
+  }
+  generateResourceFamilies(packageResources) {
+    assert2(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 = this.tsIndex.resourceChildren(resource.identifier).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}'`).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);
+  }
+  getFieldFormatFunction(format) {
+    if (!AVAILABLE_STRING_FORMATS[format]) {
+      this.logger()?.warn(`Unknown field format '${format}'. Defaulting to SnakeCase.`);
+      this.logger()?.warn(`Supported formats: ${Object.keys(AVAILABLE_STRING_FORMATS).join(", ")}`);
+      return snakeCase;
+    }
+    return AVAILABLE_STRING_FORMATS[format];
+  }
+};
+
+// src/fhir-types/hl7-fhir-r4-core/CodeSystem.ts
+var isCodeSystem = (resource) => {
+  return resource !== null && typeof resource === "object" && resource.resourceType === "CodeSystem";
+};
+
+// src/fhir-types/hl7-fhir-r4-core/ValueSet.ts
+var isValueSet = (resource) => {
+  return resource !== null && typeof resource === "object" && resource.resourceType === "ValueSet";
+};
+
+// src/typeschema/register.ts
+var readPackageDependencies = async (manager, packageMeta) => {
+  const packageJSON = await manager.packageJson(packageMeta.name);
+  const dependencies = packageJSON.dependencies;
+  if (dependencies !== void 0) {
+    return Object.entries(dependencies).map(([name, version]) => {
+      return { name, version };
+    });
+  }
+  return [];
+};
+var mkEmptyPkgIndex = (pkg) => {
+  return {
+    pkg,
+    canonicalResolution: {},
+    fhirSchemas: {},
+    valueSets: {}
+  };
+};
+var mkPackageAwareResolver = async (manager, pkg, deep, acc, logger) => {
+  const pkgId = packageMetaToFhir(pkg);
+  logger?.info(`${" ".repeat(deep * 2)}+ ${pkgId}`);
+  if (acc[pkgId]) return acc[pkgId];
+  const index = mkEmptyPkgIndex(pkg);
+  for (const resource of await manager.search({ package: pkg })) {
+    const rawUrl = resource.url;
+    if (!rawUrl) continue;
+    if (!(isStructureDefinition(resource) || isValueSet(resource) || isCodeSystem(resource))) continue;
+    const url = rawUrl;
+    if (index.canonicalResolution[url]) logger?.dry_warn(`Duplicate canonical URL: ${url} at ${pkgId}.`);
+    index.canonicalResolution[url] = [{ deep, pkg, pkgId, resource }];
+  }
+  const deps = await readPackageDependencies(manager, pkg);
+  for (const depPkg of deps) {
+    const { canonicalResolution } = await mkPackageAwareResolver(manager, depPkg, deep + 1, acc, logger);
+    for (const [surl, resolutions] of Object.entries(canonicalResolution)) {
+      const url = surl;
+      index.canonicalResolution[url] = [...index.canonicalResolution[url] || [], ...resolutions];
+    }
+  }
+  for (const resolutionOptions of Object.values(index.canonicalResolution)) {
+    resolutionOptions.sort((a, b) => a.deep - b.deep);
+  }
+  acc[pkgId] = index;
+  return index;
+};
+var packageAgnosticResolveCanonical = (resolver, url, _logger) => {
+  const options = Object.values(resolver).flatMap((pkg) => pkg.canonicalResolution[url]);
+  if (!options) throw new Error(`No canonical resolution found for ${url} in any package`);
+  return options[0]?.resource;
+};
+var registerFromManager = async (manager, { logger, fallbackPackageForNameResolution, focusedPackages }) => {
+  const packages = focusedPackages ?? await manager.packages();
+  const resolver = {};
+  for (const pkg of packages) {
+    await mkPackageAwareResolver(manager, pkg, 0, resolver, logger);
+  }
+  for (const { pkg, canonicalResolution } of Object.values(resolver)) {
+    const pkgId = packageMetaToFhir(pkg);
+    if (!resolver[pkgId]) throw new Error(`Package ${pkgId} not found`);
+    let counter = 0;
+    logger?.info(`FHIR Schema conversion for '${packageMetaToFhir(pkg)}' begins...`);
+    for (const [_url, options] of Object.entries(canonicalResolution)) {
+      const resolition = options[0];
+      if (!resolition) throw new Error(`Resource not found`);
+      const resource = resolition.resource;
+      const resourcePkg = resolition.pkg;
+      if (isStructureDefinition(resource)) {
+        const rfs = enrichFHIRSchema(
+          fhirschema.translate(resource),
+          resourcePkg
+        );
+        counter++;
+        resolver[pkgId].fhirSchemas[rfs.url] = rfs;
+      }
+      if (isValueSet(resource)) {
+        const rvs = enrichValueSet(resource, resourcePkg);
+        resolver[pkgId].valueSets[rvs.url] = rvs;
+      }
+    }
+    logger?.info(`FHIR Schema conversion for '${packageMetaToFhir(pkg)}' completed: ${counter} successful`);
+  }
+  const resolveFs = (pkg, canonicalUrl) => {
+    return resolver[packageMetaToFhir(pkg)]?.fhirSchemas[canonicalUrl] || fallbackPackageForNameResolution && resolver[packageMetaToFhir(fallbackPackageForNameResolution)]?.fhirSchemas[canonicalUrl];
+  };
+  const resolveVs = (pkg, canonicalUrl) => {
+    return resolver[packageMetaToFhir(pkg)]?.valueSets[canonicalUrl] || fallbackPackageForNameResolution && resolver[packageMetaToFhir(fallbackPackageForNameResolution)]?.valueSets[canonicalUrl];
+  };
+  const ensureSpecializationCanonicalUrl = (name) => name.match(/^[a-zA-Z0-9]+$/) && `http://hl7.org/fhir/StructureDefinition/${name}` || name;
+  const resolveFsGenealogy = (pkg, canonicalUrl) => {
+    let fs5 = resolveFs(pkg, canonicalUrl);
+    if (fs5 === void 0) throw new Error(`Failed to resolve FHIR Schema: '${canonicalUrl}'`);
+    const genealogy = [fs5];
+    while (fs5?.base) {
+      const pkg2 = fs5.package_meta;
+      const baseUrl = ensureSpecializationCanonicalUrl(fs5.base);
+      fs5 = resolveFs(pkg2, baseUrl);
+      if (fs5 === void 0)
+        throw new Error(
+          `Failed to resolve FHIR Schema base for '${canonicalUrl}'. Problem: '${baseUrl}' from '${packageMetaToFhir(pkg2)}'`
+        );
+      genealogy.push(fs5);
+    }
+    return genealogy;
+  };
+  const resolveFsSpecializations = (pkg, canonicalUrl) => {
+    return resolveFsGenealogy(pkg, canonicalUrl).filter((fs5) => fs5.derivation === "specialization");
+  };
+  const resolveElementSnapshot = (fhirSchema, path) => {
+    const geneology = resolveFsGenealogy(fhirSchema.package_meta, fhirSchema.url);
+    const elemGeneology = resolveFsElementGenealogy(geneology, path);
+    const elemSnapshot = fsElementSnapshot(elemGeneology);
+    return elemSnapshot;
+  };
+  const getAllElementKeys = (elems) => {
+    const keys = /* @__PURE__ */ new Set();
+    for (const [key, elem] of Object.entries(elems)) {
+      keys.add(key);
+      for (const choiceKey of elem?.choices || []) {
+        if (!elems[choiceKey]) {
+          keys.add(choiceKey);
+        }
+      }
+    }
+    return Array.from(keys);
+  };
+  return {
+    ...manager,
+    testAppendFs(fs5) {
+      const rfs = enrichFHIRSchema(fs5);
+      const pkgId = packageMetaToFhir(rfs.package_meta);
+      if (!resolver[pkgId]) resolver[pkgId] = mkEmptyPkgIndex(rfs.package_meta);
+      resolver[pkgId].fhirSchemas[rfs.url] = rfs;
+    },
+    resolveFs,
+    resolveFsGenealogy,
+    resolveFsSpecializations,
+    ensureSpecializationCanonicalUrl,
+    resolveSd: (_pkg, canonicalUrl) => {
+      const res = packageAgnosticResolveCanonical(resolver, canonicalUrl);
+      if (isStructureDefinition(res)) return res;
+      return void 0;
+    },
+    allFs: () => Object.values(resolver).flatMap((pkgIndex) => Object.values(pkgIndex.fhirSchemas)),
+    allVs: () => Object.values(resolver).flatMap((pkgIndex) => Object.values(pkgIndex.valueSets)),
+    resolveVs,
+    resolveAny: (canonicalUrl) => packageAgnosticResolveCanonical(resolver, canonicalUrl),
+    resolveElementSnapshot,
+    getAllElementKeys,
+    resolver,
+    resolutionTree: () => {
+      const res = {};
+      for (const [_pkgId, pkgIndex] of Object.entries(resolver)) {
+        const pkgName = pkgIndex.pkg.name;
+        res[pkgName] = {};
+        for (const [surl, resolutions] of Object.entries(pkgIndex.canonicalResolution)) {
+          const url = surl;
+          res[pkgName][url] = [];
+          for (const resolution of resolutions) {
+            res[pkgName][url].push({ deep: resolution.deep, pkg: resolution.pkg });
+          }
+        }
+      }
+      return res;
+    }
+  };
+};
+var resolveFsElementGenealogy = (genealogy, path) => {
+  const [top, ...rest] = path;
+  if (top === void 0) return [];
+  return genealogy.map((fs5) => {
+    if (!fs5.elements) return void 0;
+    let elem = fs5.elements?.[top];
+    for (const k of rest) {
+      elem = elem?.elements?.[k];
+    }
+    return elem;
+  }).filter((elem) => elem !== void 0);
+};
+function fsElementSnapshot(genealogy) {
+  const revGenealogy = genealogy.reverse();
+  const snapshot = Object.assign({}, ...revGenealogy);
+  snapshot.elements = void 0;
+  return snapshot;
+}
+
+// src/typeschema/index.ts
+var codeableReferenceInR4 = "Use CodeableReference which is not provided by FHIR R4.";
+var availabilityInR4 = "Use Availability which is not provided by FHIR R4.";
+var skipMe = {
+  "hl7.fhir.uv.extensions.r4#1.0.0": {
+    "http://hl7.org/fhir/StructureDefinition/extended-contact-availability": availabilityInR4,
+    "http://hl7.org/fhir/StructureDefinition/immunization-procedure": codeableReferenceInR4,
+    "http://hl7.org/fhir/StructureDefinition/specimen-additive": codeableReferenceInR4,
+    "http://hl7.org/fhir/StructureDefinition/workflow-barrier": codeableReferenceInR4,
+    "http://hl7.org/fhir/StructureDefinition/workflow-protectiveFactor": codeableReferenceInR4,
+    "http://hl7.org/fhir/StructureDefinition/workflow-reason": codeableReferenceInR4
+  },
+  "hl7.fhir.r5.core#5.0.0": {
+    "http://hl7.org/fhir/StructureDefinition/shareablecodesystem": "FIXME: CodeSystem.concept.concept defined by ElementReference. FHIR Schema generator output broken value in it, so we just skip it for now."
+  }
+};
+var generateTypeSchemas = async (register, logger) => {
+  const fhirSchemas = [];
+  for (const fhirSchema of register.allFs()) {
+    const pkgId = packageMetaToFhir(fhirSchema.package_meta);
+    if (skipMe[pkgId]?.[fhirSchema.url]) {
+      logger?.dry_warn(`Skip ${fhirSchema.url} from ${pkgId}. Reason: ${skipMe[pkgId]?.[fhirSchema.url]}`);
+      continue;
+    }
+    fhirSchemas.push(...await transformFhirSchema(register, fhirSchema, logger));
+  }
+  for (const vsSchema of register.allVs()) {
+    fhirSchemas.push(await transformValueSet(register, vsSchema));
+  }
+  return fhirSchemas;
+};
+
+// src/api/writer-generator/typescript.ts
+var primitiveType2tsType = {
+  boolean: "boolean",
+  instant: "string",
+  time: "string",
+  date: "string",
+  dateTime: "string",
+  decimal: "number",
   integer: "number",
   unsignedInt: "number",
   positiveInt: "number",
@@ -1765,7 +2348,7 @@ var tsModuleFileName = (id) => {
 var tsModulePath = (id) => {
   return `${tsFhirPackageDir(id.package)}/${tsModuleName(id)}`;
 };
-var canonicalToName2 = (canonical, dropFragment = true) => {
+var canonicalToName3 = (canonical, dropFragment = true) => {
   if (!canonical) return void 0;
   const localName = extractNameFromCanonical(canonical, dropFragment);
   if (!localName) return void 0;
@@ -1774,7 +2357,7 @@ var canonicalToName2 = (canonical, dropFragment = true) => {
 var tsResourceName = (id) => {
   if (id.kind === "nested") {
     const url = id.url;
-    const path = canonicalToName2(url, false);
+    const path = canonicalToName3(url, false);
     if (!path) return "";
     const [resourceName, fragment] = path.split("#");
     const name = uppercaseFirstLetterOfEach((fragment ?? "").split(".")).join("");
@@ -1840,7 +2423,7 @@ var TypeScript = class extends Writer {
           });
         } else if (isNestedIdentifier(dep)) {
           const ndep = { ...dep };
-          ndep.name = canonicalToName2(dep.url);
+          ndep.name = canonicalToName3(dep.url);
           imports.push({
             tsPackage: `../${tsModulePath(ndep)}`,
             name: tsResourceName(dep),
@@ -1893,7 +2476,7 @@ var TypeScript = class extends Writer {
       name = tsResourceName(schema.identifier);
     }
     let extendsClause;
-    if (schema.base) extendsClause = `extends ${canonicalToName2(schema.base.url)}`;
+    if (schema.base) extendsClause = `extends ${canonicalToName3(schema.base.url)}`;
     this.debugComment(schema.identifier);
     if (!schema.fields && !extendsClause && !isResourceTypeSchema(schema)) {
       this.lineSM(`export type ${name} = object`);
@@ -2200,7 +2783,7 @@ var writeTypeSchemasToSeparateFiles = async (typeSchemas, outputDir, logger) =>
     const pkgPath = normalizeFileName(packageMetaToFhir(pkg));
     const name = normalizeFileName(`${ts.identifier.name}(${extractNameFromCanonical(ts.identifier.url)})`);
     const json = JSON.stringify(ts, null, 2);
-    const baseName = Path4.join(outputDir, pkgPath, name);
+    const baseName = Path5.join(outputDir, pkgPath, name);
     if (!files[baseName]) files[baseName] = [];
     if (!files[baseName]?.some((e) => e === json)) {
       files[baseName].push(json);
@@ -2215,7 +2798,7 @@ var writeTypeSchemasToSeparateFiles = async (typeSchemas, outputDir, logger) =>
         } else {
           fullName = `${baseName}-${index}.typeschema.json`;
         }
-        await afs2.mkdir(Path4.dirname(fullName), { recursive: true });
+        await afs2.mkdir(Path5.dirname(fullName), { recursive: true });
         await afs2.writeFile(fullName, json);
       })
     );
@@ -2223,7 +2806,7 @@ var writeTypeSchemasToSeparateFiles = async (typeSchemas, outputDir, logger) =>
 };
 var writeTypeSchemasToSingleFile = async (typeSchemas, outputFile, logger) => {
   logger.info(`Writing TypeSchema files to: ${outputFile}`);
-  await afs2.mkdir(Path4.dirname(outputFile), { recursive: true });
+  await afs2.mkdir(Path5.dirname(outputFile), { recursive: true });
   logger.info(`Writing TypeSchemas to one file ${outputFile}...`);
   for (const ts of typeSchemas) {
     const json = JSON.stringify(ts, null, 2);
@@ -2234,7 +2817,7 @@ var writeTypeSchemasToSingleFile = async (typeSchemas, outputFile, logger) => {
 var tryWriteTypeSchema = async (typeSchemas, opts, logger) => {
   if (!opts.typeSchemaOutputDir) return;
   try {
-    if (Path4.extname(opts.typeSchemaOutputDir) === ".ndjson") {
+    if (Path5.extname(opts.typeSchemaOutputDir) === ".ndjson") {
       await writeTypeSchemasToSingleFile(typeSchemas, opts.typeSchemaOutputDir, logger);
     } else {
       await writeTypeSchemasToSeparateFiles(typeSchemas, opts.typeSchemaOutputDir, logger);
@@ -2297,7 +2880,7 @@ var APIBuilder = class {
     return this;
   }
   localTgzPackage(archivePath) {
-    this.localTgzArchives.push(Path4.resolve(archivePath));
+    this.localTgzArchives.push(Path5.resolve(archivePath));
     return this;
   }
   fromSchemas(schemas) {
@@ -2308,7 +2891,7 @@ var APIBuilder = class {
   typescript(userOpts) {
     const defaultWriterOpts = {
       logger: this.logger,
-      outputDir: Path4.join(this.options.outputDir, "/types"),
+      outputDir: Path5.join(this.options.outputDir, "/types"),
       tabSize: 4,
       withDebugComment: false,
       commentLinePrefix: "//",
@@ -2328,9 +2911,31 @@ var APIBuilder = class {
     this.logger.debug(`Configured TypeScript generator (${JSON.stringify(opts, void 0, 2)})`);
     return this;
   }
+  python(userOptions) {
+    const defaultWriterOpts = {
+      logger: this.logger,
+      outputDir: this.options.outputDir,
+      tabSize: 4,
+      withDebugComment: false,
+      commentLinePrefix: "#"
+    };
+    const defaultPyOpts = {
+      ...defaultWriterOpts,
+      rootPackageName: "fhir_types",
+      fieldFormat: "snake_case"
+    };
+    const opts = {
+      ...defaultPyOpts,
+      ...Object.fromEntries(Object.entries(userOptions).filter(([_, v]) => v !== void 0))
+    };
+    const generator = new Python(opts);
+    this.generators.set("python", generator);
+    this.logger.debug(`Configured python generator`);
+    return this;
+  }
   csharp(namespace, staticSourceDir) {
     const generator = new CSharp({
-      outputDir: Path4.join(this.options.outputDir, "/types"),
+      outputDir: Path5.join(this.options.outputDir, "/types"),
       staticSourceDir: staticSourceDir ?? void 0,
       targetNamespace: namespace,
       logger: new CodegenLogger({