@atomic-ehr/codegen 0.0.1-canary.20251007094146.5297616 → 0.0.1-canary.20251007114955.88a8afc

package/dist/index.js

@@ -1596,7 +1596,7 @@ function mkBindingIdentifier(fhirSchema, path, bindingName) {
 }
 
 // src/typeschema/profile/processor.ts
-async function transformProfile(register, fhirSchema) {
+async function transformProfile(register, fhirSchema, logger) {
   const identifier = mkIdentifier(fhirSchema);
   if (identifier.kind !== "profile") {
     throw new Error(`Expected profile, got ${identifier.kind} for ${fhirSchema.name}`);
@@ -1628,7 +1628,7 @@ async function transformProfile(register, fhirSchema) {
     profileSchema.metadata = metadata;
   }
   if (fhirSchema.elements) {
-    const fields = await mkFields(register, fhirSchema, [], fhirSchema.elements);
+    const fields = await mkFields(register, fhirSchema, [], fhirSchema.elements, logger);
     if (fields && Object.keys(fields).length > 0) {
       profileSchema.fields = fields;
     }
@@ -1825,13 +1825,13 @@ function buildFieldType(register, fhirSchema, element) {
   }
   return void 0;
 }
-var mkField = (register, fhirSchema, path, element) => {
+var mkField = (register, fhirSchema, path, element, logger) => {
   let binding;
   let enumValues;
   if (element.binding) {
     binding = mkBindingIdentifier(fhirSchema, path, element.binding.bindingName);
     if (element.binding.strength === "required" && element.type === "code") {
-      enumValues = buildEnum(register, element);
+      enumValues = buildEnum(register, element, logger);
     }
   }
   return {
@@ -1864,13 +1864,13 @@ function mkNestedField(register, fhirSchema, path, element) {
 }
 
 // src/typeschema/core/binding.ts
-function extractValueSetConceptsByUrl(register, valueSetUrl) {
+function extractValueSetConceptsByUrl(register, valueSetUrl, logger) {
   const cleanUrl = dropVersionFromUrl(valueSetUrl) || valueSetUrl;
   const valueSet = register.resolveVs(cleanUrl);
   if (!valueSet) return void 0;
   return extractValueSetConcepts(register, valueSet);
 }
-function extractValueSetConcepts(register, valueSet) {
+function extractValueSetConcepts(register, valueSet, _logger) {
   if (valueSet.expansion?.contains) return valueSet.expansion.contains;
   const concepts = [];
   if (valueSet.compose?.include) {
@@ -1909,7 +1909,7 @@ function extractValueSetConcepts(register, valueSet) {
   return concepts.length > 0 ? concepts : void 0;
 }
 var MAX_ENUM_LENGTH = 100;
-function buildEnum(register, element) {
+function buildEnum(register, element, logger) {
   if (!element.binding) return void 0;
   const strength = element.binding.strength;
   const valueSetUrl = element.binding.valueSet;
@@ -1920,14 +1920,14 @@ function buildEnum(register, element) {
   if (!concepts || concepts.length === 0) return void 0;
   const codes = concepts.map((c) => c.code).filter((code) => code && typeof code === "string" && code.trim().length > 0);
   if (codes.length > MAX_ENUM_LENGTH) {
-    console.warn(
+    logger?.dry_warn(
       `Value set ${valueSetUrl} has ${codes.length} which is more than ${MAX_ENUM_LENGTH} codes, which may cause issues with code generation.`
     );
     return void 0;
   }
   return codes.length > 0 ? codes : void 0;
 }
-function generateBindingSchema(register, fhirSchema, path, element) {
+function generateBindingSchema(register, fhirSchema, path, element, logger) {
   if (!element.binding?.valueSet) return void 0;
   const identifier = mkBindingIdentifier(fhirSchema, path, element.binding.bindingName);
   const fieldType = buildFieldType(register, fhirSchema, element);
@@ -1937,7 +1937,7 @@ function generateBindingSchema(register, fhirSchema, path, element) {
     dependencies.push(fieldType);
   }
   dependencies.push(valueSetIdentifier);
-  const enumValues = buildEnum(register, element);
+  const enumValues = buildEnum(register, element, logger);
   return {
     identifier,
     type: fieldType,
@@ -1947,7 +1947,7 @@ function generateBindingSchema(register, fhirSchema, path, element) {
     dependencies
   };
 }
-function collectBindingSchemas(register, fhirSchema) {
+function collectBindingSchemas(register, fhirSchema, logger) {
   const processedPaths = /* @__PURE__ */ new Set();
   if (!fhirSchema.elements) return [];
   const bindings = [];
@@ -1958,7 +1958,7 @@ function collectBindingSchemas(register, fhirSchema) {
       if (processedPaths.has(pathKey)) continue;
       processedPaths.add(pathKey);
       if (element.binding) {
-        const binding = generateBindingSchema(register, fhirSchema, path, element);
+        const binding = generateBindingSchema(register, fhirSchema, path, element, logger);
         if (binding) {
           bindings.push(binding);
         }
@@ -1995,19 +1995,19 @@ function collectNestedElements(fhirSchema, parentPath, elements) {
   }
   return nested;
 }
-function transformNestedElements(fhirSchema, parentPath, elements, register) {
+function transformNestedElements(fhirSchema, parentPath, elements, register, logger) {
   const fields = {};
   for (const [key, element] of Object.entries(elements)) {
     const path = [...parentPath, key];
     if (isNestedElement(element)) {
       fields[key] = mkNestedField(register, fhirSchema, path, element);
     } else {
-      fields[key] = mkField(register, fhirSchema, path, element);
+      fields[key] = mkField(register, fhirSchema, path, element, logger);
     }
   }
   return fields;
 }
-function mkNestedTypes(register, fhirSchema) {
+function mkNestedTypes(register, fhirSchema, logger) {
   if (!fhirSchema.elements) return void 0;
   const nestedElements = collectNestedElements(fhirSchema, [], fhirSchema.elements);
   const actualNested = nestedElements.filter(
@@ -2034,7 +2034,7 @@ function mkNestedTypes(register, fhirSchema) {
         url: `http://hl7.org/fhir/StructureDefinition/${element.type}`
       };
     }
-    const fields = transformNestedElements(fhirSchema, path, element.elements, register);
+    const fields = transformNestedElements(fhirSchema, path, element.elements, register, logger);
     const nestedType = {
       identifier,
       base,
@@ -2064,7 +2064,7 @@ function extractNestedDependencies(nestedTypes) {
 }
 
 // src/typeschema/core/transformer.ts
-function mkFields(register, fhirSchema, parentPath, elements) {
+function mkFields(register, fhirSchema, parentPath, elements, logger) {
   if (!elements) return void 0;
   const geneology = register.resolveFsGenealogy(fhirSchema.url);
   const elems = {};
@@ -2089,7 +2089,7 @@ function mkFields(register, fhirSchema, parentPath, elements) {
     if (isNestedElement(elemSnapshot)) {
       fields[key] = mkNestedField(register, fhirSchema, path, elemSnapshot);
     } else {
-      fields[key] = mkField(register, fhirSchema, path, elemSnapshot);
+      fields[key] = mkField(register, fhirSchema, path, elemSnapshot, logger);
     }
   }
   return fields;
@@ -2134,7 +2134,7 @@ function isExtensionSchema(fhirSchema, _identifier) {
   }
   return false;
 }
-async function transformValueSet(register, valueSet) {
+async function transformValueSet(register, valueSet, logger) {
   if (!valueSet.url) throw new Error("ValueSet URL is required");
   const identifier = mkValueSetIdentifierByUrl(register, valueSet.url);
   const concept = extractValueSetConceptsByUrl(register, valueSet.url);
@@ -2145,7 +2145,7 @@ async function transformValueSet(register, valueSet) {
     compose: !concept ? valueSet.compose : void 0
   };
 }
-async function transformExtension(fhirSchema, register, _packageInfo) {
+async function transformExtension(fhirSchema, register, logger) {
   try {
     const identifier = mkIdentifier(fhirSchema);
     let base;
@@ -2182,13 +2182,13 @@ async function transformExtension(fhirSchema, register, _packageInfo) {
       extensionSchema.dependencies.push(base);
     }
     if (fhirSchema.elements) {
-      const fields = mkFields(register, fhirSchema, [], fhirSchema.elements);
+      const fields = mkFields(register, fhirSchema, [], fhirSchema.elements, logger);
       if (fields && Object.keys(fields).length > 0) {
         extensionSchema.fields = fields;
         extensionSchema.dependencies.push(...extractFieldDependencies(fields));
       }
     }
-    const nestedTypes = mkNestedTypes(register, fhirSchema);
+    const nestedTypes = mkNestedTypes(register, fhirSchema, logger);
     if (nestedTypes && nestedTypes.length > 0) {
       extensionSchema.nested = nestedTypes;
       extensionSchema.dependencies.push(...extractNestedDependencies(nestedTypes));
@@ -2215,7 +2215,7 @@ function extractDependencies(identifier, base, fields, nestedTypes) {
   const result = Object.values(uniqDeps).filter((e) => !(e.kind === "nested" && localNestedTypeUrls.has(e.url))).sort((a, b) => a.url.localeCompare(b.url));
   return result.length > 0 ? result : void 0;
 }
-function transformFhirSchemaResource(register, fhirSchema) {
+function transformFhirSchemaResource(register, fhirSchema, logger) {
   const identifier = mkIdentifier(fhirSchema);
   let base;
   if (fhirSchema.base && fhirSchema.type !== "Element") {
@@ -2225,8 +2225,8 @@ function transformFhirSchemaResource(register, fhirSchema) {
     }
     base = mkIdentifier(baseFs);
   }
-  const fields = mkFields(register, fhirSchema, [], fhirSchema.elements);
-  const nested = mkNestedTypes(register, fhirSchema);
+  const fields = mkFields(register, fhirSchema, [], fhirSchema.elements, logger);
+  const nested = mkNestedTypes(register, fhirSchema, logger);
   const dependencies = extractDependencies(identifier, base, fields, nested);
   const typeSchema = {
     identifier,
@@ -2236,27 +2236,27 @@ function transformFhirSchemaResource(register, fhirSchema) {
     description: fhirSchema.description,
     dependencies
   };
-  const bindingSchemas = collectBindingSchemas(register, fhirSchema);
+  const bindingSchemas = collectBindingSchemas(register, fhirSchema, logger);
   return [typeSchema, ...bindingSchemas];
 }
-async function transformFhirSchema(register, fhirSchema) {
+async function transformFhirSchema(register, fhirSchema, logger) {
   const results = [];
   const identifier = mkIdentifier(fhirSchema);
   if (identifier.kind === "profile") {
-    const profileSchema = await transformProfile(register, fhirSchema);
+    const profileSchema = await transformProfile(register, fhirSchema, logger);
     results.push(profileSchema);
-    const bindingSchemas = collectBindingSchemas(register, fhirSchema);
+    const bindingSchemas = collectBindingSchemas(register, fhirSchema, logger);
     results.push(...bindingSchemas);
     return results;
   }
   if (isExtensionSchema(fhirSchema)) {
-    const extensionSchema = await transformExtension(fhirSchema, register, fhirSchema.package_meta);
+    const extensionSchema = await transformExtension(fhirSchema, register, logger);
     if (extensionSchema) {
       results.push(extensionSchema);
     }
     return results;
   }
-  return transformFhirSchemaResource(register, fhirSchema);
+  return transformFhirSchemaResource(register, fhirSchema, logger);
 }
 var TypeSchemaCache = class {
   cache = /* @__PURE__ */ new Map();
@@ -2478,6 +2478,7 @@ var TypeSchemaCache = class {
 };
 var CodegenLogger = class _CodegenLogger {
   options;
+  dryWarnSet = /* @__PURE__ */ new Set();
   constructor(options = {}) {
     this.options = {
       timestamp: false,
@@ -2512,13 +2513,19 @@ var CodegenLogger = class _CodegenLogger {
    * Warning message with warning sign
    */
   warn(message) {
-    console.warn(this.formatMessage("\u26A0\uFE0F", message, pc.yellow));
+    console.warn(this.formatMessage("!", message, pc.yellow));
+  }
+  dry_warn(message) {
+    if (!this.dryWarnSet.has(message)) {
+      this.warn(message);
+      this.dryWarnSet.add(message);
+    }
   }
   /**
    * Info message with info icon
    */
   info(message) {
-    console.log(this.formatMessage("\u2139\uFE0F", message, pc.blue));
+    console.log(this.formatMessage("i", message, pc.blue));
   }
   /**
    * Debug message (only shows in verbose mode)
@@ -2599,12 +2606,12 @@ var TypeSchemaGenerator = class {
   }
   async registerFromPackageMetas(packageMetas) {
     const packageNames = packageMetas.map((meta) => `${meta.name}${meta.version}`);
-    this.logger.step(`Loading FHIR packages: ${packageNames.join(", ")}`);
+    this.logger?.step(`Loading FHIR packages: ${packageNames.join(", ")}`);
     await this.manager.init();
     return registerFromManager(this.manager);
   }
   generateFhirSchemas(structureDefinitions) {
-    this.logger.progress(`Converting ${structureDefinitions.length} StructureDefinitions to FHIRSchemas`);
+    this.logger?.progress(`Converting ${structureDefinitions.length} StructureDefinitions to FHIRSchemas`);
     const filteredStructureDefinitions = this.applyStructureDefinitionTreeshaking(structureDefinitions);
     const fhirSchemas = [];
     let convertedCount = 0;
@@ -2614,56 +2621,56 @@ var TypeSchemaGenerator = class {
         const fhirSchema = fhirschema.translate(sd);
         fhirSchemas.push(fhirSchema);
         convertedCount++;
-        this.logger.debug(`Converted StructureDefinition: ${sd.name || sd.id} (${sd.resourceType})`);
+        this.logger?.debug(`Converted StructureDefinition: ${sd.name || sd.id} (${sd.resourceType})`);
       } catch (error) {
         failedCount++;
-        this.logger.warn(
+        this.logger?.warn(
           `Failed to convert StructureDefinition ${sd.name || sd.id}: ${error instanceof Error ? error.message : String(error)}`
         );
       }
     }
-    this.logger.success(
+    this.logger?.success(
       `FHIR Schema conversion completed: ${convertedCount}/${filteredStructureDefinitions.length} successful, ${failedCount} failed`
     );
     return fhirSchemas;
   }
-  async generateValueSetSchemas(valueSets) {
+  async generateValueSetSchemas(valueSets, logger) {
     if (valueSets.length > 0) {
-      this.logger.debug(`${valueSets.length} ValueSets available for enum extraction`);
+      this.logger?.debug(`${valueSets.length} ValueSets available for enum extraction`);
     }
-    const register = await registerFromManager(this.manager);
+    const register = await registerFromManager(this.manager, logger);
     const valueSetSchemas = [];
     if (valueSets.length > 0) {
-      this.logger.progress(`Converting ${valueSets.length} ValueSets to TypeSchema`);
+      this.logger?.progress(`Converting ${valueSets.length} ValueSets to TypeSchema`);
       let valueSetConvertedCount = 0;
       let valueSetFailedCount = 0;
       for (const vs of valueSets) {
         try {
-          const valueSetSchema = await transformValueSet(register, vs);
+          const valueSetSchema = await transformValueSet(register, vs, logger);
           if (valueSetSchema) {
             valueSetSchemas.push(valueSetSchema);
             valueSetConvertedCount++;
-            this.logger.debug(`Converted ValueSet: ${vs.name || vs.id}`);
+            this.logger?.debug(`Converted ValueSet: ${vs.name || vs.id}`);
           }
         } catch (error) {
           valueSetFailedCount++;
-          this.logger.warn(
+          this.logger?.warn(
             `Failed to convert ValueSet ${vs.name || vs.id}: ${error instanceof Error ? error.message : String(error)}`
           );
         }
       }
-      this.logger.success(
+      this.logger?.success(
         `ValueSet conversion completed: ${valueSetConvertedCount}/${valueSets.length} successful, ${valueSetFailedCount} failed`
       );
     }
     return valueSetSchemas;
   }
-  async generateFromPackage(packageName, packageVersion) {
+  async generateFromPackage(packageName, packageVersion, logger) {
     await this.initializeCache();
     if (this.cache && !(this.cacheConfig?.forceRegenerate ?? false)) {
       const cachedSchemas = this.cache.getByPackage(packageName);
       if (cachedSchemas.length > 0) {
-        this.logger.info(
+        this.logger?.info(
           `Using cached TypeSchemas for package: ${packageName} (${cachedSchemas.length} schemas)`
         );
         return cachedSchemas;
@@ -2674,10 +2681,9 @@ var TypeSchemaGenerator = class {
       version: packageVersion || "latest"
     };
     const register = await this.registerFromPackageMetas([packageInfo]);
-    const valueSets = await this.generateValueSetSchemas(register.allVs());
-    const fhirSchemas = (await Promise.all(register.allFs().map(async (fs2) => await transformFhirSchema(register, fs2)))).flat();
+    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 allSchemas = [...fhirSchemas, ...valueSets];
-    console.debug(111);
     if (this.cache) {
       for (const schema of allSchemas) {
         await this.cache.set(schema);
@@ -2694,7 +2700,7 @@ var TypeSchemaGenerator = class {
     if (!treeshakeList || treeshakeList.length === 0) {
       return structureDefinitions;
     }
-    this.logger.info(`Applying treeshaking filter for ResourceTypes: ${treeshakeList.join(", ")}`);
+    this.logger?.info(`Applying treeshaking filter for ResourceTypes: ${treeshakeList.join(", ")}`);
     const allStructureDefinitions = /* @__PURE__ */ new Map();
     const realDependencies = /* @__PURE__ */ new Map();
     const referenceTargets = /* @__PURE__ */ new Map();
@@ -2718,7 +2724,7 @@ var TypeSchemaGenerator = class {
       if (allStructureDefinitions.has(resourceType)) {
         structureDefinitionsToKeep.add(resourceType);
       } else {
-        this.logger.warn(`ResourceType '${resourceType}' not found in structure definitions`);
+        this.logger?.warn(`ResourceType '${resourceType}' not found in structure definitions`);
       }
     }
     const addRealDependenciesRecursively = (name, visited = /* @__PURE__ */ new Set()) => {
@@ -2754,9 +2760,9 @@ var TypeSchemaGenerator = class {
       }
     }
     if (excludedReferenceTargets.size > 0) {
-      this.logger.info(`Excluded reference-only targets: ${Array.from(excludedReferenceTargets).join(", ")}`);
+      this.logger?.info(`Excluded reference-only targets: ${Array.from(excludedReferenceTargets).join(", ")}`);
     }
-    this.logger.success(
+    this.logger?.success(
       `Treeshaking completed: kept ${filteredStructureDefinitions.length}/${structureDefinitions.length} structure definitions`
     );
     return filteredStructureDefinitions;
@@ -3045,10 +3051,10 @@ var TypeSchemaParser = class {
 };
 
 // src/typeschema/index.ts
-var generateTypeSchemas = async (register) => {
+var generateTypeSchemas = async (register, logger) => {
   const fhirSchemas = [];
   for (const fhirSchema of register.allFs()) {
-    fhirSchemas.push(...await transformFhirSchema(register, fhirSchema));
+    fhirSchemas.push(...await transformFhirSchema(register, fhirSchema, logger));
   }
   for (const vsSchema of register.allVs()) {
     fhirSchemas.push(await transformValueSet(register, vsSchema));
@@ -5094,6 +5100,13 @@ var capitalCase = (s) => {
 var pascalCase = (s) => {
   return words(s).map(capitalCase).join("");
 };
+var uppercaseFirstLetter = (str) => {
+  if (!str || str.length === 0) return str;
+  return str.charAt(0).toUpperCase() + str.slice(1);
+};
+var uppercaseFirstLetterOfEach = (strings) => {
+  return strings.map((str) => uppercaseFirstLetter(str));
+};
 var FileSystemWriter = class {
   opts;
   currentDir;
@@ -5119,7 +5132,7 @@ var FileSystemWriter = class {
     if (fn.includes("/")) throw new Error(`Change file path separatly: ${fn}`);
     const fullFn = `${this.currentDir}/${fn}`;
     try {
-      this.currentFileDescriptor = fs.openSync(fn, "w");
+      this.currentFileDescriptor = fs.openSync(fullFn, "w");
       this.writtenFilesSet.add(fn);
       this.logger()?.debug(`cat > '${fullFn}'`);
       gen();
@@ -5180,6 +5193,17 @@ var Writer = class extends FileSystemWriter {
       this.comment(...tokens);
     }
   }
+  disclaimer() {
+    return [
+      "WARNING: This file is autogenerated by FHIR Schema Codegen.",
+      "https://github.com/fhir-schema/fhir-schema-codegen",
+      "Any manual changes made to this file may be overwritten."
+    ];
+  }
+  generateDisclaimer() {
+    this.disclaimer().forEach((e) => this.comment(e));
+    this.line();
+  }
   curlyBlock(tokens, gencontent, endTokens) {
     this.line(`${tokens.filter(Boolean).join(" ")} {`);
     this.indent();
@@ -5196,9 +5220,7 @@ var Writer = class extends FileSystemWriter {
   }
 };
 
-// src/api/writer-generator/typescript.ts
-var collectComplexTypes = (tss) => tss.filter((t) => t.identifier.kind === "complex-type");
-var collectResources = (tss) => tss.filter((t) => t.identifier.kind === "resource");
+// src/typeschema/utils.ts
 var groupByPackages = (typeSchemas) => {
   const grouped = {};
   for (const ts of typeSchemas) {
@@ -5213,9 +5235,85 @@ var groupByPackages = (typeSchemas) => {
   }
   return grouped;
 };
-var fileNameStem = (id) => {
+var collectComplexTypes = (tss) => tss.filter((t) => t.identifier.kind === "complex-type");
+var collectResources = (tss) => tss.filter((t) => t.identifier.kind === "resource");
+var notChoiceDeclaration = (field) => {
+  if (field.choices) return void 0;
+  if (field.choiceOf) return field;
+  return field;
+};
+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 resourceChildren = (relatives, id) => {
+  return relatives.filter((relative2) => relative2.parent.name === id.name).map((relative2) => relative2.child);
+};
+
+// src/api/writer-generator/typescript.ts
+var primitiveType2tsType = {
+  boolean: "boolean",
+  instant: "string",
+  time: "string",
+  date: "string",
+  dateTime: "string",
+  decimal: "number",
+  integer: "number",
+  unsignedInt: "number",
+  positiveInt: "number",
+  integer64: "number",
+  base64Binary: "string",
+  uri: "string",
+  url: "string",
+  canonical: "string",
+  oid: "string",
+  uuid: "string",
+  string: "string",
+  code: "string",
+  markdown: "string",
+  id: "string",
+  xhtml: "string"
+};
+var canonicalToName = (canonical, dropFragment = true) => {
+  if (!canonical) return void 0;
+  let localName = canonical.split("/").pop();
+  if (dropFragment && localName?.includes("#")) {
+    localName = localName.split("#")[0];
+  }
+  if (/^\d/.test(localName ?? "")) {
+    localName = `number_${localName}`;
+  }
+  return localName?.replace(/[- ]/g, "_");
+};
+var tsBaseFileName = (id) => {
   return pascalCase(id.name);
 };
+var tsFileName = (id) => {
+  return `${tsBaseFileName(id)}.ts`;
+};
 var normalizeName = (n) => {
   if (n === "extends") {
     return "extends_";
@@ -5225,43 +5323,155 @@ var normalizeName = (n) => {
 var resourceName = (id) => {
   return normalizeName(id.name);
 };
+var deriveNestedSchemaName = (url) => {
+  const path = canonicalToName(url, false);
+  if (!path) {
+    return "";
+  }
+  const [resourceName2, fragment] = path.split("#");
+  const name = uppercaseFirstLetterOfEach((fragment ?? "").split(".")).join("");
+  return [resourceName2, name].join("");
+};
 var TypeScript = class extends Writer {
-  tsImportFrom(tsPackage, ...entities) {
-    this.lineSM(`import { ${entities.join(", ")} } from '${tsPackage}'`);
+  resourceRelatives = [];
+  tsImport(tsPackageName, ...entities) {
+    this.lineSM(`import { ${entities.join(", ")} } from '${tsPackageName}'`);
   }
-  generatePackageIndexFile(schemas) {
+  generateFhirPackageIndexFile(schemas) {
     this.cat("index.ts", () => {
       let exports = schemas.map((schema) => ({
         identifier: schema.identifier,
-        fileName: fileNameStem(schema.identifier),
-        name: resourceName(schema.identifier)
-      })).sort((a, b) => a.name.localeCompare(b.name));
-      exports = Array.from(new Map(exports.map((exp) => [exp.name.toLowerCase(), exp])).values()).sort(
-        (a, b) => a.name.localeCompare(b.name)
+        tsPackageName: tsBaseFileName(schema.identifier),
+        resourceName: resourceName(schema.identifier)
+      })).sort((a, b) => a.resourceName.localeCompare(b.resourceName));
+      exports = Array.from(new Map(exports.map((exp) => [exp.resourceName.toLowerCase(), exp])).values()).sort(
+        (a, b) => a.resourceName.localeCompare(b.resourceName)
       );
       for (const exp of exports) {
         this.debugComment(exp.identifier);
-        this.tsImportFrom(`./${exp.fileName}`, exp.name);
+        this.tsImport(`./${exp.tsPackageName}`, exp.resourceName);
       }
-      this.lineSM(`export { ${exports.map((e) => e.name).join(", ")} }`);
+      this.lineSM(`export { ${exports.map((e) => e.resourceName).join(", ")} }`);
       this.line("");
       this.curlyBlock(["export type ResourceTypeMap = "], () => {
         this.lineSM("User: Record<string, any>");
         exports.forEach((exp) => {
           this.debugComment(exp.identifier);
-          this.lineSM(`${exp.name}: ${exp.name}`);
+          this.lineSM(`${exp.resourceName}: ${exp.resourceName}`);
         });
       });
       this.lineSM("export type ResourceType = keyof ResourceTypeMap");
       this.squareBlock(["export const resourceList: readonly ResourceType[] = "], () => {
         exports.forEach((exp) => {
           this.debugComment(exp.identifier);
-          this.line(`'${exp.name}', `);
+          this.line(`'${exp.resourceName}', `);
         });
       });
     });
   }
+  generateDependenciesImports(schema) {
+    if (schema.dependencies) {
+      const deps = [
+        ...schema.dependencies.filter((dep) => ["complex-type", "resource", "logical"].includes(dep.kind)).map((dep) => ({
+          tsPackage: `../${kebabCase(dep.package)}/${pascalCase(dep.name)}`,
+          name: uppercaseFirstLetter(dep.name)
+        })),
+        ...schema.dependencies.filter((dep) => ["nested"].includes(dep.kind)).map((dep) => ({
+          tsPackage: `../${kebabCase(dep.package)}/${pascalCase(canonicalToName(dep.url) ?? "")}`,
+          name: deriveNestedSchemaName(dep.url)
+        }))
+      ].sort((a, b) => a.name.localeCompare(b.name));
+      for (const dep of deps) {
+        this.tsImport(dep.tsPackage, dep.name);
+      }
+    }
+  }
+  addFieldExtension(fieldName, field) {
+    if (field.type.kind === "primitive-type") {
+      this.lineSM(`_${normalizeName(fieldName)}?: Element`);
+    }
+  }
+  generateType(schema) {
+    var name;
+    if (schema.identifier.name === "Reference") {
+      name = "Reference<T extends string = string>";
+    } else if (schema.identifier.kind === "nested") {
+      name = normalizeName(deriveNestedSchemaName(schema.identifier.url));
+    } else {
+      name = normalizeName(schema.identifier.name);
+    }
+    const parent = canonicalToName(schema.base?.url);
+    const extendsClause = parent && `extends ${parent}`;
+    this.debugComment(schema.identifier);
+    this.curlyBlock(["export", "interface", name, extendsClause], () => {
+      if (!schema.fields) {
+        return;
+      }
+      if (schema.identifier.kind === "resource") {
+        const possibleResourceTypes = [schema.identifier];
+        possibleResourceTypes.push(...resourceChildren(this.resourceRelatives, schema.identifier));
+        this.lineSM(`resourceType: ${possibleResourceTypes.map((e) => `'${e.name}'`).join(" | ")}`);
+        this.line();
+      }
+      const fields = Object.entries(schema.fields).sort((a, b) => a[0].localeCompare(b[0]));
+      for (const [fieldName, anyField] of fields) {
+        const field = notChoiceDeclaration(anyField);
+        if (field === void 0) continue;
+        this.debugComment(fieldName, ":", field);
+        const fieldNameFixed = normalizeName(fieldName);
+        const optionalSymbol = field.required ? "" : "?";
+        const arraySymbol = field.array ? "[]" : "";
+        if (field.type === void 0) {
+          continue;
+        }
+        let type = field.type.name;
+        if (field.type.kind === "nested") {
+          type = deriveNestedSchemaName(field.type.url);
+        }
+        if (field.type.kind === "primitive-type") {
+          type = primitiveType2tsType[field.type.name] ?? "string";
+        }
+        if (schema.identifier.name === "Reference" && fieldNameFixed === "reference") {
+          type = "`${T}/${string}`";
+        }
+        if (field.reference?.length) {
+          const references = field.reference.map((ref) => `'${ref.name}'`).join(" | ");
+          type = `Reference<${references}>`;
+        }
+        if (field.enum) {
+          type = field.enum.map((e) => `'${e}'`).join(" | ");
+        }
+        this.lineSM(`${fieldNameFixed}${optionalSymbol}:`, `${type}${arraySymbol}`);
+        if (["resource", "complex-type"].includes(schema.identifier.kind)) {
+          this.addFieldExtension(fieldName, field);
+        }
+      }
+    });
+    this.line();
+  }
+  generateNestedTypes(schema) {
+    if (schema.nested) {
+      this.line();
+      for (const subtype of schema.nested) {
+        this.generateType(subtype);
+      }
+    }
+  }
+  generateResourceModule(schema) {
+    this.cat(`${tsFileName(schema.identifier)}`, () => {
+      this.generateDisclaimer();
+      if (["complex-type", "resource", "logical", "nested"].includes(schema.identifier.kind)) {
+        this.generateDependenciesImports(schema);
+        this.line();
+        this.generateNestedTypes(schema);
+        this.generateType(schema);
+      } else {
+        throw new Error(`Profile generation not implemented for kind: ${schema.identifier.kind}`);
+      }
+    });
+  }
   generate(schemas) {
+    this.resourceRelatives = resourceRelatives(schemas);
     const typesToGenerate = [
       ...collectComplexTypes(schemas),
       ...collectResources(schemas)
@@ -5273,7 +5483,10 @@ var TypeScript = class extends Writer {
       for (const [packageName, packageSchemas] of Object.entries(grouped)) {
         const tsPackageName = kebabCase(packageName);
         this.cd(tsPackageName, () => {
-          this.generatePackageIndexFile(packageSchemas);
+          for (const schema of packageSchemas) {
+            this.generateResourceModule(schema);
+          }
+          this.generateFhirPackageIndexFile(packageSchemas);
         });
       }
     });
@@ -5383,7 +5596,7 @@ var APIBuilder = class {
     const writerOpts = {
       outputDir: Path2.join(this.options.outputDir, "/types"),
       tabSize: 2,
-      withDebugComment: true,
+      withDebugComment: false,
       commentLinePrefix: "//"
     };
     const effectiveOpts = { logger: this.logger, ...writerOpts, ...opts };
@@ -5440,7 +5653,7 @@ var APIBuilder = class {
       });
       await manager.init();
       const register = await registerFromManager(manager, this.logger);
-      const typeSchemas = await generateTypeSchemas(register);
+      const typeSchemas = await generateTypeSchemas(register, this.logger);
       this.logger.debug(`Executing ${this.generators.size} generators`);
       await this.executeGenerators(result, typeSchemas);
       this.logger.info("Generation completed successfully");