@atomic-ehr/codegen 0.0.4-canary.20251217144707.ef99bf1 → 0.0.4-canary.20251218111944.d18e50d

package/dist/index.js

@@ -6,7 +6,7 @@ import { readFile } from 'fs/promises';
 import * as Path5 from 'path';
 import Path5__default, { resolve } from 'path';
 import { CanonicalManager } from '@atomic-ehr/fhir-canonical-manager';
-import assert2 from 'assert';
+import assert3 from 'assert';
 import { fileURLToPath } from 'url';
 import * as YAML from 'yaml';
 import * as fhirschema from '@atomic-ehr/fhirschema';
@@ -410,6 +410,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");
@@ -739,676 +743,110 @@ var CSharp = class extends Writer {
     fs__default.copyFileSync(sourceFile, destFile);
   }
 };
-
-// src/typeschema/core/identifier.ts
-function dropVersionFromUrl(url) {
-  const baseUrl = url.split("|")[0];
-  return baseUrl ? baseUrl : url;
-}
-function getVersionFromUrl(url) {
-  const version = url.split("|")[1];
-  return version;
-}
-function determineKind(fhirSchema) {
-  if (fhirSchema.derivation === "constraint") return "profile";
-  if (fhirSchema.kind === "primitive-type") return "primitive-type";
-  if (fhirSchema.kind === "complex-type") return "complex-type";
-  if (fhirSchema.kind === "resource") return "resource";
-  if (fhirSchema.kind === "logical") return "logical";
-  return "resource";
-}
-function mkIdentifier(fhirSchema) {
-  return {
-    kind: determineKind(fhirSchema),
-    package: fhirSchema.package_meta.name,
-    version: fhirSchema.package_meta.version,
-    name: fhirSchema.name,
-    url: fhirSchema.url
-  };
-}
-var getValueSetName = (url) => {
-  const urlParts = url.split("/");
-  const lastSegment = urlParts[urlParts.length - 1];
-  if (lastSegment && lastSegment.length > 0) {
-    return lastSegment.split(/[-_]/).map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase()).join("");
+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 url;
-};
-function mkValueSetIdentifierByUrl(register, pkg, fullValueSetUrl) {
-  const valueSetUrl = dropVersionFromUrl(fullValueSetUrl);
-  const valueSetNameFallback = getValueSetName(valueSetUrl);
-  const valuesSetFallback = {
-    package_meta: {
-      name: "missing_valuesets",
-      version: getVersionFromUrl(valueSetUrl) || "0.0.0"
-    },
-    id: fullValueSetUrl};
-  const valueSet = register.resolveVs(pkg, valueSetUrl) || valuesSetFallback;
-  const valueSetName = valueSet?.id && !/^[a-zA-Z0-9_-]{20,}$/.test(valueSet.id) ? valueSet.id : valueSetNameFallback;
-  return {
-    kind: "value-set",
-    package: valueSet.package_meta.name,
-    version: valueSet.package_meta.version,
-    name: valueSetName,
-    url: valueSetUrl
-  };
-}
-function mkBindingIdentifier(fhirSchema, path, bindingName) {
-  const pathStr = path.join(".");
-  const [pkg, name, url] = bindingName ? [{ name: "shared", version: "1.0.0" }, bindingName, `urn:fhir:binding:${bindingName}`] : [fhirSchema.package_meta, `${fhirSchema.name}.${pathStr}_binding`, `${fhirSchema.url}#${pathStr}_binding`];
-  return {
-    kind: "binding",
-    package: pkg.name,
-    version: pkg.version,
-    name,
-    url
-  };
-}
-
-// src/typeschema/core/nested-types.ts
-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((fs5) => mkNestedTypes(register, fs5, logger)).filter((e) => e !== void 0).flat();
-    for (const nt of nestedTypeGenealogy.reverse()) {
-      nestedTypeOrigins[nt.identifier.name] = nt.identifier.url;
+  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;
   }
-  const nestedName = path.join(".");
-  const url = nestedTypeOrigins[nestedName] ?? `${fhirSchema.url}#${nestedName}`;
-  return {
-    kind: "nested",
-    package: fhirSchema.package_meta.name,
-    version: fhirSchema.package_meta.version,
-    name: nestedName,
-    url
-  };
-}
-function collectNestedElements(fhirSchema, parentPath, elements) {
-  const nested = [];
-  for (const [key, element] of Object.entries(elements)) {
-    const path = [...parentPath, key];
-    if (isNestedElement(element)) {
-      nested.push([path, element]);
+  return grouped;
+};
+var buildDependencyGraph = (schemas) => {
+  const nameToMap = {};
+  for (const schema of schemas) {
+    nameToMap[schema.identifier.name] = schema;
+  }
+  const graph = {};
+  for (const schema of schemas) {
+    const name = schema.identifier.name;
+    const base = schema.base?.name;
+    if (!graph[name]) {
+      graph[name] = [];
     }
-    if (element.elements) {
-      nested.push(...collectNestedElements(fhirSchema, path, element.elements));
+    if (base && nameToMap[base]) {
+      graph[name].push(base);
     }
   }
-  return nested;
-}
-function transformNestedElements(register, fhirSchema, parentPath, elements, logger) {
-  const fields = {};
-  for (const [key, _element] of Object.entries(elements)) {
-    const path = [...parentPath, key];
-    const elemSnapshot = register.resolveElementSnapshot(fhirSchema, path);
-    if (isNestedElement(elemSnapshot)) {
-      fields[key] = mkNestedField(register, fhirSchema, path, elemSnapshot, logger);
-    } else {
-      fields[key] = mkField(register, fhirSchema, path, elemSnapshot, logger);
+  return graph;
+};
+var topologicalSort = (graph) => {
+  const sorted = [];
+  const visited = {};
+  const temp = {};
+  const visit = (node) => {
+    if (temp[node]) {
+      throw new Error(`Graph has cycles ${node}`);
+    }
+    if (!visited[node]) {
+      temp[node] = true;
+      for (const neighbor of graph[node] ?? []) {
+        visit(neighbor);
+      }
+      temp[node] = false;
+      visited[node] = true;
+      sorted.push(node);
+    }
+  };
+  for (const node in graph) {
+    if (!visited[node]) {
+      visit(node);
     }
   }
-  return fields;
-}
-function mkNestedTypes(register, fhirSchema, logger) {
-  if (!fhirSchema.elements) return void 0;
-  const nested = collectNestedElements(fhirSchema, [], fhirSchema.elements).filter(
-    ([_, element]) => element.elements && Object.keys(element.elements).length > 0
-  );
-  const nestedTypes = [];
-  for (const [path, element] of nested) {
-    const identifier = mkNestedIdentifier(register, fhirSchema, path, logger);
-    let baseName;
-    if (element.type === "BackboneElement" || !element.type) {
-      baseName = "BackboneElement";
-    } else {
-      baseName = element.type;
+  return sorted;
+};
+var sortAsDeclarationSequence = (schemas) => {
+  const graph = buildDependencyGraph(schemas);
+  const sorted = topologicalSort(graph);
+  return sorted.map((name) => schemas.find((schema) => schema.identifier.name === name)).filter(Boolean);
+};
+var resourceRelatives = (schemas) => {
+  const regularSchemas = schemas.filter((e) => isResourceTypeSchema(e) || isLogicalTypeSchema(e));
+  const directPairs = [];
+  for (const schema of regularSchemas) {
+    if (schema.base) {
+      directPairs.push({ parent: schema.base, child: schema.identifier });
     }
-    const baseUrl = register.ensureSpecializationCanonicalUrl(baseName);
-    const baseFs = register.resolveFs(fhirSchema.package_meta, baseUrl);
-    if (!baseFs) throw new Error(`Could not resolve base type ${baseName}`);
-    const base = {
-      kind: "complex-type",
-      package: baseFs.package_meta.name,
-      version: baseFs.package_meta.version,
-      name: baseName,
-      url: baseUrl
-    };
-    const fields = transformNestedElements(register, fhirSchema, path, element.elements ?? {}, logger);
-    const nestedType = {
-      identifier,
-      base,
-      fields
-    };
-    nestedTypes.push(nestedType);
   }
-  nestedTypes.sort((a, b) => a.identifier.url.localeCompare(b.identifier.url));
-  return nestedTypes.length === 0 ? void 0 : nestedTypes;
-}
-function extractNestedDependencies(nestedTypes) {
-  const deps = [];
-  for (const nested of nestedTypes) {
-    if (nested.base) {
-      deps.push(nested.base);
+  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));
     }
-    for (const field of Object.values(nested.fields || {})) {
-      if ("type" in field && field.type) {
-        deps.push(field.type);
-      }
-      if ("binding" in field && field.binding) {
-        deps.push(field.binding);
+    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 });
       }
     }
   }
-  return deps;
-}
-
-// src/typeschema/core/field-builder.ts
-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((fs5) => {
-    if (parentPath.length === 0) return fs5.required || [];
-    if (!fs5.elements) return [];
-    let elem = fs5;
-    for (const k of parentPath) {
-      elem = elem?.elements?.[k];
-    }
-    return elem?.required || [];
-  });
-  return new Set(requires).has(fieldName);
-}
-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((fs5) => {
-    if (parentPath.length === 0) return fs5.excluded || [];
-    if (!fs5.elements) return [];
-    let elem = fs5;
-    for (const k of parentPath) {
-      elem = elem?.elements?.[k];
-    }
-    return elem?.excluded || [];
-  });
-  return new Set(requires).has(fieldName);
-}
-var buildReferences = (register, fhirSchema, element) => {
-  if (!element.refers) return void 0;
-  return element.refers.map((ref) => {
-    const curl = register.ensureSpecializationCanonicalUrl(ref);
-    const fs5 = register.resolveFs(fhirSchema.package_meta, curl);
-    if (!fs5) throw new Error(`Failed to resolve fs for ${curl}`);
-    return mkIdentifier(fs5);
-  });
-};
-function buildFieldType(register, fhirSchema, path, element, logger) {
-  if (element.elementReference) {
-    const refPath = element.elementReference.slice(1).filter((_, i) => i % 2 === 1);
-    return mkNestedIdentifier(register, fhirSchema, refPath, logger);
-  } else if (element.type) {
-    const url = register.ensureSpecializationCanonicalUrl(element.type);
-    const fieldFs = register.resolveFs(fhirSchema.package_meta, url);
-    if (!fieldFs)
-      throw new Error(
-        `Could not resolve field type: '${element.type}' (from '${fhirSchema.url}' in '${packageMetaToFhir(fhirSchema.package_meta)}')`
-      );
-    return mkIdentifier(fieldFs);
-  } else if (element.choices) {
-    return void 0;
-  } else if (fhirSchema.derivation === "constraint") {
-    return void 0;
-  } else {
-    logger?.error(
-      `Can't recognize element type '${fhirSchema.url}' (${fhirSchema.derivation}) at '${path.join(".")}': ${JSON.stringify(element, void 0, 2)}`
-    );
-    throw new Error(`Unrecognized element type`);
-  }
-}
-var mkField = (register, fhirSchema, path, element, logger) => {
-  let binding;
-  let enumValues;
-  if (element.binding) {
-    binding = mkBindingIdentifier(fhirSchema, path, element.binding.bindingName);
-    if (element.binding.strength === "required" && element.type === "code") {
-      enumValues = buildEnum(register, fhirSchema, element, logger);
-    }
-  }
-  const fieldType = buildFieldType(register, fhirSchema, path, element, logger);
-  if (!fieldType)
-    logger?.warn(`Field type not found for '${fhirSchema.url}#${path.join(".")}' (${fhirSchema.derivation})`);
-  return {
-    type: fieldType,
-    required: isRequired(register, fhirSchema, path),
-    excluded: isExcluded(register, fhirSchema, path),
-    reference: buildReferences(register, fhirSchema, element),
-    array: element.array || false,
-    min: element.min,
-    max: element.max,
-    choices: element.choices,
-    choiceOf: element.choiceOf,
-    binding,
-    enum: enumValues
-  };
-};
-function isNestedElement(element) {
-  const isBackbone = element.type === "BackboneElement";
-  const isElement = element.type === "Element" && element.elements !== void 0 && Object.keys(element.elements).length > 0;
-  const elementsWithoutType = element.type === void 0 && element.choiceOf === void 0 && element.elements !== void 0 && Object.keys(element.elements).length > 0;
-  return isBackbone || isElement || elementsWithoutType;
-}
-function mkNestedField(register, fhirSchema, path, element, logger) {
-  const nestedIdentifier = mkNestedIdentifier(register, fhirSchema, path, logger);
-  return {
-    type: nestedIdentifier,
-    array: element.array || false,
-    required: isRequired(register, fhirSchema, path),
-    excluded: isExcluded(register, fhirSchema, path)
-  };
-}
-
-// src/typeschema/core/binding.ts
-function extractValueSetConceptsByUrl(register, pkg, valueSetUrl, logger) {
-  const cleanUrl = dropVersionFromUrl(valueSetUrl) || valueSetUrl;
-  const valueSet = register.resolveVs(pkg, cleanUrl);
-  if (!valueSet) return void 0;
-  return extractValueSetConcepts(register, valueSet);
-}
-function extractValueSetConcepts(register, valueSet, _logger) {
-  if (valueSet.expansion?.contains) {
-    return valueSet.expansion.contains.filter((item) => item.code !== void 0).map((item) => {
-      assert2(item.code);
-      return {
-        code: item.code,
-        display: item.display,
-        system: item.system
-      };
-    });
-  }
-  const concepts = [];
-  if (valueSet.compose?.include) {
-    for (const include of valueSet.compose.include) {
-      if (include.concept) {
-        for (const concept of include.concept) {
-          concepts.push({
-            system: include.system,
-            code: concept.code,
-            display: concept.display
-          });
-        }
-      } else if (include.system && !include.filter) {
-        try {
-          const codeSystem = register.resolveAny(include.system);
-          if (codeSystem?.concept) {
-            const extractConcepts = (conceptList, system) => {
-              for (const concept of conceptList) {
-                concepts.push({
-                  system,
-                  code: concept.code,
-                  display: concept.display
-                });
-                if (concept.concept) {
-                  extractConcepts(concept.concept, system);
-                }
-              }
-            };
-            extractConcepts(codeSystem.concept, include.system);
-          }
-        } catch {
-        }
-      }
-    }
-  }
-  return concepts.length > 0 ? concepts : void 0;
-}
-var MAX_ENUM_LENGTH = 100;
-function buildEnum(register, fhirSchema, element, logger) {
-  if (!element.binding) return void 0;
-  const strength = element.binding.strength;
-  const valueSetUrl = element.binding.valueSet;
-  if (!valueSetUrl) return void 0;
-  const shouldGenerateEnum = strength === "required" || strength === "extensible" && (element.type === "code" || element.type === "Coding") || strength === "preferred" && (element.type === "code" || element.type === "Coding");
-  if (!shouldGenerateEnum) return void 0;
-  const concepts = extractValueSetConceptsByUrl(register, fhirSchema.package_meta, valueSetUrl);
-  if (!concepts || concepts.length === 0) return void 0;
-  const codes = concepts.map((c) => c.code).filter((code) => code && typeof code === "string" && code.trim().length > 0);
-  if (codes.length > MAX_ENUM_LENGTH) {
-    logger?.dry_warn(
-      `Value set ${valueSetUrl} has ${codes.length} which is more than ${MAX_ENUM_LENGTH} codes, which may cause issues with code generation.`
-    );
-    return void 0;
-  }
-  return codes.length > 0 ? codes : void 0;
-}
-function generateBindingSchema(register, fhirSchema, path, element, logger) {
-  if (!element.binding?.valueSet) return void 0;
-  const identifier = mkBindingIdentifier(fhirSchema, path, element.binding.bindingName);
-  const fieldType = buildFieldType(register, fhirSchema, path, element, logger);
-  const valueSetIdentifier = mkValueSetIdentifierByUrl(
-    register,
-    fhirSchema.package_meta,
-    element.binding.valueSet
-  );
-  const dependencies = [];
-  if (fieldType) {
-    dependencies.push(fieldType);
-  }
-  dependencies.push(valueSetIdentifier);
-  const enumValues = buildEnum(register, fhirSchema, element, logger);
-  return {
-    identifier,
-    type: fieldType,
-    valueset: valueSetIdentifier,
-    strength: element.binding.strength,
-    enum: enumValues,
-    dependencies
-  };
-}
-function collectBindingSchemas(register, fhirSchema, logger) {
-  const processedPaths = /* @__PURE__ */ new Set();
-  if (!fhirSchema.elements) return [];
-  const bindings = [];
-  function collectBindings(elements, parentPath) {
-    for (const [key, element] of Object.entries(elements)) {
-      const path = [...parentPath, key];
-      const pathKey = path.join(".");
-      if (processedPaths.has(pathKey)) continue;
-      processedPaths.add(pathKey);
-      if (element.binding) {
-        const binding = generateBindingSchema(register, fhirSchema, path, element, logger);
-        if (binding) {
-          bindings.push(binding);
-        }
-      }
-      if (element.elements) {
-        collectBindings(element.elements, path);
-      }
-    }
-  }
-  collectBindings(fhirSchema.elements, []);
-  bindings.sort((a, b) => a.identifier.name.localeCompare(b.identifier.name));
-  const uniqueBindings = [];
-  const seenUrls = /* @__PURE__ */ new Set();
-  for (const binding of bindings) {
-    if (!seenUrls.has(binding.identifier.url)) {
-      seenUrls.add(binding.identifier.url);
-      uniqueBindings.push(binding);
-    }
-  }
-  return uniqueBindings;
-}
-
-// src/typeschema/core/transformer.ts
-function mkFields(register, fhirSchema, parentPath, elements, logger) {
-  if (!elements) return void 0;
-  const fields = {};
-  for (const key of register.getAllElementKeys(elements)) {
-    const path = [...parentPath, key];
-    const elemSnapshot = register.resolveElementSnapshot(fhirSchema, path);
-    if (isNestedElement(elemSnapshot)) {
-      fields[key] = mkNestedField(register, fhirSchema, path, elemSnapshot, logger);
-    } else {
-      fields[key] = mkField(register, fhirSchema, path, elemSnapshot, logger);
-    }
-  }
-  return fields;
-}
-function extractFieldDependencies(fields) {
-  const deps = [];
-  for (const field of Object.values(fields)) {
-    if ("type" in field && field.type) {
-      deps.push(field.type);
-    }
-    if ("binding" in field && field.binding) {
-      deps.push(field.binding);
-    }
-  }
-  return deps;
-}
-function isExtensionSchema(fhirSchema, _identifier) {
-  if (fhirSchema.base === "Extension" || fhirSchema.base === "http://hl7.org/fhir/StructureDefinition/Extension") {
-    return true;
-  }
-  if (fhirSchema.url?.includes("/extension/") || fhirSchema.url?.includes("-extension")) {
-    return true;
-  }
-  if (fhirSchema.name?.toLowerCase().includes("extension")) {
-    return true;
-  }
-  if (fhirSchema.type === "Extension") {
-    return true;
-  }
-  return false;
-}
-async function transformValueSet(register, valueSet, logger) {
-  if (!valueSet.url) throw new Error("ValueSet URL is required");
-  const identifier = mkValueSetIdentifierByUrl(register, valueSet.package_meta, valueSet.url);
-  const concept = extractValueSetConceptsByUrl(register, valueSet.package_meta, valueSet.url);
-  return {
-    identifier,
-    description: valueSet.description,
-    concept,
-    compose: !concept ? valueSet.compose : void 0
-  };
-}
-function extractDependencies(identifier, base, fields, nestedTypes) {
-  const deps = [];
-  if (base) deps.push(base);
-  if (fields) deps.push(...extractFieldDependencies(fields));
-  if (nestedTypes) deps.push(...extractNestedDependencies(nestedTypes));
-  const uniqDeps = {};
-  for (const dep of deps) {
-    if (dep.url === identifier.url) continue;
-    uniqDeps[dep.url] = dep;
-  }
-  const localNestedTypeUrls = new Set(nestedTypes?.map((nt) => nt.identifier.url));
-  const result = Object.values(uniqDeps).filter((e) => {
-    if (isProfileIdentifier(identifier)) return true;
-    if (!isNestedIdentifier(e)) return true;
-    return !localNestedTypeUrls.has(e.url);
-  }).sort((a, b) => a.url.localeCompare(b.url));
-  return result.length > 0 ? result : void 0;
-}
-function transformFhirSchemaResource(register, fhirSchema, logger) {
-  const identifier = mkIdentifier(fhirSchema);
-  let base;
-  if (fhirSchema.base && fhirSchema.type !== "Element") {
-    const baseFs = register.resolveFs(
-      fhirSchema.package_meta,
-      register.ensureSpecializationCanonicalUrl(fhirSchema.base)
-    );
-    if (!baseFs) {
-      throw new Error(
-        `Base resource not found '${fhirSchema.base}' for <${fhirSchema.url}> from ${packageMetaToFhir(fhirSchema.package_meta)}`
-      );
-    }
-    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/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 [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 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];
-    }
-  }
-  schema.dependencies = extractDependencies(schema.identifier, schema.base, schema.fields, schema.nested);
-  return schema;
-};
-var treeShake = (tsIndex, treeShake2, { resolutionTree, logger }) => {
-  const focusedSchemas = [];
-  for (const [pkgId, requires] of Object.entries(treeShake2)) {
-    for (const [url, rule] of Object.entries(requires)) {
-      const schema = tsIndex.resolveByUrl(pkgId, url);
-      if (!schema) throw new Error(`Schema not found for ${pkgId} ${url}`);
-      const shaked2 = treeShakeTypeSchema(schema, rule);
-      focusedSchemas.push(shaked2);
-    }
-  }
-  const collectDeps = (schemas, acc) => {
-    if (schemas.length === 0) return Object.values(acc);
-    for (const schema of schemas) {
-      acc[JSON.stringify(schema.identifier)] = schema;
-    }
-    const newSchemas = [];
-    for (const schema of schemas) {
-      if (isSpecializationTypeSchema(schema)) {
-        if (!schema.dependencies) continue;
-        schema.dependencies.forEach((dep) => {
-          const depSchema = tsIndex.resolve(dep);
-          if (!depSchema) throw new Error(`Schema not found for ${dep}`);
-          const id = JSON.stringify(depSchema.identifier);
-          if (!acc[id]) newSchemas.push(depSchema);
-        });
-        if (schema.nested) {
-          for (const nest of schema.nested) {
-            if (isNestedIdentifier(nest.identifier)) continue;
-            const id = JSON.stringify(nest.identifier);
-            if (!acc[id]) newSchemas.push(nest);
-          }
-        }
-      }
-    }
-    return collectDeps(newSchemas, acc);
-  };
-  const shaked = collectDeps(focusedSchemas, {});
-  return mkTypeSchemaIndex(shaked, { resolutionTree, logger });
-};
-var buildDependencyGraph = (schemas) => {
-  const nameToMap = {};
-  for (const schema of schemas) {
-    nameToMap[schema.identifier.name] = schema;
-  }
-  const graph = {};
-  for (const schema of schemas) {
-    const name = schema.identifier.name;
-    const base = schema.base?.name;
-    if (!graph[name]) {
-      graph[name] = [];
-    }
-    if (base && nameToMap[base]) {
-      graph[name].push(base);
-    }
-  }
-  return graph;
-};
-var topologicalSort = (graph) => {
-  const sorted = [];
-  const visited = {};
-  const temp = {};
-  const visit = (node) => {
-    if (temp[node]) {
-      throw new Error(`Graph has cycles ${node}`);
-    }
-    if (!visited[node]) {
-      temp[node] = true;
-      for (const neighbor of graph[node] ?? []) {
-        visit(neighbor);
-      }
-      temp[node] = false;
-      visited[node] = true;
-      sorted.push(node);
-    }
-  };
-  for (const node in graph) {
-    if (!visited[node]) {
-      visit(node);
-    }
-  }
-  return sorted;
-};
-var sortAsDeclarationSequence = (schemas) => {
-  const graph = buildDependencyGraph(schemas);
-  const sorted = topologicalSort(graph);
-  return sorted.map((name) => schemas.find((schema) => schema.identifier.name === name)).filter(Boolean);
-};
-var resourceRelatives = (schemas) => {
-  const regularSchemas = schemas.filter((e) => isResourceTypeSchema(e) || isLogicalTypeSchema(e));
-  const directPairs = [];
-  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];
-  };
-  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 }) => {
-  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;
+  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;
   };
@@ -1804,7 +1242,7 @@ var Python = class extends Writer {
     return names;
   }
   shouldImportResourceFamily(resource) {
-    assert2(this.tsIndex !== void 0);
+    assert3(this.tsIndex !== void 0);
     return resource.identifier.kind === "resource" && this.tsIndex.resourceChildren(resource.identifier).length > 0;
   }
   generateExportsDeclaration(packageComplexTypes, allResourceNames) {
@@ -1839,244 +1277,757 @@ var Python = class extends Writer {
     });
     this.line();
   }
-  getSuperClasses(schema) {
-    return [...schema.base ? [schema.base.name] : [], ...injectSuperClasses(schema.identifier.name)];
+  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(", ")}]`);
   }
-  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);
-    }
+  buildPyPackageName(packageName) {
+    const parts = packageName ? [snakeCase(packageName)] : [""];
+    return parts.join(".");
   }
-  generateModelConfig() {
-    const extraMode = this.opts.allowExtraFields ? "allow" : "forbid";
-    this.line(`model_config = ConfigDict(validate_by_name=True, serialize_by_alias=True, extra="${extraMode}")`);
+  pyFhirPackage(identifier) {
+    return this.pyFhirPackageByName(identifier.package);
   }
-  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(")");
+  pyFhirPackageByName(name) {
+    return [this.opts.rootPackageName, this.buildPyPackageName(name)].join(".");
   }
-  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}`);
+  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);
   }
-  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
-    };
+  getFieldFormatFunction(format) {
+    if (!AVAILABLE_STRING_FORMATS[format]) {
+      this.logger()?.warn(`Unknown field format '${format}'. Defaulting to SnakeCase.`);
+      this.logger()?.warn(`Supported formats: ${Object.keys(AVAILABLE_STRING_FORMATS).join(", ")}`);
+      return snakeCase;
+    }
+    return AVAILABLE_STRING_FORMATS[format];
   }
-  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}]`;
+};
+
+// src/typeschema/core/identifier.ts
+function dropVersionFromUrl(url) {
+  const baseUrl = url.split("|")[0];
+  return baseUrl ? baseUrl : url;
+}
+function getVersionFromUrl(url) {
+  const version = url.split("|")[1];
+  return version;
+}
+function determineKind(fhirSchema) {
+  if (fhirSchema.derivation === "constraint") return "profile";
+  if (fhirSchema.kind === "primitive-type") return "primitive-type";
+  if (fhirSchema.kind === "complex-type") return "complex-type";
+  if (fhirSchema.kind === "resource") return "resource";
+  if (fhirSchema.kind === "logical") return "logical";
+  return "resource";
+}
+function mkIdentifier(fhirSchema) {
+  return {
+    kind: determineKind(fhirSchema),
+    package: fhirSchema.package_meta.name,
+    version: fhirSchema.package_meta.version,
+    name: fhirSchema.name,
+    url: fhirSchema.url
+  };
+}
+var getValueSetName = (url) => {
+  const urlParts = url.split("/");
+  const lastSegment = urlParts[urlParts.length - 1];
+  if (lastSegment && lastSegment.length > 0) {
+    return lastSegment.split(/[-_]/).map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase()).join("");
+  }
+  return url;
+};
+function mkValueSetIdentifierByUrl(register, pkg, fullValueSetUrl) {
+  const valueSetUrl = dropVersionFromUrl(fullValueSetUrl);
+  const valueSetNameFallback = getValueSetName(valueSetUrl);
+  const valuesSetFallback = {
+    package_meta: {
+      name: "missing_valuesets",
+      version: getVersionFromUrl(valueSetUrl) || "0.0.0"
+    },
+    id: fullValueSetUrl};
+  const valueSet = register.resolveVs(pkg, valueSetUrl) || valuesSetFallback;
+  const valueSetName = valueSet?.id && !/^[a-zA-Z0-9_-]{20,}$/.test(valueSet.id) ? valueSet.id : valueSetNameFallback;
+  return {
+    kind: "value-set",
+    package: valueSet.package_meta.name,
+    version: valueSet.package_meta.version,
+    name: valueSetName,
+    url: valueSetUrl
+  };
+}
+function mkBindingIdentifier(fhirSchema, path, bindingName) {
+  const pathStr = path.join(".");
+  const [pkg, name, url] = bindingName ? [{ name: "shared", version: "1.0.0" }, bindingName, `urn:fhir:binding:${bindingName}`] : [fhirSchema.package_meta, `${fhirSchema.name}.${pathStr}_binding`, `${fhirSchema.url}#${pathStr}_binding`];
+  return {
+    kind: "binding",
+    package: pkg.name,
+    version: pkg.version,
+    name,
+    url
+  };
+}
+
+// src/typeschema/core/nested-types.ts
+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((fs5) => mkNestedTypes(register, fs5, logger)).filter((e) => e !== void 0).flat();
+    for (const nt of nestedTypeGenealogy.reverse()) {
+      nestedTypeOrigins[nt.identifier.name] = nt.identifier.url;
     }
-    if (field.array) {
-      fieldType = `PyList[${fieldType}]`;
+  }
+  const nestedName = path.join(".");
+  const url = nestedTypeOrigins[nestedName] ?? `${fhirSchema.url}#${nestedName}`;
+  return {
+    kind: "nested",
+    package: fhirSchema.package_meta.name,
+    version: fhirSchema.package_meta.version,
+    name: nestedName,
+    url
+  };
+}
+function collectNestedElements(fhirSchema, parentPath, elements) {
+  const nested = [];
+  for (const [key, element] of Object.entries(elements)) {
+    const path = [...parentPath, key];
+    if (isNestedElement(element)) {
+      nested.push([path, element]);
     }
-    if (!field.required) {
-      fieldType = `${fieldType} | None`;
+    if (element.elements) {
+      nested.push(...collectNestedElements(fhirSchema, path, element.elements));
     }
-    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 nested;
+}
+function transformNestedElements(register, fhirSchema, parentPath, elements, logger) {
+  const fields = {};
+  for (const [key, _element] of Object.entries(elements)) {
+    const path = [...parentPath, key];
+    const elemSnapshot = register.resolveElementSnapshot(fhirSchema, path);
+    if (isNestedElement(elemSnapshot)) {
+      fields[key] = mkNestedField(register, fhirSchema, path, elemSnapshot, logger);
+    } else {
+      fields[key] = mkField(register, fhirSchema, path, elemSnapshot, logger);
     }
-    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)");
+  return fields;
+}
+function mkNestedTypes(register, fhirSchema, logger) {
+  if (!fhirSchema.elements) return void 0;
+  const nested = collectNestedElements(fhirSchema, [], fhirSchema.elements).filter(
+    ([_, element]) => element.elements && Object.keys(element.elements).length > 0
+  );
+  const nestedTypes = [];
+  for (const [path, element] of nested) {
+    const identifier = mkNestedIdentifier(register, fhirSchema, path, logger);
+    let baseName;
+    if (element.type === "BackboneElement" || !element.type) {
+      baseName = "BackboneElement";
+    } else {
+      baseName = element.type;
+    }
+    const baseUrl = register.ensureSpecializationCanonicalUrl(baseName);
+    const baseFs = register.resolveFs(fhirSchema.package_meta, baseUrl);
+    if (!baseFs) throw new Error(`Could not resolve base type ${baseName}`);
+    const base = {
+      kind: "complex-type",
+      package: baseFs.package_meta.name,
+      version: baseFs.package_meta.version,
+      name: baseName,
+      url: baseUrl
+    };
+    const fields = transformNestedElements(register, fhirSchema, path, element.elements ?? {}, logger);
+    const nestedType = {
+      identifier,
+      base,
+      fields
+    };
+    nestedTypes.push(nestedType);
   }
-  generateNestedTypes(schema) {
-    if (!schema.nested) return;
-    this.line();
-    for (const subtype of schema.nested) {
-      this.generateType(subtype);
+  nestedTypes.sort((a, b) => a.identifier.url.localeCompare(b.identifier.url));
+  return nestedTypes.length === 0 ? void 0 : nestedTypes;
+}
+function extractNestedDependencies(nestedTypes) {
+  const deps = [];
+  for (const nested of nestedTypes) {
+    if (nested.base) {
+      deps.push(nested.base);
+    }
+    for (const field of Object.values(nested.fields || {})) {
+      if ("type" in field && field.type) {
+        deps.push(field.type);
+      }
+      if ("binding" in field && field.binding) {
+        deps.push(field.binding);
+      }
     }
   }
-  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());
+  return deps;
+}
+
+// src/typeschema/core/field-builder.ts
+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((fs5) => {
+    if (parentPath.length === 0) return fs5.required || [];
+    if (!fs5.elements) return [];
+    let elem = fs5;
+    for (const k of parentPath) {
+      elem = elem?.elements?.[k];
+    }
+    return elem?.required || [];
+  });
+  return new Set(requires).has(fieldName);
+}
+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((fs5) => {
+    if (parentPath.length === 0) return fs5.excluded || [];
+    if (!fs5.elements) return [];
+    let elem = fs5;
+    for (const k of parentPath) {
+      elem = elem?.elements?.[k];
     }
+    return elem?.excluded || [];
+  });
+  return new Set(requires).has(fieldName);
+}
+var buildReferences = (register, fhirSchema, element) => {
+  if (!element.refers) return void 0;
+  return element.refers.map((ref) => {
+    const curl = register.ensureSpecializationCanonicalUrl(ref);
+    const fs5 = register.resolveFs(fhirSchema.package_meta, curl);
+    if (!fs5) throw new Error(`Failed to resolve fs for ${curl}`);
+    return mkIdentifier(fs5);
+  });
+};
+function buildFieldType(register, fhirSchema, path, element, logger) {
+  if (element.elementReference) {
+    const refPath = element.elementReference.slice(1).filter((_, i) => i % 2 === 1);
+    return mkNestedIdentifier(register, fhirSchema, refPath, logger);
+  } else if (element.type) {
+    const url = register.ensureSpecializationCanonicalUrl(element.type);
+    const fieldFs = register.resolveFs(fhirSchema.package_meta, url);
+    if (!fieldFs)
+      throw new Error(
+        `Could not resolve field type: '${element.type}' (from '${fhirSchema.url}' in '${packageMetaToFhir(fhirSchema.package_meta)}')`
+      );
+    return mkIdentifier(fieldFs);
+  } else if (element.choices) {
+    return void 0;
+  } else if (fhirSchema.derivation === "constraint") {
+    return void 0;
+  } else {
+    logger?.error(
+      `Can't recognize element type '${fhirSchema.url}' (${fhirSchema.derivation}) at '${path.join(".")}': ${JSON.stringify(element, void 0, 2)}`
+    );
+    throw new Error(`Unrecognized element type`);
   }
-  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);
+}
+var mkField = (register, fhirSchema, path, element, logger) => {
+  let binding;
+  let enumValues;
+  if (element.binding) {
+    binding = mkBindingIdentifier(fhirSchema, path, element.binding.bindingName);
+    if (element.binding.strength === "required" && element.type === "code") {
+      enumValues = buildEnum(register, fhirSchema, element, logger);
     }
   }
-  groupDependenciesByPackage(dependencies) {
-    const grouped = {};
-    for (const dep of dependencies) {
-      const pyPackage = this.pyPackage(dep);
-      if (!grouped[pyPackage]) {
-        grouped[pyPackage] = [];
+  const fieldType = buildFieldType(register, fhirSchema, path, element, logger);
+  if (!fieldType)
+    logger?.warn(`Field type not found for '${fhirSchema.url}#${path.join(".")}' (${fhirSchema.derivation})`);
+  return {
+    type: fieldType,
+    required: isRequired(register, fhirSchema, path),
+    excluded: isExcluded(register, fhirSchema, path),
+    reference: buildReferences(register, fhirSchema, element),
+    array: element.array || false,
+    min: element.min,
+    max: element.max,
+    choices: element.choices,
+    choiceOf: element.choiceOf,
+    binding,
+    enum: enumValues
+  };
+};
+function isNestedElement(element) {
+  const isBackbone = element.type === "BackboneElement";
+  const isElement = element.type === "Element" && element.elements !== void 0 && Object.keys(element.elements).length > 0;
+  const elementsWithoutType = element.type === void 0 && element.choiceOf === void 0 && element.elements !== void 0 && Object.keys(element.elements).length > 0;
+  return isBackbone || isElement || elementsWithoutType;
+}
+function mkNestedField(register, fhirSchema, path, element, logger) {
+  const nestedIdentifier = mkNestedIdentifier(register, fhirSchema, path, logger);
+  return {
+    type: nestedIdentifier,
+    array: element.array || false,
+    required: isRequired(register, fhirSchema, path),
+    excluded: isExcluded(register, fhirSchema, path)
+  };
+}
+
+// src/typeschema/core/binding.ts
+function extractValueSetConceptsByUrl(register, pkg, valueSetUrl, logger) {
+  const cleanUrl = dropVersionFromUrl(valueSetUrl) || valueSetUrl;
+  const valueSet = register.resolveVs(pkg, cleanUrl);
+  if (!valueSet) return void 0;
+  return extractValueSetConcepts(register, valueSet);
+}
+function extractValueSetConcepts(register, valueSet, _logger) {
+  if (valueSet.expansion?.contains) {
+    return valueSet.expansion.contains.filter((item) => item.code !== void 0).map((item) => {
+      assert3(item.code);
+      return {
+        code: item.code,
+        display: item.display,
+        system: item.system
+      };
+    });
+  }
+  const concepts = [];
+  if (valueSet.compose?.include) {
+    for (const include of valueSet.compose.include) {
+      if (include.concept) {
+        for (const concept of include.concept) {
+          concepts.push({
+            system: include.system,
+            code: concept.code,
+            display: concept.display
+          });
+        }
+      } else if (include.system && !include.filter) {
+        try {
+          const codeSystem = register.resolveAny(include.system);
+          if (codeSystem?.concept) {
+            const extractConcepts = (conceptList, system) => {
+              for (const concept of conceptList) {
+                concepts.push({
+                  system,
+                  code: concept.code,
+                  display: concept.display
+                });
+                if (concept.concept) {
+                  extractConcepts(concept.concept, system);
+                }
+              }
+            };
+            extractConcepts(codeSystem.concept, include.system);
+          }
+        } catch {
+        }
       }
-      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);
-    }
+  return concepts.length > 0 ? concepts : void 0;
+}
+var MAX_ENUM_LENGTH = 100;
+function buildEnum(register, fhirSchema, element, logger) {
+  if (!element.binding) return void 0;
+  const strength = element.binding.strength;
+  const valueSetUrl = element.binding.valueSet;
+  if (!valueSetUrl) return void 0;
+  const shouldGenerateEnum = strength === "required" || strength === "extensible" && (element.type === "code" || element.type === "Coding") || strength === "preferred" && (element.type === "code" || element.type === "Coding");
+  if (!shouldGenerateEnum) return void 0;
+  const concepts = extractValueSetConceptsByUrl(register, fhirSchema.package_meta, valueSetUrl);
+  if (!concepts || concepts.length === 0) return void 0;
+  const codes = concepts.map((c) => c.code).filter((code) => code && typeof code === "string" && code.trim().length > 0);
+  if (codes.length > MAX_ENUM_LENGTH) {
+    logger?.dry_warn(
+      `Value set ${valueSetUrl} has ${codes.length} which is more than ${MAX_ENUM_LENGTH} codes, which may cause issues with code generation.`
+    );
+    return void 0;
   }
-  shouldUseSingleLineImport(oneLine, entities) {
-    return oneLine.length <= MAX_IMPORT_LINE_LENGTH || entities.length === 1;
+  return codes.length > 0 ? codes : void 0;
+}
+function generateBindingSchema(register, fhirSchema, path, element, logger) {
+  if (!element.binding?.valueSet) return void 0;
+  const identifier = mkBindingIdentifier(fhirSchema, path, element.binding.bindingName);
+  const fieldType = buildFieldType(register, fhirSchema, path, element, logger);
+  const valueSetIdentifier = mkValueSetIdentifierByUrl(
+    register,
+    fhirSchema.package_meta,
+    element.binding.valueSet
+  );
+  const dependencies = [];
+  if (fieldType) {
+    dependencies.push(fieldType);
   }
-  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);
+  dependencies.push(valueSetIdentifier);
+  const enumValues = buildEnum(register, fhirSchema, element, logger);
+  return {
+    identifier,
+    type: fieldType,
+    valueset: valueSetIdentifier,
+    strength: element.binding.strength,
+    enum: enumValues,
+    dependencies
+  };
+}
+function collectBindingSchemas(register, fhirSchema, logger) {
+  const processedPaths = /* @__PURE__ */ new Set();
+  if (!fhirSchema.elements) return [];
+  const bindings = [];
+  function collectBindings(elements, parentPath) {
+    for (const [key, element] of Object.entries(elements)) {
+      const path = [...parentPath, key];
+      const pathKey = path.join(".");
+      if (processedPaths.has(pathKey)) continue;
+      processedPaths.add(pathKey);
+      if (element.binding) {
+        const binding = generateBindingSchema(register, fhirSchema, path, element, logger);
+        if (binding) {
+          bindings.push(binding);
+        }
       }
-    });
-    this.line(")");
-  }
-  pyImportType(identifier) {
-    this.pyImportFrom(this.pyPackage(identifier), pascalCase(identifier.name));
-  }
-  generateResourceFamilies(packageResources) {
-    assert2(this.tsIndex !== void 0);
-    const packages = (
-      //this.helper.getPackages(packageResources, this.opts.rootPackageName);
-      Object.keys(groupByPackages(packageResources)).map(
-        (pkgName) => `${this.opts.rootPackageName}.${pkgName.replaceAll(".", "_")}`
-      )
-    );
-    const families = {};
-    for (const resource of this.tsIndex.collectResources()) {
-      const children = this.tsIndex.resourceChildren(resource.identifier).map((c) => c.name);
-      if (children.length > 0) {
-        const familyName = `${resource.identifier.name}Family`;
-        families[familyName] = children;
+      if (element.elements) {
+        collectBindings(element.elements, path);
       }
     }
-    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);
-    });
+  collectBindings(fhirSchema.elements, []);
+  bindings.sort((a, b) => a.identifier.name.localeCompare(b.identifier.name));
+  const uniqueBindings = [];
+  const seenUrls = /* @__PURE__ */ new Set();
+  for (const binding of bindings) {
+    if (!seenUrls.has(binding.identifier.url)) {
+      seenUrls.add(binding.identifier.url);
+      uniqueBindings.push(binding);
+    }
   }
-  includeResourceFamilyValidator() {
-    const content = fs__default.readFileSync(resolvePyAssets("resource_family_validator.py"), "utf-8");
-    this.line(content);
+  return uniqueBindings;
+}
+
+// src/typeschema/core/transformer.ts
+function mkFields(register, fhirSchema, parentPath, elements, logger) {
+  if (!elements) return void 0;
+  const fields = {};
+  for (const key of register.getAllElementKeys(elements)) {
+    const path = [...parentPath, key];
+    const elemSnapshot = register.resolveElementSnapshot(fhirSchema, path);
+    if (isNestedElement(elemSnapshot)) {
+      fields[key] = mkNestedField(register, fhirSchema, path, elemSnapshot, logger);
+    } else {
+      fields[key] = mkField(register, fhirSchema, path, elemSnapshot, logger);
+    }
   }
-  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);
+  return fields;
+}
+function extractFieldDependencies(fields) {
+  const deps = [];
+  for (const field of Object.values(fields)) {
+    if ("type" in field && field.type) {
+      deps.push(field.type);
+    }
+    if ("binding" in field && field.binding) {
+      deps.push(field.binding);
     }
   }
-  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();
+  return deps;
+}
+function isExtensionSchema(fhirSchema, _identifier) {
+  if (fhirSchema.base === "Extension" || fhirSchema.base === "http://hl7.org/fhir/StructureDefinition/Extension") {
+    return true;
   }
-  generateFamilyExports(exportList) {
-    this.line(`__all__ = [${exportList.map((e) => `'${e}'`).join(", ")}]`);
+  if (fhirSchema.url?.includes("/extension/") || fhirSchema.url?.includes("-extension")) {
+    return true;
   }
-  buildPyPackageName(packageName) {
-    const parts = packageName ? [snakeCase(packageName)] : [""];
-    return parts.join(".");
+  if (fhirSchema.name?.toLowerCase().includes("extension")) {
+    return true;
   }
-  pyFhirPackage(identifier) {
-    return this.pyFhirPackageByName(identifier.package);
+  if (fhirSchema.type === "Extension") {
+    return true;
   }
-  pyFhirPackageByName(name) {
-    return [this.opts.rootPackageName, this.buildPyPackageName(name)].join(".");
+  return false;
+}
+async function transformValueSet(register, valueSet, logger) {
+  if (!valueSet.url) throw new Error("ValueSet URL is required");
+  const identifier = mkValueSetIdentifierByUrl(register, valueSet.package_meta, valueSet.url);
+  const concept = extractValueSetConceptsByUrl(register, valueSet.package_meta, valueSet.url);
+  return {
+    identifier,
+    description: valueSet.description,
+    concept,
+    compose: !concept ? valueSet.compose : void 0
+  };
+}
+function extractDependencies(identifier, base, fields, nestedTypes) {
+  const deps = [];
+  if (base) deps.push(base);
+  if (fields) deps.push(...extractFieldDependencies(fields));
+  if (nestedTypes) deps.push(...extractNestedDependencies(nestedTypes));
+  const uniqDeps = {};
+  for (const dep of deps) {
+    if (dep.url === identifier.url) continue;
+    uniqDeps[dep.url] = dep;
   }
-  pyPackage(identifier) {
-    if (identifier.kind === "complex-type") {
-      return `${this.pyFhirPackage(identifier)}.base`;
-    }
-    if (identifier.kind === "resource") {
-      return [this.pyFhirPackage(identifier), snakeCase(identifier.name)].join(".");
+  const localNestedTypeUrls = new Set(nestedTypes?.map((nt) => nt.identifier.url));
+  const result = Object.values(uniqDeps).filter((e) => {
+    if (isProfileIdentifier(identifier)) return true;
+    if (!isNestedIdentifier(e)) return true;
+    return !localNestedTypeUrls.has(e.url);
+  }).sort((a, b) => a.url.localeCompare(b.url));
+  return result.length > 0 ? result : void 0;
+}
+function transformFhirSchemaResource(register, fhirSchema, logger) {
+  const identifier = mkIdentifier(fhirSchema);
+  let base;
+  if (fhirSchema.base && fhirSchema.type !== "Element") {
+    const baseFs = register.resolveFs(
+      fhirSchema.package_meta,
+      register.ensureSpecializationCanonicalUrl(fhirSchema.base)
+    );
+    if (!baseFs) {
+      throw new Error(
+        `Base resource not found '${fhirSchema.base}' for <${fhirSchema.url}> from ${packageMetaToFhir(fhirSchema.package_meta)}`
+      );
     }
-    return this.pyFhirPackage(identifier);
+    base = mkIdentifier(baseFs);
   }
-  getFieldFormatFunction(format) {
-    if (!AVAILABLE_STRING_FORMATS[format]) {
-      this.logger()?.warn(`Unknown field format '${format}'. Defaulting to SnakeCase.`);
-      this.logger()?.warn(`Supported formats: ${Object.keys(AVAILABLE_STRING_FORMATS).join(", ")}`);
-      return snakeCase;
-    }
-    return AVAILABLE_STRING_FORMATS[format];
+  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) => {
@@ -2305,6 +2256,131 @@ var generateTypeSchemas = async (register, logger) => {
   }
   return fhirSchemas;
 };
+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;
+    }
+  }
+  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 };
+  }
+  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];
+    }
+  }
+};
+var treeShakeTypeSchema = (schema, rule, _logger) => {
+  schema = structuredClone(schema);
+  if (isPrimitiveTypeSchema(schema) || isValueSetTypeSchema(schema) || isBindingSchema(schema)) return schema;
+  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;
+};
+var treeShake = (tsIndex, treeShake2, { resolutionTree, logger }) => {
+  const focusedSchemas = [];
+  for (const [pkgId, requires] of Object.entries(treeShake2)) {
+    for (const [url, rule] of Object.entries(requires)) {
+      const schema = tsIndex.resolveByUrl(pkgId, url);
+      if (!schema) throw new Error(`Schema not found for ${pkgId} ${url}`);
+      const shaked2 = treeShakeTypeSchema(schema, rule);
+      focusedSchemas.push(shaked2);
+    }
+  }
+  const collectDeps = (schemas, acc) => {
+    if (schemas.length === 0) return Object.values(acc);
+    for (const schema of schemas) {
+      acc[JSON.stringify(schema.identifier)] = schema;
+    }
+    const newSchemas = [];
+    for (const schema of schemas) {
+      if (isSpecializationTypeSchema(schema)) {
+        if (!schema.dependencies) continue;
+        schema.dependencies.forEach((dep) => {
+          const depSchema = tsIndex.resolve(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);
+        });
+        if (schema.nested) {
+          for (const nest of schema.nested) {
+            if (isNestedIdentifier(nest.identifier)) continue;
+            const id = JSON.stringify(nest.identifier);
+            if (!acc[id]) newSchemas.push(nest);
+          }
+        }
+      }
+    }
+    return collectDeps(newSchemas, acc);
+  };
+  const shaked = collectDeps(focusedSchemas, {});
+  return mkTypeSchemaIndex(shaked, { resolutionTree, logger });
+};
 
 // src/api/writer-generator/typescript.ts
 var primitiveType2tsType = {