@atomic-ehr/codegen 0.0.9 → 0.0.10-canary.20260330084405.5054c4a

package/dist/index.js

@@ -1,5 +1,5 @@
 import pc from 'picocolors';
-import assert3 from 'assert';
+import assert4 from 'assert';
 import * as fs from 'fs';
 import fs__default from 'fs';
 import * as Path5 from 'path';
@@ -138,9 +138,6 @@ var uppercaseFirstLetter = (str) => {
 var uppercaseFirstLetterOfEach = (strings) => {
   return strings.map((str) => uppercaseFirstLetter(str));
 };
-var typeSchemaInfo = (schema) => {
-  return `<${schema.identifier.url}> from ${schema.identifier.package}#${schema.identifier.version}`;
-};
 var FileSystemWriter = class {
   opts;
   currentDir;
@@ -362,8 +359,11 @@ var hashSchema = (schema) => {
   return createHash("sha256").update(json).digest("hex").slice(0, 16);
 };
 var enrichFHIRSchema = (schema, packageMeta2) => {
+  const derivation = schema.derivation === "constraint" ? "constraint" : "specialization";
   return {
     ...schema,
+    derivation,
+    kind: schema.kind,
     package_meta: schema.package_meta || packageMeta2,
     name: schema.name,
     url: schema.url,
@@ -382,15 +382,15 @@ var isPrimitiveIdentifier = (id) => {
 var isNestedIdentifier = (id) => {
   return id?.kind === "nested";
 };
-var isProfileIdentifier = (id) => {
-  return id?.kind === "profile";
-};
 var concatIdentifiers = (...sources) => {
   const entries = sources.filter((s) => s !== void 0).flatMap((s) => s.map((id) => [id.url, id]));
   if (entries.length === 0) return void 0;
   const deduped = Object.values(Object.fromEntries(entries));
   return deduped.sort((a, b) => a.url.localeCompare(b.url));
 };
+var isNestedTypeSchema = (schema) => {
+  return schema !== void 0 && isNestedIdentifier(schema.identifier);
+};
 var isSpecializationTypeSchema = (schema) => {
   return schema?.identifier.kind === "resource" || schema?.identifier.kind === "complex-type" || schema?.identifier.kind === "logical";
 };
@@ -409,12 +409,17 @@ var isLogicalTypeSchema = (schema) => {
 var isProfileTypeSchema = (schema) => {
   return schema?.identifier.kind === "profile";
 };
-function isBindingSchema(schema) {
+var isBindingSchema = (schema) => {
   return schema?.identifier.kind === "binding";
-}
-function isValueSetTypeSchema(schema) {
+};
+var isValueSetTypeSchema = (schema) => {
   return schema?.identifier.kind === "value-set";
-}
+};
+var extractExtensionDeps = (ext) => [
+  ...ext.valueFieldTypes ?? [],
+  ...ext.profile ? [ext.profile] : [],
+  ...ext.subExtensions?.flatMap((sub) => sub.valueFieldType ? [sub.valueFieldType] : []) ?? []
+];
 var isNotChoiceDeclarationField = (field) => {
   if (!field) return false;
   return field.choices === void 0;
@@ -832,51 +837,36 @@ var sortAsDeclarationSequence = (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 = [];
-  const childrenByParent = /* @__PURE__ */ new Map();
-  for (const schema of regularSchemas) {
-    if (schema.base) {
-      directPairs.push({ parent: schema.base, child: schema.identifier });
-      const parentName = schema.base.name;
-      let children = childrenByParent.get(parentName);
-      if (!children) {
-        children = [];
-        childrenByParent.set(parentName, children);
-      }
-      children.push(schema.identifier);
-    }
-  }
-  const transitiveCache = /* @__PURE__ */ new Map();
-  const getTransitiveChildren = (parentName) => {
-    const cached = transitiveCache.get(parentName);
-    if (cached) return cached;
-    const directChildren = childrenByParent.get(parentName) ?? [];
-    const result = [...directChildren];
-    for (const child of directChildren) {
-      result.push(...getTransitiveChildren(child.name));
-    }
-    transitiveCache.set(parentName, result);
+var populateTypeFamily = (schemas) => {
+  const directChildrenByParent = {};
+  for (const schema of schemas) {
+    if (!isSpecializationTypeSchema(schema) || !schema.base) continue;
+    const parentUrl = schema.base.url;
+    if (!directChildrenByParent[parentUrl]) directChildrenByParent[parentUrl] = [];
+    directChildrenByParent[parentUrl].push(schema.identifier);
+  }
+  const transitiveCache = {};
+  const getTransitiveChildren = (parentUrl) => {
+    if (transitiveCache[parentUrl]) return transitiveCache[parentUrl];
+    const direct = directChildrenByParent[parentUrl] ?? [];
+    const result = [...direct];
+    for (const child of direct) {
+      result.push(...getTransitiveChildren(child.url));
+    }
+    transitiveCache[parentUrl] = result;
     return result;
   };
-  const seen = /* @__PURE__ */ new Set();
-  const allPairs = [];
-  for (const pair of directPairs) {
-    const key = `${pair.parent.name}|${pair.child.name}`;
-    seen.add(key);
-    allPairs.push(pair);
-    for (const transitiveChild of getTransitiveChildren(pair.child.name)) {
-      const transitiveKey = `${pair.parent.name}|${transitiveChild.name}`;
-      if (!seen.has(transitiveKey)) {
-        seen.add(transitiveKey);
-        allPairs.push({ parent: pair.parent, child: transitiveChild });
-      }
-    }
+  for (const schema of schemas) {
+    if (!isSpecializationTypeSchema(schema)) continue;
+    const allChildren = getTransitiveChildren(schema.identifier.url);
+    if (allChildren.length === 0) continue;
+    const resources = allChildren.filter(isResourceIdentifier);
+    const complexTypes = allChildren.filter(isComplexTypeIdentifier);
+    const family = {};
+    if (resources.length > 0) family.resources = resources;
+    if (complexTypes.length > 0) family.complexTypes = complexTypes;
+    if (Object.keys(family).length > 0) schema.typeFamily = family;
   }
-  return allPairs;
 };
 var mkTypeSchemaIndex = (schemas, {
   register,
@@ -910,9 +900,12 @@ var mkTypeSchemaIndex = (schemas, {
   for (const schema of schemas) {
     append(schema);
   }
-  const relations = resourceRelatives(schemas);
+  populateTypeFamily(schemas);
   const resolve6 = (id) => {
-    if (id.kind === "nested") return nestedIndex[id.url]?.[id.package];
+    return index[id.url]?.[id.package];
+  };
+  const resolveType = (id) => {
+    if (isNestedIdentifier(id)) return nestedIndex[id.url]?.[id.package];
     return index[id.url]?.[id.package];
   };
   const resolveByUrl = (pkgName, url) => {
@@ -924,6 +917,7 @@ var mkTypeSchemaIndex = (schemas, {
       }
     }
     if (index[url]?.[pkgName]) return index[url]?.[pkgName];
+    if (nestedIndex[url]?.[pkgName]) return nestedIndex[url]?.[pkgName];
     logger?.dryWarn(`Type '${url}' not found in '${pkgName}'`);
     if (index[url]) {
       const anyPkg = Object.keys(index[url])[0];
@@ -932,11 +926,15 @@ var mkTypeSchemaIndex = (schemas, {
         return index[url]?.[anyPkg];
       }
     }
+    if (nestedIndex[url]) {
+      const anyPkg = Object.keys(nestedIndex[url])[0];
+      if (anyPkg) {
+        logger?.dryWarn(`Type '${url}' fallback to package ${anyPkg}`);
+        return nestedIndex[url]?.[anyPkg];
+      }
+    }
     return void 0;
   };
-  const resourceChildren = (id) => {
-    return relations.filter((relative) => relative.parent.name === id.name).map((relative) => relative.child);
-  };
   const tryHierarchy = (schema) => {
     const res = [];
     let cur = schema;
@@ -944,6 +942,7 @@ var mkTypeSchemaIndex = (schemas, {
       res.push(cur);
       const base = cur.base;
       if (base === void 0) break;
+      if (isNestedIdentifier(base)) break;
       const resolved = resolve6(base);
       if (!resolved) {
         logger?.warn(
@@ -971,9 +970,35 @@ var mkTypeSchemaIndex = (schemas, {
     return nonConstraintSchema;
   };
   const findLastSpecializationByIdentifier = (id) => {
-    const schema = resolve6(id);
-    if (!schema) return id;
-    return findLastSpecialization(schema).identifier;
+    const resolved = resolveType(id);
+    if (!resolved) return id;
+    if (isNestedTypeSchema(resolved)) return findLastSpecializationByIdentifier(resolved.base);
+    return findLastSpecialization(resolved).identifier;
+  };
+  const narrowMergedChoiceDeclarations = (mergedFields, constraintSchemas) => {
+    const result = { ...mergedFields };
+    for (const [declName, declField] of Object.entries(result)) {
+      if (!isChoiceDeclarationField(declField) || declField.excluded) continue;
+      for (const cSchema of constraintSchemas) {
+        const sFields = cSchema.fields;
+        if (!sFields) continue;
+        if (sFields[declName] && isChoiceDeclarationField(sFields[declName])) continue;
+        const instancesInSchema = Object.entries(sFields).filter(([_, f]) => isChoiceInstanceField(f) && f.choiceOf === declName).map(([name]) => name);
+        if (instancesInSchema.length === 0) continue;
+        const allowed = new Set(instancesInSchema);
+        result[declName] = { ...declField, choices: declField.choices.filter((c) => allowed.has(c)) };
+        break;
+      }
+    }
+    for (const [declName, declField] of Object.entries(result)) {
+      if (!isChoiceDeclarationField(declField)) continue;
+      const permitted = new Set(declField.excluded ? [] : declField.choices);
+      const prohibited = Object.entries(result).filter(
+        (e) => isChoiceInstanceField(e[1]) && e[1].choiceOf === declName
+      ).filter(([name]) => !permitted.has(name)).map(([name]) => name);
+      if (prohibited.length > 0) result[declName] = { ...declField, prohibited };
+    }
+    return result;
   };
   const flatProfile = (schema) => {
     const hierarchySchemas = hierarchy(schema);
@@ -996,6 +1021,7 @@ var mkTypeSchemaIndex = (schemas, {
         }
       }
     }
+    const narrowedFields = narrowMergedChoiceDeclarations(mergedFields, constraintSchemas);
     const dependencies = Object.values(
       Object.fromEntries(
         constraintSchemas.flatMap((s) => s.dependencies ?? []).map((dep) => [dep.url, dep])
@@ -1011,7 +1037,7 @@ var mkTypeSchemaIndex = (schemas, {
     return {
       ...schema,
       base: nonConstraintSchema.identifier,
-      fields: mergedFields,
+      fields: narrowedFields,
       dependencies,
       extensions: mergedExtensions.length > 0 ? mergedExtensions : void 0
     };
@@ -1069,7 +1095,6 @@ var mkTypeSchemaIndex = (schemas, {
   };
   return {
     _schemaIndex: index,
-    _relations: relations,
     schemas,
     schemasByPackage: groupByPackages(schemas),
     register,
@@ -1078,8 +1103,8 @@ var mkTypeSchemaIndex = (schemas, {
     collectLogicalModels: () => schemas.filter(isLogicalTypeSchema),
     collectProfiles: () => schemas.filter(isProfileTypeSchema),
     resolve: resolve6,
+    resolveType,
     resolveByUrl,
-    resourceChildren,
     tryHierarchy,
     hierarchy,
     findLastSpecialization,
@@ -1373,8 +1398,7 @@ var Python = class extends Writer {
     return names;
   }
   shouldImportResourceFamily(resource) {
-    assert3(this.tsIndex !== void 0);
-    return resource.identifier.kind === "resource" && this.tsIndex.resourceChildren(resource.identifier).length > 0;
+    return resource.identifier.kind === "resource" && (resource.typeFamily?.resources?.length ?? 0) > 0;
   }
   generateExportsDeclaration(packageComplexTypes, allResourceNames) {
     this.squareBlock(["__all__", "="], () => {
@@ -1426,11 +1450,11 @@ var Python = class extends Writer {
       this.line("pass");
       return;
     }
-    if (schema.identifier.kind === "resource") {
+    if (isResourceTypeSchema(schema)) {
       this.generateResourceTypeField(schema);
     }
     this.generateFields(schema, schema.identifier.name);
-    if (schema.identifier.kind === "resource") {
+    if (isResourceTypeSchema(schema)) {
       this.generateResourceMethods(schema);
     }
   }
@@ -1439,8 +1463,7 @@ var Python = class extends Writer {
     this.line(`model_config = ConfigDict(validate_by_name=True, serialize_by_alias=True, extra="${extraMode}")`);
   }
   generateResourceTypeField(schema) {
-    assert3(this.tsIndex !== void 0);
-    const hasChildren = this.tsIndex.resourceChildren(schema.identifier).length > 0;
+    const hasChildren = (schema.typeFamily?.resources?.length ?? 0) > 0;
     if (hasChildren) {
       this.line(`${this.nameFormatFunction("resourceType")}: str = Field(`);
     } else {
@@ -1602,7 +1625,7 @@ var Python = class extends Writer {
     this.pyImportFrom(this.pyPackage(identifier), pascalCase(identifier.name));
   }
   generateResourceFamilies(packageResources) {
-    assert3(this.tsIndex !== void 0);
+    assert4(this.tsIndex !== void 0);
     const packages = (
       //this.helper.getPackages(packageResources, this.opts.rootPackageName);
       Object.keys(groupByPackages(packageResources)).map(
@@ -1611,7 +1634,7 @@ var Python = class extends Writer {
     );
     const families = {};
     for (const resource of this.tsIndex.collectResources()) {
-      const children = this.tsIndex.resourceChildren(resource.identifier).map((c) => c.name);
+      const children = (resource.typeFamily?.resources ?? []).map((c) => c.name);
       if (children.length > 0) {
         const familyName = `${resource.identifier.name}Family`;
         families[familyName] = children;
@@ -1730,22 +1753,20 @@ 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";
-}
+var identifierBase = (fhirSchema) => ({
+  package: fhirSchema.package_meta.name,
+  version: fhirSchema.package_meta.version,
+  name: fhirSchema.name,
+  url: fhirSchema.url
+});
 function mkIdentifier(fhirSchema) {
-  return {
-    kind: determineKind(fhirSchema),
-    package: fhirSchema.package_meta.name,
-    version: fhirSchema.package_meta.version,
-    name: fhirSchema.name,
-    url: fhirSchema.url
-  };
+  const fields = identifierBase(fhirSchema);
+  if (fhirSchema.derivation === "constraint") return { kind: "profile", ...fields };
+  if (fhirSchema.kind === "primitive-type") return { kind: "primitive-type", ...fields };
+  if (fhirSchema.kind === "complex-type") return { kind: "complex-type", ...fields };
+  if (fhirSchema.kind === "resource") return { kind: "resource", ...fields };
+  if (fhirSchema.kind === "logical") return { kind: "logical", ...fields };
+  return { kind: "resource", ...fields };
 }
 var getValueSetName = (url) => {
   const urlParts = url.split("/");
@@ -1797,7 +1818,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) => {
-      assert3(item.code);
+      assert4(item.code);
       return {
         code: item.code,
         display: item.display,
@@ -2455,12 +2476,29 @@ var collectDiscriminatorValue = (schema, segments, index, result) => {
   }
   collectDiscriminatorValue(element, segments, index + 1, result);
 };
+var computeTypeDiscriminatorMatch = (path, schema, result) => {
+  if (path === "$this") return;
+  const segments = path.split(".");
+  let elem = schema;
+  for (const seg of segments) {
+    elem = elem?.elements?.[seg];
+    if (!elem) return;
+  }
+  const typeName = elem.type;
+  if (!typeName || typeName.includes("/")) return;
+  setNestedValue(result, segments, { resourceType: typeName });
+};
 var computeMatchFromSchema = (discriminators, schema) => {
-  if (!schema?.elements || !discriminators || discriminators.length === 0) return void 0;
+  if (!schema || !discriminators || discriminators.length === 0) return void 0;
   const result = {};
   for (const disc of discriminators) {
-    const segments = disc.path.split(".");
-    collectDiscriminatorValue(schema, segments, 0, result);
+    if (disc.type === "type") {
+      computeTypeDiscriminatorMatch(disc.path, schema, result);
+    } else {
+      if (!schema.elements) continue;
+      const segments = disc.path.split(".");
+      collectDiscriminatorValue(schema, segments, 0, result);
+    }
   }
   return Object.keys(result).length > 0 ? result : void 0;
 };
@@ -2481,7 +2519,7 @@ var buildSlicing = (element) => {
     };
   }
   return {
-    discriminator: slicing.discriminator,
+    discriminator: slicing.discriminator ?? [],
     rules: slicing.rules,
     ordered: slicing.ordered,
     slices: Object.keys(slices).length > 0 ? slices : void 0
@@ -2579,16 +2617,16 @@ function mkNestedField(register, fhirSchema, path, element) {
 }
 
 // src/typeschema/core/profile-extensions.ts
-var extractExtensionValueTypes = (register, fhirSchema, extensionUrl, logger) => {
+var extractExtensionValueFieldTypes = (register, fhirSchema, extensionUrl, logger) => {
   const extensionSchema = register.resolveFs(fhirSchema.package_meta, extensionUrl);
   if (!extensionSchema?.elements) return void 0;
-  const valueTypes = [];
+  const valueFieldTypes = [];
   for (const [key, element] of Object.entries(extensionSchema.elements)) {
     if (element.choiceOf !== "value" && !key.startsWith("value")) continue;
     const fieldType = buildFieldType(register, extensionSchema, [key], element, logger);
-    if (fieldType) valueTypes.push(fieldType);
+    if (fieldType) valueFieldTypes.push(fieldType);
   }
-  return concatIdentifiers(valueTypes);
+  return concatIdentifiers(valueFieldTypes);
 };
 var extractLegacySubExtensions = (register, extensionSchema, logger) => {
   const subExtensions = [];
@@ -2606,14 +2644,14 @@ var extractLegacySubExtensions = (register, extensionSchema, logger) => {
     subExtensions.push({
       name: sliceName,
       url: element.url ?? sliceName,
-      valueType,
+      valueFieldType: valueType,
       min: element.min,
       max: element.max !== void 0 ? String(element.max) : void 0
     });
   }
   return subExtensions;
 };
-var extractSlicingSubExtensions = (extensionSchema) => {
+var extractSlicingSubExtensions = (register, extensionSchema, logger) => {
   const subExtensions = [];
   const extensionElement = extensionSchema.elements?.extension;
   const slices = extensionElement?.slicing?.slices;
@@ -2626,21 +2664,13 @@ var extractSlicingSubExtensions = (extensionSchema) => {
     for (const [elemKey, elemValue] of Object.entries(schema.elements ?? {})) {
       const elem = elemValue;
       if (elem.choiceOf !== "value" && !elemKey.startsWith("value")) continue;
-      if (elem.type) {
-        valueType = {
-          kind: "complex-type",
-          package: extensionSchema.package_meta.name,
-          version: extensionSchema.package_meta.version,
-          name: elem.type,
-          url: `http://hl7.org/fhir/StructureDefinition/${elem.type}`
-        };
-        break;
-      }
+      valueType = buildFieldType(register, extensionSchema, [elemKey], elem, logger);
+      if (valueType) break;
     }
     subExtensions.push({
       name: sliceName,
       url: slice.match?.url ?? sliceName,
-      valueType,
+      valueFieldType: valueType,
       min: schema._required ? 1 : schema.min ?? 0,
       // biome-ignore lint/style/noNestedTernary : okay here
       max: schema.max !== void 0 ? String(schema.max) : schema.array ? "*" : "1"
@@ -2652,7 +2682,7 @@ var extractSubExtensions = (register, fhirSchema, extensionUrl, logger) => {
   const extensionSchema = register.resolveFs(fhirSchema.package_meta, extensionUrl);
   if (!extensionSchema?.elements) return void 0;
   const legacySubs = extractLegacySubExtensions(register, extensionSchema, logger);
-  const slicingSubs = extractSlicingSubExtensions(extensionSchema);
+  const slicingSubs = extractSlicingSubExtensions(register, extensionSchema, logger);
   const subExtensions = [...legacySubs, ...slicingSubs];
   return subExtensions.length > 0 ? subExtensions : void 0;
 };
@@ -2660,38 +2690,36 @@ var extractProfileExtensions = (register, fhirSchema, logger) => {
   const extensions = [];
   const addExtensionEntry = (path, name, schema) => {
     let url = schema.url;
-    let valueTypes = url ? extractExtensionValueTypes(register, fhirSchema, url, logger) : void 0;
+    let valueFieldTypes = url ? extractExtensionValueFieldTypes(register, fhirSchema, url, logger) : void 0;
     const subExtensions = url ? extractSubExtensions(register, fhirSchema, url, logger) : void 0;
     if (!url) {
       const sliceSchema = fhirSchema.elements?.extension?.slicing?.slices?.[name]?.schema;
       if (sliceSchema) {
         url = sliceSchema.elements?.url?.fixed?.value ?? name;
-        for (const [_elemKey, elemValue] of Object.entries(sliceSchema.elements ?? {})) {
+        for (const [elemKey, elemValue] of Object.entries(sliceSchema.elements ?? {})) {
           const elem = elemValue;
-          if (elem.choiceOf === "value" && elem.type) {
-            valueTypes = [
-              {
-                kind: "complex-type",
-                package: fhirSchema.package_meta.name,
-                version: fhirSchema.package_meta.version,
-                name: elem.type,
-                url: `http://hl7.org/fhir/StructureDefinition/${elem.type}`
-              }
-            ];
-            break;
+          if (elem.choiceOf === "value" || elemKey.startsWith("value")) {
+            const ft = buildFieldType(register, fhirSchema, [elemKey], elem, logger);
+            if (ft) {
+              valueFieldTypes = [ft];
+              break;
+            }
           }
         }
       }
     }
     const isComplex = subExtensions && subExtensions.length > 0;
+    const extFs = url ? register.resolveFs(fhirSchema.package_meta, url) : void 0;
+    const profile = extFs ? mkIdentifier(extFs) : void 0;
     extensions.push({
       name,
       path: [...path, "extension"].join("."),
       url,
+      profile,
       min: schema.min,
       max: schema.max !== void 0 ? String(schema.max) : void 0,
       mustSupport: schema.mustSupport,
-      valueTypes,
+      valueFieldTypes,
       subExtensions,
       isComplex
     });
@@ -2765,22 +2793,28 @@ async function transformValueSet(register, valueSet, logger) {
     compose: !concept ? valueSet.compose : void 0
   };
 }
-function extractDependencies(identifier, base, fields, nestedTypes) {
+var collectRawDeps = (base, fields, nestedTypes) => {
   const deps = [];
   if (base) deps.push(base);
   if (fields) deps.push(...extractFieldDependencies(fields));
   if (nestedTypes) deps.push(...extractNestedDependencies(nestedTypes));
-  const localNestedTypeUrls = new Set(nestedTypes?.map((nt) => nt.identifier.url));
+  return deps;
+};
+var extractDependencies = (identifier, base, fields, nestedTypes) => {
+  const deps = collectRawDeps(base, fields, nestedTypes);
   const filtered = deps.filter((dep) => {
     if (dep.url === identifier.url) return false;
-    if (isProfileIdentifier(identifier)) return true;
-    if (!isNestedIdentifier(dep)) return true;
-    return !localNestedTypeUrls.has(dep.url);
+    if (isNestedIdentifier(dep)) return false;
+    return true;
   });
   return concatIdentifiers(filtered);
-}
-function transformFhirSchemaResource(register, fhirSchema, logger) {
-  const identifier = mkIdentifier(fhirSchema);
+};
+var extractProfileDependencies = (identifier, base, fields, nestedTypes) => {
+  const deps = collectRawDeps(base, fields, nestedTypes);
+  const filtered = deps.filter((dep) => dep.url !== identifier.url);
+  return concatIdentifiers(filtered);
+};
+function transformFhirSchema(register, fhirSchema, logger) {
   let base;
   if (fhirSchema.base) {
     const baseFs = register.resolveFs(
@@ -2791,31 +2825,60 @@ function transformFhirSchemaResource(register, fhirSchema, logger) {
       throw new Error(
         `Base resource not found '${fhirSchema.base}' for <${fhirSchema.url}> from ${packageMetaToFhir(fhirSchema.package_meta)}`
       );
-    base = mkIdentifier(baseFs);
+    const baseId = mkIdentifier(baseFs);
+    assert4(!isNestedIdentifier(baseId), `Unexpected nested base for ${fhirSchema.url}`);
+    base = baseId;
   }
   const fields = mkFields(register, fhirSchema, [], fhirSchema.elements, logger);
   const nested = mkNestedTypes(register, fhirSchema, logger);
-  const extensions = fhirSchema.derivation === "constraint" ? extractProfileExtensions(register, fhirSchema, logger) : void 0;
-  const extensionDeps = extensions?.flatMap((ext) => ext.valueTypes ?? []) ?? [];
-  const dependencies = extractDependencies(identifier, base, fields, nested);
-  const typeSchema = {
+  const bindingSchemas = collectBindingSchemas(register, fhirSchema, logger);
+  if (fhirSchema.derivation === "constraint") {
+    const identifier2 = mkIdentifier(fhirSchema);
+    if (!base) throw new Error(`Profile ${fhirSchema.url} must have a base type`);
+    const extensions = extractProfileExtensions(register, fhirSchema, logger);
+    const extensionDeps = extensions?.flatMap(extractExtensionDeps);
+    const rawDeps = extractProfileDependencies(identifier2, base, fields, nested);
+    return [
+      {
+        identifier: identifier2,
+        base,
+        fields,
+        nested,
+        description: fhirSchema.description,
+        dependencies: concatIdentifiers(rawDeps, extensionDeps),
+        extensions
+      },
+      ...bindingSchemas
+    ];
+  }
+  if (fhirSchema.kind === "primitive-type") {
+    const identifier2 = mkIdentifier(fhirSchema);
+    assert4(base, `Primitive type ${fhirSchema.url} must have a base type`);
+    return [
+      {
+        identifier: identifier2,
+        description: fhirSchema.description,
+        base,
+        dependencies: extractDependencies(identifier2, base, fields, nested)
+      },
+      ...bindingSchemas
+    ];
+  }
+  const identifier = mkIdentifier(fhirSchema);
+  const schema = {
     identifier,
     base,
     fields,
     nested,
     description: fhirSchema.description,
-    dependencies: concatIdentifiers(dependencies, extensionDeps),
-    extensions
+    dependencies: extractDependencies(identifier, base, fields, nested),
+    typeFamily: void 0
   };
-  const bindingSchemas = collectBindingSchemas(register, fhirSchema, logger);
-  return [typeSchema, ...bindingSchemas];
-}
-async function transformFhirSchema(register, fhirSchema, logger) {
-  return transformFhirSchemaResource(register, fhirSchema, logger);
+  return [schema, ...bindingSchemas];
 }
 
 // src/typeschema/index.ts
-var deduplicateSchemas = (schemasWithSources, logger) => {
+var deduplicateSchemas = (schemasWithSources, resolveCollisions, logger) => {
   const groups = {};
   for (const item of schemasWithSources) {
     const key = `${item.schema.identifier.url}|${item.schema.identifier.package}`;
@@ -2830,11 +2893,30 @@ var deduplicateSchemas = (schemasWithSources, logger) => {
     const sorted = Object.values(versions).sort((a, b) => b.sources.length - a.sources.length);
     const best = sorted[0];
     if (!best) continue;
-    schemas.push(best.typeSchema);
     if (sorted.length > 1) {
-      const pkg = best.typeSchema.identifier.package;
       const url = best.typeSchema.identifier.url;
-      logger?.dryWarn("#duplicateSchema", `'${url}' from '${pkg}' has ${sorted.length} versions`);
+      const pkg = best.typeSchema.identifier.package;
+      const preferredCanonical = resolveCollisions?.[url];
+      if (preferredCanonical) {
+        const allSources = sorted.flatMap((v) => v.sources);
+        const match = sorted.find(
+          (v) => v.sources.some(
+            (s) => s.sourceCanonical === preferredCanonical.canonical && s.sourcePackage === preferredCanonical.package
+          )
+        );
+        if (match) {
+          schemas.push(match.typeSchema);
+        } else {
+          logger?.dryWarn(
+            "#resolveCollisionMiss",
+            `'${url}': preferred source '${preferredCanonical.canonical}' from '${preferredCanonical.package}' not found among variants: ${allSources.map((s) => `${s.sourceCanonical} (${s.sourcePackage})`).join(", ")}`
+          );
+          schemas.push(best.typeSchema);
+        }
+      } else {
+        logger?.dryWarn("#duplicateSchema", `'${url}' from '${pkg}' has ${sorted.length} versions`);
+        schemas.push(best.typeSchema);
+      }
       collisions[pkg] ??= {};
       collisions[pkg][url] = sorted.flatMap(
         (v) => v.sources.map((s) => ({
@@ -2843,11 +2925,13 @@ var deduplicateSchemas = (schemasWithSources, logger) => {
           sourceCanonical: s.sourceCanonical
         }))
       );
+    } else {
+      schemas.push(best.typeSchema);
     }
   }
   return { schemas, collisions };
 };
-var generateTypeSchemas = async (register, logger) => {
+var generateTypeSchemas = async (register, resolveCollisions, logger) => {
   const schemasWithSources = [];
   for (const fhirSchema of register.allFs()) {
     const pkgId = packageMetaToFhir(fhirSchema.package_meta);
@@ -2856,7 +2940,7 @@ var generateTypeSchemas = async (register, logger) => {
       logger?.dryWarn("#skipCanonical", `Skip ${fhirSchema.url} from ${pkgId}. Reason: ${skipCheck.reason}`);
       continue;
     }
-    for (const schema of await transformFhirSchema(register, fhirSchema, logger)) {
+    for (const schema of transformFhirSchema(register, fhirSchema, logger)) {
       schemasWithSources.push({
         schema,
         sourcePackage: pkgId,
@@ -2871,7 +2955,7 @@ var generateTypeSchemas = async (register, logger) => {
       sourceCanonical: vsSchema.url
     });
   }
-  return deduplicateSchemas(schemasWithSources, logger);
+  return deduplicateSchemas(schemasWithSources, resolveCollisions, logger);
 };
 
 // src/typeschema/ir/logic-promotion.ts
@@ -2884,7 +2968,7 @@ var promoteLogical = (tsIndex, promotes) => {
     tsIndex.schemas.map((schema) => {
       const promo = promoteSets[schema.identifier.package]?.has(schema.identifier.url);
       if (!promo) return void 0;
-      if (schema.identifier.kind !== "logical")
+      if (!isLogicalTypeSchema(schema))
         throw new Error(`Unexpected schema kind: ${JSON.stringify(schema.identifier)}`);
       return [identifierToString(schema.identifier), { ...schema.identifier, kind: "resource" }];
     }).filter((e) => e !== void 0)
@@ -2943,14 +3027,14 @@ var mutableSelectFields = (schema, selectFields) => {
   }
   for (const [choiceName, { declaration, instances }] of Object.entries(selectPolimorphic)) {
     const choices = instances ?? declaration;
-    assert3(choices);
+    assert4(choices);
     for (const choiceInstanceName of choices) {
       const field = schema.fields?.[choiceInstanceName];
-      assert3(field);
+      assert4(field);
       selectedFields[choiceInstanceName] = field;
     }
     const decl = schema.fields?.[choiceName];
-    assert3(decl);
+    assert4(decl);
     selectedFields[choiceName] = { ...decl, choices };
   }
   schema.fields = selectedFields;
@@ -2967,7 +3051,7 @@ var mutableIgnoreFields = (schema, ignoreFields) => {
       }
       if (isChoiceInstanceField(field)) {
         const choiceDeclaration = schema.fields[field.choiceOf];
-        assert3(isChoiceDeclarationField(choiceDeclaration));
+        assert4(isChoiceDeclarationField(choiceDeclaration));
         choiceDeclaration.choices = choiceDeclaration.choices.filter((c) => c !== fieldName);
         if (choiceDeclaration.choices.length === 0) {
           delete schema.fields[field.choiceOf];
@@ -2977,6 +3061,15 @@ var mutableIgnoreFields = (schema, ignoreFields) => {
     }
   }
 };
+var mutableIgnoreExtensions = (schema, ignoreExtensions) => {
+  if (!schema.extensions) return;
+  for (const url of ignoreExtensions) {
+    if (!schema.extensions.some((ext) => ext.url === url))
+      throw new Error(`Extension ${url} not found in profile ${schema.identifier.url}`);
+  }
+  schema.extensions = schema.extensions.filter((ext) => !ext.url || !ignoreExtensions.includes(ext.url));
+  if (schema.extensions.length === 0) schema.extensions = void 0;
+};
 var mutableFillReport = (report, tsIndex, shakedIndex) => {
   const packages = Object.keys(tsIndex.schemasByPackage);
   const shakedPackages = Object.keys(shakedIndex.schemasByPackage);
@@ -2985,15 +3078,15 @@ var mutableFillReport = (report, tsIndex, shakedIndex) => {
   for (const [pkgName, shakedSchemas] of Object.entries(shakedIndex.schemasByPackage)) {
     if (skippedPackages.includes(pkgName)) continue;
     const tsSchemas = tsIndex.schemasByPackage[pkgName];
-    assert3(tsSchemas);
+    assert4(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);
+          assert4(schema);
           if (!isSpecializationTypeSchema(schema)) return void 0;
-          assert3(isSpecializationTypeSchema(shakedSchema));
+          assert4(isSpecializationTypeSchema(shakedSchema));
           if (!schema.fields) return void 0;
           if (!shakedSchema.fields) {
             return [shakedSchema.identifier.url, Object.keys(schema.fields)];
@@ -3018,6 +3111,9 @@ var treeShakeTypeSchema = (schema, rule, _logger) => {
     if (rule.selectFields) throw new Error("Cannot use both ignoreFields and selectFields in the same rule");
     mutableIgnoreFields(schema, rule.ignoreFields);
   }
+  if (isProfileTypeSchema(schema) && rule.ignoreExtensions) {
+    mutableIgnoreExtensions(schema, rule.ignoreExtensions);
+  }
   if (schema.nested) {
     const usedTypes = /* @__PURE__ */ new Set();
     const collectUsedNestedTypes = (s) => {
@@ -3026,7 +3122,7 @@ var treeShakeTypeSchema = (schema, rule, _logger) => {
         if (!usedTypes.has(url)) {
           usedTypes.add(url);
           const nestedTypeDef = schema.nested?.find((f2) => f2.identifier.url === url);
-          assert3(nestedTypeDef);
+          assert4(nestedTypeDef);
           collectUsedNestedTypes(nestedTypeDef);
         }
       });
@@ -3034,7 +3130,16 @@ var treeShakeTypeSchema = (schema, rule, _logger) => {
     collectUsedNestedTypes(schema);
     schema.nested = schema.nested.filter((n) => usedTypes.has(n.identifier.url));
   }
-  schema.dependencies = extractDependencies(schema.identifier, schema.base, schema.fields, schema.nested);
+  if (isProfileTypeSchema(schema)) {
+    const extDeps = schema.extensions?.flatMap(extractExtensionDeps);
+    schema.dependencies = concatIdentifiers(
+      extractProfileDependencies(schema.identifier, schema.base, schema.fields, schema.nested),
+      extDeps
+    );
+  } else {
+    assert4(!isNestedIdentifier(schema.identifier));
+    schema.dependencies = extractDependencies(schema.identifier, schema.base, schema.fields, schema.nested);
+  }
   return schema;
 };
 var treeShake = (tsIndex, treeShake2) => {
@@ -3042,7 +3147,7 @@ var treeShake = (tsIndex, treeShake2) => {
   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}`);
+      if (!schema || isNestedTypeSchema(schema)) throw new Error(`Schema not found for ${pkgId} ${url}`);
       const shaked2 = treeShakeTypeSchema(schema, rule);
       focusedSchemas.push(shaked2);
     }
@@ -3057,6 +3162,7 @@ var treeShake = (tsIndex, treeShake2) => {
       if (isSpecializationTypeSchema(schema) || isProfileTypeSchema(schema)) {
         if (!schema.dependencies) continue;
         schema.dependencies.forEach((dep) => {
+          if (isNestedIdentifier(dep)) return;
           const depSchema = tsIndex.resolve(dep);
           if (!depSchema)
             throw new Error(
@@ -3065,13 +3171,6 @@ var treeShake = (tsIndex, treeShake2) => {
           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);
@@ -3149,7 +3248,7 @@ var IntrospectionWriter = class extends FileSystemWriter {
               for (const [canonical, entries] of Object.entries(canonicals)) {
                 if (entries.length <= 1) continue;
                 const firstEntry = entries[0];
-                assert3(firstEntry);
+                assert4(firstEntry);
                 const name = normalizeFileName(
                   `${firstEntry.typeSchema.identifier.name}(${extractNameFromCanonical(canonical)})`
                 );
@@ -3289,31 +3388,42 @@ var generatePackageSection = (lines, pkgName, treeShakePkg, promotedCanonicals)
     lines.push("");
   }
 };
-var generateCollisionVersionLines = (entries) => {
+var groupCollisionVersions = (entries, resolution) => {
   const uniqueSchemas = /* @__PURE__ */ new Map();
   for (const entry of entries) {
     const key = JSON.stringify(entry.typeSchema);
     if (!uniqueSchemas.has(key)) uniqueSchemas.set(key, []);
     uniqueSchemas.get(key)?.push(entry);
   }
-  const versionLines = [];
-  const sortedVersions = [...uniqueSchemas.values()].sort((a, b) => b.length - a.length);
+  const sorted = [...uniqueSchemas.values()].sort((a, b) => b.length - a.length);
+  const markVersion = (group, i) => {
+    if (resolution)
+      return group.some(
+        (e) => e.sourceCanonical === resolution.canonical && e.sourcePackage === resolution.package
+      ) ? "selected" : void 0;
+    return i === 0 ? "auto" : void 0;
+  };
+  return sorted.map((group, i) => ({ entries: group, mark: markVersion(group, i) }));
+};
+var versionMarkLabel = { selected: " (selected)", auto: " (auto)" };
+var generateCollisionVersionLines = (versions) => {
   let version = 1;
-  for (const schemaEntries of sortedVersions) {
-    const sourceList = schemaEntries.map((e) => {
+  return versions.map((v) => {
+    const sourceList = v.entries.map((e) => {
       const name = extractNameFromCanonical(e.sourceCanonical) ?? e.sourceCanonical;
       return `${name} (${e.sourcePackage})`;
     }).join(", ");
-    versionLines.push(`  - Version ${version++}: ${sourceList}`);
-  }
-  return versionLines;
+    const mark = v.mark ? versionMarkLabel[v.mark] : "";
+    return `  - Version ${version++}${mark}: ${sourceList}`;
+  });
 };
-var generateCollisionsSection = (lines, collisions) => {
+var generateCollisionsSection = (lines, collisions, resolveCollisions) => {
   if (!collisions) return;
   lines.push("## Schema Collisions", "");
   lines.push("The following canonicals have multiple schema versions with different content.");
   lines.push("To inspect collision versions, export TypeSchemas using `.introspection({ typeSchemas: 'path' })`");
   lines.push("and check `<pkg>/collisions/<name>/1.json, 2.json, ...` files.", "");
+  const allCollisions = [];
   const collisionPackages = Object.keys(collisions).sort();
   for (const pkgName of collisionPackages) {
     const collisionsPkg = collisions[pkgName];
@@ -3326,13 +3436,34 @@ var generateCollisionsSection = (lines, collisions) => {
     if (sortedEntries.length > 0) {
       lines.push(`### \`${pkgName}\``, "");
       for (const [canonical, entries] of sortedEntries) {
-        const versionLines = generateCollisionVersionLines(entries);
-        lines.push(`- \`${canonical}\` (${versionLines.length} versions)`);
+        const versions = groupCollisionVersions(entries, resolveCollisions?.[canonical]);
+        const versionLines = generateCollisionVersionLines(versions);
+        lines.push(`- \`${canonical}\` (${versions.length} versions)`);
         lines.push(...versionLines);
+        if (entries[0]) allCollisions.push({ url: canonical, firstSource: entries[0] });
       }
       lines.push("");
     }
   }
+  if (allCollisions.length > 0) {
+    const unresolved = allCollisions.filter((c) => !resolveCollisions?.[c.url]);
+    if (unresolved.length > 0) {
+      lines.push("### Suggested `resolveCollisions` config", "");
+      lines.push("Add to `.typeSchema({ resolveCollisions: { ... } })` to resolve remaining collisions:", "");
+      lines.push("```typescript");
+      lines.push(".typeSchema({");
+      lines.push("    resolveCollisions: {");
+      for (const { url, firstSource } of unresolved) {
+        lines.push(`        "${url}": {`);
+        lines.push(`            package: "${firstSource.sourcePackage}",`);
+        lines.push(`            canonical: "${firstSource.sourceCanonical}",`);
+        lines.push("        },");
+      }
+      lines.push("    },");
+      lines.push("})");
+      lines.push("```", "");
+    }
+  }
 };
 var generateIrReportReadme = (report) => {
   const lines = ["# IR Report", ""];
@@ -3360,7 +3491,7 @@ var generateIrReportReadme = (report) => {
     );
   }
   if (hasCollisions) {
-    generateCollisionsSection(lines, report.collisions);
+    generateCollisionsSection(lines, report.collisions, report.resolveCollisions);
   }
   return lines.join("\n");
 };
@@ -3654,7 +3785,7 @@ var ViewModelFactory = class {
     throw new Error(`Unknown type ${typeRef.kind}`);
   }
   _createForComplexType(typeRef, cache, nestedIn) {
-    const type = this.tsIndex.resolve(typeRef);
+    const type = this.tsIndex.resolveType(typeRef);
     if (!type) {
       throw new Error(`ComplexType ${typeRef.name} not found`);
     }
@@ -3666,7 +3797,7 @@ var ViewModelFactory = class {
     return res;
   }
   _createForResource(typeRef, cache, nestedIn) {
-    const type = this.tsIndex.resolve(typeRef);
+    const type = this.tsIndex.resolveType(typeRef);
     if (!type) {
       throw new Error(`Resource ${typeRef.name} not found`);
     }
@@ -3678,11 +3809,13 @@ var ViewModelFactory = class {
     return res;
   }
   _createChildrenFor(typeRef, cache, nestedIn) {
-    if (isComplexTypeIdentifier(typeRef)) {
-      return this.tsIndex.resourceChildren(typeRef).filter(isComplexTypeIdentifier).filter(this.filterPred).map((childRef) => this._createFor(childRef, cache, nestedIn));
+    const schema = this.tsIndex.resolveType(typeRef);
+    if (!schema) return [];
+    if (isComplexTypeTypeSchema(schema)) {
+      return (schema.typeFamily?.complexTypes ?? []).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));
+    if (isResourceTypeSchema(schema)) {
+      return (schema.typeFamily?.resources ?? []).filter(this.filterPred).map((childRef) => this._createFor(childRef, cache, nestedIn));
     }
     return [];
   }
@@ -3691,7 +3824,7 @@ var ViewModelFactory = class {
     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);
+      const parent = this.tsIndex.resolveType(parentRef);
       parentRef = parent && "base" in parent ? parent.base : void 0;
     }
     return parents;
@@ -4151,7 +4284,8 @@ var rewriteFieldTypeDefs = {
   Reference: { reference: () => "`${T}/${string}`" },
   CodeableConcept: { coding: () => "Coding<T>" }
 };
-var resolveFieldTsType = (schemaName, tsName, field, resolveRef) => {
+var resolveFieldTsType = (schemaName, tsName, field, resolveRef, genericFieldMap) => {
+  if (genericFieldMap?.[tsName]) return genericFieldMap[tsName];
   const rewriteFieldType = rewriteFieldTypeDefs[schemaName]?.[tsName];
   if (rewriteFieldType) return rewriteFieldType();
   if (field.enum) {
@@ -4325,7 +4459,7 @@ var generateComplexExtensionSetter = (w, info) => {
     w.curlyBlock(["public", setMethodName, `(input: ${inputTypeName}): this`], () => {
       w.line("const subExtensions: Extension[] = []");
       for (const sub of ext.subExtensions ?? []) {
-        const valueField = sub.valueType ? tsValueFieldName(sub.valueType) : "value";
+        const valueField = sub.valueFieldType ? tsValueFieldName(sub.valueFieldType) : "value";
         if (sub.max === "*") {
           w.curlyBlock(["if", `(input.${sub.name})`], () => {
             w.curlyBlock(["for", `(const item of input.${sub.name})`], () => {
@@ -4362,7 +4496,7 @@ var generateComplexExtensionGetter = (w, info) => {
   const inputType = extProfileHasFlatInput && extProfileInfo ? `${extProfileInfo.className}Flat` : inputTypeName;
   generateExtensionGetterOverloads(w, ext, targetPath, getMethodName, inputType, extProfileInfo, () => {
     const configItems = (ext.subExtensions ?? []).map((sub) => {
-      const valueField = sub.valueType ? tsValueFieldName(sub.valueType) : "value";
+      const valueField = sub.valueFieldType ? tsValueFieldName(sub.valueFieldType) : "value";
       const isArray = sub.max === "*";
       return `{ name: "${sub.url}", valueField: "${valueField}", isArray: ${isArray} }`;
     });
@@ -4372,7 +4506,7 @@ var generateComplexExtensionGetter = (w, info) => {
 };
 var generateSingleValueExtensionSetter = (w, tsIndex, info) => {
   const { ext, setMethodName, targetPath, extProfileInfo } = info;
-  const firstValueType = ext.valueTypes?.[0];
+  const firstValueType = ext.valueFieldTypes?.[0];
   if (!firstValueType) return;
   const valueType = tsTypeFromIdentifier(firstValueType);
   const valueField = tsValueFieldName(firstValueType);
@@ -4408,7 +4542,7 @@ var generateSingleValueExtensionSetter = (w, tsIndex, info) => {
 };
 var generateSingleValueExtensionGetter = (w, info) => {
   const { ext, getMethodName, targetPath, extProfileInfo } = info;
-  const firstValueType = ext.valueTypes?.[0];
+  const firstValueType = ext.valueFieldTypes?.[0];
   if (!firstValueType) return;
   const valueType = tsTypeFromIdentifier(firstValueType);
   const valueField = tsValueFieldName(firstValueType);
@@ -4462,7 +4596,7 @@ var generateExtensionMethods = (w, tsIndex, flatProfile, extensionBaseNames) =>
       generateComplexExtensionSetter(w, info);
       w.line();
       generateComplexExtensionGetter(w, info);
-    } else if (ext.valueTypes?.length === 1 && ext.valueTypes[0]) {
+    } else if (ext.valueFieldTypes?.length === 1 && ext.valueFieldTypes[0]) {
       generateSingleValueExtensionSetter(w, tsIndex, info);
       w.line();
       generateSingleValueExtensionGetter(w, info);
@@ -4480,21 +4614,21 @@ var collectTypesFromExtensions = (tsIndex, flatProfile, addType) => {
     if (ext.isComplex && ext.subExtensions) {
       needsExtensionType = true;
       for (const sub of ext.subExtensions) {
-        if (!sub.valueType) continue;
+        if (!sub.valueFieldType) continue;
         const resolvedType = tsIndex.resolveByUrl(
           flatProfile.identifier.package,
-          sub.valueType.url
+          sub.valueFieldType.url
         );
-        addType(resolvedType?.identifier ?? sub.valueType);
+        addType(resolvedType?.identifier ?? sub.valueFieldType);
       }
-    } else if (ext.valueTypes && ext.valueTypes.length === 1) {
+    } else if (ext.valueFieldTypes && ext.valueFieldTypes.length === 1) {
       needsExtensionType = true;
-      if (ext.valueTypes[0]) {
+      if (ext.valueFieldTypes[0]) {
         const resolvedType = tsIndex.resolveByUrl(
           flatProfile.identifier.package,
-          ext.valueTypes[0].url
+          ext.valueFieldTypes[0].url
         );
-        addType(resolvedType?.identifier ?? ext.valueTypes[0]);
+        addType(resolvedType?.identifier ?? ext.valueFieldTypes[0]);
       }
     } else {
       needsExtensionType = true;
@@ -4517,7 +4651,7 @@ var collectTypesFromFlatInput = (tsIndex, flatProfile, addType) => {
 // src/api/writer-generator/typescript/profile-slices.ts
 var collectChoiceBaseNames = (tsIndex, typeId) => {
   const names = /* @__PURE__ */ new Set();
-  const schema = tsIndex.resolve(typeId);
+  const schema = tsIndex.resolveType(typeId);
   if (schema && "fields" in schema && schema.fields) {
     for (const [name, f] of Object.entries(schema.fields)) {
       if (isChoiceDeclarationField(f)) names.add(name);
@@ -4525,15 +4659,35 @@ var collectChoiceBaseNames = (tsIndex, typeId) => {
   }
   return names;
 };
+var extractResourceTypeFromMatch = (match) => {
+  for (const value of Object.values(match)) {
+    if (typeof value !== "object" || value === null) continue;
+    const obj = value;
+    if (typeof obj.resourceType === "string") return obj.resourceType;
+    const nested = extractResourceTypeFromMatch(obj);
+    if (nested) return nested;
+  }
+  return void 0;
+};
 var collectTypesFromSlices = (tsIndex, flatProfile, addType) => {
   const pkgName = flatProfile.identifier.package;
   for (const field of Object.values(flatProfile.fields ?? {})) {
     if (!isNotChoiceDeclarationField(field) || !field.slicing?.slices || !field.type) continue;
+    const isTypeDisc = field.slicing.discriminator?.some((d) => d.type === "type") ?? false;
     for (const slice of Object.values(field.slicing.slices)) {
       if (Object.keys(slice.match ?? {}).length > 0) {
         addType(field.type);
         const cc = slice.elements ? tsIndex.constrainedChoice(pkgName, field.type, slice.elements) : void 0;
         if (cc) addType(cc.variantType);
+        if (isTypeDisc && slice.match) {
+          const resourceTypeName = extractResourceTypeFromMatch(slice.match);
+          if (resourceTypeName) {
+            const resourceSchema = tsIndex.schemas.find(
+              (s) => s.identifier.name === resourceTypeName && s.identifier.kind === "resource"
+            );
+            if (resourceSchema) addType(resourceSchema.identifier);
+          }
+        }
       }
     }
   }
@@ -4548,6 +4702,7 @@ var collectSliceDefs = (tsIndex, flatProfile) => Object.entries(flatProfile.fiel
   const baseType = tsTypeFromIdentifier(field.type);
   const pkgName = flatProfile.identifier.package;
   const choiceBaseNames = collectChoiceBaseNames(tsIndex, field.type);
+  const isTypeDisc = field.slicing.discriminator?.some((d) => d.type === "type") ?? false;
   return Object.entries(field.slicing.slices).filter(([_, slice]) => Object.keys(slice.match ?? {}).length > 0).map(([sliceName, slice]) => {
     const matchFields = Object.keys(slice.match ?? {});
     const required = (slice.required ?? []).filter(
@@ -4555,15 +4710,19 @@ var collectSliceDefs = (tsIndex, flatProfile) => Object.entries(flatProfile.fiel
     );
     const cc = slice.elements ? tsIndex.constrainedChoice(pkgName, field.type, slice.elements) : void 0;
     const constrainedChoice = cc && !isPrimitiveIdentifier(cc.variantType) ? cc : void 0;
+    const resourceType = isTypeDisc ? extractResourceTypeFromMatch(slice.match ?? {}) : void 0;
+    const typedBaseType = resourceType ? `${baseType}<${resourceType}>` : baseType;
     return {
       fieldName,
       baseType,
+      typedBaseType,
       sliceName,
       match: slice.match ?? {},
       required,
       excluded: slice.excluded ?? [],
       array: Boolean(field.array),
-      constrainedChoice
+      constrainedChoice,
+      typeDiscriminator: isTypeDisc
     };
   });
 });
@@ -4577,7 +4736,7 @@ var generateSliceSetters = (w, sliceDefs, flatProfile, sliceBaseNames) => {
     const matchRef = `${profileClassName}.${tsSliceStaticName(sliceDef.sliceName)}SliceMatch`;
     const tsField = tsFieldName(sliceDef.fieldName);
     const fieldAccess = tsGet("this.resource", tsField);
-    const baseType = sliceDef.baseType;
+    const baseType = sliceDef.typedBaseType;
     const inputOptional = sliceDef.required.length === 0;
     const unionType = `${typeName} | ${baseType}`;
     const paramSignature = inputOptional ? `(input?: ${unionType}): this` : `(input: ${unionType}): this`;
@@ -4621,7 +4780,7 @@ var generateSliceGetters = (w, sliceDefs, flatProfile, sliceBaseNames) => {
     const matchKeys = JSON.stringify(Object.keys(sliceDef.match));
     const tsField = tsFieldName(sliceDef.fieldName);
     const fieldAccess = tsGet("this.resource", tsField);
-    const baseType = sliceDef.baseType;
+    const baseType = sliceDef.typedBaseType;
     const defaultReturn = defaultMode === "raw" ? baseType : typeName;
     w.lineSM(`public ${getMethodName}(mode: 'flat'): ${typeName} | undefined`);
     w.lineSM(`public ${getMethodName}(mode: 'raw'): ${baseType} | undefined`);
@@ -4641,8 +4800,14 @@ var generateSliceGetters = (w, sliceDefs, flatProfile, sliceBaseNames) => {
           w.line(`const item = ${fieldAccess}`);
           w.line("if (!item || !matchesValue(item, match)) return undefined");
         }
-        w.line("if (mode === 'raw') return item");
-        if (sliceDef.constrainedChoice) {
+        if (sliceDef.typeDiscriminator) {
+          w.line(`if (mode === 'raw') return item as ${baseType}`);
+        } else {
+          w.line("if (mode === 'raw') return item");
+        }
+        if (sliceDef.typeDiscriminator) {
+          w.line(`return item as ${typeName}`);
+        } else if (sliceDef.constrainedChoice) {
           const cc = sliceDef.constrainedChoice;
           w.line(`return unwrapSliceChoice<${typeName}>(item, ${matchKeys}, ${JSON.stringify(cc.variant)})`);
         } else {
@@ -4699,7 +4864,12 @@ var generateValidateMethod = (w, tsIndex, flatProfile) => {
     const errors = [];
     const warnings = [];
     for (const [name, field] of Object.entries(fields)) {
-      if (isChoiceInstanceField(field)) continue;
+      if (isChoiceInstanceField(field)) {
+        const decl = fields[field.choiceOf];
+        if (decl && isChoiceDeclarationField(decl) && decl.prohibited?.includes(name))
+          errors.push(`...validateExcluded(res, profileName, ${JSON.stringify(name)})`);
+        continue;
+      }
       if (isChoiceDeclarationField(field)) {
         if (field.required)
           errors.push(`...validateChoiceRequired(res, profileName, ${JSON.stringify(field.choices)})`);
@@ -4812,7 +4982,7 @@ var collectProfileFactoryInfo = (tsIndex, flatProfile) => {
 };
 var collectBaseRequiredParams = (tsIndex, flatProfile, resolveRef, params, coveredNames) => {
   const covered = new Set(coveredNames);
-  const baseSchema = tsIndex.resolve(flatProfile.base);
+  const baseSchema = tsIndex.resolveType(flatProfile.base);
   if (!baseSchema || !("fields" in baseSchema) || !baseSchema.fields) return;
   for (const [name, field] of Object.entries(baseSchema.fields)) {
     if (covered.has(name)) continue;
@@ -4829,78 +4999,20 @@ var generateProfileIndexFile = (w, tsIndex, initialProfiles) => {
   if (initialProfiles.length === 0) return;
   w.cd("profiles", () => {
     w.cat("index.ts", () => {
-      const profiles = initialProfiles.map((profile) => {
+      const exports$1 = /* @__PURE__ */ new Map();
+      for (const profile of initialProfiles) {
         const className = tsProfileClassName(profile);
-        const resourceName = tsResourceName(profile.identifier);
-        const overrides = detectFieldOverrides(tsIndex, profile);
-        let typeExport;
-        if (overrides.size > 0) typeExport = resourceName;
-        return [profile, className, typeExport];
-      });
-      if (profiles.length === 0) return;
-      const classExports = /* @__PURE__ */ new Map();
-      const typeExports = /* @__PURE__ */ new Map();
-      for (const [profile, className, typeName] of profiles) {
         const moduleName = tsProfileModuleName(tsIndex, profile);
-        if (!classExports.has(className)) {
-          classExports.set(className, `export { ${className} } from "./${moduleName}"`);
-        }
-        if (typeName && !typeExports.has(typeName) && !classExports.has(typeName)) {
-          typeExports.set(typeName, `export type { ${typeName} } from "./${moduleName}"`);
+        if (!exports$1.has(className)) {
+          exports$1.set(className, `export { ${className} } from "./${moduleName}"`);
         }
       }
-      const allExports = [...classExports.values(), ...typeExports.values()].sort();
-      for (const exp of allExports) {
+      for (const exp of [...exports$1.values()].sort()) {
         w.lineSM(exp);
       }
     });
   });
 };
-var tsTypeForProfileField = (tsIndex, flatProfile, fieldName, field) => {
-  if (!isNotChoiceDeclarationField(field)) {
-    throw new Error(`Choice declaration fields not supported for '${fieldName}'`);
-  }
-  let tsType;
-  if (field.enum) {
-    if (field.type?.name === "Coding") {
-      tsType = `Coding<${tsEnumType(field.enum)}>`;
-    } else if (field.type?.name === "CodeableConcept") {
-      tsType = `CodeableConcept<${tsEnumType(field.enum)}>`;
-    } else {
-      tsType = tsEnumType(field.enum);
-    }
-  } else if (field.reference && field.reference.length > 0) {
-    const specialization = tsIndex.findLastSpecialization(flatProfile);
-    if (!isSpecializationTypeSchema(specialization))
-      throw new Error(`Invalid specialization for ${flatProfile.identifier}`);
-    const sField = specialization.fields?.[fieldName];
-    if (sField === void 0 || isChoiceDeclarationField(sField) || sField.reference === void 0)
-      throw new Error(`Invalid field declaration for ${fieldName}`);
-    const sRefs = sField.reference.map((e) => e.name);
-    const references = field.reference.map((ref) => {
-      const resRef = tsIndex.findLastSpecializationByIdentifier(ref);
-      if (resRef.name !== ref.name) {
-        return `"${resRef.name}" /*${ref.name}*/`;
-      }
-      return `'${ref.name}'`;
-    }).join(" | ");
-    if (sRefs.length === 1 && sRefs[0] === "Resource" && references !== '"Resource"') {
-      const cleanRefs = references.replace(/\/\*[^*]*\*\//g, "").trim();
-      tsType = `Reference<"Resource" /* ${cleanRefs} */ >`;
-    } else {
-      tsType = `Reference<${references}>`;
-    }
-  } else if (isPrimitiveIdentifier(field.type)) {
-    tsType = resolvePrimitiveType(field.type.name);
-  } else if (isNestedIdentifier(field.type)) {
-    tsType = tsResourceName(field.type);
-  } else if (field.type === void 0) {
-    throw new Error(`Undefined type for '${fieldName}' field at ${typeSchemaInfo(flatProfile)}`);
-  } else {
-    tsType = field.type.name;
-  }
-  return tsType;
-};
 var generateProfileHelpersImport = (w, tsIndex, flatProfile, sliceDefs, factoryInfo) => {
   const extensions = flatProfile.extensions ?? [];
   const hasMeta = tsIndex.isWithMetaField(flatProfile);
@@ -4914,7 +5026,7 @@ var generateProfileHelpersImport = (w, tsIndex, flatProfile, sliceDefs, factoryI
     imports.push("applySliceMatch", "matchesValue", "setArraySlice", "getArraySlice", "ensureSliceDefaults");
   if (extensions.some((ext) => ext.path.split(".").some((s) => s !== "extension"))) imports.push("ensurePath");
   if (extensions.some((ext) => ext.isComplex && ext.subExtensions)) imports.push("extractComplexExtension");
-  if (sliceDefs.length > 0) imports.push("stripMatchKeys");
+  if (sliceDefs.some((s) => !s.typeDiscriminator)) imports.push("stripMatchKeys");
   if (sliceDefs.some((s) => s.constrainedChoice)) imports.push("wrapSliceChoice", "unwrapSliceChoice");
   if (extensions.some((ext) => ext.url)) imports.push("isExtension", "getExtensionValue", "pushExtension");
   if (Object.keys(flatProfile.fields ?? {}).length > 0)
@@ -4933,7 +5045,7 @@ var generateProfileHelpersImport = (w, tsIndex, flatProfile, sliceDefs, factoryI
     w.line();
   }
 };
-var generateProfileImports = (w, tsIndex, flatProfile, overrides) => {
+var generateProfileImports = (w, tsIndex, flatProfile) => {
   const usedTypes = /* @__PURE__ */ new Map();
   const getModulePath = (typeId) => {
     if (isNestedIdentifier(typeId)) {
@@ -4952,7 +5064,6 @@ var generateProfileImports = (w, tsIndex, flatProfile, overrides) => {
   addType(flatProfile.base);
   collectTypesFromSlices(tsIndex, flatProfile, addType);
   const needsExtensionType = collectTypesFromExtensions(tsIndex, flatProfile, addType);
-  for (const { typeId } of overrides.values()) addType(typeId);
   collectTypesFromFlatInput(tsIndex, flatProfile, addType);
   const factoryInfo = collectProfileFactoryInfo(tsIndex, flatProfile);
   for (const param of factoryInfo.params) addType(param.typeId);
@@ -5198,7 +5309,7 @@ var generateInlineExtensionInputTypes = (w, tsIndex, flatProfile) => {
     const typeName = tsExtensionFlatTypeName(tsProfileName, ext.name);
     w.curlyBlock(["export", "type", typeName, "="], () => {
       for (const sub of ext.subExtensions ?? []) {
-        const tsType = sub.valueType ? tsTypeFromIdentifier(sub.valueType) : "unknown";
+        const tsType = sub.valueFieldType ? tsTypeFromIdentifier(sub.valueFieldType) : "unknown";
         const isArray = sub.max === "*";
         const isRequired2 = sub.min !== void 0 && sub.min > 0;
         w.lineSM(`${sub.name}${isRequired2 ? "" : "?"}: ${tsType}${isArray ? "[]" : ""}`);
@@ -5212,7 +5323,7 @@ var generateSliceInputTypes = (w, flatProfile, sliceDefs) => {
   const tsProfileName = tsResourceName(flatProfile.identifier);
   for (const sliceDef of sliceDefs) {
     const typeName = tsSliceFlatTypeName(tsProfileName, sliceDef.fieldName, sliceDef.sliceName);
-    const matchFields = Object.keys(sliceDef.match);
+    const matchFields = sliceDef.typeDiscriminator ? [] : Object.keys(sliceDef.match);
     const allExcluded = [.../* @__PURE__ */ new Set([...sliceDef.excluded, ...matchFields])];
     if (sliceDef.constrainedChoice) {
       const cc = sliceDef.constrainedChoice;
@@ -5223,12 +5334,13 @@ var generateSliceInputTypes = (w, flatProfile, sliceDefs) => {
     }
     const excludedNames = allExcluded.map((name) => JSON.stringify(name));
     const requiredNames = sliceDef.required.map((name) => JSON.stringify(name));
-    let typeExpr = sliceDef.baseType;
+    const baseType = sliceDef.typedBaseType;
+    let typeExpr = baseType;
     if (excludedNames.length > 0) {
       typeExpr = `Omit<${typeExpr}, ${excludedNames.join(" | ")}>`;
     }
     if (requiredNames.length > 0) {
-      typeExpr = `${typeExpr} & Required<Pick<${sliceDef.baseType}, ${requiredNames.join(" | ")}>>`;
+      typeExpr = `${typeExpr} & Required<Pick<${baseType}, ${requiredNames.join(" | ")}>>`;
     }
     if (sliceDef.constrainedChoice) {
       typeExpr = `${typeExpr} & ${tsTypeFromIdentifier(sliceDef.constrainedChoice.variantType)}`;
@@ -5343,57 +5455,6 @@ var generateProfileClass = (w, tsIndex, flatProfile) => {
   });
   w.line();
 };
-var detectFieldOverrides = (tsIndex, flatProfile) => {
-  const overrides = /* @__PURE__ */ new Map();
-  const specialization = tsIndex.findLastSpecialization(flatProfile);
-  if (!isSpecializationTypeSchema(specialization)) return overrides;
-  const referenceUrl = "http://hl7.org/fhir/StructureDefinition/Reference";
-  const referenceSchema = tsIndex.resolveByUrl(flatProfile.identifier.package, referenceUrl);
-  for (const [fieldName, pField] of Object.entries(flatProfile.fields ?? {})) {
-    if (!isNotChoiceDeclarationField(pField)) continue;
-    const sField = specialization.fields?.[fieldName];
-    if (!sField || isChoiceDeclarationField(sField)) continue;
-    if (pField.reference && sField.reference && pField.reference.length < sField.reference.length) {
-      if (!referenceSchema) continue;
-      const references = pField.reference.map((ref) => {
-        const resRef = tsIndex.findLastSpecializationByIdentifier(ref);
-        if (resRef.name !== ref.name) {
-          return `"${resRef.name}"`;
-        }
-        return `"${ref.name}"`;
-      }).join(" | ");
-      overrides.set(fieldName, {
-        profileType: `Reference<${references}>`,
-        required: pField.required ?? false,
-        array: pField.array ?? false,
-        typeId: referenceSchema.identifier
-      });
-    } else if (pField.required && !sField.required) {
-      const tsType = tsTypeForProfileField(tsIndex, flatProfile, fieldName, pField);
-      overrides.set(fieldName, {
-        profileType: tsType,
-        required: true,
-        array: pField.array ?? false,
-        typeId: pField.type
-      });
-    }
-  }
-  return overrides;
-};
-var generateProfileOverrideInterface = (w, flatProfile, overrides) => {
-  if (overrides.size === 0) return;
-  const tsProfileName = tsResourceName(flatProfile.identifier);
-  const tsBaseResourceName = tsResourceName(flatProfile.base);
-  w.curlyBlock(["export", "interface", tsProfileName, "extends", tsBaseResourceName], () => {
-    for (const [fieldName, override] of overrides) {
-      const tsField = tsFieldName(fieldName);
-      const optionalSymbol = override.required ? "" : "?";
-      const arraySymbol = override.array ? "[]" : "";
-      w.lineSM(`${tsField}${optionalSymbol}: ${override.profileType}${arraySymbol}`);
-    }
-  });
-  w.line();
-};
 
 // src/api/writer-generator/typescript/writer.ts
 var resolveTsAssets = (fn) => {
@@ -5488,14 +5549,6 @@ var TypeScript = class extends Writer {
             name: tsResourceName(dep),
             dep
           });
-        } else if (isNestedIdentifier(dep)) {
-          const ndep = { ...dep };
-          ndep.name = tsNameFromCanonical(dep.url);
-          imports.push({
-            tsPackage: `${importPrefix}${tsModulePath(ndep)}`,
-            name: tsResourceName(dep),
-            dep
-          });
         } else {
           skipped.push(dep);
         }
@@ -5537,11 +5590,32 @@ var TypeScript = class extends Writer {
     const genericTypes = ["Reference", "Coding", "CodeableConcept"];
     if (genericTypes.includes(schema.identifier.name)) {
       name = `${schema.identifier.name}<T extends string = string>`;
-    } else if (schema.identifier.kind === "nested") {
-      name = tsResourceName(schema.identifier);
     } else {
       name = tsResourceName(schema.identifier);
     }
+    const typeFamilyFields = [];
+    for (const [fieldName, field] of Object.entries(schema.fields ?? {})) {
+      if (isChoiceDeclarationField(field) || !field.type) continue;
+      const fieldTypeSchema = tsIndex.resolveType(field.type);
+      if (isSpecializationTypeSchema(fieldTypeSchema) && (fieldTypeSchema.typeFamily?.resources?.length ?? 0) > 0) {
+        typeFamilyFields.push({ fieldName: tsFieldName(fieldName), familyTypeName: field.type.name });
+      }
+    }
+    const genericFieldMap = {};
+    if (!genericTypes.includes(schema.identifier.name) && typeFamilyFields.length > 0) {
+      const [first, ...rest] = typeFamilyFields;
+      if (first && rest.length === 0) {
+        genericFieldMap[first.fieldName] = "T";
+        name += `<T extends ${first.familyTypeName} = ${first.familyTypeName}>`;
+      } else {
+        const params = typeFamilyFields.map((tf) => {
+          const paramName = `T${uppercaseFirstLetter(tf.fieldName)}`;
+          genericFieldMap[tf.fieldName] = paramName;
+          return `${paramName} extends ${tf.familyTypeName} = ${tf.familyTypeName}`;
+        });
+        name += `<${params.join(", ")}>`;
+      }
+    }
     let extendsClause;
     if (schema.base) extendsClause = `extends ${tsNameFromCanonical(schema.base.url)}`;
     this.debugComment(schema.identifier);
@@ -5551,8 +5625,7 @@ var TypeScript = class extends Writer {
     }
     this.curlyBlock(["export", "interface", name, extendsClause], () => {
       if (isResourceTypeSchema(schema)) {
-        const possibleResourceTypes = [schema.identifier];
-        possibleResourceTypes.push(...tsIndex.resourceChildren(schema.identifier));
+        const possibleResourceTypes = [schema.identifier, ...schema.typeFamily?.resources ?? []];
         const openSetSuffix = this.opts.openResourceTypeSet && possibleResourceTypes.length > 1 ? " | string" : "";
         this.lineSM(
           `resourceType: ${possibleResourceTypes.sort((a, b) => a.name.localeCompare(b.name)).map((e) => `"${e.name}"`).join(" | ")}${openSetSuffix}`
@@ -5566,7 +5639,7 @@ var TypeScript = class extends Writer {
         if (!field.type) continue;
         this.debugComment(fieldName, ":", field);
         const tsName = tsFieldName(fieldName);
-        const tsType = resolveFieldTsType(schema.identifier.name, tsName, field);
+        const tsType = resolveFieldTsType(schema.identifier.name, tsName, field, void 0, genericFieldMap);
         const optionalSymbol = field.required ? "" : "?";
         const arraySymbol = field.array ? "[]" : "";
         this.lineSM(`${tsName}${optionalSymbol}: ${tsType}${arraySymbol}`);
@@ -5610,13 +5683,11 @@ var TypeScript = class extends Writer {
         this.cat(`${tsProfileModuleFileName(tsIndex, schema)}`, () => {
           this.generateDisclaimer();
           const flatProfile = tsIndex.flatProfile(schema);
-          const overrides = detectFieldOverrides(tsIndex, flatProfile);
-          generateProfileImports(this, tsIndex, flatProfile, overrides);
-          generateProfileOverrideInterface(this, flatProfile, overrides);
+          generateProfileImports(this, tsIndex, flatProfile);
           generateProfileClass(this, tsIndex, flatProfile);
         });
       });
-    } else if (["complex-type", "resource", "logical"].includes(schema.identifier.kind)) {
+    } else if (isSpecializationTypeSchema(schema)) {
       this.cat(`${tsModuleFileName(schema.identifier)}`, () => {
         this.generateDisclaimer();
         this.generateDependenciesImports(tsIndex, schema);
@@ -5707,8 +5778,6 @@ var APIBuilder = class {
       outputDir: "./generated",
       cleanOutput: true,
       throwException: false,
-      treeShake: void 0,
-      promoteLogical: void 0,
       registry: void 0,
       dropCanonicalManagerCache: false
     };
@@ -5885,13 +5954,18 @@ var APIBuilder = class {
     return this;
   }
   typeSchema(cfg) {
+    this.options.typeSchema ??= {};
     if (cfg.treeShake) {
-      assert3(this.options.treeShake === void 0, "treeShake option is already set");
-      this.options.treeShake = cfg.treeShake;
+      assert4(this.options.typeSchema.treeShake === void 0, "treeShake option is already set");
+      this.options.typeSchema.treeShake = cfg.treeShake;
     }
     if (cfg.promoteLogical) {
-      assert3(this.options.promoteLogical === void 0, "promoteLogical option is already set");
-      this.options.promoteLogical = cfg.promoteLogical;
+      assert4(this.options.typeSchema.promoteLogical === void 0, "promoteLogical option is already set");
+      this.options.typeSchema.promoteLogical = cfg.promoteLogical;
+    }
+    if (cfg.resolveCollisions) {
+      assert4(this.options.typeSchema.resolveCollisions === void 0, "resolveCollisions option is already set");
+      this.options.typeSchema.resolveCollisions = cfg.resolveCollisions;
     }
     this.irReport({});
     return this;
@@ -5948,15 +6022,20 @@ var APIBuilder = class {
         });
       }
       const tsLogger = this.logger.fork("ts");
-      const { schemas: typeSchemas, collisions } = await generateTypeSchemas(register, tsLogger);
-      const tsIndexOpts = {
+      const { schemas: typeSchemas, collisions } = await generateTypeSchemas(
         register,
-        logger: tsLogger,
-        irReport: Object.keys(collisions).length > 0 ? { collisions } : {}
+        this.options.typeSchema?.resolveCollisions,
+        tsLogger
+      );
+      const irReport = {
+        resolveCollisions: this.options.typeSchema?.resolveCollisions,
+        collisions
       };
+      const tsIndexOpts = { register, irReport, logger: tsLogger };
       let tsIndex = mkTypeSchemaIndex(typeSchemas, tsIndexOpts);
-      if (this.options.treeShake) tsIndex = treeShake(tsIndex, this.options.treeShake);
-      if (this.options.promoteLogical) tsIndex = promoteLogical(tsIndex, this.options.promoteLogical);
+      if (this.options.typeSchema?.treeShake) tsIndex = treeShake(tsIndex, this.options.typeSchema.treeShake);
+      if (this.options.typeSchema?.promoteLogical)
+        tsIndex = promoteLogical(tsIndex, this.options.typeSchema.promoteLogical);
       tsLogger.printTagSummary();
       this.logger.debug(`Executing ${this.generators.length} generators`);
       await this.executeGenerators(result, tsIndex);