@atomic-ehr/codegen 0.0.4 → 0.0.5-canary.20251229160950.1f6114f

package/dist/index.js

@@ -1,17 +1,183 @@
+import pc from 'picocolors';
 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 Path from 'path';
+import Path__default, { resolve } from 'path';
 import { CanonicalManager } from '@atomic-ehr/fhir-canonical-manager';
+import { fileURLToPath } from 'url';
+import assert3 from 'assert';
+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';
-import pc from 'picocolors';
+import { spawn } from 'child_process';
+import * as util from 'util';
+import Mustache from 'mustache';
 
-// src/api/builder.ts
+// src/utils/codegen-logger.ts
+var LogLevel = /* @__PURE__ */ ((LogLevel2) => {
+  LogLevel2[LogLevel2["DEBUG"] = 0] = "DEBUG";
+  LogLevel2[LogLevel2["INFO"] = 1] = "INFO";
+  LogLevel2[LogLevel2["WARN"] = 2] = "WARN";
+  LogLevel2[LogLevel2["ERROR"] = 3] = "ERROR";
+  LogLevel2[LogLevel2["SILENT"] = 4] = "SILENT";
+  return LogLevel2;
+})(LogLevel || {});
+var parseLogLevel = (level) => {
+  switch (level.toUpperCase()) {
+    case "DEBUG":
+      return 0 /* DEBUG */;
+    case "INFO":
+      return 1 /* INFO */;
+    case "WARN":
+      return 2 /* WARN */;
+    case "ERROR":
+      return 3 /* ERROR */;
+    case "SILENT":
+      return 4 /* SILENT */;
+    default:
+      throw new Error(`Invalid log level: ${level}`);
+  }
+};
+var CodegenLogger = class _CodegenLogger {
+  options;
+  dryWarnSet = /* @__PURE__ */ new Set();
+  constructor(options = {}) {
+    this.options = {
+      timestamp: false,
+      level: 1 /* INFO */,
+      ...options
+    };
+  }
+  /**
+   * Check if a message at the given level should be logged
+   */
+  shouldLog(messageLevel) {
+    const currentLevel = this.options.level ?? 1 /* INFO */;
+    return messageLevel >= currentLevel;
+  }
+  static consoleLevelsMap = {
+    [1 /* INFO */]: console.log,
+    [2 /* WARN */]: console.warn,
+    [3 /* ERROR */]: console.error,
+    [0 /* DEBUG */]: console.log,
+    [4 /* SILENT */]: () => {
+    }
+  };
+  formatMessage(level, message, color) {
+    const timestamp = this.options.timestamp ? `${pc.gray((/* @__PURE__ */ new Date()).toLocaleTimeString())} ` : "";
+    const prefix = this.options.prefix ? `${pc.cyan(`[${this.options.prefix}]`)} ` : "";
+    return `${timestamp}${color(level)} ${prefix}${message}`;
+  }
+  isSuppressed(level) {
+    return this.options.suppressLoggingLevel === "all" || this.options.suppressLoggingLevel?.includes(level) || false;
+  }
+  tryWriteToConsole(level, formattedMessage) {
+    if (this.isSuppressed(level)) return;
+    if (!this.shouldLog(level)) return;
+    const logFn = _CodegenLogger.consoleLevelsMap[level] || console.log;
+    logFn(formattedMessage);
+  }
+  /**
+   * Success message with checkmark
+   */
+  success(message) {
+    this.tryWriteToConsole(1 /* INFO */, this.formatMessage("", message, pc.green));
+  }
+  /**
+   * Error message with X mark
+   */
+  error(message, error) {
+    if (this.isSuppressed(3 /* ERROR */)) return;
+    if (!this.shouldLog(3 /* ERROR */)) return;
+    console.error(this.formatMessage("X", message, pc.red));
+    const showDetails = this.options.level === 0 /* DEBUG */;
+    if (error && showDetails) {
+      console.error(pc.red(`   ${error.message}`));
+      if (error.stack) {
+        console.error(pc.gray(error.stack));
+      }
+    }
+  }
+  /**
+   * Warning message with warning sign
+   */
+  warn(message) {
+    this.tryWriteToConsole(2 /* WARN */, this.formatMessage("!", message, pc.yellow));
+  }
+  dry_warn(message) {
+    if (!this.dryWarnSet.has(message)) {
+      this.warn(message);
+      this.dryWarnSet.add(message);
+    }
+  }
+  /**
+   * Info message with info icon
+   */
+  info(message) {
+    this.tryWriteToConsole(1 /* INFO */, this.formatMessage("i", message, pc.blue));
+  }
+  /**
+   * Debug message (only shows when log level is DEBUG or verbose is true)
+   */
+  debug(message) {
+    if (this.shouldLog(0 /* DEBUG */)) {
+      this.tryWriteToConsole(0 /* DEBUG */, this.formatMessage("\u{1F41B}", message, pc.magenta));
+    }
+  }
+  /**
+   * Step message with rocket
+   */
+  step(message) {
+    this.tryWriteToConsole(1 /* INFO */, this.formatMessage("\u{1F680}", message, pc.cyan));
+  }
+  /**
+   * Progress message with clock
+   */
+  progress(message) {
+    this.tryWriteToConsole(1 /* INFO */, this.formatMessage("\u23F3", message, pc.blue));
+  }
+  /**
+   * Plain message (no icon, just colored text)
+   */
+  plain(message, color = (s) => s) {
+    const timestamp = this.options.timestamp ? `${pc.gray((/* @__PURE__ */ new Date()).toLocaleTimeString())} ` : "";
+    const prefix = this.options.prefix ? `${pc.cyan(`[${this.options.prefix}]`)} ` : "";
+    this.tryWriteToConsole(1 /* INFO */, `${timestamp}${prefix}${color(message)}`);
+  }
+  /**
+   * Dimmed/gray text for less important info
+   */
+  dim(message) {
+    this.plain(message, pc.gray);
+  }
+  /**
+   * Create a child logger with a prefix
+   */
+  child(prefix) {
+    return new _CodegenLogger({
+      ...this.options,
+      prefix: this.options.prefix ? `${this.options.prefix}:${prefix}` : prefix
+    });
+  }
+  /**
+   * Update options
+   */
+  configure(options) {
+    this.options = { ...this.options, ...options };
+  }
+  getLevel() {
+    return this.options.level ?? 1 /* INFO */;
+  }
+  setLevel(level) {
+    this.options.level = level;
+  }
+};
+new CodegenLogger();
+function createLogger(options = {}) {
+  return new CodegenLogger(options);
+}
 
 // src/api/writer-generator/utils.ts
 var words = (s) => {
@@ -32,6 +198,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);
@@ -78,7 +247,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("/") ? Path.join(this.opts.outputDir, path) : Path.join(this.currentDir ?? this.opts.outputDir, path);
     this.onDiskMkDir(this.currentDir);
     this.logger()?.debug(`cd '${this.currentDir}'`);
     gen();
@@ -87,12 +256,16 @@ 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 = Path.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: Path.resolve(relPath),
+        tokens: []
+      };
       gen();
     } finally {
       if (this.currentFile) this.onDiskCloseFile(this.currentFile.descriptor);
@@ -106,9 +279,21 @@ var FileSystemWriter = class {
     if (!buf) throw new Error("No buffer found");
     buf.tokens.push(str);
   }
+  cp(source, destination) {
+    if (!this.opts.resolveAssets) throw new Error("resolveAssets is not defined");
+    source = Path.resolve(this.opts.resolveAssets(source));
+    destination = Path.normalize(`${this.currentDir ?? this.opts.outputDir}/${destination}`);
+    const content = fs.readFileSync(source, "utf8");
+    this.writtenFilesBuffer[destination] = {
+      relPath: destination,
+      absPath: Path.resolve(destination),
+      tokens: [content]
+    };
+    fs.cpSync(source, destination);
+  }
   writtenFiles() {
     return Object.values(this.writtenFilesBuffer).map(({ relPath, absPath, tokens }) => {
-      return { relPath, absPath, content: tokens.join() };
+      return { relPath, absPath, content: tokens.join("") };
     }).sort((a, b) => a.relPath.localeCompare(b.relPath));
   }
 };
@@ -216,15 +401,18 @@ var enrichFHIRSchema = (schema, packageMeta) => {
     base: schema.base
   };
 };
+var isResourceIdentifier = (id) => {
+  return id?.kind === "resource";
+};
+var isComplexTypeIdentifier = (id) => {
+  return id?.kind === "complex-type";
+};
 var isPrimitiveIdentifier = (id) => {
   return id?.kind === "primitive-type";
 };
 var isNestedIdentifier = (id) => {
   return id?.kind === "nested";
 };
-var isComplexTypeIdentifier = (id) => {
-  return id?.kind === "complex-type";
-};
 var isProfileIdentifier = (id) => {
   return id?.kind === "profile";
 };
@@ -260,6 +448,10 @@ var isChoiceDeclarationField = (field) => {
   if (!field) return false;
   return field.choices !== void 0;
 };
+var isChoiceInstanceField = (field) => {
+  if (!field) return false;
+  return field.choiceOf !== void 0;
+};
 var enrichValueSet = (vs, packageMeta) => {
   if (!vs.url) throw new Error("ValueSet must have a URL");
   if (!vs.name) throw new Error("ValueSet must have a name");
@@ -318,6 +510,15 @@ function formatName(input) {
 }
 
 // src/api/writer-generator/csharp/csharp.ts
+var resolveCSharpAssets = (fn) => {
+  const __filename2 = fileURLToPath(import.meta.url);
+  const __dirname = Path__default.dirname(__filename2);
+  if (__filename2.endsWith("dist/index.js")) {
+    return Path__default.resolve(__dirname, "..", "assets", "api", "writer-generator", "csharp", fn);
+  } else {
+    return Path__default.resolve(__dirname, "../../../..", "assets", "api", "writer-generator", "csharp", fn);
+  }
+};
 var PRIMITIVE_TYPE_MAP = {
   boolean: "bool",
   instant: "string",
@@ -383,6 +584,7 @@ var CSharp = class extends Writer {
       tabSize: 4,
       withDebugComment: false,
       commentLinePrefix: "//",
+      resolveAssets: options.resolveAssets ?? resolveCSharpAssets,
       ...options
     });
   }
@@ -488,8 +690,8 @@ var CSharp = class extends Writer {
       "CSharpSDK",
       "System.Text.Json",
       "System.Text.Json.Serialization",
-      this.opts.targetNamespace,
-      ...packages.map((pkg) => `${this.opts.targetNamespace}.${pkg}`)
+      this.opts.rootNamespace,
+      ...packages.map((pkg) => `${this.opts.rootNamespace}.${pkg}`)
     ];
     for (const using of globalUsings) this.lineSM("global", "using", using);
   }
@@ -498,7 +700,7 @@ var CSharp = class extends Writer {
       this.cat("base.cs", () => {
         this.generateDisclaimer();
         this.line();
-        this.lineSM("namespace", this.opts.targetNamespace);
+        this.lineSM("namespace", this.opts.rootNamespace);
         for (const schema of complexTypes) {
           const packageName = formatName(schema.identifier.package);
           this.generateType(schema, packageName);
@@ -515,7 +717,7 @@ var CSharp = class extends Writer {
       this.cat(`${schema.identifier.name}.cs`, () => {
         this.generateDisclaimer();
         this.line();
-        this.lineSM("namespace", `${this.opts.targetNamespace}.${packageName}`);
+        this.lineSM("namespace", `${this.opts.rootNamespace}.${packageName}`);
         this.line();
         this.generateType(schema, packageName);
       });
@@ -539,7 +741,7 @@ var CSharp = class extends Writer {
   generateEnumFileContent(packageName, enums) {
     this.lineSM("using", "System.ComponentModel");
     this.line();
-    this.lineSM(`namespace ${this.opts.targetNamespace}.${packageName}`);
+    this.lineSM(`namespace ${this.opts.rootNamespace}.${packageName}`);
     for (const [enumName, values] of Object.entries(enums)) {
       this.generateEnum(enumName, values);
     }
@@ -561,7 +763,7 @@ var CSharp = class extends Writer {
         this.cat(`${packageName}ResourceDictionary.cs`, () => {
           this.generateDisclaimer();
           this.line();
-          this.lineSM(`namespace ${this.opts.targetNamespace}`);
+          this.lineSM(`namespace ${this.opts.rootNamespace}`);
           this.generateResourceDictionaryClass(packageName, packageResources);
         });
       }
@@ -579,212 +781,802 @@ var CSharp = class extends Writer {
     });
   }
   copyStaticFiles() {
-    if (!this.opts.staticSourceDir) return;
-    const sourcePath = Path4__default.resolve(this.opts.staticSourceDir);
-    fs__default.cpSync(sourcePath, this.opts.outputDir, { recursive: true });
+    this.cp("Client.cs", "Client.cs");
+    this.cp("Helper.cs", "Helper.cs");
   }
   generateHelperFile() {
-    const sourceFile = "src/api/writer-generator/csharp/Helper.cs";
-    const destFile = Path4__default.join(this.opts.outputDir, "Helper.cs");
+    if (this.opts.inMemoryOnly) return;
+    const sourceFile = resolveCSharpAssets("Helper.cs");
+    const destFile = Path__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 };
-    });
+var groupByPackages = (typeSchemas) => {
+  const grouped = {};
+  for (const ts of typeSchemas) {
+    const pkgName = ts.identifier.package;
+    if (!grouped[pkgName]) grouped[pkgName] = [];
+    grouped[pkgName].push(ts);
   }
-  return [];
-};
-var mkEmptyPkgIndex = (pkg) => {
-  return {
-    pkg,
-    canonicalResolution: {},
-    fhirSchemas: {},
-    valueSets: {}
-  };
+  for (const [packageName, typeSchemas2] of Object.entries(grouped)) {
+    const dict = {};
+    for (const ts of typeSchemas2) {
+      dict[JSON.stringify(ts.identifier)] = ts;
+    }
+    const tmp = Object.values(dict);
+    tmp.sort((a, b) => a.identifier.name.localeCompare(b.identifier.name));
+    grouped[packageName] = tmp;
+  }
+  return grouped;
 };
-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 }];
+var buildDependencyGraph = (schemas) => {
+  const nameToMap = {};
+  for (const schema of schemas) {
+    nameToMap[schema.identifier.name] = schema;
   }
-  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];
+  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);
     }
   }
-  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;
+  return graph;
 };
-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;
+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);
     }
-    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];
+  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) || isComplexTypeTypeSchema(e)
+  );
+  const directPairs = [];
+  for (const schema of regularSchemas) {
+    if (schema.base) {
+      directPairs.push({ parent: schema.base, child: schema.identifier });
+    }
+  }
+  const allPairs = [...directPairs];
+  const findTransitiveRelatives = (parentRef) => {
+    const directChildren = directPairs.filter((pair) => pair.parent.name === parentRef.name).map((pair) => pair.child);
+    const transitiveChildren = [];
+    for (const child of directChildren) {
+      transitiveChildren.push(...findTransitiveRelatives(child));
+    }
+    return [...directChildren, ...transitiveChildren];
   };
-  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)}'`
+  for (const pair of directPairs) {
+    const transitiveChildren = findTransitiveRelatives(pair.child);
+    for (const transitiveChild of transitiveChildren) {
+      if (!directPairs.some((dp) => dp.parent.name === pair.parent.name && dp.child.name === transitiveChild.name)) {
+        allPairs.push({ parent: pair.parent, child: transitiveChild });
+      }
+    }
+  }
+  return allPairs;
+};
+var mkTypeSchemaIndex = (schemas, {
+  resolutionTree,
+  logger,
+  treeShakeReport
+}) => {
+  const index = {};
+  const append = (schema) => {
+    const url = schema.identifier.url;
+    const pkg = schema.identifier.package;
+    if (!index[url]) index[url] = {};
+    if (index[url][schema.identifier.package] && pkg !== "shared") {
+      const r1 = JSON.stringify(schema.identifier, void 0, 2);
+      const r2 = JSON.stringify(index[url][pkg]?.identifier, void 0, 2);
+      if (r1 !== r2) throw new Error(`Duplicate schema: ${r1} and ${r2}`);
+      return;
+    }
+    index[url][pkg] = schema;
+  };
+  for (const schema of schemas) {
+    append(schema);
+  }
+  const relations = resourceRelatives(schemas);
+  const resolve6 = (id) => index[id.url]?.[id.package];
+  const resolveByUrl = (pkgName, url) => {
+    if (resolutionTree) {
+      const resolution = resolutionTree[pkgName]?.[url]?.[0];
+      if (resolution) {
+        return index[url]?.[resolution.pkg.name];
+      }
+    }
+    return index[url]?.[pkgName];
+  };
+  const resourceChildren = (id) => {
+    return relations.filter((relative) => relative.parent.name === id.name).map((relative) => relative.child);
+  };
+  const tryHierarchy = (schema) => {
+    const res = [];
+    let cur = schema;
+    while (cur) {
+      res.push(cur);
+      const base = cur.base;
+      if (base === void 0) break;
+      const resolved = resolve6(base);
+      if (!resolved) {
+        logger?.warn(
+          `Failed to resolve base type: ${res.map((e) => `${e.identifier.url} (${e.identifier.kind})`).join(", ")}`
         );
-      genealogy.push(fs4);
+        return void 0;
+      }
+      cur = resolved;
+    }
+    return res;
+  };
+  const hierarchy = (schema) => {
+    const genealogy = tryHierarchy(schema);
+    if (genealogy === void 0) {
+      throw new Error(`Failed to resolve base type: ${schema.identifier.url} (${schema.identifier.kind})`);
     }
     return genealogy;
   };
-  const resolveFsSpecializations = (pkg, canonicalUrl) => {
-    return resolveFsGenealogy(pkg, canonicalUrl).filter((fs4) => fs4.derivation === "specialization");
+  const findLastSpecialization = (schema) => {
+    const nonConstraintSchema = hierarchy(schema).find((s) => s.identifier.kind !== "profile");
+    if (!nonConstraintSchema) {
+      throw new Error(`No non-constraint schema found in hierarchy for: ${schema.identifier.name}`);
+    }
+    return nonConstraintSchema;
   };
-  const resolveElementSnapshot = (fhirSchema, path) => {
-    const geneology = resolveFsGenealogy(fhirSchema.package_meta, fhirSchema.url);
-    const elemGeneology = resolveFsElementGenealogy(geneology, path);
-    const elemSnapshot = fsElementSnapshot(elemGeneology);
-    return elemSnapshot;
+  const findLastSpecializationByIdentifier = (id) => {
+    const schema = resolve6(id);
+    if (!schema) return id;
+    return findLastSpecialization(schema).identifier;
   };
-  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);
+  const flatProfile = (schema) => {
+    const hierarchySchemas = hierarchy(schema);
+    const constraintSchemas = hierarchySchemas.filter((s) => s.identifier.kind === "profile");
+    const nonConstraintSchema = hierarchySchemas.find((s) => s.identifier.kind !== "profile");
+    if (!nonConstraintSchema)
+      throw new Error(`No non-constraint schema found in hierarchy for ${schema.identifier.name}`);
+    const mergedFields = {};
+    for (const anySchema of constraintSchemas.slice().reverse()) {
+      const schema2 = anySchema;
+      if (!schema2.fields) continue;
+      for (const [fieldName, fieldConstraints] of Object.entries(schema2.fields)) {
+        if (mergedFields[fieldName]) {
+          mergedFields[fieldName] = {
+            ...mergedFields[fieldName],
+            ...fieldConstraints
+          };
+        } else {
+          mergedFields[fieldName] = { ...fieldConstraints };
         }
       }
     }
-    return Array.from(keys);
+    const deps = {};
+    for (const e of constraintSchemas.flatMap((e2) => e2.dependencies ?? [])) {
+      deps[e.url] = e;
+    }
+    const dependencies = Object.values(deps);
+    return {
+      ...schema,
+      base: nonConstraintSchema.identifier,
+      fields: mergedFields,
+      dependencies
+    };
   };
-  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 });
-          }
-        }
+  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: {},
+        logical: {}
+      };
+      for (const schema of shemas) {
+        tree[pkgId][schema.identifier.kind][schema.identifier.url] = {};
       }
-      return res;
     }
+    return tree;
+  };
+  const exportTree = async (filename) => {
+    const tree = entityTree();
+    const raw = filename.endsWith(".yaml") ? YAML.stringify(tree) : JSON.stringify(tree, void 0, 2);
+    await afs2.mkdir(Path.dirname(filename), { recursive: true });
+    await afs2.writeFile(filename, raw);
+  };
+  return {
+    _schemaIndex: index,
+    _relations: relations,
+    schemas,
+    schemasByPackage: groupByPackages(schemas),
+    collectComplexTypes: () => schemas.filter(isComplexTypeTypeSchema),
+    collectResources: () => schemas.filter(isResourceTypeSchema),
+    collectLogicalModels: () => schemas.filter(isLogicalTypeSchema),
+    collectProfiles: () => schemas.filter(isProfileTypeSchema),
+    resolve: resolve6,
+    resolveByUrl,
+    resourceChildren,
+    tryHierarchy,
+    hierarchy,
+    findLastSpecialization,
+    findLastSpecializationByIdentifier,
+    flatProfile,
+    isWithMetaField,
+    entityTree,
+    exportTree,
+    treeShakeReport: () => treeShakeReport
   };
 };
-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);
+
+// 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 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 = Path.dirname(fileURLToPath(import.meta.url));
+  if (__filename.endsWith("dist/index.js")) {
+    return Path.resolve(__dirname, "..", "assets", "api", "writer-generator", "python", fn);
+  } else {
+    return Path.resolve(__dirname, "../../..", "assets", "api", "writer-generator", "python", fn);
+  }
+};
+var Python = class extends Writer {
+  nameFormatFunction;
+  tsIndex;
+  constructor(options) {
+    super({ ...options, resolveAssets: options.resolveAssets ?? resolvePyAssets });
+    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);
+    this.cp(resolvePyAssets("requirements.txt"), "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) {
+    assert3(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) {
+    assert3(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(format2) {
+    if (!AVAILABLE_STRING_FORMATS[format2]) {
+      this.logger()?.warn(`Unknown field format '${format2}'. Defaulting to SnakeCase.`);
+      this.logger()?.warn(`Supported formats: ${Object.keys(AVAILABLE_STRING_FORMATS).join(", ")}`);
+      return snakeCase;
+    }
+    return AVAILABLE_STRING_FORMATS[format2];
+  }
 };
-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) {
@@ -856,7 +1648,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((fs7) => mkNestedTypes(register, fs7, logger)).filter((e) => e !== void 0).flat();
     for (const nt of nestedTypeGenealogy.reverse()) {
       nestedTypeOrigins[nt.identifier.name] = nt.identifier.url;
     }
@@ -955,10 +1747,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((fs7) => {
+    if (parentPath.length === 0) return fs7.required || [];
+    if (!fs7.elements) return [];
+    let elem = fs7;
     for (const k of parentPath) {
       elem = elem?.elements?.[k];
     }
@@ -970,10 +1762,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((fs7) => {
+    if (parentPath.length === 0) return fs7.excluded || [];
+    if (!fs7.elements) return [];
+    let elem = fs7;
     for (const k of parentPath) {
       elem = elem?.elements?.[k];
     }
@@ -985,9 +1777,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 fs7 = register.resolveFs(fhirSchema.package_meta, curl);
+    if (!fs7) throw new Error(`Failed to resolve fs for ${curl}`);
+    return mkIdentifier(fs7);
   });
 };
 function buildFieldType(register, fhirSchema, path, element, logger) {
@@ -1065,7 +1857,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);
+      assert3(item.code);
       return {
         code: item.code,
         display: item.display,
@@ -1270,62 +2062,422 @@ function transformFhirSchemaResource(register, fhirSchema, logger) {
         `Base resource not found '${fhirSchema.base}' for <${fhirSchema.url}> from ${packageMetaToFhir(fhirSchema.package_meta)}`
       );
     }
-    base = mkIdentifier(baseFs);
+    base = mkIdentifier(baseFs);
+  }
+  const fields = mkFields(register, fhirSchema, [], fhirSchema.elements, logger);
+  const nested = mkNestedTypes(register, fhirSchema, logger);
+  const dependencies = extractDependencies(identifier, base, fields, nested);
+  const typeSchema = {
+    identifier,
+    base,
+    fields,
+    nested,
+    description: fhirSchema.description,
+    dependencies
+  };
+  const bindingSchemas = collectBindingSchemas(register, fhirSchema, logger);
+  return [typeSchema, ...bindingSchemas];
+}
+async function transformFhirSchema(register, fhirSchema, logger) {
+  const schemas = transformFhirSchemaResource(register, fhirSchema, logger);
+  if (isExtensionSchema(fhirSchema, mkIdentifier(fhirSchema))) {
+    const schema = schemas[0];
+    if (!schema) throw new Error(`Expected schema to be defined`);
+    schema.metadata = {
+      isExtension: true
+      // Mark as extension for file organization
+    };
+  }
+  return schemas;
+}
+
+// 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 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)
+        throw new Error(
+          `Failed to resolve FHIR Schema base for '${canonicalUrl}'. Problem: '${baseUrl}' from '${packageMetaToFhir(pkg2)}'`
+        );
+      genealogy.push(fs7);
+    }
+    return genealogy;
+  };
+  const resolveFsSpecializations = (pkg, canonicalUrl) => {
+    return resolveFsGenealogy(pkg, canonicalUrl).filter((fs7) => fs7.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(fs7) {
+      const rfs = enrichFHIRSchema(fs7);
+      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((fs7) => {
+    if (!fs7.elements) return void 0;
+    let elem = fs7.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;
+};
+var ensureTreeShakeReport = (indexOrReport) => {
+  if ("treeShakeReport" in indexOrReport && typeof indexOrReport.treeShakeReport === "function") {
+    const report = indexOrReport.treeShakeReport();
+    assert3(report);
+    return report;
+  } else {
+    return indexOrReport;
+  }
+};
+var rootTreeShakeReadme = (report) => {
+  report = ensureTreeShakeReport(report);
+  const lines = ["# Tree Shake Report", ""];
+  if (report.skippedPackages.length === 0) lines.push("All packages are included.");
+  else lines.push("Skipped packages:", "");
+  for (const pkgName of report.skippedPackages) {
+    lines.push(`- ${pkgName}`);
+  }
+  lines.push("");
+  return lines.join("\n");
+};
+var packageTreeShakeReadme = (report, pkgName) => {
+  report = ensureTreeShakeReport(report);
+  const lines = [`# Package: ${pkgName}`, ""];
+  assert3(report.packages[pkgName]);
+  lines.push("## Canonical Fields Changes", "");
+  if (Object.keys(report.packages[pkgName].canonicals).length === 0) {
+    lines.push("All canonicals translated as is.", "");
+  } else {
+    for (const [canonicalUrl, { skippedFields }] of Object.entries(report.packages[pkgName].canonicals)) {
+      lines.push(`- <${canonicalUrl}>`);
+      if (skippedFields.length === 0) {
+        lines.push("    - All fields translated as is.", "");
+      } else {
+        lines.push(`    - Skipped fields: ${skippedFields.map((f) => `\`${f}\``).join(", ")}`);
+        lines.push("");
+      }
+    }
+    lines.push("");
+  }
+  lines.push("## Skipped Canonicals", "");
+  if (report.packages[pkgName].skippedCanonicals.length === 0) {
+    lines.push("No skipped canonicals");
+  } else {
+    lines.push("Skipped canonicals:", "");
+    for (const canonicalUrl of report.packages[pkgName].skippedCanonicals) {
+      lines.push(`- <${canonicalUrl}>`);
+    }
+    lines.push("");
   }
-  const fields = mkFields(register, fhirSchema, [], fhirSchema.elements, logger);
-  const nested = mkNestedTypes(register, fhirSchema, logger);
-  const dependencies = extractDependencies(identifier, base, fields, nested);
-  const typeSchema = {
-    identifier,
-    base,
-    fields,
-    nested,
-    description: fhirSchema.description,
-    dependencies
-  };
-  const bindingSchemas = collectBindingSchemas(register, fhirSchema, logger);
-  return [typeSchema, ...bindingSchemas];
-}
-async function transformFhirSchema(register, fhirSchema, logger) {
-  const schemas = transformFhirSchemaResource(register, fhirSchema, logger);
-  if (isExtensionSchema(fhirSchema, mkIdentifier(fhirSchema))) {
-    const schema = schemas[0];
-    if (!schema) throw new Error(`Expected schema to be defined`);
-    schema.metadata = {
-      isExtension: true
-      // Mark as extension for file organization
-    };
+  return lines.join("\n");
+};
+var mutableSelectFields = (schema, selectFields) => {
+  const selectedFields = {};
+  const selectPolimorphic = {};
+  for (const fieldName of selectFields) {
+    const field = schema.fields?.[fieldName];
+    if (!schema.fields || !field) throw new Error(`Field ${fieldName} not found`);
+    if (isChoiceDeclarationField(field)) {
+      if (!selectPolimorphic[fieldName]) selectPolimorphic[fieldName] = {};
+      selectPolimorphic[fieldName].declaration = field.choices;
+    } else if (isChoiceInstanceField(field)) {
+      const choiceName = field.choiceOf;
+      if (!selectPolimorphic[choiceName]) selectPolimorphic[choiceName] = {};
+      selectPolimorphic[choiceName].instances = [...selectPolimorphic[choiceName].instances ?? [], fieldName];
+    } else {
+      selectedFields[fieldName] = field;
+    }
   }
-  return schemas;
-}
-
-// src/typeschema/utils.ts
-var groupByPackages = (typeSchemas) => {
-  const grouped = {};
-  for (const ts of typeSchemas) {
-    const pkgName = ts.identifier.package;
-    if (!grouped[pkgName]) grouped[pkgName] = [];
-    grouped[pkgName].push(ts);
+  for (const [choiceName, { declaration, instances }] of Object.entries(selectPolimorphic)) {
+    const choices = instances ?? declaration;
+    assert3(choices);
+    for (const choiceInstanceName of choices) {
+      const field = schema.fields?.[choiceInstanceName];
+      assert3(field);
+      selectedFields[choiceInstanceName] = field;
+    }
+    const decl = schema.fields?.[choiceName];
+    assert3(decl);
+    selectedFields[choiceName] = { ...decl, choices };
   }
-  for (const [packageName, typeSchemas2] of Object.entries(grouped)) {
-    const dict = {};
-    for (const ts of typeSchemas2) {
-      dict[JSON.stringify(ts.identifier)] = ts;
+  schema.fields = selectedFields;
+};
+var mutableIgnoreFields = (schema, ignoreFields) => {
+  for (const fieldName of ignoreFields) {
+    const field = schema.fields?.[fieldName];
+    if (!schema.fields || !field) throw new Error(`Field ${fieldName} not found`);
+    if (schema.fields) {
+      if (isChoiceDeclarationField(field)) {
+        for (const choiceName of field.choices) {
+          delete schema.fields[choiceName];
+        }
+      }
+      if (isChoiceInstanceField(field)) {
+        const choiceDeclaration = schema.fields[field.choiceOf];
+        assert3(isChoiceDeclarationField(choiceDeclaration));
+        choiceDeclaration.choices = choiceDeclaration.choices.filter((c) => c !== fieldName);
+        if (choiceDeclaration.choices.length === 0) {
+          delete schema.fields[field.choiceOf];
+        }
+      }
+      delete schema.fields[fieldName];
     }
-    const tmp = Object.values(dict);
-    tmp.sort((a, b) => a.identifier.name.localeCompare(b.identifier.name));
-    grouped[packageName] = tmp;
   }
-  return grouped;
+};
+var mutableFillReport = (report, tsIndex, shakedIndex) => {
+  const packages = Object.keys(tsIndex.schemasByPackage);
+  const shakedPackages = Object.keys(shakedIndex.schemasByPackage);
+  const skippedPackages = packages.filter((pkg) => !shakedPackages.includes(pkg));
+  report.skippedPackages = skippedPackages;
+  for (const [pkgName, shakedSchemas] of Object.entries(shakedIndex.schemasByPackage)) {
+    if (skippedPackages.includes(pkgName)) continue;
+    const tsSchemas = tsIndex.schemasByPackage[pkgName];
+    assert3(tsSchemas);
+    report.packages[pkgName] = {
+      skippedCanonicals: tsSchemas.filter((schema) => !shakedSchemas.includes(schema)).map((schema) => schema.identifier.url).sort(),
+      canonicals: Object.fromEntries(
+        shakedSchemas.map((shakedSchema) => {
+          const schema = tsIndex.resolve(shakedSchema.identifier);
+          assert3(schema);
+          if (!isSpecializationTypeSchema(schema)) return void 0;
+          assert3(isSpecializationTypeSchema(shakedSchema));
+          if (!schema.fields) return void 0;
+          if (!shakedSchema.fields) {
+            return [shakedSchema.identifier.url, Object.keys(schema.fields)];
+          }
+          const shakedFieldNames = Object.keys(shakedSchema.fields);
+          const skippedFields = Object.keys(schema.fields).filter((field) => !shakedFieldNames.includes(field)).sort();
+          if (skippedFields.length === 0) return void 0;
+          return [shakedSchema.identifier.url, { skippedFields }];
+        }).filter((e) => e !== void 0)
+      )
+    };
+  }
 };
 var treeShakeTypeSchema = (schema, rule, _logger) => {
   schema = structuredClone(schema);
   if (isPrimitiveTypeSchema(schema) || isValueSetTypeSchema(schema) || isBindingSchema(schema)) return schema;
-  for (const fieldName of rule.ignoreFields ?? []) {
-    if (schema.fields && !schema.fields[fieldName]) throw new Error(`Field ${fieldName} not found`);
-    if (schema.fields) {
-      delete schema.fields[fieldName];
-    }
+  if (rule.selectFields) {
+    if (rule.ignoreFields) throw new Error("Cannot use both ignoreFields and selectFields in the same rule");
+    mutableSelectFields(schema, rule.selectFields);
+  }
+  if (rule.ignoreFields) {
+    if (rule.selectFields) throw new Error("Cannot use both ignoreFields and selectFields in the same rule");
+    mutableIgnoreFields(schema, rule.ignoreFields);
+  }
+  if (schema.nested) {
+    const usedTypes = /* @__PURE__ */ new Set();
+    const collectUsedNestedTypes = (s) => {
+      Object.values(s.fields ?? {}).filter(isNotChoiceDeclarationField).filter((f) => isNestedIdentifier(f.type)).forEach((f) => {
+        const url = f.type.url;
+        if (!usedTypes.has(url)) {
+          usedTypes.add(url);
+          const nestedTypeDef = schema.nested?.find((f2) => f2.identifier.url === url);
+          assert3(nestedTypeDef);
+          collectUsedNestedTypes(nestedTypeDef);
+        }
+      });
+    };
+    collectUsedNestedTypes(schema);
+    schema.nested = schema.nested.filter((n) => usedTypes.has(n.identifier.url));
   }
   schema.dependencies = extractDependencies(schema.identifier, schema.base, schema.fields, schema.nested);
   return schema;
@@ -1351,7 +2503,10 @@ var treeShake = (tsIndex, treeShake2, { resolutionTree, logger }) => {
         if (!schema.dependencies) continue;
         schema.dependencies.forEach((dep) => {
           const depSchema = tsIndex.resolve(dep);
-          if (!depSchema) throw new Error(`Schema not found for ${dep}`);
+          if (!depSchema)
+            throw new Error(
+              `Dependent schema ${JSON.stringify(dep)} not found for ${JSON.stringify(schema.identifier)}`
+            );
           const id = JSON.stringify(depSchema.identifier);
           if (!acc[id]) newSchemas.push(depSchema);
         });
@@ -1367,336 +2522,657 @@ var treeShake = (tsIndex, treeShake2, { resolutionTree, logger }) => {
     return collectDeps(newSchemas, acc);
   };
   const shaked = collectDeps(focusedSchemas, {});
-  return mkTypeSchemaIndex(shaked, { resolutionTree, logger });
+  const report = { skippedPackages: [], packages: {} };
+  const shakedIndex = mkTypeSchemaIndex(shaked, { resolutionTree, logger, treeShakeReport: report });
+  mutableFillReport(report, tsIndex, shakedIndex);
+  return shakedIndex;
 };
-var resourceRelatives = (schemas) => {
-  const regularSchemas = schemas.filter((e) => isResourceTypeSchema(e) || isLogicalTypeSchema(e));
-  const directPairs = [];
-  for (const schema of regularSchemas) {
-    if (schema.base) {
-      directPairs.push({ parent: schema.base, child: schema.identifier });
-    }
+
+// src/api/mustache/generator/DebugMixinProvider.ts
+var DebugMixinProvider = class {
+  constructor(mode) {
+    this.mode = mode;
   }
-  const allPairs = [...directPairs];
-  const findTransitiveRelatives = (parentRef) => {
-    const directChildren = directPairs.filter((pair) => pair.parent.name === parentRef.name).map((pair) => pair.child);
-    const transitiveChildren = [];
-    for (const child of directChildren) {
-      transitiveChildren.push(...findTransitiveRelatives(child));
+  apply(target) {
+    return this._addDebug(target);
+  }
+  _addDebug(value) {
+    if (Array.isArray(value)) {
+      return value.map((v) => this._addDebug(v));
     }
-    return [...directChildren, ...transitiveChildren];
-  };
-  for (const pair of directPairs) {
-    const transitiveChildren = findTransitiveRelatives(pair.child);
-    for (const transitiveChild of transitiveChildren) {
-      if (!directPairs.some((dp) => dp.parent.name === pair.parent.name && dp.child.name === transitiveChild.name)) {
-        allPairs.push({ parent: pair.parent, child: transitiveChild });
+    if (value !== null && typeof value === "object") {
+      const obj = value;
+      const result = {};
+      const debugString = JSON.stringify(obj, null, this.mode === "FORMATTED" ? 2 : void 0);
+      for (const [key, val] of Object.entries(obj)) {
+        result[key] = this._addDebug(val);
       }
+      result.debug = debugString;
+      return result;
     }
+    return value;
   }
-  return allPairs;
 };
-var mkTypeSchemaIndex = (schemas, { resolutionTree, logger }) => {
-  const index = {};
-  const append = (schema) => {
-    const url = schema.identifier.url;
-    const pkg = schema.identifier.package;
-    if (!index[url]) index[url] = {};
-    if (index[url][schema.identifier.package] && pkg !== "shared") {
-      const r1 = JSON.stringify(schema.identifier, void 0, 2);
-      const r2 = JSON.stringify(index[url][pkg]?.identifier, void 0, 2);
-      if (r1 !== r2) throw new Error(`Duplicate schema: ${r1} and ${r2}`);
-      return;
-    }
-    index[url][pkg] = schema;
-  };
-  for (const schema of schemas) {
-    append(schema);
+
+// src/api/mustache/generator/LambdaMixinProvider.ts
+var LambdaMixinProvider = class {
+  constructor(nameGenerator) {
+    this.nameGenerator = nameGenerator;
+    this.lambda = {
+      saveTypeName: () => (text, render) => this.nameGenerator.generateType(render(text)),
+      saveEnumValueName: () => (text, render) => this.nameGenerator.generateEnumValue(render(text)),
+      saveFieldName: () => (text, render) => this.nameGenerator.generateField(render(text)),
+      camelCase: () => (text, render) => camelCase(render(text)),
+      snakeCase: () => (text, render) => snakeCase(render(text)),
+      pascalCase: () => (text, render) => pascalCase(render(text)),
+      kebabCase: () => (text, render) => kebabCase(render(text)),
+      lowerCase: () => (text, render) => render(text).toLowerCase(),
+      upperCase: () => (text, render) => render(text).toUpperCase()
+    };
   }
-  const relations = resourceRelatives(schemas);
-  const resolve3 = (id) => index[id.url]?.[id.package];
-  const resolveByUrl = (pkgName, url) => {
-    if (resolutionTree) {
-      const resolution = resolutionTree[pkgName]?.[url]?.[0];
-      if (resolution) {
-        return index[url]?.[resolution.pkg.name];
-      }
+  lambda;
+  apply(target) {
+    return {
+      ...target,
+      lambda: this.lambda
+    };
+  }
+};
+
+// src/api/mustache/generator/NameGenerator.ts
+var NameGenerator = class {
+  constructor(keywords, typeMap, nameTransformations, unsaveCharacterPattern) {
+    this.keywords = keywords;
+    this.typeMap = typeMap;
+    this.nameTransformations = nameTransformations;
+    this.unsaveCharacterPattern = unsaveCharacterPattern;
+  }
+  _replaceUnsaveChars(name) {
+    const pattern = this.unsaveCharacterPattern instanceof RegExp ? this.unsaveCharacterPattern : new RegExp(this.unsaveCharacterPattern, "g");
+    return name.replace(pattern, "_");
+  }
+  _applyNameTransformations(name, transformations) {
+    for (const transformation of this.nameTransformations.common) {
+      name = name.replace(
+        transformation.pattern instanceof RegExp ? transformation.pattern : new RegExp(transformation.pattern, "g"),
+        transformation.format
+      );
     }
-    return index[url]?.[pkgName];
-  };
-  const resourceChildren = (id) => {
-    return relations.filter((relative) => relative.parent.name === id.name).map((relative) => relative.child);
-  };
-  const tryHierarchy = (schema) => {
-    const res = [];
-    let cur = schema;
-    while (cur) {
-      res.push(cur);
-      const base = cur.base;
-      if (base === void 0) break;
-      const resolved = resolve3(base);
-      if (!resolved) {
-        logger?.warn(
-          `Failed to resolve base type: ${res.map((e) => `${e.identifier.url} (${e.identifier.kind})`).join(", ")}`
-        );
-        return void 0;
+    for (const transformation of transformations) {
+      name = name.replace(
+        transformation.pattern instanceof RegExp ? transformation.pattern : new RegExp(transformation.pattern, "g"),
+        transformation.format
+      );
+    }
+    return name;
+  }
+  _generateTypeName(name) {
+    if (this.typeMap[name]) {
+      name = this.typeMap[name];
+    } else {
+      name = this._applyNameTransformations(name, this.nameTransformations.type);
+      name = name.charAt(0).toUpperCase() + name.slice(1);
+      if (this.keywords.has(name)) {
+        return `_${name}`;
       }
-      cur = resolved;
+      name = this._replaceUnsaveChars(name);
     }
-    return res;
-  };
-  const hierarchy = (schema) => {
-    const genealogy = tryHierarchy(schema);
-    if (genealogy === void 0) {
-      throw new Error(`Failed to resolve base type: ${schema.identifier.url} (${schema.identifier.kind})`);
+    return name;
+  }
+  generateEnumType(name) {
+    return this._generateTypeName(name);
+  }
+  _generateTypeFromTypeRef(typeRef) {
+    if (typeRef.kind === "primitive-type") {
+      return this._generateTypeName(typeRef.name);
     }
-    return genealogy;
-  };
-  const findLastSpecialization = (schema) => {
-    const nonConstraintSchema = hierarchy(schema).find((s) => s.identifier.kind !== "profile");
-    if (!nonConstraintSchema) {
-      throw new Error(`No non-constraint schema found in hierarchy for: ${schema.identifier.name}`);
+    return this._generateTypeName(
+      typeRef.url.split("/").pop()?.split("#").map((s) => s.charAt(0).toUpperCase() + s.slice(1)).join("") ?? "<UNKNOWN>"
+    );
+  }
+  generateFieldType(schema) {
+    if (schema.enum) {
+      return this.generateEnumType(schema.binding?.name ?? schema.type.name);
     }
-    return nonConstraintSchema;
-  };
-  const findLastSpecializationByIdentifier = (id) => {
-    const schema = resolve3(id);
-    if (!schema) return id;
-    return findLastSpecialization(schema).identifier;
-  };
-  const flatProfile = (schema) => {
-    const hierarchySchemas = hierarchy(schema);
-    const constraintSchemas = hierarchySchemas.filter((s) => s.identifier.kind === "profile");
-    const nonConstraintSchema = hierarchySchemas.find((s) => s.identifier.kind !== "profile");
-    if (!nonConstraintSchema)
-      throw new Error(`No non-constraint schema found in hierarchy for ${schema.identifier.name}`);
-    const mergedFields = {};
-    for (const anySchema of constraintSchemas.slice().reverse()) {
-      const schema2 = anySchema;
-      if (!schema2.fields) continue;
-      for (const [fieldName, fieldConstraints] of Object.entries(schema2.fields)) {
-        if (mergedFields[fieldName]) {
-          mergedFields[fieldName] = {
-            ...mergedFields[fieldName],
-            ...fieldConstraints
-          };
-        } else {
-          mergedFields[fieldName] = { ...fieldConstraints };
-        }
-      }
+    return this._generateTypeFromTypeRef(schema.type);
+  }
+  generateType(schemaOrRefOrString) {
+    if (typeof schemaOrRefOrString === "string") {
+      return this._generateTypeName(schemaOrRefOrString);
     }
-    const deps = {};
-    for (const e of constraintSchemas.flatMap((e2) => e2.dependencies ?? [])) {
-      deps[e.url] = e;
+    if ("url" in schemaOrRefOrString) {
+      return this._generateTypeFromTypeRef(schemaOrRefOrString);
     }
-    const dependencies = Object.values(deps);
-    return {
-      ...schema,
-      base: nonConstraintSchema.identifier,
-      fields: mergedFields,
-      dependencies
-    };
-  };
-  const isWithMetaField = (profile) => {
-    const genealogy = tryHierarchy(profile);
-    if (!genealogy) return false;
-    return genealogy.filter(isSpecializationTypeSchema).some((schema) => {
-      return schema.fields?.meta !== void 0;
-    });
-  };
-  const exportTree = async (filename) => {
-    const tree = {};
-    for (const [pkgId, shemas] of Object.entries(groupByPackages(schemas))) {
-      tree[pkgId] = {
-        "primitive-type": {},
-        "complex-type": {},
-        resource: {},
-        "value-set": {},
-        nested: {},
-        binding: {},
-        profile: {},
-        logical: {}
-      };
-      for (const schema of shemas) {
-        tree[pkgId][schema.identifier.kind][schema.identifier.url] = {};
-      }
+    return this._generateTypeFromTypeRef(schemaOrRefOrString.identifier);
+  }
+  generateField(name) {
+    name = this._applyNameTransformations(name, this.nameTransformations.field);
+    if (this.keywords.has(name)) {
+      return `_${name}`;
     }
-    const raw = filename.endsWith(".yaml") ? YAML.stringify(tree) : JSON.stringify(tree, void 0, 2);
-    await afs2.mkdir(Path4.dirname(filename), { recursive: true });
-    await afs2.writeFile(filename, raw);
-  };
-  return {
-    _schemaIndex: index,
-    _relations: relations,
-    collectComplexTypes: () => schemas.filter(isComplexTypeTypeSchema),
-    collectResources: () => schemas.filter(isResourceTypeSchema),
-    collectLogicalModels: () => schemas.filter(isLogicalTypeSchema),
-    collectProfiles: () => schemas.filter(isProfileTypeSchema),
-    resolve: resolve3,
-    resolveByUrl,
-    resourceChildren,
-    tryHierarchy,
-    hierarchy,
-    findLastSpecialization,
-    findLastSpecializationByIdentifier,
-    flatProfile,
-    isWithMetaField,
-    exportTree
-  };
-};
-var CodegenLogger = class _CodegenLogger {
-  options;
-  dryWarnSet = /* @__PURE__ */ new Set();
-  constructor(options = {}) {
-    this.options = {
-      timestamp: false,
-      verbose: false,
-      ...options
-    };
+    name = this._replaceUnsaveChars(name);
+    return name;
   }
-  static consoleLevelsMap = {
-    [1 /* INFO */]: console.log,
-    [2 /* WARN */]: console.warn,
-    [3 /* ERROR */]: console.error,
-    [0 /* DEBUG */]: console.log,
-    [4 /* SILENT */]: () => {
+  generateEnumValue(name) {
+    name = this._applyNameTransformations(name, this.nameTransformations.enumValue);
+    if (this.keywords.has(name)) {
+      return `_${name}`;
     }
-  };
-  formatMessage(level, message, color) {
-    const timestamp = this.options.timestamp ? `${pc.gray((/* @__PURE__ */ new Date()).toLocaleTimeString())} ` : "";
-    const prefix = this.options.prefix ? `${pc.cyan(`[${this.options.prefix}]`)} ` : "";
-    return `${timestamp}${color(level)} ${prefix}${message}`;
+    name = this._replaceUnsaveChars(name).toUpperCase();
+    return name;
   }
-  isSuppressed(level) {
-    return this.options.suppressLoggingLevel === "all" || this.options.suppressLoggingLevel?.includes(level) || false;
+};
+var TemplateFileCache = class {
+  templateBaseDir;
+  templateCache = {};
+  constructor(templateBaseDir) {
+    this.templateBaseDir = Path__default.resolve(templateBaseDir);
+  }
+  _normalizeName(name) {
+    if (name.endsWith(".mustache")) {
+      return name;
+    }
+    return `${name}.mustache`;
   }
-  tryWriteToConsole(level, formattedMessage) {
-    if (this.isSuppressed(level)) return;
-    const logFn = _CodegenLogger.consoleLevelsMap[level] || console.log;
-    logFn(formattedMessage);
+  read(template) {
+    return this.readTemplate(template.source);
   }
-  /**
-   * Success message with checkmark
-   */
-  success(message) {
-    this.tryWriteToConsole(1 /* INFO */, this.formatMessage("", message, pc.green));
+  readTemplate(name) {
+    const normalizedName = this._normalizeName(name);
+    if (!this.templateCache[normalizedName]) {
+      this.templateCache[normalizedName] = fs__default.readFileSync(
+        Path__default.join(this.templateBaseDir, normalizedName),
+        "utf-8"
+      );
+    }
+    return this.templateCache[normalizedName];
   }
-  /**
-   * Error message with X mark
-   */
-  error(message, error) {
-    if (this.isSuppressed(3 /* ERROR */)) return;
-    console.error(this.formatMessage("X", message, pc.red));
-    if (error && this.options.verbose) {
-      console.error(pc.red(`   ${error.message}`));
-      if (error.stack) {
-        console.error(pc.gray(error.stack));
+};
+
+// src/api/mustache/generator/ListElementInformationMixinProvider.ts
+var ListElementInformationMixinProvider = class _ListElementInformationMixinProvider {
+  static _array(value) {
+    return Array.isArray(value) ? value : Array.from(value);
+  }
+  apply(source) {
+    return this._addListElementInformation(source);
+  }
+  _addListElementInformation(value) {
+    if (Array.isArray(value) || value instanceof Set) {
+      return _ListElementInformationMixinProvider._array(value).map((v, index, array) => {
+        if (typeof v === "object" && v !== null) {
+          return {
+            ...this._addListElementInformation(v),
+            "-index": index,
+            "-length": array.length,
+            "-first": index === 0,
+            "-last": index === array.length - 1
+          };
+        }
+        return v;
+      });
+    }
+    if (value !== null && typeof value === "object") {
+      const obj = value;
+      const result = {};
+      for (const [key, val] of Object.entries(obj)) {
+        result[key] = this._addListElementInformation(val);
       }
+      return result;
     }
+    return value;
   }
-  /**
-   * Warning message with warning sign
-   */
-  warn(message) {
-    this.tryWriteToConsole(2 /* WARN */, this.formatMessage("!", message, pc.yellow));
+};
+
+// src/api/mustache/types.ts
+var PRIMITIVE_TYPES = [
+  "boolean",
+  "instant",
+  "time",
+  "date",
+  "dateTime",
+  "decimal",
+  "integer",
+  "unsignedInt",
+  "positiveInt",
+  "integer64",
+  "base64Binary",
+  "uri",
+  "url",
+  "canonical",
+  "oid",
+  "uuid",
+  "string",
+  "code",
+  "markdown",
+  "id",
+  "xhtml"
+];
+
+// src/api/mustache/generator/ViewModelFactory.ts
+var ViewModelFactory = class {
+  constructor(tsIndex, nameGenerator, filterPred) {
+    this.tsIndex = tsIndex;
+    this.nameGenerator = nameGenerator;
+    this.filterPred = filterPred;
+  }
+  arrayMixinProvider = new ListElementInformationMixinProvider();
+  createUtility() {
+    return this._createForRoot();
+  }
+  createComplexType(typeRef, cache = { resourcesByUri: {}, complexTypesByUri: {} }) {
+    const base = this._createForComplexType(typeRef, cache);
+    const parents = this._createParentsFor(base.schema, cache);
+    const children = this._createChildrenFor(typeRef, cache);
+    const inheritedFields = parents.flatMap((p) => p.fields);
+    return this.arrayMixinProvider.apply({
+      ...this._createForRoot(),
+      ...base,
+      parents,
+      children,
+      inheritedFields,
+      allFields: [...base.fields, ...parents.flatMap((p) => p.fields)],
+      hasChildren: children.length > 0,
+      hasParents: parents.length > 0,
+      hasInheritedFields: inheritedFields.length > 0
+    });
   }
-  dry_warn(message) {
-    if (!this.dryWarnSet.has(message)) {
-      this.warn(message);
-      this.dryWarnSet.add(message);
+  createResource(typeRef, cache = { resourcesByUri: {}, complexTypesByUri: {} }) {
+    const base = this._createForResource(typeRef, cache);
+    const parents = this._createParentsFor(base.schema, cache);
+    const children = this._createChildrenFor(typeRef, cache);
+    const inheritedFields = parents.flatMap((p) => p.fields);
+    return this.arrayMixinProvider.apply({
+      ...this._createForRoot(),
+      ...base,
+      parents,
+      children,
+      inheritedFields,
+      allFields: [...base.fields, ...inheritedFields],
+      hasChildren: children.length > 0,
+      hasParents: parents.length > 0,
+      hasInheritedFields: inheritedFields.length > 0
+    });
+  }
+  _createFor(typeRef, cache, nestedIn) {
+    if (typeRef.kind === "complex-type") {
+      return this._createForComplexType(typeRef, cache, nestedIn);
+    }
+    if (typeRef.kind === "resource") {
+      return this._createForResource(typeRef, cache, nestedIn);
     }
+    throw new Error(`Unknown type ${typeRef.kind}`);
   }
-  /**
-   * Info message with info icon
-   */
-  info(message) {
-    this.tryWriteToConsole(1 /* INFO */, this.formatMessage("i", message, pc.blue));
+  _createForComplexType(typeRef, cache, nestedIn) {
+    const type = this.tsIndex.resolve(typeRef);
+    if (!type) {
+      throw new Error(`ComplexType ${typeRef.name} not found`);
+    }
+    if (!Object.hasOwn(cache.complexTypesByUri, type.identifier.url)) {
+      cache.complexTypesByUri[type.identifier.url] = this._createTypeViewModel(type, cache, nestedIn);
+    }
+    const res = cache.complexTypesByUri[type.identifier.url];
+    if (!res) throw new Error(`ComplexType ${typeRef.name} not found`);
+    return res;
   }
-  /**
-   * Debug message (only shows in verbose mode)
-   */
-  debug(message) {
-    if (this.options.verbose) {
-      this.tryWriteToConsole(0 /* DEBUG */, this.formatMessage("\u{1F41B}", message, pc.magenta));
+  _createForResource(typeRef, cache, nestedIn) {
+    const type = this.tsIndex.resolve(typeRef);
+    if (!type) {
+      throw new Error(`Resource ${typeRef.name} not found`);
     }
+    if (!Object.hasOwn(cache.resourcesByUri, type.identifier.url)) {
+      cache.resourcesByUri[type.identifier.url] = this._createTypeViewModel(type, cache, nestedIn);
+    }
+    const res = cache.resourcesByUri[type.identifier.url];
+    if (!res) throw new Error(`Resource ${typeRef.name} not found`);
+    return res;
   }
-  /**
-   * Step message with rocket
-   */
-  step(message) {
-    this.tryWriteToConsole(1 /* INFO */, this.formatMessage("\u{1F680}", message, pc.cyan));
+  _createChildrenFor(typeRef, cache, nestedIn) {
+    if (isComplexTypeIdentifier(typeRef)) {
+      return this.tsIndex.resourceChildren(typeRef).filter(isComplexTypeIdentifier).filter(this.filterPred).map((childRef) => this._createFor(childRef, cache, nestedIn));
+    }
+    if (isResourceIdentifier(typeRef)) {
+      return this.tsIndex.resourceChildren(typeRef).filter(isResourceIdentifier).filter(this.filterPred).map((childRef) => this._createFor(childRef, cache, nestedIn));
+    }
+    return [];
+  }
+  _createParentsFor(base, cache) {
+    const parents = [];
+    let parentRef = "base" in base ? base.base : void 0;
+    while (parentRef) {
+      parents.push(this._createFor(parentRef, cache, void 0));
+      const parent = this.tsIndex.resolve(parentRef);
+      parentRef = parent && "base" in parent ? parent.base : void 0;
+    }
+    return parents;
   }
-  /**
-   * Progress message with clock
-   */
-  progress(message) {
-    this.tryWriteToConsole(1 /* INFO */, this.formatMessage("\u23F3", message, pc.blue));
+  _createForNestedType(nested, cache, nestedIn) {
+    const base = this._createTypeViewModel(nested, cache, nestedIn);
+    const parents = this._createParentsFor(nested, cache);
+    const children = this._createChildrenFor(nested.identifier, cache, nestedIn);
+    const inheritedFields = parents.flatMap((p) => p.fields);
+    return {
+      ...base,
+      parents,
+      children,
+      inheritedFields,
+      allFields: [...base.fields, ...inheritedFields],
+      hasChildren: children.length > 0,
+      hasParents: parents.length > 0,
+      hasInheritedFields: inheritedFields.length > 0
+    };
   }
-  /**
-   * Plain message (no icon, just colored text)
-   */
-  plain(message, color = (s) => s) {
-    const timestamp = this.options.timestamp ? `${pc.gray((/* @__PURE__ */ new Date()).toLocaleTimeString())} ` : "";
-    const prefix = this.options.prefix ? `${pc.cyan(`[${this.options.prefix}]`)} ` : "";
-    this.tryWriteToConsole(1 /* INFO */, `${timestamp}${prefix}${color(message)}`);
+  _createTypeViewModel(schema, cache, nestedIn) {
+    const fields = Object.entries(("fields" in schema ? schema.fields : {}) ?? {});
+    const nestedComplexTypes = this._collectNestedComplex(schema, cache);
+    const nestedEnums = this._collectNestedEnums(fields);
+    const dependencies = this._collectDependencies(schema);
+    const name = {
+      name: schema.identifier.name,
+      saveName: this.nameGenerator.generateType(schema)
+    };
+    return {
+      nestedComplexTypes,
+      nestedEnums,
+      dependencies,
+      isNested: !!nestedIn,
+      schema,
+      ...name,
+      isResource: this._createIsResource(schema.identifier),
+      isComplexType: this._createIsComplexType(schema.identifier),
+      hasFields: fields.length > 0,
+      hasNestedComplexTypes: nestedComplexTypes.length > 0,
+      hasNestedEnums: nestedEnums.length > 0,
+      fields: fields.filter(([_fieldName, fieldSchema]) => !!fieldSchema.type).sort((a, b) => a[0].localeCompare(b[0])).map(([fieldName, fieldSchema]) => {
+        return {
+          owner: name,
+          schema: fieldSchema,
+          name: fieldName,
+          saveName: this.nameGenerator.generateField(fieldName),
+          typeName: this.nameGenerator.generateFieldType(fieldSchema),
+          isArray: fieldSchema.array,
+          isRequired: fieldSchema.required,
+          isEnum: !!fieldSchema.enum,
+          isSizeConstrained: fieldSchema.min !== void 0 || fieldSchema.max !== void 0,
+          min: fieldSchema.min,
+          max: fieldSchema.max,
+          isResource: this._createIsResource(fieldSchema.type),
+          isComplexType: this._createIsComplexType(fieldSchema.type),
+          isPrimitive: this._createIsPrimitiveType(fieldSchema.type),
+          isCode: fieldSchema.type?.name === "code",
+          isIdentifier: fieldSchema.type?.name === "Identifier",
+          isReference: fieldSchema.type?.name === "Reference"
+        };
+      })
+    };
   }
-  /**
-   * Dimmed/gray text for less important info
-   */
-  dim(message) {
-    this.plain(message, pc.gray);
+  _collectDependencies(schema) {
+    const dependencies = {
+      resources: [],
+      complexTypes: []
+    };
+    if ("dependencies" in schema && schema.dependencies) {
+      schema.dependencies.filter((dependency) => dependency.kind === "complex-type").map((dependency) => ({ name: dependency.name, saveName: this.nameGenerator.generateType(dependency) })).forEach((dependency) => {
+        dependencies.complexTypes.push(dependency);
+      });
+      schema.dependencies.filter((dependency) => dependency.kind === "resource").map((dependency) => ({ name: dependency.name, saveName: this.nameGenerator.generateType(dependency) })).forEach((dependency) => {
+        dependencies.resources.push(dependency);
+      });
+    }
+    if ("nested" in schema && schema.nested) {
+      schema.nested.map((nested) => this._collectDependencies(nested)).forEach((d) => {
+        d.complexTypes.filter(
+          (complexType) => !dependencies.complexTypes.some((dependency) => dependency.name === complexType.name)
+        ).forEach((complexType) => {
+          dependencies.complexTypes.push(complexType);
+        });
+        d.resources.filter(
+          (resource) => !dependencies.resources.some((dependency) => dependency.name === resource.name)
+        ).forEach((resource) => {
+          dependencies.resources.push(resource);
+        });
+      });
+    }
+    return dependencies;
   }
-  /**
-   * Create a child logger with a prefix
-   */
-  child(prefix) {
-    return new _CodegenLogger({
-      ...this.options,
-      prefix: this.options.prefix ? `${this.options.prefix}:${prefix}` : prefix
+  _createIsResource(typeRef) {
+    if (typeRef.kind !== "resource") {
+      return false;
+    }
+    return Object.fromEntries(
+      this.tsIndex.collectResources().map((e) => e.identifier).map((resourceRef) => [
+        `is${resourceRef.name.charAt(0).toUpperCase() + resourceRef.name.slice(1)}`,
+        resourceRef.url === typeRef.url
+      ])
+    );
+  }
+  _createIsComplexType(typeRef) {
+    if (typeRef.kind !== "complex-type" && typeRef.kind !== "nested") {
+      return false;
+    }
+    return Object.fromEntries(
+      this.tsIndex.collectComplexTypes().map((e) => e.identifier).map((complexTypeRef) => [
+        `is${complexTypeRef.name.charAt(0).toUpperCase() + complexTypeRef.name.slice(1)}`,
+        complexTypeRef.url === typeRef.url
+      ])
+    );
+  }
+  _createIsPrimitiveType(typeRef) {
+    if (typeRef.kind !== "primitive-type") {
+      return false;
+    }
+    return Object.fromEntries(
+      PRIMITIVE_TYPES.map((type) => [`is${type.charAt(0).toUpperCase()}${type.slice(1)}`, typeRef.name === type])
+    );
+  }
+  _collectNestedComplex(schema, cache) {
+    const nested = [];
+    if ("nested" in schema && schema.nested) {
+      schema.nested.map((nested2) => this._createForNestedType(nested2, cache, schema)).forEach((n) => {
+        nested.push(n);
+      });
+    }
+    return nested;
+  }
+  _collectNestedEnums(fields) {
+    const nestedEnumValues = {};
+    fields.forEach(([fieldName, fieldSchema]) => {
+      if ("enum" in fieldSchema && fieldSchema.enum) {
+        const name = ("binding" in fieldSchema && fieldSchema.binding?.name) ?? fieldName;
+        if (typeof name === "string") {
+          nestedEnumValues[name] = nestedEnumValues[name] ?? /* @__PURE__ */ new Set();
+          fieldSchema.enum?.forEach(nestedEnumValues[name].add.bind(nestedEnumValues[name]));
+        }
+      }
     });
+    return Object.entries(nestedEnumValues).map(([name, values]) => ({
+      name,
+      saveName: this.nameGenerator.generateEnumType(name),
+      values: Array.from(values).map((value) => ({
+        name: value,
+        saveName: this.nameGenerator.generateEnumValue(value)
+      }))
+    }));
   }
-  /**
-   * Update options
-   */
-  configure(options) {
-    this.options = { ...this.options, ...options };
+  _createForRoot() {
+    return this.arrayMixinProvider.apply({
+      complexTypes: this.tsIndex.collectComplexTypes().map((e) => e.identifier).map((typeRef) => ({
+        name: typeRef.name,
+        saveName: this.nameGenerator.generateType(typeRef)
+      })),
+      resources: this.tsIndex.collectResources().map((e) => e.identifier).map((typeRef) => ({
+        name: typeRef.name,
+        saveName: this.nameGenerator.generateType(typeRef)
+      }))
+    });
   }
 };
-new CodegenLogger();
-function createLogger(options = {}) {
-  return new CodegenLogger(options);
-}
-
-// 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."
+function loadMustacheGeneratorConfig(templatePath, logger) {
+  const filePath = Path.resolve(templatePath, "config.json");
+  try {
+    const raw = fs.readFileSync(filePath, "utf-8");
+    const parsed = JSON.parse(raw);
+    if (parsed && typeof parsed === "object") {
+      return parsed;
+    }
+  } catch (_e) {
   }
+  return {};
+}
+var createGenerator = (templatePath, apiOpts) => {
+  const defaultFileOpts = {
+    debug: "OFF",
+    hooks: {},
+    meta: {},
+    keywords: [],
+    unsaveCharacterPattern: /[^a-zA-Z0-9]/g,
+    nameTransformations: {
+      common: [],
+      enumValue: [],
+      type: [],
+      field: []
+    },
+    renderings: {
+      utility: [],
+      resource: [],
+      complexType: []
+    },
+    shouldRunHooks: true,
+    primitiveTypeMap: {}
+  };
+  const actualFileOpts = loadMustacheGeneratorConfig(templatePath);
+  const mustacheOptions = {
+    ...defaultFileOpts,
+    ...apiOpts,
+    ...actualFileOpts,
+    sources: {
+      staticSource: Path.resolve(templatePath, "static"),
+      templateSource: Path.resolve(templatePath, "templates")
+    }
+  };
+  return new MustacheGenerator(mustacheOptions);
 };
-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;
+function runCommand(cmd, args = [], options = {}) {
+  return new Promise((resolve6, reject) => {
+    const child = spawn(cmd, args, {
+      stdio: "inherit",
+      ...options
+    });
+    child.on("error", reject);
+    child.on("close", (code) => {
+      if (code === 0) resolve6(code);
+      else reject(new Error(`Prozess beendet mit Fehlercode ${code}`));
+    });
+  });
+}
+var MustacheGenerator = class extends FileSystemWriter {
+  templateFileCache;
+  nameGenerator;
+  lambdaMixinProvider;
+  debugMixinProvider;
+  constructor(opts) {
+    super(opts);
+    this.nameGenerator = new NameGenerator(
+      new Set(opts.keywords),
+      opts.primitiveTypeMap,
+      opts.nameTransformations,
+      opts.unsaveCharacterPattern
+    );
+    this.templateFileCache = new TemplateFileCache(opts.sources.templateSource);
+    this.lambdaMixinProvider = new LambdaMixinProvider(this.nameGenerator);
+    this.debugMixinProvider = opts.debug !== "OFF" ? new DebugMixinProvider(opts.debug) : void 0;
+  }
+  async generate(tsIndex) {
+    const modelFactory = new ViewModelFactory(tsIndex, this.nameGenerator, () => true);
+    const cache = {
+      resourcesByUri: {},
+      complexTypesByUri: {}
+    };
+    tsIndex.collectComplexTypes().map((i) => i.identifier).sort((a, b) => a.url.localeCompare(b.url)).map((typeRef) => modelFactory.createComplexType(typeRef, cache)).forEach(this._renderComplexType.bind(this));
+    tsIndex.collectResources().map((i) => i.identifier).sort((a, b) => a.url.localeCompare(b.url)).map((typeRef) => modelFactory.createResource(typeRef, cache)).forEach(this._renderResource.bind(this));
+    this._renderUtility(modelFactory.createUtility());
+    this.copyStaticFiles();
+    if (this.opts.shouldRunHooks) {
+      await this._runHooks(this.opts.hooks.afterGenerate);
     }
-    fhirSchemas.push(...await transformFhirSchema(register, fhirSchema, logger));
+    return;
   }
-  for (const vsSchema of register.allVs()) {
-    fhirSchemas.push(await transformValueSet(register, vsSchema));
+  copyStaticFiles() {
+    const staticDir = Path.resolve(this.opts.sources.staticSource);
+    if (!staticDir) {
+      throw new Error("staticDir must be set in subclass.");
+    }
+    fs.cpSync(staticDir, this.opts.outputDir, { recursive: true });
+  }
+  async _runHooks(hooks) {
+    for (const hook of hooks ?? []) {
+      console.info(`Running hook (${this.opts.outputDir}): ${hook.cmd} ${hook.args?.join(" ")}`);
+      await runCommand(hook.cmd, hook.args ?? [], {
+        cwd: this.opts.outputDir
+      });
+      console.info(`Completed hook: ${hook.cmd} ${hook.args?.join(" ")}`);
+    }
+  }
+  _checkRenderingFilter(model, rendering) {
+    if (!rendering.filter?.whitelist?.length && !rendering.filter?.blacklist?.length) {
+      return true;
+    }
+    if ((rendering.filter?.blacklist ?? []).find((v) => model.name.match(v))) {
+      return false;
+    }
+    if ((rendering.filter?.whitelist ?? []).find((v) => model.name.match(v))) {
+      return true;
+    }
+    return !rendering.filter.whitelist?.length;
+  }
+  _renderUtility(model) {
+    this.opts.renderings.utility.forEach((rendering) => {
+      this.cd(rendering.path, () => {
+        this.cat(rendering.fileNameFormat, () => {
+          this.write(this._render(model, rendering));
+        });
+      });
+    });
+  }
+  _renderResource(model) {
+    this.opts.renderings.resource.filter((rendering) => this._checkRenderingFilter(model, rendering)).forEach((rendering) => {
+      this.cd(rendering.path, () => {
+        this.cat(this._calculateFilename(model, rendering), () => {
+          this.write(this._render(model, rendering));
+        });
+      });
+    });
+  }
+  _renderComplexType(model) {
+    this.opts.renderings.complexType.filter((rendering) => this._checkRenderingFilter(model, rendering)).forEach((rendering) => {
+      this.cd(rendering.path, () => {
+        this.cat(this._calculateFilename(model, rendering), () => {
+          this.write(this._render(model, rendering));
+        });
+      });
+    });
+  }
+  _calculateFilename(model, rendering) {
+    return util.format(rendering.fileNameFormat, model.saveName);
+  }
+  _render(model, rendering) {
+    let view = this.lambdaMixinProvider.apply({
+      meta: {
+        timestamp: this.opts.meta.timestamp ?? (/* @__PURE__ */ new Date()).toISOString(),
+        generator: this.opts.meta.generator ?? "@atomic-ehr/codegen mustache generator"
+      },
+      model,
+      properties: rendering.properties ?? {}
+    });
+    if (this.debugMixinProvider) {
+      view = this.debugMixinProvider.apply(view);
+    }
+    return Mustache.render(
+      this.templateFileCache.read(rendering),
+      view,
+      (partialName) => this.templateFileCache.readTemplate(partialName)
+    );
   }
-  return fhirSchemas;
 };
 
 // src/api/writer-generator/typescript.ts
@@ -1741,7 +3217,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;
@@ -1750,7 +3226,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("");
@@ -1816,7 +3292,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),
@@ -1869,7 +3345,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`);
@@ -2121,7 +3597,13 @@ var TypeScript = class extends Writer {
       ...this.opts.generateProfile ? tsIndex.collectProfiles().filter((p) => tsIndex.isWithMetaField(p)) : []
     ];
     const grouped = groupByPackages(typesToGenerate);
+    const treeShakeReport = tsIndex.treeShakeReport();
     this.cd("/", () => {
+      if (treeShakeReport) {
+        this.cat("README.md", () => {
+          this.write(rootTreeShakeReadme(treeShakeReport));
+        });
+      }
       for (const [packageName, packageSchemas] of Object.entries(grouped)) {
         const tsPackageDir = tsFhirPackageDir(packageName);
         this.cd(tsPackageDir, () => {
@@ -2129,6 +3611,11 @@ var TypeScript = class extends Writer {
             this.generateResourceModule(tsIndex, schema);
           }
           this.generateFhirPackageIndexFile(packageSchemas);
+          if (treeShakeReport) {
+            this.cat("README.md", () => {
+              this.write(packageTreeShakeReadme(treeShakeReport, packageName));
+            });
+          }
         });
       }
     });
@@ -2136,6 +3623,25 @@ var TypeScript = class extends Writer {
 };
 
 // src/api/builder.ts
+var prettyReport = (report) => {
+  const { success, filesGenerated, errors, warnings, duration } = report;
+  const errorsStr = errors.length > 0 ? `Errors: ${errors.join(", ")}` : void 0;
+  const warningsStr = warnings.length > 0 ? `Warnings: ${warnings.join(", ")}` : void 0;
+  let allLoc = 0;
+  const files = Object.entries(filesGenerated).map(([path, content]) => {
+    const loc = content.split("\n").length;
+    allLoc += loc;
+    return `  - ${path} (${loc} loc)`;
+  }).join("\n");
+  return [
+    `Generated files (${Math.round(allLoc / 1e3)} kloc):`,
+    files,
+    errorsStr,
+    warningsStr,
+    `Duration: ${Math.round(duration)}ms`,
+    `Status: ${success ? "\u{1F7E9} Success" : "\u{1F7E5} Failure"}`
+  ].filter((e) => e).join("\n");
+};
 var normalizeFileName = (str) => {
   const res = str.replace(/[^a-zA-Z0-9\-_.@#()]/g, "");
   if (res.length === 0) return "unknown";
@@ -2176,7 +3682,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 = Path.join(outputDir, pkgPath, name);
     if (!files[baseName]) files[baseName] = [];
     if (!files[baseName]?.some((e) => e === json)) {
       files[baseName].push(json);
@@ -2191,7 +3697,7 @@ var writeTypeSchemasToSeparateFiles = async (typeSchemas, outputDir, logger) =>
         } else {
           fullName = `${baseName}-${index}.typeschema.json`;
         }
-        await afs2.mkdir(Path4.dirname(fullName), { recursive: true });
+        await afs2.mkdir(Path.dirname(fullName), { recursive: true });
         await afs2.writeFile(fullName, json);
       })
     );
@@ -2199,7 +3705,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(Path.dirname(outputFile), { recursive: true });
   logger.info(`Writing TypeSchemas to one file ${outputFile}...`);
   for (const ts of typeSchemas) {
     const json = JSON.stringify(ts, null, 2);
@@ -2210,7 +3716,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 (Path.extname(opts.typeSchemaOutputDir) === ".ndjson") {
       await writeTypeSchemasToSingleFile(typeSchemas, opts.typeSchemaOutputDir, logger);
     } else {
       await writeTypeSchemasToSeparateFiles(typeSchemas, opts.typeSchemaOutputDir, logger);
@@ -2227,12 +3733,13 @@ var APIBuilder = class {
   generators = /* @__PURE__ */ new Map();
   logger;
   packages = [];
+  localStructurePackages = [];
+  localTgzArchives = [];
   progressCallback;
   typeSchemaConfig;
   constructor(options = {}) {
     this.options = {
       outputDir: options.outputDir || "./generated",
-      verbose: options.verbose ?? false,
       overwrite: options.overwrite ?? true,
       cache: options.cache ?? true,
       cleanOutput: options.cleanOutput ?? true,
@@ -2241,12 +3748,13 @@ var APIBuilder = class {
       throwException: options.throwException || false,
       typeSchemaOutputDir: options.typeSchemaOutputDir,
       exportTypeTree: options.exportTypeTree,
-      treeShake: options.treeShake
+      treeShake: options.treeShake,
+      registry: options.registry
     };
     this.typeSchemaConfig = options.typeSchemaConfig;
     this.logger = options.logger || createLogger({
-      verbose: this.options.verbose,
-      prefix: "API"
+      prefix: "API",
+      level: options.logLevel
     });
   }
   fromPackage(packageName, version) {
@@ -2258,6 +3766,22 @@ var APIBuilder = class {
     this.packages.push(packageRef);
     return this;
   }
+  /**
+   * Set a custom FHIR package registry URL
+   * @param url The registry URL (default: https://fs.get-ig.org/pkgs/)
+   */
+  registry(url) {
+    this.options.registry = url;
+    return this;
+  }
+  localStructureDefinitions(config) {
+    this.localStructurePackages.push(config);
+    return this;
+  }
+  localTgzPackage(archivePath) {
+    this.localTgzArchives.push(Path.resolve(archivePath));
+    return this;
+  }
   fromSchemas(schemas) {
     this.logger.debug(`Adding ${schemas.length} TypeSchemas to generation`);
     this.schemas = [...this.schemas, ...schemas];
@@ -2266,7 +3790,7 @@ var APIBuilder = class {
   typescript(userOpts) {
     const defaultWriterOpts = {
       logger: this.logger,
-      outputDir: Path4.join(this.options.outputDir, "/types"),
+      outputDir: Path.join(this.options.outputDir, "/types"),
       tabSize: 4,
       withDebugComment: false,
       commentLinePrefix: "//",
@@ -2286,19 +3810,67 @@ var APIBuilder = class {
     this.logger.debug(`Configured TypeScript generator (${JSON.stringify(opts, void 0, 2)})`);
     return this;
   }
-  csharp(namespace, staticSourceDir) {
-    const generator = new CSharp({
-      outputDir: Path4.join(this.options.outputDir, "/types"),
-      staticSourceDir: staticSourceDir ?? void 0,
-      targetNamespace: namespace,
-      logger: new CodegenLogger({
-        prefix: "C#",
-        timestamp: true,
-        verbose: true,
-        suppressLoggingLevel: []
-      })
-    });
-    this.generators.set("C#", generator);
+  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;
+  }
+  mustache(templatePath, userOpts) {
+    const defaultWriterOpts = {
+      logger: this.logger,
+      outputDir: this.options.outputDir
+    };
+    const defaultMustacheOpts = {
+      meta: {
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        generator: "atomic-codegen"
+      }
+    };
+    const opts = {
+      ...defaultWriterOpts,
+      ...defaultMustacheOpts,
+      ...userOpts
+    };
+    const generator = createGenerator(templatePath, opts);
+    this.generators.set(`mustache[${templatePath}]`, generator);
+    this.logger.debug(`Configured TypeScript generator (${JSON.stringify(opts, void 0, 2)})`);
+    return this;
+  }
+  csharp(userOptions) {
+    const defaultWriterOpts = {
+      logger: this.logger,
+      outputDir: Path.join(this.options.outputDir, "/types"),
+      tabSize: 4,
+      withDebugComment: false,
+      commentLinePrefix: "//"
+    };
+    const defaultCSharpOpts = {
+      ...defaultWriterOpts,
+      rootNamespace: "Fhir.Types"
+    };
+    const opts = {
+      ...defaultCSharpOpts,
+      ...Object.fromEntries(Object.entries(userOptions).filter(([_, v]) => v !== void 0))
+    };
+    const generator = new CSharp(opts);
+    this.generators.set("csharp", generator);
     this.logger.debug(`Configured C# generator`);
     return this;
   }
@@ -2320,9 +3892,8 @@ var APIBuilder = class {
     }
     return this;
   }
-  verbose(enabled = true) {
-    this.options.verbose = enabled;
-    this.logger?.configure({ verbose: enabled });
+  setLogLevel(level) {
+    this.logger?.setLevel(typeof level === "string" ? parseLogLevel(level) : level);
     return this;
   }
   throwException(enabled = true) {
@@ -2350,7 +3921,7 @@ var APIBuilder = class {
     const result = {
       success: false,
       outputDir: this.options.outputDir,
-      filesGenerated: [],
+      filesGenerated: {},
       errors: [],
       warnings: [],
       duration: 0
@@ -2359,10 +3930,28 @@ var APIBuilder = class {
     try {
       if (this.options.cleanOutput) cleanup(this.options, this.logger);
       this.logger.info("Initialize Canonical Manager");
-      const manager = CanonicalManager({
+      const manager = this.options.manager || CanonicalManager({
         packages: this.packages,
-        workingDir: ".codegen-cache/canonical-manager-cache"
+        workingDir: ".codegen-cache/canonical-manager-cache",
+        registry: this.options.registry || void 0
       });
+      if (this.localStructurePackages.length > 0) {
+        for (const config of this.localStructurePackages) {
+          this.logger.info(
+            `Registering local StructureDefinitions for ${config.package.name}@${config.package.version}`
+          );
+          await manager.addLocalPackage({
+            name: config.package.name,
+            version: config.package.version,
+            path: config.path,
+            dependencies: config.dependencies?.map((dep) => packageMetaToNpm(dep))
+          });
+        }
+      }
+      for (const archivePath of this.localTgzArchives) {
+        this.logger.info(`Registering local tgz package: ${archivePath}`);
+        await manager.addTgzPackage({ archivePath });
+      }
       const ref2meta = await manager.init();
       const packageMetas = Object.values(ref2meta);
       const register = await registerFromManager(manager, {
@@ -2370,13 +3959,13 @@ var APIBuilder = class {
         focusedPackages: packageMetas
       });
       const typeSchemas = await generateTypeSchemas(register, this.logger);
-      await tryWriteTypeSchema(typeSchemas, this.options, this.logger);
       const tsIndexOpts = {
         resolutionTree: register.resolutionTree(),
         logger: this.logger
       };
       let tsIndex = mkTypeSchemaIndex(typeSchemas, tsIndexOpts);
       if (this.options.treeShake) tsIndex = treeShake(tsIndex, this.options.treeShake, tsIndexOpts);
+      await tryWriteTypeSchema(tsIndex.schemas, this.options, this.logger);
       if (this.options.exportTypeTree) await tsIndex.exportTree(this.options.exportTypeTree);
       this.logger.debug(`Executing ${this.generators.size} generators`);
       await this.executeGenerators(result, tsIndex);
@@ -2401,6 +3990,9 @@ var APIBuilder = class {
     this.schemas = [];
     this.generators.clear();
     this.progressCallback = void 0;
+    this.packages = [];
+    this.localStructurePackages = [];
+    this.localTgzArchives = [];
     return this;
   }
   /**
@@ -2421,7 +4013,9 @@ var APIBuilder = class {
       try {
         await generator.generate(tsIndex);
         const fileBuffer = generator.writtenFiles();
-        result.filesGenerated.push(...fileBuffer.map((e) => e.absPath));
+        fileBuffer.forEach((buf) => {
+          result.filesGenerated[buf.relPath] = buf.content;
+        });
         this.logger.info(`Generating ${type} finished successfully`);
       } catch (error) {
         result.errors.push(
@@ -2439,6 +4033,7 @@ var DEFAULT_CONFIG = {
   validate: true,
   cache: true,
   cleanOutput: true,
+  registry: "",
   typescript: {
     moduleFormat: "esm",
     generateIndex: true,
@@ -2945,6 +4540,6 @@ function defineConfig(config) {
   return config;
 }
 
-export { APIBuilder, CONFIG_FILE_NAMES, ConfigLoader, ConfigValidator, DEFAULT_CONFIG, configLoader, defineConfig, isConfig, loadConfig };
+export { APIBuilder, CONFIG_FILE_NAMES, ConfigLoader, ConfigValidator, DEFAULT_CONFIG, LogLevel, configLoader, defineConfig, isConfig, loadConfig, prettyReport };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map