@atomic-ehr/codegen 0.0.1-canary.20251008162621.549c5d8 → 0.0.1-canary.20251009074815.3e20aa6

package/dist/index.d.ts

@@ -433,6 +433,7 @@ interface Config {
     overwrite?: boolean;
     validate?: boolean;
     cache?: boolean;
+    cleanOutput?: boolean;
     typescript?: TypeScriptGeneratorConfig;
     typeSchema?: TypeSchemaConfig;
     packages?: string[];
@@ -752,6 +753,7 @@ interface APIBuilderOptions {
     verbose?: boolean;
     overwrite?: boolean;
     cache?: boolean;
+    cleanOutput?: boolean;
     typeSchemaConfig?: TypeSchemaConfig;
     logger?: CodegenLogger;
     manager?: ReturnType<typeof CanonicalManager> | null;
@@ -823,6 +825,7 @@ declare class APIBuilder {
     outputTo(directory: string): APIBuilder;
     verbose(enabled?: boolean): APIBuilder;
     throwException(enabled?: boolean): APIBuilder;
+    cleanOutput(enabled?: boolean): APIBuilder;
     generate(): Promise<GenerationResult>;
     /**
      * Generate and return the results without writing to files

package/dist/index.js

@@ -1421,6 +1421,15 @@ var isFhirSchemaBased = (schema) => {
 var isSpecializationTypeSchema = (schema) => {
   return schema?.identifier.kind === "resource" || schema?.identifier.kind === "complex-type" || schema?.identifier.kind === "logical";
 };
+var isComplexTypeTypeSchema = (schema) => {
+  return schema?.identifier.kind === "complex-type";
+};
+var isResourceTypeSchema = (schema) => {
+  return schema?.identifier.kind === "resource";
+};
+var isLogicalTypeSchema = (schema) => {
+  return schema?.identifier.kind === "logical";
+};
 var isProfileTypeSchema = (schema) => {
   return schema?.identifier.kind === "profile";
 };
@@ -1487,29 +1496,29 @@ var registerFromManager = async (manager, logger) => {
     );
   }
   const complexTypes = {};
-  for (const fs2 of Object.values(fsIndex)) {
-    if (fs2.kind === "complex-type") {
-      complexTypes[fs2.url] = fs2;
+  for (const fs3 of Object.values(fsIndex)) {
+    if (fs3.kind === "complex-type") {
+      complexTypes[fs3.url] = fs3;
     }
   }
   const resolveFsGenealogy = (canonicalUrl) => {
-    let fs2 = fsIndex[canonicalUrl];
-    if (fs2 === void 0) throw new Error(`Failed to resolve FHIR Schema genealogy for '${canonicalUrl}'`);
-    const genealogy = [fs2];
-    while (fs2?.base) {
-      fs2 = fsIndex[fs2.base] || fsIndex[nameToCanonical[fs2.base]];
-      genealogy.push(fs2);
-      if (fs2 === void 0) throw new Error(`Failed to resolve FHIR Schema genealogy for '${canonicalUrl}'`);
+    let fs3 = fsIndex[canonicalUrl];
+    if (fs3 === void 0) throw new Error(`Failed to resolve FHIR Schema genealogy for '${canonicalUrl}'`);
+    const genealogy = [fs3];
+    while (fs3?.base) {
+      fs3 = fsIndex[fs3.base] || fsIndex[nameToCanonical[fs3.base]];
+      genealogy.push(fs3);
+      if (fs3 === void 0) throw new Error(`Failed to resolve FHIR Schema genealogy for '${canonicalUrl}'`);
     }
     return genealogy;
   };
   const resolveFsSpecializations = (canonicalUrl) => {
-    return resolveFsGenealogy(canonicalUrl).filter((fs2) => fs2.derivation === "specialization");
+    return resolveFsGenealogy(canonicalUrl).filter((fs3) => fs3.derivation === "specialization");
   };
   return {
     ...manager,
-    appendFs(fs2) {
-      const rfs = enrichFHIRSchema(fs2);
+    appendFs(fs3) {
+      const rfs = enrichFHIRSchema(fs3);
       fsIndex[rfs.url] = rfs;
       nameToCanonical[rfs.name] = rfs.url;
     },
@@ -1529,9 +1538,9 @@ var registerFromManager = async (manager, logger) => {
 var resolveFsElementGenealogy = (genealogy, path) => {
   const [top, ...rest] = path;
   if (top === void 0) return [];
-  return genealogy.map((fs2) => {
-    if (!fs2.elements) return void 0;
-    let elem = fs2.elements?.[top];
+  return genealogy.map((fs3) => {
+    if (!fs3.elements) return void 0;
+    let elem = fs3.elements?.[top];
     for (const k of rest) {
       elem = elem?.elements?.[k];
     }
@@ -1613,7 +1622,7 @@ function mkNestedIdentifier(register, fhirSchema, path, logger) {
   var nestedTypeOrigins = {};
   if (fhirSchema.derivation === "constraint") {
     const specializations = register.resolveFsSpecializations(fhirSchema.url);
-    const nestedTypeGenealogy = specializations.map((fs2) => mkNestedTypes(register, fs2, logger)).filter((e) => e !== void 0).flat();
+    const nestedTypeGenealogy = specializations.map((fs3) => mkNestedTypes(register, fs3, logger)).filter((e) => e !== void 0).flat();
     for (const nt of nestedTypeGenealogy.reverse()) {
       nestedTypeOrigins[nt.identifier.name] = nt.identifier.url;
     }
@@ -1707,10 +1716,10 @@ function extractNestedDependencies(nestedTypes) {
 function isRequired(register, fhirSchema, path) {
   const fieldName = path[path.length - 1];
   const parentPath = path.slice(0, -1);
-  const requires = register.resolveFsGenealogy(fhirSchema.url).flatMap((fs2) => {
-    if (parentPath.length === 0) return fs2.required || [];
-    if (!fs2.elements) return [];
-    let elem = fs2;
+  const requires = register.resolveFsGenealogy(fhirSchema.url).flatMap((fs3) => {
+    if (parentPath.length === 0) return fs3.required || [];
+    if (!fs3.elements) return [];
+    let elem = fs3;
     for (const k of parentPath) {
       elem = elem?.elements?.[k];
     }
@@ -1722,10 +1731,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.url).flatMap((fs2) => {
-    if (parentPath.length === 0) return fs2.excluded || [];
-    if (!fs2.elements) return [];
-    let elem = fs2;
+  const requires = register.resolveFsGenealogy(fhirSchema.url).flatMap((fs3) => {
+    if (parentPath.length === 0) return fs3.excluded || [];
+    if (!fs3.elements) return [];
+    let elem = fs3;
     for (const k of parentPath) {
       elem = elem?.elements?.[k];
     }
@@ -1737,8 +1746,8 @@ var buildReferences = (element, register, _packageInfo) => {
   if (!element.refers) return void 0;
   return element.refers.map((ref) => {
     const curl = register.ensureCanonicalUrl(ref);
-    const fs2 = register.resolveFs(curl);
-    return mkIdentifier(fs2);
+    const fs3 = register.resolveFs(curl);
+    return mkIdentifier(fs3);
   });
 };
 function buildFieldType(register, fhirSchema, element, logger) {
@@ -2554,7 +2563,7 @@ var TypeSchemaGenerator = class {
     };
     const register = await this.registerFromPackageMetas([packageInfo]);
     const valueSets = await this.generateValueSetSchemas(register.allVs(), logger);
-    const fhirSchemas = (await Promise.all(register.allFs().map(async (fs2) => await transformFhirSchema(register, fs2, logger)))).flat();
+    const fhirSchemas = (await Promise.all(register.allFs().map(async (fs3) => await transformFhirSchema(register, fs3, logger)))).flat();
     const allSchemas = [...fhirSchemas, ...valueSets];
     if (this.cache) {
       for (const schema of allSchemas) {
@@ -2934,6 +2943,143 @@ var generateTypeSchemas = async (register, logger) => {
   return fhirSchemas;
 };
 
+// src/typeschema/utils.ts
+var groupByPackages = (typeSchemas) => {
+  const grouped = {};
+  for (const ts of typeSchemas) {
+    const packageName = ts.identifier.package;
+    if (!grouped[packageName]) {
+      grouped[packageName] = [];
+    }
+    grouped[packageName].push(ts);
+  }
+  for (const [_packageName, typeSchemas2] of Object.entries(grouped)) {
+    typeSchemas2.sort((a, b) => a.identifier.name.localeCompare(b.identifier.name));
+  }
+  return grouped;
+};
+var resourceRelatives = (schemas) => {
+  const regularSchemas = schemas.filter(isResourceTypeSchema);
+  const directPairs = [];
+  for (const schema of regularSchemas) {
+    if (schema.base) {
+      directPairs.push({ parent: schema.base, child: schema.identifier });
+    }
+  }
+  const allPairs = [...directPairs];
+  const findTransitiveRelatives = (parentRef) => {
+    const directChildren = directPairs.filter((pair) => pair.parent.name === parentRef.name).map((pair) => pair.child);
+    const transitiveChildren = [];
+    for (const child of directChildren) {
+      transitiveChildren.push(...findTransitiveRelatives(child));
+    }
+    return [...directChildren, ...transitiveChildren];
+  };
+  for (const pair of directPairs) {
+    const transitiveChildren = findTransitiveRelatives(pair.child);
+    for (const transitiveChild of transitiveChildren) {
+      if (!directPairs.some((dp) => dp.parent.name === pair.parent.name && dp.child.name === transitiveChild.name)) {
+        allPairs.push({ parent: pair.parent, child: transitiveChild });
+      }
+    }
+  }
+  return allPairs;
+};
+var mkTypeSchemaIndex = (schemas) => {
+  const index = {};
+  const append = (schema) => {
+    const url = schema.identifier.url;
+    if (!index[url]) {
+      index[url] = {};
+    }
+    index[url][schema.identifier.package] = schema;
+  };
+  for (const schema of schemas) {
+    append(schema);
+  }
+  const relations = resourceRelatives(schemas);
+  const resolve2 = (id) => index[id.url]?.[id.package];
+  const resourceChildren = (id) => {
+    return relations.filter((relative2) => relative2.parent.name === id.name).map((relative2) => relative2.child);
+  };
+  const hierarchy = (schema) => {
+    const res = [];
+    let cur = schema;
+    while (cur) {
+      res.push(cur);
+      const base = cur.base;
+      if (base === void 0) break;
+      const resolved = resolve2(base);
+      if (!resolved) {
+        throw new Error(
+          `Failed to resolve base type: ${res.map((e) => `${e.identifier.url} (${e.identifier.kind})`).join(", ")}`
+        );
+      }
+      cur = resolved;
+    }
+    return res;
+  };
+  const findLastSpecialization = (id) => {
+    const schema = resolve2(id);
+    if (!schema) return id;
+    const nonConstraintSchema = hierarchy(schema).find((s) => s.identifier.kind !== "profile");
+    if (!nonConstraintSchema) {
+      throw new Error(`No non-constraint schema found in hierarchy for ${id.name}`);
+    }
+    return nonConstraintSchema.identifier;
+  };
+  const flatProfile = (schema) => {
+    const hierarchySchemas = hierarchy(schema);
+    const constraintSchemas = hierarchySchemas.filter((s) => s.identifier.kind === "profile");
+    const nonConstraintSchema = hierarchySchemas.find((s) => s.identifier.kind !== "profile");
+    if (!nonConstraintSchema)
+      throw new Error(`No non-constraint schema found in hierarchy for ${schema.identifier.name}`);
+    const mergedFields = {};
+    for (const anySchema of constraintSchemas.slice().reverse()) {
+      const schema2 = anySchema;
+      if (!schema2.fields) continue;
+      for (const [fieldName, fieldConstraints] of Object.entries(schema2.fields)) {
+        if (mergedFields[fieldName]) {
+          mergedFields[fieldName] = { ...mergedFields[fieldName], ...fieldConstraints };
+        } else {
+          mergedFields[fieldName] = { ...fieldConstraints };
+        }
+      }
+    }
+    const deps = {};
+    for (const e of constraintSchemas.flatMap((e2) => e2.dependencies ?? [])) {
+      deps[e.url] = e;
+    }
+    const dependencies = Object.values(deps);
+    return {
+      ...schema,
+      base: nonConstraintSchema.identifier,
+      fields: mergedFields,
+      dependencies
+    };
+  };
+  const isWithMetaField = (profile) => {
+    return hierarchy(profile).filter(isSpecializationTypeSchema).some((schema) => {
+      console.log(schema.fields?.meta);
+      return schema.fields?.meta !== void 0;
+    });
+  };
+  return {
+    _schemaIndex: index,
+    _relations: relations,
+    collectComplexTypes: () => schemas.filter(isComplexTypeTypeSchema),
+    collectResources: () => schemas.filter(isResourceTypeSchema),
+    collectLogicalModels: () => schemas.filter(isLogicalTypeSchema),
+    collectProfiles: () => schemas.filter(isProfileTypeSchema),
+    resolve: resolve2,
+    resourceChildren,
+    hierarchy,
+    findLastSpecialization,
+    flatProfile,
+    isWithMetaField
+  };
+};
+
 // src/api/generators/base/error-handler.ts
 init_errors();
 var ErrorHandler = class {
@@ -5019,7 +5165,7 @@ var FileSystemWriter = class {
     if (!this.currentFileDescriptor) throw new Error("No file opened");
     fs.writeSync(this.currentFileDescriptor, str);
   }
-  generate(_schemas) {
+  generate(_tsIndex) {
     throw new Error("Not implemented");
   }
   writtenFiles() {
@@ -5101,142 +5247,6 @@ var Writer = class extends FileSystemWriter {
   }
 };
 
-// src/typeschema/utils.ts
-var groupByPackages = (typeSchemas) => {
-  const grouped = {};
-  for (const ts of typeSchemas) {
-    const packageName = ts.identifier.package;
-    if (!grouped[packageName]) {
-      grouped[packageName] = [];
-    }
-    grouped[packageName].push(ts);
-  }
-  for (const [_packageName, typeSchemas2] of Object.entries(grouped)) {
-    typeSchemas2.sort((a, b) => a.identifier.name.localeCompare(b.identifier.name));
-  }
-  return grouped;
-};
-var collectComplexTypes = (tss) => tss.filter((t) => t.identifier.kind === "complex-type");
-var collectResources = (tss) => tss.filter((t) => t.identifier.kind === "resource");
-var collectProfiles = (tss) => tss.filter(isProfileTypeSchema);
-var resourceRelatives = (schemas) => {
-  const regularSchemas = collectResources(schemas);
-  const directPairs = [];
-  for (const schema of regularSchemas) {
-    if (schema.base) {
-      directPairs.push({ parent: schema.base, child: schema.identifier });
-    }
-  }
-  const allPairs = [...directPairs];
-  const findTransitiveRelatives = (parentRef) => {
-    const directChildren = directPairs.filter((pair) => pair.parent.name === parentRef.name).map((pair) => pair.child);
-    const transitiveChildren = [];
-    for (const child of directChildren) {
-      transitiveChildren.push(...findTransitiveRelatives(child));
-    }
-    return [...directChildren, ...transitiveChildren];
-  };
-  for (const pair of directPairs) {
-    const transitiveChildren = findTransitiveRelatives(pair.child);
-    for (const transitiveChild of transitiveChildren) {
-      if (!directPairs.some((dp) => dp.parent.name === pair.parent.name && dp.child.name === transitiveChild.name)) {
-        allPairs.push({ parent: pair.parent, child: transitiveChild });
-      }
-    }
-  }
-  return allPairs;
-};
-var mkTypeSchemaIndex = (schemas) => {
-  const index = {};
-  const append = (schema) => {
-    const url = schema.identifier.url;
-    if (!index[url]) {
-      index[url] = {};
-    }
-    index[url][schema.identifier.package] = schema;
-  };
-  for (const schema of schemas) {
-    append(schema);
-  }
-  const relations = resourceRelatives(schemas);
-  const resolve2 = (id) => index[id.url]?.[id.package];
-  const resourceChildren = (id) => {
-    return relations.filter((relative2) => relative2.parent.name === id.name).map((relative2) => relative2.child);
-  };
-  const hierarchy = (schema) => {
-    const res = [];
-    let cur = schema;
-    while (cur) {
-      res.push(cur);
-      const base = cur.base;
-      if (base === void 0) break;
-      const resolved = resolve2(base);
-      if (!resolved) {
-        throw new Error(
-          `Failed to resolve base type: ${res.map((e) => `${e.identifier.url} (${e.identifier.kind})`).join(", ")}`
-        );
-      }
-      cur = resolved;
-    }
-    return res;
-  };
-  const findLastSpecialization = (id) => {
-    const schema = resolve2(id);
-    if (!schema) return id;
-    const nonConstraintSchema = hierarchy(schema).find((s) => s.identifier.kind !== "profile");
-    if (!nonConstraintSchema) {
-      throw new Error(`No non-constraint schema found in hierarchy for ${id.name}`);
-    }
-    return nonConstraintSchema.identifier;
-  };
-  const flatProfile = (schema) => {
-    const hierarchySchemas = hierarchy(schema);
-    const constraintSchemas = hierarchySchemas.filter((s) => s.identifier.kind === "profile");
-    const nonConstraintSchema = hierarchySchemas.find((s) => s.identifier.kind !== "profile");
-    if (!nonConstraintSchema)
-      throw new Error(`No non-constraint schema found in hierarchy for ${schema.identifier.name}`);
-    const mergedFields = {};
-    for (const anySchema of constraintSchemas.slice().reverse()) {
-      const schema2 = anySchema;
-      if (!schema2.fields) continue;
-      for (const [fieldName, fieldConstraints] of Object.entries(schema2.fields)) {
-        if (mergedFields[fieldName]) {
-          mergedFields[fieldName] = { ...mergedFields[fieldName], ...fieldConstraints };
-        } else {
-          mergedFields[fieldName] = { ...fieldConstraints };
-        }
-      }
-    }
-    const deps = {};
-    for (const e of constraintSchemas.flatMap((e2) => e2.dependencies ?? [])) {
-      deps[e.url] = e;
-    }
-    const dependencies = Object.values(deps);
-    return {
-      ...schema,
-      base: nonConstraintSchema.identifier,
-      fields: mergedFields,
-      dependencies
-    };
-  };
-  const isWithMetaField = (profile) => {
-    return hierarchy(profile).filter(isSpecializationTypeSchema).some((schema) => {
-      console.log(schema.fields?.meta);
-      return schema.fields?.meta !== void 0;
-    });
-  };
-  return {
-    schemaIndex: index,
-    relations,
-    resolve: resolve2,
-    resourceChildren,
-    hierarchy,
-    findLastSpecialization,
-    flatProfile,
-    isWithMetaField
-  };
-};
-
 // src/api/writer-generator/typescript.ts
 var primitiveType2tsType = {
   boolean: "boolean",
@@ -5302,7 +5312,6 @@ var normalizeTsName = (n) => {
   return n.replace(/[- ]/g, "_");
 };
 var TypeScript = class extends Writer {
-  tsIndex = mkTypeSchemaIndex([]);
   tsImportType(tsPackageName, ...entities) {
     this.lineSM(`import type { ${entities.join(", ")} } from "${tsPackageName}"`);
   }
@@ -5368,7 +5377,7 @@ var TypeScript = class extends Writer {
       this.lineSM(`_${tsFieldName(fieldName)}?: Element`);
     }
   }
-  generateType(schema) {
+  generateType(tsIndex, schema) {
     var name;
     if (schema.identifier.name === "Reference") {
       name = "Reference<T extends string = string>";
@@ -5384,7 +5393,7 @@ var TypeScript = class extends Writer {
       if (!schema.fields) return;
       if (schema.identifier.kind === "resource") {
         const possibleResourceTypes = [schema.identifier];
-        possibleResourceTypes.push(...this.tsIndex.resourceChildren(schema.identifier));
+        possibleResourceTypes.push(...tsIndex.resourceChildren(schema.identifier));
         this.lineSM(`resourceType: ${possibleResourceTypes.map((e) => `"${e.name}"`).join(" | ")}`);
         this.line();
       }
@@ -5420,14 +5429,14 @@ var TypeScript = class extends Writer {
       }
     });
   }
-  generateNestedTypes(schema) {
+  generateNestedTypes(tsIndex, schema) {
     if (schema.nested) {
       for (const subtype of schema.nested) {
-        this.generateType(subtype);
+        this.generateType(tsIndex, subtype);
       }
     }
   }
-  generateProfileType(schema) {
+  generateProfileType(tsIndex, schema) {
     const name = tsResourceName(schema.identifier);
     this.debugComment("identifier", schema.identifier);
     this.debugComment("base", schema.base);
@@ -5445,8 +5454,8 @@ var TypeScript = class extends Writer {
         } else if (field.enum) {
           tsType = field.enum.map((e) => `'${e}'`).join(" | ");
         } else if (field.reference && field.reference.length > 0) {
-          const specializationId = this.tsIndex.findLastSpecialization(schema.identifier);
-          const specialization = this.tsIndex.resolve(specializationId);
+          const specializationId = tsIndex.findLastSpecialization(schema.identifier);
+          const specialization = tsIndex.resolve(specializationId);
           if (!isSpecializationTypeSchema(specialization))
             throw new Error(`Invalid specialization for ${schema.identifier}`);
           const sField = specialization.fields?.[fieldName];
@@ -5454,7 +5463,7 @@ var TypeScript = class extends Writer {
             throw new Error(`Invalid field declaration for ${fieldName}`);
           const sRefs = (sField.reference ?? []).map((e) => e.name);
           const references = field.reference.map((ref) => {
-            const resRef = this.tsIndex.findLastSpecialization(ref);
+            const resRef = tsIndex.findLastSpecialization(ref);
             if (resRef.name !== ref.name) {
               return `"${resRef.name}" /*${ref.name}*/`;
             }
@@ -5499,13 +5508,13 @@ var TypeScript = class extends Writer {
     );
     this.line();
   }
-  generateExtractProfile(flatProfile) {
+  generateExtractProfile(tsIndex, flatProfile) {
     const tsBaseResourceName = tsResourceName(flatProfile.base);
     const tsProfileName = tsResourceName(flatProfile.identifier);
     const profileFields = Object.entries(flatProfile.fields || {}).filter(([_fieldName, field]) => {
       return isNotChoiceDeclarationField(field) && field.type !== void 0;
     }).map(([fieldName]) => fieldName);
-    const specialization = this.tsIndex.resolve(this.tsIndex.findLastSpecialization(flatProfile.identifier));
+    const specialization = tsIndex.resolve(tsIndex.findLastSpecialization(flatProfile.identifier));
     if (!isSpecializationTypeSchema(specialization))
       throw new Error(`Specialization not found for ${flatProfile.identifier.url}`);
     const shouldCast = {};
@@ -5571,30 +5580,29 @@ var TypeScript = class extends Writer {
       }
     );
   }
-  generateResourceModule(schema) {
+  generateResourceModule(tsIndex, schema) {
     this.cat(`${tsModuleFileName(schema.identifier)}`, () => {
       this.generateDisclaimer();
       if (["complex-type", "resource", "logical"].includes(schema.identifier.kind)) {
         this.generateDependenciesImports(schema);
         this.generateComplexTypeReexports(schema);
-        this.generateNestedTypes(schema);
-        this.generateType(schema);
+        this.generateNestedTypes(tsIndex, schema);
+        this.generateType(tsIndex, schema);
       } else if (isProfileTypeSchema(schema)) {
-        const flatProfile = this.tsIndex.flatProfile(schema);
+        const flatProfile = tsIndex.flatProfile(schema);
         this.generateDependenciesImports(flatProfile);
-        this.generateProfileType(flatProfile);
+        this.generateProfileType(tsIndex, flatProfile);
         this.generateAttachProfile(flatProfile);
-        this.generateExtractProfile(flatProfile);
+        this.generateExtractProfile(tsIndex, flatProfile);
       } else throw new Error(`Profile generation not implemented for kind: ${schema.identifier.kind}`);
     });
   }
-  generate(schemas) {
-    this.tsIndex = mkTypeSchemaIndex(schemas);
+  generate(tsIndex) {
     const typesToGenerate = [
-      ...collectComplexTypes(schemas),
-      ...collectResources(schemas),
-      // ...collectLogicalModels(schemas),
-      ...collectProfiles(schemas).filter((p) => this.tsIndex.isWithMetaField(p))
+      ...tsIndex.collectComplexTypes(),
+      ...tsIndex.collectResources(),
+      // ...tsIndex.collectLogicalModels(),
+      ...tsIndex.collectProfiles().filter((p) => tsIndex.isWithMetaField(p))
     ];
     const grouped = groupByPackages(typesToGenerate);
     this.cd("/", () => {
@@ -5602,7 +5610,7 @@ var TypeScript = class extends Writer {
         const tsPackageDir = tsFhirPackageDir(packageName);
         this.cd(tsPackageDir, () => {
           for (const schema of packageSchemas) {
-            this.generateResourceModule(schema);
+            this.generateResourceModule(tsIndex, schema);
           }
           this.generateFhirPackageIndexFile(packageSchemas);
         });
@@ -5627,7 +5635,8 @@ var writerToGenerator = (writerGen) => {
   };
   return {
     generate: async (schemas) => {
-      writerGen.generate(schemas);
+      const tsIndex = mkTypeSchemaIndex(schemas);
+      writerGen.generate(tsIndex);
       return getGeneratedFiles();
     },
     setOutputDir: (outputDir) => writerGen.opts.outputDir = outputDir,
@@ -5651,6 +5660,7 @@ var APIBuilder = class {
       verbose: options.verbose ?? false,
       overwrite: options.overwrite ?? true,
       cache: options.cache ?? true,
+      cleanOutput: options.cleanOutput ?? true,
       typeSchemaConfig: options.typeSchemaConfig,
       manager: options.manager || null,
       throwException: options.throwException || false
@@ -5752,6 +5762,10 @@ var APIBuilder = class {
     this.options.throwException = enabled;
     return this;
   }
+  cleanOutput(enabled = true) {
+    this.options.cleanOutput = enabled;
+    return this;
+  }
   async generate() {
     const startTime = performance.now();
     const result = {
@@ -5763,6 +5777,17 @@ var APIBuilder = class {
       duration: 0
     };
     this.logger.debug(`Starting generation with ${this.generators.size} generators`);
+    if (this.options.cleanOutput) {
+      this.logger.info(`Cleaning output directory: ${this.options.outputDir}`);
+      try {
+        fs.rmSync(this.options.outputDir, { recursive: true, force: true });
+        fs.mkdirSync(this.options.outputDir, { recursive: true });
+      } catch (error) {
+        this.logger.warn(
+          `Error cleaning output directory: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
     try {
       this.logger.info("Initialize Canonical Manager");
       const manager = CanonicalManager({
@@ -5864,6 +5889,7 @@ function createAPIFromConfig(config) {
     verbose: config.verbose,
     overwrite: config.overwrite,
     cache: config.cache,
+    cleanOutput: config.cleanOutput,
     typeSchemaConfig: config.typeSchema
   });
   if (config.packages && config.packages.length > 0) {
@@ -5897,6 +5923,7 @@ var DEFAULT_CONFIG = {
   overwrite: true,
   validate: true,
   cache: true,
+  cleanOutput: true,
   typescript: {
     moduleFormat: "esm",
     generateIndex: true,