@atomic-ehr/codegen 0.0.14 → 0.0.15-canary.20260604110458.894c975

package/dist/index.js

@@ -382,6 +382,13 @@ var isPrimitiveIdentifier = (id) => {
 var isNestedIdentifier = (id) => {
   return id?.kind === "nested";
 };
+var isSnapshotProfileIdentifier = (id) => {
+  return id?.kind === "profile-snapshot";
+};
+var snapshotIdentifier = (id) => ({
+  ...id,
+  kind: "profile-snapshot"
+});
 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;
@@ -415,6 +422,9 @@ var isBindingSchema = (schema) => {
 var isValueSetTypeSchema = (schema) => {
   return schema?.identifier.kind === "value-set";
 };
+var isSnapshotProfileTypeSchema = (s) => {
+  return s?.identifier.kind === "profile-snapshot";
+};
 var extractExtensionDeps = (ext) => [
   ...ext.valueFieldTypes ?? [],
   ...ext.profile ? [ext.profile] : [],
@@ -927,10 +937,9 @@ var populateGeneric = (schemas, resolveType) => {
   for (const c of carriers) c.generic = void 0;
   const sameParams = (a, b) => {
     if (a.length !== b.length) return false;
-    for (let i = 0; i < a.length; i++) {
-      const x = a[i];
+    for (const [i, x] of a.entries()) {
       const y = b[i];
-      if (x.typeVar !== y.typeVar || !samePath(x.path, y.path) || x.constraint.url !== y.constraint.url)
+      if (!y || x.typeVar !== y.typeVar || !samePath(x.path, y.path) || x.constraint.url !== y.constraint.url)
         return false;
     }
     return true;
@@ -970,6 +979,7 @@ var mkTypeSchemaIndex = (schemas, {
 }) => {
   const index = {};
   const nestedIndex = {};
+  const snapshotIndex = {};
   const append = (schema) => {
     const url = schema.identifier.url;
     const pkg = schema.identifier.package;
@@ -996,13 +1006,15 @@ var mkTypeSchemaIndex = (schemas, {
     append(schema);
   }
   populateTypeFamily(schemas);
-  const resolve6 = (id) => {
+  const resolve6 = ((id) => {
+    if (isSnapshotProfileIdentifier(id)) return snapshotIndex[id.url]?.[id.package];
     return index[id.url]?.[id.package];
-  };
-  const resolveType = (id) => {
+  });
+  const resolveType = ((id) => {
     if (isNestedIdentifier(id)) return nestedIndex[id.url]?.[id.package];
+    if (isSnapshotProfileIdentifier(id)) return snapshotIndex[id.url]?.[id.package];
     return index[id.url]?.[id.package];
-  };
+  });
   populateGeneric(schemas, resolveType);
   const resolveByUrl = (pkgName, url) => {
     if (register) {
@@ -1059,7 +1071,9 @@ var mkTypeSchemaIndex = (schemas, {
     return genealogy;
   };
   const findLastSpecialization = (schema) => {
-    const nonConstraintSchema = hierarchy(schema).find((s) => s.identifier.kind !== "profile");
+    const nonConstraintSchema = hierarchy(schema).find(
+      (s) => !isProfileTypeSchema(s) && !isSnapshotProfileTypeSchema(s)
+    );
     if (!nonConstraintSchema) {
       throw new Error(`No non-constraint schema found in hierarchy for: ${schema.identifier.name}`);
     }
@@ -1107,14 +1121,11 @@ var mkTypeSchemaIndex = (schemas, {
       const schema2 = anySchema;
       if (!schema2.fields) continue;
       for (const [fieldName, fieldConstraints] of Object.entries(schema2.fields)) {
-        if (mergedFields[fieldName]) {
-          mergedFields[fieldName] = {
-            ...mergedFields[fieldName],
-            ...fieldConstraints
-          };
-        } else {
-          mergedFields[fieldName] = { ...fieldConstraints };
+        const merged = mergedFields[fieldName] ? { ...mergedFields[fieldName], ...fieldConstraints } : { ...fieldConstraints };
+        if ("min" in fieldConstraints && fieldConstraints.min === 0) {
+          merged.required = false;
         }
+        mergedFields[fieldName] = merged;
       }
     }
     const narrowedFields = narrowMergedChoiceDeclarations(mergedFields, constraintSchemas);
@@ -1138,6 +1149,42 @@ var mkTypeSchemaIndex = (schemas, {
       extensions: mergedExtensions.length > 0 ? mergedExtensions : void 0
     };
   };
+  const buildProfileSnapshot = (schema) => {
+    const flat = flatProfile(schema);
+    const flatFields = flat.fields ?? {};
+    const hierarchySchemas = hierarchy(schema);
+    const nonConstraintSchema = hierarchySchemas.find((s) => s.identifier.kind !== "profile");
+    const inheritedRequiredFields = [];
+    if (nonConstraintSchema?.fields) {
+      for (const [name, baseField] of Object.entries(nonConstraintSchema.fields)) {
+        if (!baseField.required) continue;
+        if (isChoiceDeclarationField(baseField)) continue;
+        const flat2 = flatFields[name];
+        if (flat2?.min === 0) continue;
+        if (flat2?.required) continue;
+        inheritedRequiredFields.push(name);
+      }
+    }
+    return {
+      identifier: snapshotIdentifier(flat.identifier),
+      base: flat.base,
+      description: flat.description,
+      fields: flatFields,
+      inheritedRequiredFields: inheritedRequiredFields.length > 0 ? inheritedRequiredFields : void 0,
+      extensions: flat.extensions,
+      dependencies: flat.dependencies,
+      nested: flat.nested
+    };
+  };
+  for (const schema of schemas) {
+    if (!isProfileTypeSchema(schema)) continue;
+    const hier = tryHierarchy(schema);
+    if (!hier?.some((s) => !isProfileTypeSchema(s) && !isSnapshotProfileTypeSchema(s))) continue;
+    const snap = buildProfileSnapshot(schema);
+    const byPkg = snapshotIndex[snap.identifier.url] ??= {};
+    byPkg[snap.identifier.package] = snap;
+  }
+  const collectSnapshotProfiles = () => Object.values(snapshotIndex).flatMap((byPkg) => Object.values(byPkg));
   const constrainedChoice = (pkgName, baseTypeId, sliceElements) => {
     const baseSchema = resolveByUrl(pkgName, baseTypeId.url);
     if (!baseSchema || !("fields" in baseSchema) || !baseSchema.fields) return void 0;
@@ -1175,6 +1222,7 @@ var mkTypeSchemaIndex = (schemas, {
         nested: {},
         binding: {},
         profile: {},
+        "profile-snapshot": {},
         logical: {}
       };
       for (const schema of shemas) {
@@ -1198,6 +1246,7 @@ var mkTypeSchemaIndex = (schemas, {
     collectResources: () => schemas.filter(isResourceTypeSchema),
     collectLogicalModels: () => schemas.filter(isLogicalTypeSchema),
     collectProfiles: () => schemas.filter(isProfileTypeSchema),
+    collectSnapshotProfiles,
     resolve: resolve6,
     resolveType,
     resolveByUrl,
@@ -1287,6 +1336,18 @@ var GENERIC_FIELD_REWRITES = {
   Coding: { code: "T" },
   CodeableConcept: { coding: "Coding[T]" }
 };
+var leafOf2 = (path) => path[path.length - 1] ?? "";
+var collectResourceGenericTypeVars = (schema) => {
+  const all = {};
+  const addParams = (s) => {
+    for (const p of s.generic?.params ?? []) {
+      if (!(p.typeVar in all)) all[p.typeVar] = p.constraint.name;
+    }
+  };
+  addParams(schema);
+  for (const nested of schema.nested ?? []) addParams(nested);
+  return Object.entries(all).sort(([a], [b]) => a.localeCompare(b)).map(([typeVar, constraint]) => ({ typeVar, constraint }));
+};
 var pyEnumType = (enumDef) => {
   const values = enumDef.values.map((e) => `"${e}"`).join(", ");
   return enumDef.isOpen ? `Literal[${values}] | str` : `Literal[${values}]`;
@@ -1383,7 +1444,10 @@ var Python = class extends Writer {
   generateResourcePackageContent(packageName, packageResources, packageComplexTypes) {
     const pyPackageName = this.pyFhirPackageByName(packageName);
     this.generateResourcePackageInit(pyPackageName, packageResources, packageComplexTypes);
-    this.generateResourceFamilies(packageResources);
+    const hasAnyResourceGenericParams = packageResources.some((s) => collectResourceGenericTypeVars(s).length > 0);
+    if (hasAnyResourceGenericParams) {
+      this.copyAssets(resolvePyAssets("resource_preprocessor.py"), "resource_preprocessor.py");
+    }
     for (const schema of packageResources) {
       this.generateResourceModule(schema);
     }
@@ -1478,12 +1542,7 @@ var Python = class extends Writer {
     const moduleName = `${fullPyPackageName}.${snakeCase(resource.identifier.name)}`;
     const importNames = this.collectResourceImportNames(resource);
     this.pyImportFrom(moduleName, ...importNames);
-    const names = [...importNames];
-    if (this.shouldImportResourceFamily(resource)) {
-      const familyName = `${resource.identifier.name}Family`;
-      this.pyImportFrom(`${fullPyPackageName}.resource_families`, familyName);
-    }
-    return names;
+    return importNames;
   }
   collectResourceImportNames(resource) {
     const names = [deriveResourceName(resource.identifier)];
@@ -1493,9 +1552,6 @@ var Python = class extends Writer {
     }
     return names;
   }
-  shouldImportResourceFamily(resource) {
-    return resource.identifier.kind === "resource" && (resource.typeFamily?.resources?.length ?? 0) > 0;
-  }
   generateExportsDeclaration(packageComplexTypes, allResourceNames) {
     this.squareBlock(["__all__", "="], () => {
       const allExports = [
@@ -1508,12 +1564,22 @@ var Python = class extends Writer {
     });
   }
   generateResourceModule(schema) {
+    const typeVars = collectResourceGenericTypeVars(schema);
+    const hasResourceGenericParams = typeVars.length > 0;
     this.cat(`${snakeCase(schema.identifier.name)}.py`, () => {
       this.generateDisclaimer();
-      this.generateDefaultImports(false);
+      this.generateDefaultImports(false, hasResourceGenericParams, true);
       this.generateFhirBaseModelImport();
       this.line();
       this.generateDependenciesImports(schema);
+      if (hasResourceGenericParams) {
+        const pyFhirPackage = this.pyFhirPackageByName(schema.identifier.package);
+        this.pyImportFrom(`${pyFhirPackage}.resource_preprocessor`, "preprocess_resource_fields");
+        this.line();
+        for (const { typeVar, constraint } of typeVars) {
+          this.line(`${typeVar} = TypeVar('${typeVar}', bound=${constraint}, default=${constraint})`);
+        }
+      }
       this.line();
       this.generateNestedTypes(schema);
       this.line();
@@ -1538,6 +1604,11 @@ var Python = class extends Writer {
     if (schema.base) bases.push(schema.base.name);
     bases.push(...this.injectSuperClasses(schema.identifier.url));
     if (schema.identifier.name in GENERIC_FIELD_REWRITES) bases.push("Generic[T]");
+    const params = schema.generic?.params ?? [];
+    if (params.length > 0) {
+      const typeVars = params.map((p) => p.typeVar).join(", ");
+      bases.push(`Generic[${typeVars}]`);
+    }
     return bases;
   }
   generateClassBody(schema) {
@@ -1549,10 +1620,23 @@ var Python = class extends Writer {
     if (isResourceTypeSchema(schema)) {
       this.generateResourceTypeField(schema);
     }
-    this.generateFields(schema, schema.identifier.name);
+    this.generateFields(schema);
     if (isResourceTypeSchema(schema)) {
       this.generateResourceMethods(schema);
     }
+    if ((schema.generic?.params?.length ?? 0) > 0) {
+      this.generateResourcePreprocessorMethod(schema);
+    }
+  }
+  generateResourcePreprocessorMethod(schema) {
+    const pyFhirPackage = this.pyFhirPackageByName(schema.identifier.package);
+    this.line();
+    this.line("@model_validator(mode='before')");
+    this.line("@classmethod");
+    this.line("def _preprocess_resources(cls, data: Any) -> Any:");
+    this.line("    if isinstance(data, dict):");
+    this.line(`        return preprocess_resource_fields(data, "${pyFhirPackage}")`);
+    this.line("    return data");
   }
   generateModelConfig() {
     const extraMode = this.opts.allowExtraFields ? "allow" : "forbid";
@@ -1576,12 +1660,12 @@ var Python = class extends Writer {
     });
     this.line(")");
   }
-  generateFields(schema, schemaName) {
+  generateFields(schema) {
     const sortedFields = Object.entries(schema.fields ?? []).sort(([a], [b]) => a.localeCompare(b));
     const withExtensions = this.shouldAddPrimitiveExtensions(schema);
     for (const [fieldName, field] of sortedFields) {
       if ("choices" in field && field.choices) continue;
-      const fieldInfo = this.buildFieldInfo(fieldName, field, schemaName);
+      const fieldInfo = this.buildFieldInfo(fieldName, field, schema);
       this.line(`${fieldInfo.name}: ${fieldInfo.type}${fieldInfo.defaultValue}`);
       if (withExtensions && "type" in field && isPrimitiveIdentifier(field.type)) {
         this.addPrimitiveExtensionField(fieldName, field.array ?? false);
@@ -1604,9 +1688,9 @@ var Python = class extends Writer {
     const aliasSpec = `alias="${alias}", serialization_alias="${alias}"`;
     this.line(`${pyFieldName}: ${typeExpr} = Field(None, ${aliasSpec})`);
   }
-  buildFieldInfo(fieldName, field, schemaName) {
+  buildFieldInfo(fieldName, field, schema) {
     const pyFieldName = fixReservedWords(this.nameFormatFunction(fieldName));
-    const fieldType = this.determineFieldType(field, fieldName, schemaName);
+    const fieldType = this.determineFieldType(field, fieldName, schema);
     const defaultValue = this.getFieldDefaultValue(field, fieldName);
     return {
       name: pyFieldName,
@@ -1614,7 +1698,8 @@ var Python = class extends Writer {
       defaultValue
     };
   }
-  determineFieldType(field, fieldName, schemaName) {
+  determineFieldType(field, fieldName, schema) {
+    const schemaName = schema.identifier.name;
     let fieldType = field ? this.getBaseFieldType(field) : "";
     const rewrite = GENERIC_FIELD_REWRITES[schemaName]?.[fieldName];
     if (rewrite) {
@@ -1623,6 +1708,27 @@ var Python = class extends Writer {
       if (!field.required) fieldType = `${fieldType} | None`;
       return fieldType;
     }
+    const params = schema.generic?.params ?? [];
+    const directParam = params.find((p) => leafOf2(p.path) === fieldName);
+    if (directParam) {
+      fieldType = directParam.typeVar;
+      if (field.array) fieldType = `PyList[${fieldType}]`;
+      if (!field.required) fieldType = `${fieldType} | None`;
+      return fieldType;
+    }
+    if ("type" in field && field.type && params.length > 0) {
+      assert4(this.tsIndex !== void 0);
+      const target = this.tsIndex.resolveType(field.type);
+      if (target && (isNestedTypeSchema(target) || isSpecializationTypeSchema(target))) {
+        const nestedParams = target.generic?.params ?? [];
+        if (nestedParams.length > 0) {
+          const args = nestedParams.map(
+            (np) => params.find((p) => leafOf2(p.path) === leafOf2(np.path))?.typeVar ?? np.typeVar
+          );
+          fieldType = `${fieldType}[${args.join(", ")}]`;
+        }
+      }
+    }
     if ("enum" in field && field.enum) {
       const baseTypeName = "type" in field ? field.type.name : "";
       if (baseTypeName in GENERIC_FIELD_REWRITES) {
@@ -1654,8 +1760,7 @@ var Python = class extends Writer {
     }
     return ` = Field(${aliasSpec})`;
   }
-  generateResourceMethods(schema) {
-    const className = schema.identifier.name.toString();
+  generateResourceMethods(_schema) {
     this.line();
     this.line("def model_post_init(self, __context: Any) -> None:");
     this.line('    self.__pydantic_fields_set__.add("resource_type")');
@@ -1664,7 +1769,7 @@ var Python = class extends Writer {
     this.line("    return self.model_dump_json(exclude_unset=True, exclude_none=True, indent=indent)");
     this.line();
     this.line("@classmethod");
-    this.line(`def from_json(cls, json: str) -> ${className}:`);
+    this.line("def from_json(cls, json: str) -> Self:");
     this.line("    return cls.model_validate_json(json)");
   }
   generateNestedTypes(schema) {
@@ -1674,17 +1779,20 @@ var Python = class extends Writer {
       this.generateType(subtype);
     }
   }
-  generateDefaultImports(includeGenericImports) {
+  generateDefaultImports(includeGenericImports, includeResourceGenericImports = false, includeResourceMethods = false) {
     this.pyImportFrom("__future__", "annotations");
-    this.pyImportFrom("pydantic", "BaseModel", "ConfigDict", "Field", "PositiveInt");
+    const pydanticImports = ["BaseModel", "ConfigDict", "Field", "PositiveInt"];
+    if (includeResourceGenericImports) pydanticImports.push("model_validator");
+    this.pyImportFrom("pydantic", ...pydanticImports.sort());
     const typingImports = ["Any", "List as PyList", "Literal"];
-    if (includeGenericImports) {
+    if (includeGenericImports || includeResourceGenericImports) {
       typingImports.push("Generic");
     }
     this.pyImportFrom("typing", ...typingImports.sort());
-    if (includeGenericImports) {
-      this.pyImportFrom("typing_extensions", "TypeVar");
-    }
+    const typingExtImports = [];
+    if (includeGenericImports || includeResourceGenericImports) typingExtImports.push("TypeVar");
+    if (includeResourceMethods) typingExtImports.push("Self");
+    if (typingExtImports.length > 0) this.pyImportFrom("typing_extensions", ...typingExtImports.sort());
   }
   generateDependenciesImports(schema) {
     if (!schema.dependencies || schema.dependencies.length === 0) return;
@@ -1714,9 +1822,6 @@ var Python = class extends Writer {
     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) {
@@ -1755,61 +1860,6 @@ var Python = class extends Writer {
   pyImportType(identifier) {
     this.pyImportFrom(this.pyPackage(identifier), pascalCase(identifier.name));
   }
-  generateResourceFamilies(packageResources) {
-    assert4(this.tsIndex !== void 0);
-    const packages = (
-      //this.helper.getPackages(packageResources, this.opts.rootPackageName);
-      Object.keys(groupByPackages(packageResources)).map(
-        (pkgName) => `${this.opts.rootPackageName}.${pkgName.replaceAll(".", "_")}`
-      )
-    );
-    const families = {};
-    for (const resource of this.tsIndex.collectResources()) {
-      const children = (resource.typeFamily?.resources ?? []).map((c) => c.name);
-      if (children.length > 0) {
-        const familyName = `${resource.identifier.name}Family`;
-        families[familyName] = children;
-      }
-    }
-    const exportList = Object.keys(families);
-    if (exportList.length === 0) return;
-    this.buildResourceFamiliesFile(packages, families, exportList);
-  }
-  buildResourceFamiliesFile(packages, families, exportList) {
-    this.cat("resource_families.py", () => {
-      this.generateDisclaimer();
-      this.includeResourceFamilyValidator();
-      this.line();
-      this.generateFamilyDefinitions(packages, families);
-      this.generateFamilyExports(exportList);
-    });
-  }
-  includeResourceFamilyValidator() {
-    const content = fs__default.readFileSync(resolvePyAssets("resource_family_validator.py"), "utf-8");
-    this.line(content);
-  }
-  generateFamilyDefinitions(packages, families) {
-    this.line(`packages = [${packages.map((p) => `'${p}'`).join(", ")}]`);
-    this.line();
-    for (const [familyName, resources] of Object.entries(families)) {
-      this.generateFamilyDefinition(familyName, resources);
-    }
-  }
-  generateFamilyDefinition(familyName, resources) {
-    const listName = `${familyName}_resources`;
-    this.line(
-      `${listName} = [${resources.map((r) => `'${r}'`).sort().join(", ")}]`
-    );
-    this.line();
-    this.line(`def validate_and_downcast_${familyName}(v: Any) -> Any:`);
-    this.line(`   return validate_and_downcast(v, packages, ${listName})`);
-    this.line();
-    this.line(`type ${familyName} = Annotated[Any, BeforeValidator(validate_and_downcast_${familyName})]`);
-    this.line();
-  }
-  generateFamilyExports(exportList) {
-    this.line(`__all__ = [${exportList.map((e) => `'${e}'`).join(", ")}]`);
-  }
   buildPyPackageName(packageName) {
     const parts = packageName ? [snakeCase(packageName)] : [""];
     return parts.join(".");
@@ -1996,6 +2046,7 @@ function extractValueSetConcepts(register, valueSet, _logger) {
   return concepts.length > 0 ? concepts : void 0;
 }
 var MAX_ENUM_LENGTH = 100;
+var PLACEHOLDER_ONLY_ENUM_CODES = /* @__PURE__ */ new Set(["UNK"]);
 var BINDABLE_TYPES = /* @__PURE__ */ new Set([
   "code",
   "Coding",
@@ -2023,6 +2074,14 @@ function buildEnum(register, fhirSchema, element, logger) {
   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);
+  const onlyCode = codes.length === 1 ? codes[0] : void 0;
+  if (onlyCode && PLACEHOLDER_ONLY_ENUM_CODES.has(onlyCode)) {
+    logger?.dryWarn(
+      "#placeholderValueSet",
+      `Value set ${valueSetUrl} only expands to placeholder code '${onlyCode}'; skipping enum generation.`
+    );
+    return void 0;
+  }
   if (codes.length > MAX_ENUM_LENGTH) {
     logger?.dryWarn(
       "#largeValueSet",
@@ -2241,8 +2300,8 @@ var enrichResolver = (resolver, logger) => {
       const resource = resolition.resource;
       const resourcePkg = resolition.pkg;
       if (isStructureDefinition(resource)) {
-        const fs7 = fhirschema.translate(resource);
-        const rfs = enrichFHIRSchema(fs7, resourcePkg);
+        const fs6 = fhirschema.translate(resource);
+        const rfs = enrichFHIRSchema(fs6, resourcePkg);
         counter++;
         resolver[pkgId].fhirSchemas[rfs.url] = rfs;
       }
@@ -2275,12 +2334,12 @@ var registerFromManager = async (manager, { logger, focusedPackages }) => {
       }
     }
     for (const idx of Object.values(resolver)) {
-      const fs7 = idx.fhirSchemas[canonicalUrl];
-      if (fs7 && fs7.package_meta.name === pkg.name) return fs7;
+      const fs6 = idx.fhirSchemas[canonicalUrl];
+      if (fs6 && fs6.package_meta.name === pkg.name) return fs6;
     }
     for (const idx of Object.values(resolver)) {
-      const fs7 = idx.fhirSchemas[canonicalUrl];
-      if (fs7) return fs7;
+      const fs6 = idx.fhirSchemas[canonicalUrl];
+      if (fs6) return fs6;
     }
     return void 0;
   };
@@ -2310,23 +2369,23 @@ var registerFromManager = async (manager, { logger, focusedPackages }) => {
     return name;
   };
   const resolveFsGenealogy = (pkg, canonicalUrl) => {
-    let fs7 = resolveFs(pkg, canonicalUrl);
-    if (fs7 === void 0) throw new Error(`Failed to resolve FHIR Schema: '${canonicalUrl}'`);
-    const genealogy = [fs7];
-    while (fs7?.base) {
-      const pkg2 = fs7.package_meta;
-      const baseUrl = ensureSpecializationCanonicalUrl(fs7.base);
-      fs7 = resolveFs(pkg2, baseUrl);
-      if (fs7 === void 0)
+    let fs6 = resolveFs(pkg, canonicalUrl);
+    if (fs6 === void 0) throw new Error(`Failed to resolve FHIR Schema: '${canonicalUrl}'`);
+    const genealogy = [fs6];
+    while (fs6?.base) {
+      const pkg2 = fs6.package_meta;
+      const baseUrl = ensureSpecializationCanonicalUrl(fs6.base);
+      fs6 = resolveFs(pkg2, baseUrl);
+      if (fs6 === void 0)
         throw new Error(
           `Failed to resolve FHIR Schema base for '${canonicalUrl}'. Problem: '${baseUrl}' from '${packageMetaToFhir(pkg2)}'`
         );
-      genealogy.push(fs7);
+      genealogy.push(fs6);
     }
     return genealogy;
   };
   const resolveFsSpecializations = (pkg, canonicalUrl) => {
-    return resolveFsGenealogy(pkg, canonicalUrl).filter((fs7) => fs7.derivation === "specialization");
+    return resolveFsGenealogy(pkg, canonicalUrl).filter((fs6) => fs6.derivation === "specialization");
   };
   const resolveElementSnapshot = (fhirSchema, path) => {
     const geneology = resolveFsGenealogy(fhirSchema.package_meta, fhirSchema.url);
@@ -2421,9 +2480,9 @@ var registerFromPackageMetas = async (packageMetas, conf) => {
 var resolveFsElementGenealogy = (genealogy, path) => {
   const [top, ...rest] = path;
   if (top === void 0) return [];
-  return genealogy.map((fs7) => {
-    if (!fs7.elements) return void 0;
-    let elem = fs7.elements?.[top];
+  return genealogy.map((fs6) => {
+    if (!fs6.elements) return void 0;
+    let elem = fs6.elements?.[top];
     for (const k of rest) {
       elem = elem?.elements?.[k];
     }
@@ -2446,7 +2505,7 @@ var hasStructuralElements = (register, fhirSchema, path) => {
   if (elemType) {
     const typeUrl = register.ensureSpecializationCanonicalUrl(elemType);
     const typeGenealogy = register.resolveFsGenealogy(fhirSchema.package_meta, typeUrl);
-    const keys = typeGenealogy.flatMap((fs7) => Object.keys(fs7.elements ?? {}));
+    const keys = typeGenealogy.flatMap((fs6) => Object.keys(fs6.elements ?? {}));
     if (keys.length > 0) typeKeys = new Set(keys);
   }
   for (const elem of elemGens) {
@@ -2461,19 +2520,19 @@ var isNestedElement = (register, fhirSchema, path, snapshot, raw) => {
   if (!raw?.elements || raw.choiceOf !== void 0) return false;
   return hasStructuralElements(register, fhirSchema, path);
 };
-var collectNestedPaths = (fs7) => {
-  if (!fs7.elements) return /* @__PURE__ */ new Set();
+var collectNestedPaths = (fs6) => {
+  if (!fs6.elements) return /* @__PURE__ */ new Set();
   return new Set(
-    collectNestedElements(fs7, [], fs7.elements).filter(([_, el]) => el.elements && Object.keys(el.elements).length > 0).map(([path]) => path.join("."))
+    collectNestedElements(fs6, [], fs6.elements).filter(([_, el]) => el.elements && Object.keys(el.elements).length > 0).map(([path]) => path.join("."))
   );
 };
 function mkNestedIdentifier(register, fhirSchema, path) {
   const nestedTypeOrigins = {};
   const genealogy = fhirSchema.derivation === "constraint" ? register.resolveFsSpecializations(fhirSchema.package_meta, fhirSchema.url) : register.resolveFsGenealogy(fhirSchema.package_meta, fhirSchema.url);
-  for (const fs7 of [...genealogy].reverse()) {
-    const paths = collectNestedPaths(fs7);
+  for (const fs6 of [...genealogy].reverse()) {
+    const paths = collectNestedPaths(fs6);
     for (const p of paths) {
-      nestedTypeOrigins[p] = `${fs7.url}#${p}`;
+      nestedTypeOrigins[p] = `${fs6.url}#${p}`;
     }
   }
   const nestedName = path.join(".");
@@ -2608,10 +2667,10 @@ function isRequired(register, fhirSchema, path) {
   const fieldName = path[path.length - 1];
   if (!fieldName) throw new Error(`Internal error: fieldName is missing for path ${path.join("/")}`);
   const parentPath = path.slice(0, -1);
-  const requires = register.resolveFsGenealogy(fhirSchema.package_meta, fhirSchema.url).flatMap((fs7) => {
-    if (parentPath.length === 0) return fs7.required || [];
-    if (!fs7.elements) return [];
-    let elem = fs7;
+  const requires = register.resolveFsGenealogy(fhirSchema.package_meta, fhirSchema.url).flatMap((fs6) => {
+    if (parentPath.length === 0) return fs6.required || [];
+    if (!fs6.elements) return [];
+    let elem = fs6;
     for (const k of parentPath) {
       elem = elem?.elements?.[k];
     }
@@ -2623,10 +2682,10 @@ function isExcluded(register, fhirSchema, path) {
   const fieldName = path[path.length - 1];
   if (!fieldName) throw new Error(`Internal error: fieldName is missing for path ${path.join("/")}`);
   const parentPath = path.slice(0, -1);
-  const requires = register.resolveFsGenealogy(fhirSchema.package_meta, fhirSchema.url).flatMap((fs7) => {
-    if (parentPath.length === 0) return fs7.excluded || [];
-    if (!fs7.elements) return [];
-    let elem = fs7;
+  const requires = register.resolveFsGenealogy(fhirSchema.package_meta, fhirSchema.url).flatMap((fs6) => {
+    if (parentPath.length === 0) return fs6.excluded || [];
+    if (!fs6.elements) return [];
+    let elem = fs6;
     for (const k of parentPath) {
       elem = elem?.elements?.[k];
     }
@@ -2638,9 +2697,9 @@ var buildReferences = (register, fhirSchema, element) => {
   if (!element.refers) return void 0;
   return element.refers.map((ref) => {
     const curl = register.ensureSpecializationCanonicalUrl(ref);
-    const fs7 = register.resolveFs(fhirSchema.package_meta, curl);
-    if (!fs7) throw new Error(`Failed to resolve fs for ${curl}`);
-    return mkIdentifier(fs7);
+    const fs6 = register.resolveFs(fhirSchema.package_meta, curl);
+    if (!fs6) throw new Error(`Failed to resolve fs for ${curl}`);
+    return mkIdentifier(fs6);
   });
 };
 var extractSliceFieldNames = (schema) => {
@@ -3372,7 +3431,8 @@ var mutableFillReport = (report, tsIndex, shakedIndex) => {
 };
 var treeShakeTypeSchema = (schema, rule, _logger) => {
   schema = JSON.parse(JSON.stringify(schema));
-  if (isPrimitiveTypeSchema(schema) || isValueSetTypeSchema(schema) || isBindingSchema(schema)) return schema;
+  if (isPrimitiveTypeSchema(schema) || isValueSetTypeSchema(schema) || isBindingSchema(schema) || isSnapshotProfileTypeSchema(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);
@@ -3467,13 +3527,13 @@ var typeSchemaToJson = (ts, pretty) => {
     genContent: () => JSON.stringify(ts, null, pretty ? 2 : void 0)
   };
 };
-var fhirSchemaToJson = (fs7, pretty) => {
-  const pkgPath = normalizeFileName(fs7.package_meta.name);
-  const name = normalizeFileName(`${fs7.name}(${extractNameFromCanonical(fs7.url)})`);
+var fhirSchemaToJson = (fs6, pretty) => {
+  const pkgPath = normalizeFileName(fs6.package_meta.name);
+  const name = normalizeFileName(`${fs6.name}(${extractNameFromCanonical(fs6.url)})`);
   const baseName = Path5.join(pkgPath, name);
   return {
     filename: baseName,
-    genContent: () => JSON.stringify(fs7, null, pretty ? 2 : void 0)
+    genContent: () => JSON.stringify(fs6, null, pretty ? 2 : void 0)
   };
 };
 var structureDefinitionToJson = (sd, pretty) => {
@@ -3543,16 +3603,16 @@ var IntrospectionWriter = class extends FileSystemWriter {
       const outputPath = this.opts.fhirSchemas;
       const allFs = tsIndex.register.allFs();
       const seenUrls = /* @__PURE__ */ new Set();
-      const fhirSchemas = allFs.filter((fs7) => {
-        if (seenUrls.has(fs7.url)) return false;
-        seenUrls.add(fs7.url);
+      const fhirSchemas = allFs.filter((fs6) => {
+        if (seenUrls.has(fs6.url)) return false;
+        seenUrls.add(fs6.url);
         return true;
       });
       if (Path5.extname(outputPath) === ".ndjson") {
         this.writeNdjson(fhirSchemas, outputPath, fhirSchemaToJson);
       } else {
         this.writeJsonFiles(
-          fhirSchemas.map((fs7) => fhirSchemaToJson(fs7, true)),
+          fhirSchemas.map((fs6) => fhirSchemaToJson(fs6, true)),
           outputPath
         );
       }
@@ -4477,8 +4537,8 @@ var tsFieldName = (n) => {
   return n;
 };
 var tsProfileModuleName = (tsIndex, schema) => {
-  const resourceSchema = tsIndex.findLastSpecialization(schema);
-  const resourceName = uppercaseFirstLetter(normalizeTsName(resourceSchema.identifier.name));
+  const resourceId = tsIndex.findLastSpecializationByIdentifier(schema.identifier);
+  const resourceName = uppercaseFirstLetter(normalizeTsName(resourceId.name));
   return `${resourceName}_${normalizeTsName(schema.identifier.name)}`;
 };
 var tsProfileModuleFileName = (tsIndex, schema) => {
@@ -4605,7 +4665,7 @@ var valueFieldToTsType = (valueField) => {
   return primitives[fhirName] ?? fhirName;
 };
 var collectSubExtensionSlices = (extProfile) => {
-  const extensionField = extProfile.fields?.extension;
+  const extensionField = extProfile.fields.extension;
   if (!extensionField || isChoiceDeclarationField(extensionField) || !extensionField.slicing?.slices) return [];
   const result = [];
   for (const [sliceName, slice] of Object.entries(extensionField.slicing.slices)) {
@@ -4629,10 +4689,11 @@ var resolveExtensionProfile = (tsIndex, pkgName, url) => {
   const schema = tsIndex.resolveByUrl(pkgName, url);
   if (!schema || !isProfileTypeSchema(schema)) return void 0;
   if (schema.identifier.package !== pkgName) return void 0;
-  const className = tsProfileClassName(schema);
-  const modulePath = `./${tsProfileModuleName(tsIndex, schema)}`;
-  const flatProfile = tsIndex.flatProfile(schema);
-  return { className, modulePath, flatProfile };
+  const snapshot = tsIndex.resolve(snapshotIdentifier(schema.identifier));
+  if (!snapshot) return void 0;
+  const className = tsProfileClassName(snapshot);
+  const modulePath = `./${tsProfileModuleName(tsIndex, snapshot)}`;
+  return { className, modulePath, snapshot };
 };
 var generateRawExtensionBody = (w, ext, targetPath, paramName = "input", useUpsert = false) => {
   w.line(
@@ -4698,10 +4759,10 @@ var generateExtensionGetterOverloads = (w, ext, targetPath, methodName, inputTyp
   );
 };
 var generateComplexExtensionSetter = (w, info) => {
-  const { ext, flatProfile, setMethodName, targetPath, extProfileInfo } = info;
-  const tsProfileName = tsResourceName(flatProfile.identifier);
+  const { ext, snapshot, setMethodName, targetPath, extProfileInfo } = info;
+  const tsProfileName = tsResourceName(snapshot.identifier);
   const inputTypeName = tsExtensionFlatTypeName(tsProfileName, ext.name);
-  const extProfileHasFlatInput = extProfileInfo ? collectSubExtensionSlices(extProfileInfo.flatProfile).length > 0 : false;
+  const extProfileHasFlatInput = extProfileInfo ? collectSubExtensionSlices(extProfileInfo.snapshot).length > 0 : false;
   const useUpsert = ext.max === "1";
   if (extProfileInfo && extProfileHasFlatInput) {
     const paramType = `${extProfileInfo.className}Flat | ${extProfileInfo.className} | Extension`;
@@ -4761,10 +4822,10 @@ var generateComplexExtensionSetter = (w, info) => {
   }
 };
 var generateComplexExtensionGetter = (w, info) => {
-  const { ext, flatProfile, getMethodName, targetPath, extProfileInfo } = info;
-  const tsProfileName = tsResourceName(flatProfile.identifier);
+  const { ext, snapshot, getMethodName, targetPath, extProfileInfo } = info;
+  const tsProfileName = tsResourceName(snapshot.identifier);
   const inputTypeName = tsExtensionFlatTypeName(tsProfileName, ext.name);
-  const extProfileHasFlatInput = extProfileInfo ? collectSubExtensionSlices(extProfileInfo.flatProfile).length > 0 : false;
+  const extProfileHasFlatInput = extProfileInfo ? collectSubExtensionSlices(extProfileInfo.snapshot).length > 0 : false;
   const inputType = extProfileHasFlatInput && extProfileInfo ? `${extProfileInfo.className}Flat` : inputTypeName;
   generateExtensionGetterOverloads(w, ext, targetPath, getMethodName, inputType, extProfileInfo, () => {
     const configItems = (ext.subExtensions ?? []).map((sub) => {
@@ -4784,7 +4845,7 @@ var generateSingleValueExtensionSetter = (w, tsIndex, info) => {
   const valueField = tsValueFieldName(firstValueType);
   const useUpsert = ext.max === "1";
   if (extProfileInfo) {
-    const extFactoryInfo = collectProfileFactoryInfo(tsIndex, extProfileInfo.flatProfile);
+    const extFactoryInfo = collectProfileFactoryInfo(tsIndex, extProfileInfo.snapshot);
     const extValueParam = extFactoryInfo.params.find((p) => p.name === valueField);
     const resolvedValueType = extValueParam?.tsType ?? valueType;
     const paramType = `${extProfileInfo.className} | Extension | ${resolvedValueType}`;
@@ -4852,15 +4913,15 @@ var generateGenericExtensionGetter = (w, info) => {
     }
   });
 };
-var generateExtensionMethods = (w, tsIndex, flatProfile) => {
-  for (const ext of flatProfile.extensions ?? []) {
+var generateExtensionMethods = (w, tsIndex, snapshot) => {
+  for (const ext of snapshot.extensions ?? []) {
     if (!ext.url) continue;
     const baseName = ext.nameCandidates.recommended;
     const targetPath = ext.path.split(".").filter((segment) => segment !== "extension");
-    const extProfileInfo = resolveExtensionProfile(tsIndex, flatProfile.identifier.package, ext.url);
+    const extProfileInfo = resolveExtensionProfile(tsIndex, snapshot.identifier.package, ext.url);
     const info = {
       ext,
-      flatProfile,
+      snapshot,
       setMethodName: `set${baseName}`,
       getMethodName: `get${baseName}`,
       targetPath,
@@ -4882,15 +4943,15 @@ var generateExtensionMethods = (w, tsIndex, flatProfile) => {
     w.line();
   }
 };
-var collectTypesFromExtensions = (tsIndex, flatProfile, addType) => {
+var collectTypesFromExtensions = (tsIndex, snapshot, addType) => {
   let needsExtensionType = false;
-  for (const ext of flatProfile.extensions ?? []) {
+  for (const ext of snapshot.extensions ?? []) {
     if (ext.isComplex && ext.subExtensions) {
       needsExtensionType = true;
       for (const sub of ext.subExtensions) {
         if (!sub.valueFieldType) continue;
         const resolvedType = tsIndex.resolveByUrl(
-          flatProfile.identifier.package,
+          snapshot.identifier.package,
           sub.valueFieldType.url
         );
         addType(resolvedType?.identifier ?? sub.valueFieldType);
@@ -4899,7 +4960,7 @@ var collectTypesFromExtensions = (tsIndex, flatProfile, addType) => {
       needsExtensionType = true;
       if (ext.valueFieldTypes[0]) {
         const resolvedType = tsIndex.resolveByUrl(
-          flatProfile.identifier.package,
+          snapshot.identifier.package,
           ext.valueFieldTypes[0].url
         );
         addType(resolvedType?.identifier ?? ext.valueFieldTypes[0]);
@@ -4910,14 +4971,14 @@ var collectTypesFromExtensions = (tsIndex, flatProfile, addType) => {
   }
   return needsExtensionType;
 };
-var collectTypesFromFlatInput = (tsIndex, flatProfile, addType) => {
-  if (flatProfile.base.name !== "Extension") return;
-  const subSlices = collectSubExtensionSlices(flatProfile);
+var collectTypesFromFlatInput = (tsIndex, snapshot, addType) => {
+  if (snapshot.base.name !== "Extension") return;
+  const subSlices = collectSubExtensionSlices(snapshot);
   for (const sub of subSlices) {
     const tsType = sub.tsType;
     if (["string", "boolean", "number"].includes(tsType)) continue;
     const fhirUrl = `http://hl7.org/fhir/StructureDefinition/${tsType}`;
-    const schema = tsIndex.resolveByUrl(flatProfile.identifier.package, fhirUrl);
+    const schema = tsIndex.resolveByUrl(snapshot.identifier.package, fhirUrl);
     if (schema) addType(schema.identifier);
   }
 };
@@ -4943,9 +5004,9 @@ var extractResourceTypeFromMatch = (match) => {
   }
   return void 0;
 };
-var collectTypesFromSlices = (tsIndex, flatProfile, addType) => {
-  const pkgName = flatProfile.identifier.package;
-  for (const field of Object.values(flatProfile.fields ?? {})) {
+var collectTypesFromSlices = (tsIndex, snapshot, addType) => {
+  const pkgName = snapshot.identifier.package;
+  for (const field of Object.values(snapshot.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)) {
@@ -4978,10 +5039,10 @@ var collectRequiredSliceNames = (field) => {
   }).map(([name]) => name);
   return names.length > 0 ? names : void 0;
 };
-var collectSliceDefs = (tsIndex, flatProfile) => Object.entries(flatProfile.fields ?? {}).filter(([_, field]) => isNotChoiceDeclarationField(field) && field.slicing?.slices).flatMap(([fieldName, field]) => {
+var collectSliceDefs = (tsIndex, snapshot) => Object.entries(snapshot.fields).filter(([_, field]) => isNotChoiceDeclarationField(field) && field.slicing?.slices).flatMap(([fieldName, field]) => {
   if (!isNotChoiceDeclarationField(field) || !field.slicing?.slices || !field.type) return [];
   const baseType = tsTypeFromIdentifier(field.type);
-  const pkgName = flatProfile.identifier.package;
+  const pkgName = snapshot.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]) => {
@@ -5009,9 +5070,9 @@ var collectSliceDefs = (tsIndex, flatProfile) => Object.entries(flatProfile.fiel
     };
   });
 });
-var generateSliceSetters = (w, sliceDefs, flatProfile) => {
-  const profileClassName = tsProfileClassName(flatProfile);
-  const tsProfileName = tsResourceName(flatProfile.identifier);
+var generateSliceSetters = (w, sliceDefs, snapshot) => {
+  const profileClassName = tsProfileClassName(snapshot);
+  const tsProfileName = tsResourceName(snapshot.identifier);
   for (const sliceDef of sliceDefs) {
     const baseName = sliceDef.baseName;
     const methodName = `set${baseName}`;
@@ -5073,9 +5134,9 @@ var generateSliceSetters = (w, sliceDefs, flatProfile) => {
     w.line();
   }
 };
-var generateSliceGetters = (w, sliceDefs, flatProfile) => {
-  const profileClassName = tsProfileClassName(flatProfile);
-  const tsProfileName = tsResourceName(flatProfile.identifier);
+var generateSliceGetters = (w, sliceDefs, snapshot) => {
+  const profileClassName = tsProfileClassName(snapshot);
+  const tsProfileName = tsResourceName(snapshot.identifier);
   const defaultMode = w.opts.sliceGetterDefault ?? "flat";
   for (const sliceDef of sliceDefs) {
     const baseName = sliceDef.baseName;
@@ -5206,11 +5267,11 @@ var collectRegularFieldValidation = (errors, warnings, name, field, resolveRef,
     }
   }
 };
-var generateValidateMethod = (w, tsIndex, flatProfile) => {
-  const fields = flatProfile.fields ?? {};
-  const profileName = flatProfile.identifier.name;
-  const canonicalUrl = flatProfile.identifier.url;
-  const canonicalUrlExpr = canonicalUrl ? { url: canonicalUrl, expr: `${tsProfileClassName(flatProfile)}.canonicalUrl` } : void 0;
+var generateValidateMethod = (w, tsIndex, snapshot) => {
+  const fields = snapshot.fields;
+  const profileName = snapshot.identifier.name;
+  const canonicalUrl = snapshot.identifier.url;
+  const canonicalUrlExpr = canonicalUrl ? { url: canonicalUrl, expr: `${tsProfileClassName(snapshot)}.canonicalUrl` } : void 0;
   w.curlyBlock(["validate(): { errors: string[]; warnings: string[] }"], () => {
     w.line(`const profileName = "${profileName}"`);
     w.line("const res = this.resource");
@@ -5238,6 +5299,9 @@ var generateValidateMethod = (w, tsIndex, flatProfile) => {
         tsIndex
       );
     }
+    for (const inheritedName of snapshot.inheritedRequiredFields ?? []) {
+      errors.push(`...validateRequired(res, profileName, ${JSON.stringify(inheritedName)})`);
+    }
     const emitArray = (label, exprs) => {
       if (exprs.length === 0) {
         w.line(`${label}: [],`);
@@ -5256,16 +5320,29 @@ var generateValidateMethod = (w, tsIndex, flatProfile) => {
 };
 
 // src/api/writer-generator/typescript/profile.ts
-var collectChoiceAccessors = (flatProfile, promotedChoices) => {
+var choiceClearMethodName = (choiceOf) => `clear${uppercaseFirstLetter(tsCamelCase(choiceOf))}`;
+var collectChoiceAccessors = (snapshot, promotedChoices) => {
+  const variantsByChoice = {};
+  for (const [name, field] of Object.entries(snapshot.fields)) {
+    if (field.excluded) continue;
+    if (!isChoiceInstanceField(field)) continue;
+    (variantsByChoice[field.choiceOf] ??= []).push(name);
+  }
   const accessors = [];
-  for (const [name, field] of Object.entries(flatProfile.fields ?? {})) {
+  for (const [name, field] of Object.entries(snapshot.fields)) {
     if (field.excluded) continue;
     if (!isChoiceInstanceField(field)) continue;
     if (promotedChoices.has(name)) continue;
     const tsType = tsTypeFromIdentifier(field.type) + (field.array ? "[]" : "");
-    accessors.push({ name, tsType, typeId: field.type });
+    const hasSiblings = (variantsByChoice[field.choiceOf]?.length ?? 0) > 1;
+    const choiceClearMethod = hasSiblings ? choiceClearMethodName(field.choiceOf) : void 0;
+    accessors.push({ name, tsType, typeId: field.type, choiceClearMethod });
   }
-  return accessors;
+  const choiceClearMethods = Object.entries(variantsByChoice).filter(([, variants]) => variants.length > 1).map(([choiceOf, variants]) => ({
+    method: choiceClearMethodName(choiceOf),
+    variants: variants.map(tsFieldName)
+  }));
+  return { accessors, choiceClearMethods };
 };
 var tryPromoteChoice = (field, fields, params, promotedChoices, resolveRef, isFamilyType) => {
   if (!isChoiceDeclarationField(field) || !field.required || field.choices.length !== 1) return;
@@ -5282,18 +5359,18 @@ var mkIsFamilyType = (tsIndex) => (ref) => {
   if (!schema || !("typeFamily" in schema)) return false;
   return (schema.typeFamily?.resources?.length ?? 0) > 0;
 };
-var collectProfileFactoryInfo = (tsIndex, flatProfile) => {
+var collectProfileFactoryInfo = (tsIndex, snapshot) => {
   const autoFields = [];
   const sliceAutoFields = [];
   const params = [];
   const autoAccessors = [];
   const fixedFields = /* @__PURE__ */ new Set();
-  const fields = flatProfile.fields ?? {};
+  const fields = snapshot.fields;
   const promotedChoices = /* @__PURE__ */ new Set();
   const resolveRef = tsIndex.findLastSpecializationByIdentifier;
   const isFamilyType = mkIsFamilyType(tsIndex);
-  if (isResourceIdentifier(flatProfile.base)) {
-    autoFields.push({ name: "resourceType", value: JSON.stringify(flatProfile.base.name) });
+  if (isResourceIdentifier(snapshot.base)) {
+    autoFields.push({ name: "resourceType", value: JSON.stringify(snapshot.base.name) });
   }
   for (const [name, field] of Object.entries(fields)) {
     if (field.excluded) continue;
@@ -5335,7 +5412,7 @@ var collectProfileFactoryInfo = (tsIndex, flatProfile) => {
   }
   collectBaseRequiredParams(
     tsIndex,
-    flatProfile,
+    snapshot,
     resolveRef,
     params,
     [
@@ -5346,12 +5423,13 @@ var collectProfileFactoryInfo = (tsIndex, flatProfile) => {
     ],
     isFamilyType
   );
-  const accessors = [...autoAccessors, ...collectChoiceAccessors(flatProfile, promotedChoices)];
-  return { autoFields, sliceAutoFields, params, accessors, fixedFields };
+  const { accessors: choiceAccessors, choiceClearMethods } = collectChoiceAccessors(snapshot, promotedChoices);
+  const accessors = [...autoAccessors, ...choiceAccessors];
+  return { autoFields, sliceAutoFields, params, accessors, choiceClearMethods, fixedFields };
 };
-var collectBaseRequiredParams = (tsIndex, flatProfile, resolveRef, params, coveredNames, isFamilyType) => {
+var collectBaseRequiredParams = (tsIndex, snapshot, resolveRef, params, coveredNames, isFamilyType) => {
   const covered = new Set(coveredNames);
-  const baseSchema = tsIndex.resolveType(flatProfile.base);
+  const baseSchema = tsIndex.resolveType(snapshot.base);
   if (!baseSchema || !("fields" in baseSchema) || !baseSchema.fields) return;
   for (const [name, field] of Object.entries(baseSchema.fields)) {
     if (covered.has(name)) continue;
@@ -5364,14 +5442,14 @@ var collectBaseRequiredParams = (tsIndex, flatProfile, resolveRef, params, cover
     }
   }
 };
-var generateProfileIndexFile = (w, tsIndex, initialProfiles) => {
-  if (initialProfiles.length === 0) return;
+var generateProfileIndexFile = (w, tsIndex, snapshots) => {
+  if (snapshots.length === 0) return;
   w.cd("profiles", () => {
     w.cat("index.ts", () => {
       const exports$1 = /* @__PURE__ */ new Map();
-      for (const profile of initialProfiles) {
-        const className = tsProfileClassName(profile);
-        const moduleName = tsProfileModuleName(tsIndex, profile);
+      for (const snapshot of snapshots) {
+        const className = tsProfileClassName(snapshot);
+        const moduleName = tsProfileModuleName(tsIndex, snapshot);
         if (!exports$1.has(className)) {
           exports$1.set(className, `export { ${className} } from "./${moduleName}"`);
         }
@@ -5382,14 +5460,15 @@ var generateProfileIndexFile = (w, tsIndex, initialProfiles) => {
     });
   });
 };
-var generateProfileHelpersImport = (w, tsIndex, flatProfile, sliceDefs, factoryInfo) => {
-  const extensions = flatProfile.extensions ?? [];
-  const hasMeta = tsIndex.isWithMetaField(flatProfile);
-  const canonicalUrl = flatProfile.identifier.url;
+var generateProfileHelpersImport = (w, tsIndex, snapshot, sliceDefs, factoryInfo) => {
+  const extensions = snapshot.extensions ?? [];
+  const hasMeta = tsIndex.isWithMetaField(snapshot);
+  const canonicalUrl = snapshot.identifier.url;
   const imports = [];
-  if (flatProfile.base.name === "Extension" && !!canonicalUrl && collectSubExtensionSlices(flatProfile).length > 0)
+  if (snapshot.base.name === "Extension" && canonicalUrl && collectSubExtensionSlices(snapshot).length > 0)
     imports.push("isRawExtensionInput");
   if (canonicalUrl && hasMeta) imports.push("ensureProfile");
+  if (factoryInfo.autoFields.some((f) => f.name !== "resourceType")) imports.push("applyFixedValue");
   if (sliceDefs.length > 0 || factoryInfo.sliceAutoFields.length > 0)
     imports.push("applySliceMatch", "matchesValue", "setArraySlice", "getArraySlice", "ensureSliceDefaults");
   const hasUnboundedSlice = sliceDefs.some((s) => s.array && (s.max === 0 || s.max === void 0));
@@ -5401,7 +5480,7 @@ var generateProfileHelpersImport = (w, tsIndex, flatProfile, sliceDefs, factoryI
     imports.push("isExtension", "getExtensionValue", "pushExtension");
     if (extensions.some((ext) => ext.url && ext.max === "1")) imports.push("upsertExtension");
   }
-  if (Object.keys(flatProfile.fields ?? {}).length > 0)
+  if (Object.keys(snapshot.fields).length > 0 || (snapshot.inheritedRequiredFields?.length ?? 0) > 0)
     imports.push(
       "validateRequired",
       "validateExcluded",
@@ -5418,7 +5497,7 @@ var generateProfileHelpersImport = (w, tsIndex, flatProfile, sliceDefs, factoryI
     w.line();
   }
 };
-var generateProfileImports = (w, tsIndex, flatProfile) => {
+var generateProfileImports = (w, tsIndex, snapshot) => {
   const usedTypes = /* @__PURE__ */ new Map();
   const getModulePath = (typeId) => {
     if (isNestedIdentifier(typeId)) {
@@ -5434,17 +5513,17 @@ var generateProfileImports = (w, tsIndex, flatProfile) => {
       usedTypes.set(tsName, { importPath: getModulePath(typeId), tsName });
     }
   };
-  addType(flatProfile.base);
-  collectTypesFromSlices(tsIndex, flatProfile, addType);
-  const needsExtensionType = collectTypesFromExtensions(tsIndex, flatProfile, addType);
-  collectTypesFromFlatInput(tsIndex, flatProfile, addType);
-  const factoryInfo = collectProfileFactoryInfo(tsIndex, flatProfile);
+  addType(snapshot.base);
+  collectTypesFromSlices(tsIndex, snapshot, addType);
+  const needsExtensionType = collectTypesFromExtensions(tsIndex, snapshot, addType);
+  collectTypesFromFlatInput(tsIndex, snapshot, addType);
+  const factoryInfo = collectProfileFactoryInfo(tsIndex, snapshot);
   for (const param of factoryInfo.params) addType(param.typeId);
   for (const f of factoryInfo.sliceAutoFields) addType(f.typeId);
   for (const accessor of factoryInfo.accessors) addType(accessor.typeId);
   if (needsExtensionType) {
     const extensionUrl = "http://hl7.org/fhir/StructureDefinition/Extension";
-    const extensionSchema = tsIndex.resolveByUrl(flatProfile.identifier.package, extensionUrl);
+    const extensionSchema = tsIndex.resolveByUrl(snapshot.identifier.package, extensionUrl);
     if (extensionSchema) addType(extensionSchema.identifier);
   }
   const grouped = /* @__PURE__ */ new Map();
@@ -5462,12 +5541,12 @@ var generateProfileImports = (w, tsIndex, flatProfile) => {
   }
   if (sortedModules.length > 0) w.line();
   const extProfileImports = /* @__PURE__ */ new Map();
-  for (const ext of flatProfile.extensions ?? []) {
+  for (const ext of snapshot.extensions ?? []) {
     if (!ext.url) continue;
-    const info = resolveExtensionProfile(tsIndex, flatProfile.identifier.package, ext.url);
+    const info = resolveExtensionProfile(tsIndex, snapshot.identifier.package, ext.url);
     if (!info) continue;
     if (!extProfileImports.has(info.className)) {
-      const hasFlatInput = collectSubExtensionSlices(info.flatProfile).length > 0;
+      const hasFlatInput = collectSubExtensionSlices(info.snapshot).length > 0;
       extProfileImports.set(info.className, { modulePath: info.modulePath, hasFlatInput });
     }
   }
@@ -5496,10 +5575,10 @@ var generateStaticSliceFields = (w, sliceDefs) => {
   }
   if (sliceDefs.length > 0) w.line();
 };
-var generateFactoryMethods = (w, tsIndex, flatProfile, factoryInfo) => {
-  const profileClassName = tsProfileClassName(flatProfile);
-  const tsBaseResourceName = tsTypeFromIdentifier(flatProfile.base);
-  const hasMeta = tsIndex.isWithMetaField(flatProfile);
+var generateFactoryMethods = (w, tsIndex, snapshot, factoryInfo) => {
+  const profileClassName = tsProfileClassName(snapshot);
+  const tsBaseResourceName = tsTypeFromIdentifier(snapshot.base);
+  const hasMeta = tsIndex.isWithMetaField(snapshot);
   const hasParams = factoryInfo.params.length > 0 || factoryInfo.sliceAutoFields.length > 0;
   const createArgsTypeName = `${profileClassName}Raw`;
   const paramSignature = hasParams ? `args: ${createArgsTypeName}` : "";
@@ -5526,13 +5605,13 @@ var generateFactoryMethods = (w, tsIndex, flatProfile, factoryInfo) => {
     w.lineSM("return profile");
   });
   w.line();
-  const canEmitIs = hasMeta && isResourceIdentifier(flatProfile.base) || flatProfile.base.name === "Extension";
+  const canEmitIs = hasMeta && isResourceIdentifier(snapshot.base) || snapshot.base.name === "Extension";
   if (canEmitIs) {
     w.curlyBlock(["static", "is", "(resource: unknown)", `: resource is ${tsBaseResourceName}`], () => {
       w.line(`if (typeof resource !== "object" || resource === null) return false;`);
-      if (hasMeta && isResourceIdentifier(flatProfile.base)) {
+      if (hasMeta && isResourceIdentifier(snapshot.base)) {
         w.line(`const r = resource as { resourceType?: string; meta?: { profile?: string[] } };`);
-        w.line(`if (r.resourceType !== ${JSON.stringify(flatProfile.base.name)}) return false;`);
+        w.line(`if (r.resourceType !== ${JSON.stringify(snapshot.base.name)}) return false;`);
         w.lineSM(`return (r.meta?.profile ?? []).includes(${profileClassName}.canonicalUrl)`);
       } else {
         w.lineSM(`return (resource as { url?: string }).url === ${profileClassName}.canonicalUrl`);
@@ -5544,16 +5623,14 @@ var generateFactoryMethods = (w, tsIndex, flatProfile, factoryInfo) => {
     if (hasMeta) {
       w.lineSM(`ensureProfile(resource, ${profileClassName}.canonicalUrl)`);
     }
-    if (flatProfile.base.name === "Extension" && flatProfile.identifier.url) {
+    if (snapshot.base.name === "Extension" && snapshot.identifier.url) {
       w.lineSM(`resource.url = ${profileClassName}.canonicalUrl`);
     }
     const applyAutoFields = factoryInfo.autoFields.filter((f) => f.name !== "resourceType");
     if (applyAutoFields.length > 0) {
-      w.curlyBlock(["Object.assign(resource,"], () => {
-        for (const f of applyAutoFields) {
-          w.line(`${f.name}: ${f.value},`);
-        }
-      }, [")"]);
+      for (const f of applyAutoFields) {
+        w.lineSM(`applyFixedValue(resource, ${JSON.stringify(f.name)}, ${f.value})`);
+      }
     }
     for (const f of factoryInfo.sliceAutoFields) {
       const matchRefs = f.sliceNames.map((s) => `${profileClassName}.${tsSliceStaticName(s)}SliceMatch`);
@@ -5569,7 +5646,7 @@ var generateFactoryMethods = (w, tsIndex, flatProfile, factoryInfo) => {
     w.lineSM(`return new ${profileClassName}(resource)`);
   });
   w.line();
-  const subSlicesForInput = flatProfile.base.name === "Extension" ? collectSubExtensionSlices(flatProfile) : [];
+  const subSlicesForInput = snapshot.base.name === "Extension" ? collectSubExtensionSlices(snapshot) : [];
   const hasInputHelper = subSlicesForInput.length > 0;
   if (hasInputHelper) {
     const rawInputTypeName = `${profileClassName}Raw`;
@@ -5669,7 +5746,7 @@ var generateFactoryMethods = (w, tsIndex, flatProfile, factoryInfo) => {
       if (factoryInfo.sliceAutoFields.length > 0) {
         w.line();
       }
-      if (isPrimitiveIdentifier(flatProfile.base)) {
+      if (isPrimitiveIdentifier(snapshot.base)) {
         w.lineSM(`const resource = undefined as unknown as ${tsBaseResourceName}`);
       } else {
         const hasMetaParam = allFields.some((f) => f.name === "meta");
@@ -5726,20 +5803,27 @@ var generateFieldAccessors = (w, factoryInfo) => {
     w.line();
     if (!factoryInfo.fixedFields.has(a.name)) {
       w.curlyBlock([`set${methodBaseName}`, `(value: ${a.tsType})`, ": this"], () => {
+        if (a.choiceClearMethod) w.lineSM(`this.${a.choiceClearMethod}()`);
         w.lineSM(`Object.assign(this.resource, { ${fieldAccess}: value })`);
         w.lineSM("return this");
       });
       w.line();
     }
   }
+  for (const { method, variants } of factoryInfo.choiceClearMethods) {
+    w.curlyBlock([method, "()", ": void"], () => {
+      for (const variant of variants) w.lineSM(`delete ${tsGet("this.resource", variant)}`);
+    });
+    w.line();
+  }
 };
-var generateInlineExtensionInputTypes = (w, tsIndex, flatProfile) => {
-  const tsProfileName = tsResourceName(flatProfile.identifier);
-  const complexExtensions = (flatProfile.extensions ?? []).filter((ext) => ext.isComplex && ext.subExtensions);
+var generateInlineExtensionInputTypes = (w, tsIndex, snapshot) => {
+  const tsProfileName = tsResourceName(snapshot.identifier);
+  const complexExtensions = (snapshot.extensions ?? []).filter((ext) => ext.isComplex && ext.subExtensions);
   for (const ext of complexExtensions) {
     if (!ext.url) continue;
-    const extProfileInfo = resolveExtensionProfile(tsIndex, flatProfile.identifier.package, ext.url);
-    const hasFlatInput = extProfileInfo ? collectSubExtensionSlices(extProfileInfo.flatProfile).length > 0 : false;
+    const extProfileInfo = resolveExtensionProfile(tsIndex, snapshot.identifier.package, ext.url);
+    const hasFlatInput = extProfileInfo ? collectSubExtensionSlices(extProfileInfo.snapshot).length > 0 : false;
     if (hasFlatInput) continue;
     const typeName = tsExtensionFlatTypeName(tsProfileName, ext.name);
     w.curlyBlock(["export", "type", typeName, "="], () => {
@@ -5764,9 +5848,9 @@ var valueToTypeLiteral = (value) => {
   }
   return "unknown";
 };
-var generateSliceInputTypes = (w, flatProfile, sliceDefs) => {
+var generateSliceInputTypes = (w, snapshot, sliceDefs) => {
   if (sliceDefs.length === 0) return;
-  const tsProfileName = tsResourceName(flatProfile.identifier);
+  const tsProfileName = tsResourceName(snapshot.identifier);
   for (const sliceDef of sliceDefs) {
     const inputTypeName = tsSliceFlatTypeName(tsProfileName, sliceDef.fieldName, sliceDef.sliceName);
     const flatTypeName = tsSliceFlatAllTypeName(tsProfileName, sliceDef.fieldName, sliceDef.sliceName);
@@ -5809,11 +5893,11 @@ var generateSliceInputTypes = (w, flatProfile, sliceDefs) => {
     w.line();
   }
 };
-var generateRawType = (w, flatProfile, factoryInfo) => {
+var generateRawType = (w, snapshot, factoryInfo) => {
   const hasParams = factoryInfo.params.length > 0 || factoryInfo.sliceAutoFields.length > 0;
-  const subSlices = flatProfile.base.name === "Extension" ? collectSubExtensionSlices(flatProfile) : [];
+  const subSlices = snapshot.base.name === "Extension" ? collectSubExtensionSlices(snapshot) : [];
   if (!hasParams && subSlices.length === 0) return;
-  const createArgsTypeName = `${tsProfileClassName(flatProfile)}Raw`;
+  const createArgsTypeName = `${tsProfileClassName(snapshot)}Raw`;
   w.curlyBlock(["export", "type", createArgsTypeName, "="], () => {
     for (const p of factoryInfo.params) {
       w.lineSM(`${p.name}: ${p.tsType}`);
@@ -5828,10 +5912,10 @@ var generateRawType = (w, flatProfile, factoryInfo) => {
   });
   w.line();
 };
-var generateFlatInputType = (w, flatProfile) => {
-  const subSlices = flatProfile.base.name === "Extension" ? collectSubExtensionSlices(flatProfile) : [];
+var generateFlatInputType = (w, snapshot) => {
+  const subSlices = snapshot.base.name === "Extension" ? collectSubExtensionSlices(snapshot) : [];
   if (subSlices.length === 0) return;
-  const flatInputTypeName = `${tsProfileClassName(flatProfile)}Flat`;
+  const flatInputTypeName = `${tsProfileClassName(snapshot)}Flat`;
   w.curlyBlock(["export", "type", flatInputTypeName, "="], () => {
     for (const sub of subSlices) {
       const opt = sub.isRequired ? "" : "?";
@@ -5841,33 +5925,33 @@ var generateFlatInputType = (w, flatProfile) => {
   });
   w.line();
 };
-var generateProfileClass = (w, tsIndex, flatProfile) => {
-  const tsBaseResourceName = tsTypeFromIdentifier(flatProfile.base);
-  const profileClassName = tsProfileClassName(flatProfile);
-  const sliceDefs = collectSliceDefs(tsIndex, flatProfile);
-  const factoryInfo = collectProfileFactoryInfo(tsIndex, flatProfile);
-  generateInlineExtensionInputTypes(w, tsIndex, flatProfile);
-  generateSliceInputTypes(w, flatProfile, sliceDefs);
-  generateProfileHelpersImport(w, tsIndex, flatProfile, sliceDefs, factoryInfo);
-  generateRawType(w, flatProfile, factoryInfo);
-  generateFlatInputType(w, flatProfile);
-  const canonicalUrl = flatProfile.identifier.url;
-  w.comment("CanonicalURL:", canonicalUrl, `(pkg: ${packageMetaToFhir(packageMeta(flatProfile))})`);
+var generateProfileClass = (w, tsIndex, snapshot) => {
+  const tsBaseResourceName = tsTypeFromIdentifier(snapshot.base);
+  const profileClassName = tsProfileClassName(snapshot);
+  const sliceDefs = collectSliceDefs(tsIndex, snapshot);
+  const factoryInfo = collectProfileFactoryInfo(tsIndex, snapshot);
+  generateInlineExtensionInputTypes(w, tsIndex, snapshot);
+  generateSliceInputTypes(w, snapshot, sliceDefs);
+  generateProfileHelpersImport(w, tsIndex, snapshot, sliceDefs, factoryInfo);
+  generateRawType(w, snapshot, factoryInfo);
+  generateFlatInputType(w, snapshot);
+  const canonicalUrl = snapshot.identifier.url;
+  w.comment("CanonicalURL:", canonicalUrl, `(pkg: ${packageMetaToFhir(packageMeta(snapshot))})`);
   w.curlyBlock(["export", "class", profileClassName], () => {
     w.lineSM(`static readonly canonicalUrl = ${JSON.stringify(canonicalUrl)}`);
     w.line();
     generateStaticSliceFields(w, sliceDefs);
     w.lineSM(`private resource: ${tsBaseResourceName}`);
     w.line();
-    generateFactoryMethods(w, tsIndex, flatProfile, factoryInfo);
+    generateFactoryMethods(w, tsIndex, snapshot, factoryInfo);
     generateFieldAccessors(w, factoryInfo);
     w.line("// Extensions");
-    generateExtensionMethods(w, tsIndex, flatProfile);
+    generateExtensionMethods(w, tsIndex, snapshot);
     w.line("// Slices");
-    generateSliceSetters(w, sliceDefs, flatProfile);
-    generateSliceGetters(w, sliceDefs, flatProfile);
+    generateSliceSetters(w, sliceDefs, snapshot);
+    generateSliceGetters(w, sliceDefs, snapshot);
     w.line("// Validation");
-    generateValidateMethod(w, tsIndex, flatProfile);
+    generateValidateMethod(w, tsIndex, snapshot);
   });
   w.line();
 };
@@ -5881,7 +5965,7 @@ var resolveTsAssets = (fn) => {
   }
   return Path5.resolve(__dirname, "../../../..", "assets", "api", "writer-generator", "typescript", fn);
 };
-var leafOf2 = (path) => path[path.length - 1] ?? "";
+var leafOf3 = (path) => path[path.length - 1] ?? "";
 var TS_HARDCODED_GENERIC_NAMES = /* @__PURE__ */ new Set(["Reference", "Coding", "CodeableConcept"]);
 var TypeScript = class extends Writer {
   constructor(options) {
@@ -5921,13 +6005,13 @@ var TypeScript = class extends Writer {
   }
   generateFhirPackageIndexFile(schemas) {
     this.cat("index.ts", () => {
-      const profiles = schemas.filter(isProfileTypeSchema);
+      const profiles = schemas.filter(isSnapshotProfileTypeSchema);
       if (profiles.length > 0) {
         this.lineSM(`export * from "./profiles"`);
       }
       let exports$1 = schemas.flatMap((schema) => {
         const resourceName = tsResourceName(schema.identifier);
-        const typeExports = isProfileTypeSchema(schema) ? [] : [
+        const typeExports = isSnapshotProfileTypeSchema(schema) ? [] : [
           resourceName,
           ...isResourceTypeSchema(schema) && schema.nested || isLogicalTypeSchema(schema) && schema.nested ? schema.nested.map((n) => tsResourceName(n.identifier)) : []
         ];
@@ -6024,11 +6108,11 @@ var TypeScript = class extends Writer {
         const targetParams = isNestedTypeSchema(target) || isSpecializationTypeSchema(target) ? target.generic?.params : void 0;
         if (targetParams?.length) {
           const args = targetParams.map(
-            (tp) => params.find((q) => leafOf2(q.path) === leafOf2(tp.path))?.typeVar ?? tp.typeVar
+            (tp) => params.find((q) => leafOf3(q.path) === leafOf3(tp.path))?.typeVar ?? tp.typeVar
           );
           nestedArgsByField[tsName] = `<${args.join(", ")}>`;
         } else if (isSpecializationTypeSchema(target) && (target.typeFamily?.resources?.length ?? 0) > 0) {
-          const p = params.find((q) => leafOf2(q.path) === fieldName);
+          const p = params.find((q) => leafOf3(q.path) === fieldName);
           if (p) fieldMap[tsName] = p.typeVar;
         }
       }
@@ -6106,13 +6190,12 @@ var TypeScript = class extends Writer {
     }
   }
   generateResourceModule(tsIndex, schema) {
-    if (isProfileTypeSchema(schema)) {
+    if (isSnapshotProfileTypeSchema(schema)) {
       this.cd("profiles", () => {
         this.cat(`${tsProfileModuleFileName(tsIndex, schema)}`, () => {
           this.generateDisclaimer();
-          const flatProfile = tsIndex.flatProfile(schema);
-          generateProfileImports(this, tsIndex, flatProfile);
-          generateProfileClass(this, tsIndex, flatProfile);
+          generateProfileImports(this, tsIndex, schema);
+          generateProfileClass(this, tsIndex, schema);
         });
       });
     } else if (isSpecializationTypeSchema(schema)) {
@@ -6139,10 +6222,10 @@ var TypeScript = class extends Writer {
       ...tsIndex.collectComplexTypes(),
       ...tsIndex.collectResources(),
       ...tsIndex.collectLogicalModels(),
-      ...this.opts.generateProfile ? tsIndex.collectProfiles() : []
+      ...this.opts.generateProfile ? tsIndex.collectSnapshotProfiles() : []
     ];
     const grouped = groupByPackages(typesToGenerate);
-    const hasProfiles = this.opts.generateProfile && typesToGenerate.some(isProfileTypeSchema);
+    const hasProfiles = this.opts.generateProfile && typesToGenerate.some(isSnapshotProfileTypeSchema);
     this.cd("/", () => {
       if (hasProfiles) {
         this.cp("profile-helpers.ts", "profile-helpers.ts");
@@ -6153,7 +6236,7 @@ var TypeScript = class extends Writer {
           for (const schema of packageSchemas) {
             this.generateResourceModule(tsIndex, schema);
           }
-          generateProfileIndexFile(this, tsIndex, packageSchemas.filter(isProfileTypeSchema));
+          generateProfileIndexFile(this, tsIndex, packageSchemas.filter(isSnapshotProfileTypeSchema));
           this.generateFhirPackageIndexFile(packageSchemas);
         });
       }