@atomic-ehr/codegen 0.0.1-canary.20251015064414.0fcee22 → 0.0.1

package/dist/index.js

@@ -1,11 +1,12 @@
 import * as fs from 'fs';
-import { existsSync, mkdirSync } from 'fs';
-import * as afs from 'fs/promises';
+import fs__default, { existsSync, mkdirSync } from 'fs';
+import * as afs2 from 'fs/promises';
 import { readdir, stat, unlink, readFile, writeFile, access, mkdir, rm } from 'fs/promises';
-import * as Path2 from 'path';
-import { join, resolve, dirname, relative } from 'path';
+import * as Path4 from 'path';
+import Path4__default, { join, resolve, dirname, relative } from 'path';
 import { CanonicalManager } from '@atomic-ehr/fhir-canonical-manager';
 import * as fhirschema from '@atomic-ehr/fhirschema';
+import { isStructureDefinition } from '@atomic-ehr/fhirschema';
 import pc from 'picocolors';
 
 var __defProp = Object.defineProperty;
@@ -1445,6 +1446,22 @@ var isChoiceDeclarationField = (field) => {
   if (!field) return false;
   return field.choices !== void 0;
 };
+var isValueSet = (res) => {
+  return res.resourceType === "ValueSet";
+};
+var isCodeSystem = (res) => {
+  return res.resourceType === "CodeSystem";
+};
+var enrichValueSet = (vs, packageMeta) => {
+  if (!vs.url) throw new Error("ValueSet must have a URL");
+  if (!vs.name) throw new Error("ValueSet must have a name");
+  return {
+    ...vs,
+    package_meta: vs.package_meta || packageMeta,
+    name: vs.name,
+    url: vs.url
+  };
+};
 
 // src/typeschema/core/identifier.ts
 function dropVersionFromUrl(url) {
@@ -1479,7 +1496,7 @@ var getValueSetName = (url) => {
   }
   return url;
 };
-function mkValueSetIdentifierByUrl(register, fullValueSetUrl) {
+function mkValueSetIdentifierByUrl(register, pkg, fullValueSetUrl) {
   const valueSetUrl = dropVersionFromUrl(fullValueSetUrl);
   const valueSetNameFallback = getValueSetName(valueSetUrl);
   const valuesSetFallback = {
@@ -1488,7 +1505,7 @@ function mkValueSetIdentifierByUrl(register, fullValueSetUrl) {
       version: getVersionFromUrl(valueSetUrl) || "0.0.0"
     },
     id: fullValueSetUrl};
-  const valueSet = register.resolveVs(valueSetUrl) || valuesSetFallback;
+  const valueSet = register.resolveVs(pkg, valueSetUrl) || valuesSetFallback;
   const valueSetName = valueSet?.id && !/^[a-zA-Z0-9_-]{20,}$/.test(valueSet.id) ? valueSet.id : valueSetNameFallback;
   return {
     kind: "value-set",
@@ -1514,8 +1531,8 @@ function mkBindingIdentifier(fhirSchema, path, bindingName) {
 function mkNestedIdentifier(register, fhirSchema, path, logger) {
   const nestedTypeOrigins = {};
   if (fhirSchema.derivation === "constraint") {
-    const specializations = register.resolveFsSpecializations(fhirSchema.url);
-    const nestedTypeGenealogy = specializations.map((fs3) => mkNestedTypes(register, fs3, logger)).filter((e) => e !== void 0).flat();
+    const specializations = register.resolveFsSpecializations(fhirSchema.package_meta, fhirSchema.url);
+    const nestedTypeGenealogy = specializations.map((fs4) => mkNestedTypes(register, fs4, logger)).filter((e) => e !== void 0).flat();
     for (const nt of nestedTypeGenealogy.reverse()) {
       nestedTypeOrigins[nt.identifier.name] = nt.identifier.url;
     }
@@ -1575,7 +1592,7 @@ function mkNestedTypes(register, fhirSchema, logger) {
       package: fhirSchema.package_meta.name,
       version: fhirSchema.package_meta.version,
       name: baseName,
-      url: register.ensureSpecializationCanonicalUrl(baseName)
+      url: register.ensureSpecializationCanonicalUrl(fhirSchema.package_meta, baseName)
     };
     const fields = transformNestedElements(register, fhirSchema, path, element.elements, logger);
     const nestedType = {
@@ -1610,10 +1627,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((fs3) => {
-    if (parentPath.length === 0) return fs3.required || [];
-    if (!fs3.elements) return [];
-    let elem = fs3;
+  const requires = register.resolveFsGenealogy(fhirSchema.package_meta, fhirSchema.url).flatMap((fs4) => {
+    if (parentPath.length === 0) return fs4.required || [];
+    if (!fs4.elements) return [];
+    let elem = fs4;
     for (const k of parentPath) {
       elem = elem?.elements?.[k];
     }
@@ -1625,10 +1642,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((fs3) => {
-    if (parentPath.length === 0) return fs3.excluded || [];
-    if (!fs3.elements) return [];
-    let elem = fs3;
+  const requires = register.resolveFsGenealogy(fhirSchema.package_meta, fhirSchema.url).flatMap((fs4) => {
+    if (parentPath.length === 0) return fs4.excluded || [];
+    if (!fs4.elements) return [];
+    let elem = fs4;
     for (const k of parentPath) {
       elem = elem?.elements?.[k];
     }
@@ -1636,12 +1653,12 @@ function isExcluded(register, fhirSchema, path) {
   });
   return new Set(requires).has(fieldName);
 }
-var buildReferences = (element, register, _packageInfo) => {
+var buildReferences = (register, fhirSchema, element) => {
   if (!element.refers) return void 0;
   return element.refers.map((ref) => {
-    const curl = register.ensureSpecializationCanonicalUrl(ref);
-    const fs3 = register.resolveFs(curl);
-    return mkIdentifier(fs3);
+    const curl = register.ensureSpecializationCanonicalUrl(fhirSchema.package_meta, ref);
+    const fs4 = register.resolveFs(fhirSchema.package_meta, curl);
+    return mkIdentifier(fs4);
   });
 };
 function buildFieldType(register, fhirSchema, path, element, logger) {
@@ -1649,9 +1666,9 @@ function buildFieldType(register, fhirSchema, path, element, logger) {
     const refPath = element.elementReference.slice(1).filter((_, i) => i % 2 === 1);
     return mkNestedIdentifier(register, fhirSchema, refPath, logger);
   } else if (element.type) {
-    const url = register.ensureSpecializationCanonicalUrl(element.type);
-    const fieldFs = register.resolveFs(url);
-    if (!fieldFs) throw new Error(`Could not resolve field '${element.type}'`);
+    const url = register.ensureSpecializationCanonicalUrl(fhirSchema.package_meta, element.type);
+    const fieldFs = register.resolveFs(fhirSchema.package_meta, url);
+    if (!fieldFs) throw new Error(`Could not resolve field type: '${element.type}'`);
     return mkIdentifier(fieldFs);
   } else if (element.choices) {
     return void 0;
@@ -1670,14 +1687,14 @@ var mkField = (register, fhirSchema, path, element, logger) => {
   if (element.binding) {
     binding = mkBindingIdentifier(fhirSchema, path, element.binding.bindingName);
     if (element.binding.strength === "required" && element.type === "code") {
-      enumValues = buildEnum(register, element, logger);
+      enumValues = buildEnum(register, fhirSchema, element, logger);
     }
   }
   return {
     type: buildFieldType(register, fhirSchema, path, element, logger),
     required: isRequired(register, fhirSchema, path),
     excluded: isExcluded(register, fhirSchema, path),
-    reference: buildReferences(element, register, fhirSchema.package_meta),
+    reference: buildReferences(register, fhirSchema, element),
     array: element.array || false,
     min: element.min,
     max: element.max,
@@ -1703,9 +1720,9 @@ function mkNestedField(register, fhirSchema, path, element, logger) {
 }
 
 // src/typeschema/core/binding.ts
-function extractValueSetConceptsByUrl(register, valueSetUrl, logger) {
+function extractValueSetConceptsByUrl(register, pkg, valueSetUrl, logger) {
   const cleanUrl = dropVersionFromUrl(valueSetUrl) || valueSetUrl;
-  const valueSet = register.resolveVs(cleanUrl);
+  const valueSet = register.resolveVs(pkg, cleanUrl);
   if (!valueSet) return void 0;
   return extractValueSetConcepts(register, valueSet);
 }
@@ -1748,14 +1765,14 @@ function extractValueSetConcepts(register, valueSet, _logger) {
   return concepts.length > 0 ? concepts : void 0;
 }
 var MAX_ENUM_LENGTH = 100;
-function buildEnum(register, element, logger) {
+function buildEnum(register, fhirSchema, element, logger) {
   if (!element.binding) return void 0;
   const strength = element.binding.strength;
   const valueSetUrl = element.binding.valueSet;
   if (!valueSetUrl) return void 0;
   const shouldGenerateEnum = strength === "required" || strength === "extensible" && (element.type === "code" || element.type === "Coding") || strength === "preferred" && (element.type === "code" || element.type === "Coding");
   if (!shouldGenerateEnum) return void 0;
-  const concepts = extractValueSetConceptsByUrl(register, valueSetUrl);
+  const concepts = extractValueSetConceptsByUrl(register, fhirSchema.package_meta, valueSetUrl);
   if (!concepts || concepts.length === 0) return void 0;
   const codes = concepts.map((c) => c.code).filter((code) => code && typeof code === "string" && code.trim().length > 0);
   if (codes.length > MAX_ENUM_LENGTH) {
@@ -1770,13 +1787,17 @@ function generateBindingSchema(register, fhirSchema, path, element, logger) {
   if (!element.binding?.valueSet) return void 0;
   const identifier = mkBindingIdentifier(fhirSchema, path, element.binding.bindingName);
   const fieldType = buildFieldType(register, fhirSchema, path, element, logger);
-  const valueSetIdentifier = mkValueSetIdentifierByUrl(register, element.binding.valueSet);
+  const valueSetIdentifier = mkValueSetIdentifierByUrl(
+    register,
+    fhirSchema.package_meta,
+    element.binding.valueSet
+  );
   const dependencies = [];
   if (fieldType) {
     dependencies.push(fieldType);
   }
   dependencies.push(valueSetIdentifier);
-  const enumValues = buildEnum(register, element, logger);
+  const enumValues = buildEnum(register, fhirSchema, element, logger);
   return {
     identifier,
     type: fieldType,
@@ -1877,8 +1898,8 @@ function isExtensionSchema(fhirSchema, _identifier) {
 }
 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);
+  const identifier = mkValueSetIdentifierByUrl(register, valueSet.package_meta, valueSet.url);
+  const concept = extractValueSetConceptsByUrl(register, valueSet.package_meta, valueSet.url);
   return {
     identifier,
     description: valueSet.description,
@@ -1964,7 +1985,10 @@ function transformFhirSchemaResource(register, fhirSchema, logger) {
   const identifier = mkIdentifier(fhirSchema);
   let base;
   if (fhirSchema.base && fhirSchema.type !== "Element") {
-    const baseFs = register.resolveFs(register.ensureSpecializationCanonicalUrl(fhirSchema.base));
+    const baseFs = register.resolveFs(
+      fhirSchema.package_meta,
+      register.ensureSpecializationCanonicalUrl(fhirSchema.package_meta, fhirSchema.base)
+    );
     if (!baseFs) {
       throw new Error(`Base resource not found '${fhirSchema.base}' for '${fhirSchema.url}'`);
     }
@@ -2336,120 +2360,129 @@ new CodegenLogger();
 function createLogger(options = {}) {
   return new CodegenLogger(options);
 }
-var registerFromManager = async (manager, conf) => {
-  const packageNameResolver = conf?.packageNameResolver ?? ["hl7.fhir.r5.core", "hl7.cda.uv.core"];
-  const logger = conf?.logger;
-  const flatRawIndex = {};
-  const canonicalToPackages = {};
-  const resourceTypes = /* @__PURE__ */ new Set(["StructureDefinition", "ValueSet", "CodeSystem"]);
-  for (const res of await manager.search({})) {
-    const rawUrl = res.url;
-    if (!rawUrl) continue;
-    if (!resourceTypes.has(res.resourceType)) continue;
-    const url = rawUrl;
-    const pkg = (await manager.resolveEntry(url)).package;
-    if (!pkg) throw new Error(`Can't resolve package for ${url}`);
-    if (!canonicalToPackages[url]) canonicalToPackages[url] = [];
-    canonicalToPackages[url].push(pkg);
-    flatRawIndex[url] = res;
-  }
-  const collisions = Object.entries(canonicalToPackages).filter(([_, e]) => e.length > 1).map(([url, pkgs]) => `${url}: ${pkgs.map((p) => `${p.name}@${p.version}`).join(", ")}`).join("\n");
-  logger?.warn(`Duplicated canonicals: ${collisions}`);
-  const packageToResources = {};
-  const packageToPackageMeta = {};
-  for (const [url, _pkgs] of Object.entries(canonicalToPackages)) {
-    const pkg = (await manager.resolveEntry(url)).package;
-    if (!pkg) throw new Error(`Can't find package for ${url}`);
-    const pkgId = packageMetaToFhir(pkg);
-    packageToPackageMeta[pkgId] = pkg;
-    const res = await manager.resolve(url);
-    if (!packageToResources[pkgId]) {
-      packageToResources[pkgId] = {};
-    }
-    const index = packageToResources[pkgId];
-    if (!index) throw new Error(`Can't find index for ${pkg.name}@${pkg.version}`);
-    index[url] = res;
-  }
-  const indexByPackages = [];
-  for (const [pkgId, index] of Object.entries(packageToResources)) {
-    indexByPackages.push({
-      package_meta: packageToPackageMeta[pkgId],
-      index
+var readPackageJSON = async (workDir, packageMeta) => {
+  const packageJSONFileName = Path4.join(workDir, "node_modules", packageMeta.name, "package.json");
+  const packageJSON = JSON.parse(await afs2.readFile(packageJSONFileName, "utf8"));
+  return packageJSON;
+};
+var readPackageDependencies = async (workDir, packageMeta) => {
+  const packageJSON = await readPackageJSON(workDir, packageMeta);
+  const dependencies = packageJSON.dependencies;
+  if (dependencies !== void 0) {
+    return Object.entries(dependencies).map(([name, version]) => {
+      return { name, version };
     });
   }
-  const sdIndex = {};
-  const vsIndex = {};
-  const fsIndex = {};
-  for (const resourcesByPackage of indexByPackages) {
-    const packageMeta = resourcesByPackage.package_meta;
-    let counter = 0;
-    logger?.info(`FHIR Schema conversion for '${packageMetaToFhir(packageMeta)}' begins...`);
-    for (const [surl, resource] of Object.entries(resourcesByPackage.index)) {
-      const url = surl;
-      if (resource.resourceType === "StructureDefinition") {
-        const sd = resource;
-        sdIndex[url] = sd;
-        const rfs = enrichFHIRSchema(fhirschema.translate(sd), packageMeta);
-        counter++;
-        fsIndex[rfs.url] = rfs;
-      }
-      if (resource.resourceType === "ValueSet") {
-        if (!resource.package_meta) {
-          resource.package_meta = packageMeta;
+  return [];
+};
+var mkEmptyPkgIndex = (pkg) => {
+  return { pkg, nameResolution: {}, canonicalResolution: {}, fhirSchemas: {}, valueSets: {} };
+};
+var mkPackageAwareResolver = async (manager, pkg, deep = 0, _logger) => {
+  const options = {};
+  const deps = await readPackageDependencies("tmp/fhir", pkg);
+  for (const dep of deps) {
+    const depOptions = mkPackageAwareResolver(manager, dep, deep);
+    Object.assign(options, depOptions);
+  }
+  const pkgId = packageMetaToFhir(pkg);
+  if (!options[pkgId]) options[pkgId] = mkEmptyPkgIndex(pkg);
+  for (const resource of await manager.search({ package: pkg })) {
+    const rawUrl = resource.url;
+    if (!rawUrl) continue;
+    if (!(isStructureDefinition(resource) || isValueSet(resource) || isCodeSystem(resource))) continue;
+    const url = rawUrl;
+    if (!options[pkgId].canonicalResolution[url]) {
+      options[pkgId].canonicalResolution[url] = [];
+      for (const [depPkgId, { canonicalResolution }] of Object.entries(options)) {
+        if (pkgId === depPkgId) continue;
+        if (!canonicalResolution[url]) continue;
+        for (const deepRes of canonicalResolution[url]) {
+          options[pkgId].canonicalResolution[url].push({
+            deep: deepRes.deep + 1,
+            resource: deepRes.resource,
+            packageMeta: deepRes.packageMeta
+          });
         }
-        vsIndex[resource.url] = resource;
       }
     }
-    logger?.success(
-      `FHIR Schema conversion for '${packageMetaToFhir(packageMeta)}' completed: ${counter} successful`
-    );
-  }
-  const specNameToCanonicals = {};
-  for (const rfs of Object.values(fsIndex)) {
-    if (rfs.derivation === "constraint") continue;
-    const name = rfs.name;
-    if (!specNameToCanonicals[name]) specNameToCanonicals[name] = {};
-    specNameToCanonicals[name][rfs.package_meta.name] = rfs.url;
-  }
-  const specNameToCanonical = {};
-  for (const [sname, canonicals] of Object.entries(specNameToCanonicals)) {
-    const name = sname;
-    const canonicalValues = Object.values(canonicals);
-    if (canonicalValues.length === 1) {
-      const url = canonicalValues[0];
-      specNameToCanonical[name] = url;
-    } else {
-      for (const pname of packageNameResolver) {
-        if (canonicals[pname]) {
-          specNameToCanonical[name] = canonicals[pname];
-          break;
-        }
+    options[pkgId].canonicalResolution[url].push({ deep, packageMeta: pkg, resource });
+    options[pkgId].canonicalResolution[url].sort((a, b) => a.deep - b.deep);
+    const name = resource.name;
+    if (name && isStructureDefinition(resource) && (resource.derivation === "specialization" || resource.derivation === void 0)) {
+      if (!options[pkgId].nameResolution[name]) {
+        options[pkgId].nameResolution[name] = resource.url;
+      } else {
+        throw new Error(`Duplicate name ${name} in package ${pkgId}`);
       }
-      if (specNameToCanonical[name] === void 0) throw new Error(`No canonical URL found for ${name}`);
     }
   }
-  const complexTypes = {};
-  for (const fs3 of Object.values(fsIndex)) {
-    if (fs3.kind === "complex-type") {
-      complexTypes[fs3.url] = fs3;
+  return options;
+};
+var packageAwareResolveName = (resolver, pkg, name) => {
+  const pkgId = packageMetaToFhir(pkg);
+  if (!resolver[pkgId]) throw new Error(`Package ${pkgId} not found`);
+  const resource = resolver[pkgId].nameResolution[name];
+  return resource;
+};
+var packageAgnosticResolveCanonical = (resolver, url, logger) => {
+  const options = Object.values(resolver).flatMap((pkg) => pkg.canonicalResolution[url]);
+  if (!options) throw new Error(`No canonical resolution found for ${url} in any package`);
+  if (options.length > 1)
+    logger?.dry_warn(
+      `Multiple canonical resolutions found for ${url} in: ${JSON.stringify(options, void 0, 2)}`
+    );
+  return options[0]?.resource;
+};
+var registerFromManager = async (manager, { logger, fallbackPackageForNameResolution }) => {
+  const packages = await manager.packages();
+  const resolver = {};
+  for (const pkg of packages) {
+    Object.assign(resolver, await mkPackageAwareResolver(manager, pkg));
+  }
+  for (const { pkg, canonicalResolution } of Object.values(resolver)) {
+    const pkgId = packageMetaToFhir(pkg);
+    if (!resolver[pkgId]) throw new Error(`Package ${pkgId} not found`);
+    let counter = 0;
+    logger?.info(`FHIR Schema conversion for '${packageMetaToFhir(pkg)}' begins...`);
+    for (const [_url, options] of Object.entries(canonicalResolution)) {
+      const resource = options[0]?.resource;
+      if (!resource) throw new Error(`Resource not found`);
+      if (isStructureDefinition(resource)) {
+        const rfs = enrichFHIRSchema(fhirschema.translate(resource), pkg);
+        counter++;
+        resolver[pkgId].fhirSchemas[rfs.url] = rfs;
+      }
+      if (isValueSet(resource)) {
+        const rvs = enrichValueSet(resource, pkg);
+        resolver[pkgId].valueSets[rvs.url] = rvs;
+      }
     }
+    logger?.success(`FHIR Schema conversion for '${packageMetaToFhir(pkg)}' completed: ${counter} successful`);
   }
-  const resolveFsGenealogy = (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[specNameToCanonical[fs3.base]];
-      genealogy.push(fs3);
-      if (fs3 === void 0) throw new Error(`Failed to resolve FHIR Schema genealogy for '${canonicalUrl}'`);
+  const resolveFs = (pkg, canonicalUrl) => {
+    return resolver[packageMetaToFhir(pkg)]?.fhirSchemas[canonicalUrl] || fallbackPackageForNameResolution && resolver[packageMetaToFhir(fallbackPackageForNameResolution)]?.fhirSchemas[canonicalUrl];
+  };
+  const resolveVs = (pkg, canonicalUrl) => {
+    return resolver[packageMetaToFhir(pkg)]?.valueSets[canonicalUrl] || fallbackPackageForNameResolution && resolver[packageMetaToFhir(fallbackPackageForNameResolution)]?.valueSets[canonicalUrl];
+  };
+  const ensureSpecializationCanonicalUrl = (pkg, name) => packageAwareResolveName(resolver, pkg, name) || fallbackPackageForNameResolution && packageAwareResolveName(resolver, fallbackPackageForNameResolution, name) || name;
+  const resolveFsGenealogy = (pkg, canonicalUrl) => {
+    let fs4 = resolveFs(pkg, canonicalUrl);
+    if (fs4 === void 0) throw new Error(`Failed to resolve FHIR Schema genealogy for '${canonicalUrl}'`);
+    const genealogy = [fs4];
+    while (fs4?.base) {
+      fs4 = resolveFs(fs4.package_meta, fs4.base) || resolveFs(fs4.package_meta, ensureSpecializationCanonicalUrl(fs4.package_meta, fs4.base));
+      if (fs4 === void 0) throw new Error(`Failed to resolve FHIR Schema genealogy for '${canonicalUrl}'`);
+      genealogy.push(fs4);
     }
     return genealogy;
   };
-  const resolveFsSpecializations = (canonicalUrl) => {
-    return resolveFsGenealogy(canonicalUrl).filter((fs3) => fs3.derivation === "specialization");
+  const resolveFsSpecializations = (pkg, canonicalUrl) => {
+    return resolveFsGenealogy(pkg, canonicalUrl).filter((fs4) => fs4.derivation === "specialization");
   };
   const resolveElementSnapshot = (fhirSchema, path) => {
-    const geneology = resolveFsGenealogy(fhirSchema.url);
+    const geneology = resolveFsGenealogy(fhirSchema.package_meta, fhirSchema.url);
     const elemGeneology = resolveFsElementGenealogy(geneology, path);
     const elemSnapshot = fsElementSnapshot(elemGeneology);
     return elemSnapshot;
@@ -2468,22 +2501,26 @@ var registerFromManager = async (manager, conf) => {
   };
   return {
     ...manager,
-    appendFs(fs3) {
-      const rfs = enrichFHIRSchema(fs3);
-      fsIndex[rfs.url] = rfs;
-      specNameToCanonical[rfs.name] = rfs.url;
+    unsafeAppendFs(fs4) {
+      const rfs = enrichFHIRSchema(fs4);
+      const pkgId = packageMetaToFhir(rfs.package_meta);
+      if (!resolver[pkgId]) resolver[pkgId] = mkEmptyPkgIndex(rfs.package_meta);
+      resolver[pkgId].nameResolution[rfs.name] = rfs.url;
+      resolver[pkgId].fhirSchemas[rfs.url] = rfs;
     },
-    resolveFs: (canonicalUrl) => fsIndex[canonicalUrl],
+    resolveFs,
     resolveFsGenealogy,
     resolveFsSpecializations,
-    ensureSpecializationCanonicalUrl: (name) => specNameToCanonical[name] || name,
-    allSd: () => Object.values(sdIndex),
-    resolveSd: (canonicalUrl) => sdIndex[canonicalUrl],
-    allFs: () => Object.values(fsIndex),
-    allVs: () => Object.values(vsIndex),
-    resolveVs: (canonicalUrl) => vsIndex[canonicalUrl],
-    complexTypeDict: () => complexTypes,
-    resolveAny: (canonicalUrl) => flatRawIndex[canonicalUrl],
+    ensureSpecializationCanonicalUrl,
+    resolveSd: (_pkg, canonicalUrl) => {
+      const res = packageAgnosticResolveCanonical(resolver, canonicalUrl, logger);
+      if (isStructureDefinition(res)) return res;
+      return void 0;
+    },
+    allFs: () => Object.values(resolver).flatMap((pkgIndex) => Object.values(pkgIndex.fhirSchemas)),
+    allVs: () => Object.values(resolver).flatMap((pkgIndex) => Object.values(pkgIndex.valueSets)),
+    resolveVs,
+    resolveAny: (canonicalUrl) => packageAgnosticResolveCanonical(resolver, canonicalUrl, logger),
     resolveElementSnapshot,
     getAllElementKeys
   };
@@ -2491,9 +2528,9 @@ var registerFromManager = async (manager, conf) => {
 var resolveFsElementGenealogy = (genealogy, path) => {
   const [top, ...rest] = path;
   if (top === void 0) return [];
-  return genealogy.map((fs3) => {
-    if (!fs3.elements) return void 0;
-    let elem = fs3.elements?.[top];
+  return genealogy.map((fs4) => {
+    if (!fs4.elements) return void 0;
+    let elem = fs4.elements?.[top];
     for (const k of rest) {
       elem = elem?.elements?.[k];
     }
@@ -2501,7 +2538,8 @@ var resolveFsElementGenealogy = (genealogy, path) => {
   }).filter((elem) => elem !== void 0);
 };
 function fsElementSnapshot(genealogy) {
-  const snapshot = genealogy.reverse().reduce((snapshot2, elem) => ({ ...snapshot2, ...elem }), {});
+  const revGenealogy = genealogy.reverse();
+  const snapshot = Object.assign({}, ...revGenealogy);
   snapshot.elements = void 0;
   return snapshot;
 }
@@ -2532,7 +2570,7 @@ var TypeSchemaGenerator = class {
     const packageNames = packageMetas.map((meta) => `${meta.name}${meta.version}`);
     this.logger?.step(`Loading FHIR packages: ${packageNames.join(", ")}`);
     await this.manager.init();
-    return registerFromManager(this.manager);
+    return registerFromManager(this.manager, {});
   }
   generateFhirSchemas(structureDefinitions) {
     this.logger?.progress(`Converting ${structureDefinitions.length} StructureDefinitions to FHIRSchemas`);
@@ -2606,7 +2644,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 (fs3) => await transformFhirSchema(register, fs3, logger)))).flat();
+    const fhirSchemas = (await Promise.all(register.allFs().map(async (fs4) => await transformFhirSchema(register, fs4, logger)))).flat();
     const allSchemas = [...fhirSchemas, ...valueSets];
     if (this.cache) {
       for (const schema of allSchemas) {
@@ -3029,6 +3067,451 @@ function deepEqual(obj1, obj2) {
   if (keys1.length !== keys2.length) return false;
   return keys1.every((key) => keys2.includes(key) && deepEqual(obj1[key], obj2[key]));
 }
+var FileSystemWriter = class {
+  opts;
+  currentDir;
+  currentFileDescriptor;
+  writtenFilesSet = /* @__PURE__ */ new Set();
+  constructor(opts) {
+    this.opts = opts;
+    this.currentDir = opts.outputDir;
+  }
+  logger() {
+    return this.opts.logger;
+  }
+  cd(path, gen) {
+    this.currentDir = path.startsWith("/") ? Path4.join(this.opts.outputDir, path) : Path4.join(this.currentDir, path);
+    if (!fs.existsSync(this.currentDir)) {
+      fs.mkdirSync(this.currentDir, { recursive: true });
+    }
+    this.logger()?.debug(`cd '${this.currentDir}'`);
+    gen();
+  }
+  cat(fn, gen) {
+    if (this.currentFileDescriptor) throw new Error("Can't open file in file");
+    if (fn.includes("/")) throw new Error(`Change file path separatly: ${fn}`);
+    const fullFn = `${this.currentDir}/${fn}`;
+    try {
+      this.currentFileDescriptor = fs.openSync(fullFn, "w");
+      this.writtenFilesSet.add(fn);
+      this.logger()?.debug(`cat > '${fullFn}'`);
+      gen();
+    } finally {
+      if (this.currentFileDescriptor) {
+        fs.closeSync(this.currentFileDescriptor);
+      }
+      this.currentFileDescriptor = void 0;
+    }
+  }
+  write(str) {
+    if (!this.currentFileDescriptor) throw new Error("No file opened");
+    fs.writeSync(this.currentFileDescriptor, str);
+  }
+  generate(_tsIndex) {
+    throw new Error("Not implemented");
+  }
+  writtenFiles() {
+    return Array.from(this.writtenFilesSet);
+  }
+};
+var Writer = class extends FileSystemWriter {
+  currentIndent = 0;
+  indent() {
+    this.currentIndent += this.opts.tabSize;
+  }
+  deindent() {
+    this.currentIndent -= this.opts.tabSize;
+  }
+  writeIndent() {
+    this.write(" ".repeat(this.currentIndent));
+  }
+  line(...tokens) {
+    if (tokens.length === 0) {
+      this.write("\n");
+    } else {
+      this.writeIndent();
+      this.write(`${tokens.join(" ")}
+`);
+    }
+  }
+  lineSM(...tokens) {
+    this.writeIndent();
+    this.write(`${tokens.join(" ")};
+`);
+  }
+  comment(...tokens) {
+    const lines = tokens.join(" ").split("\n");
+    for (const line of lines) {
+      this.line(this.opts.commentLinePrefix, line);
+    }
+  }
+  debugComment(...tokens) {
+    if (this.opts.withDebugComment) {
+      tokens = tokens.map((token) => {
+        if (typeof token === "string") {
+          return token;
+        } else {
+          return JSON.stringify(token, null, 2);
+        }
+      });
+      this.comment(...tokens);
+    }
+  }
+  disclaimer() {
+    return [
+      "WARNING: This file is autogenerated by @atomic-ehr/codegen.",
+      "GitHub: https://github.com/orgs/atomic-ehr/repositories",
+      "Any manual changes made to this file may be overwritten."
+    ];
+  }
+  generateDisclaimer() {
+    this.disclaimer().forEach((e) => this.comment(e));
+    this.line();
+  }
+  indentBlock(gencontent) {
+    this.indent();
+    gencontent();
+    this.deindent();
+  }
+  curlyBlock(tokens, gencontent, endTokens) {
+    this.line(`${tokens.filter(Boolean).join(" ")} {`);
+    this.indent();
+    gencontent();
+    this.deindent();
+    this.line(`}${endTokens?.filter(Boolean).join(" ") ?? ""}`);
+  }
+  squareBlock(tokens, gencontent, endTokens) {
+    this.line(`${tokens.filter(Boolean).join(" ")} [`);
+    this.indent();
+    gencontent();
+    this.deindent();
+    this.line(`]${endTokens?.filter(Boolean).join(" ") ?? ""}`);
+  }
+};
+
+// src/api/writer-generator/csharp/formatHelper.ts
+var ops = {
+  "!": "Not",
+  "<=": "LessOrEqual",
+  ">=": "GreaterOrEqual",
+  "<": "Less",
+  ">": "Greater",
+  "=": "Equal",
+  "-": "Dash",
+  "+": "Plus",
+  "*": "Asterisk",
+  "/": "Slash",
+  "%": "Percent",
+  "&": "And",
+  "|": "Or",
+  "^": "Xor",
+  "~": "Tilde",
+  "?": "Question",
+  ".": "Dot"
+};
+function formatEnumDashHandle(entry) {
+  return entry.split("-").map((part) => uppercaseFirstLetter(part)).join("-");
+}
+function formatEnumEntryOperation(entry) {
+  let res = entry;
+  for (const op in ops) res = res.replaceAll(op, ops[op] ?? "");
+  return res;
+}
+function formatEnumNumber(entry) {
+  const num = Number(entry[0]);
+  if (Number.isInteger(num) && !Number.isNaN(num)) {
+    return `_${entry}`;
+  }
+  return entry;
+}
+function formatEnumEntry(entry) {
+  let res = formatEnumDashHandle(entry);
+  res = formatEnumNumber(res);
+  res = formatEnumEntryOperation(res);
+  res = uppercaseFirstLetter(res);
+  return res;
+}
+function formatName(input) {
+  return uppercaseFirstLetter(camelCase(input.replaceAll(".", "-")));
+}
+
+// src/api/writer-generator/csharp/csharp.ts
+var PRIMITIVE_TYPE_MAP = {
+  boolean: "bool",
+  instant: "string",
+  time: "string",
+  date: "string",
+  dateTime: "string",
+  decimal: "decimal",
+  integer: "int",
+  unsignedInt: "long",
+  positiveInt: "long",
+  integer64: "long",
+  base64Binary: "string",
+  uri: "string",
+  url: "string",
+  canonical: "string",
+  oid: "string",
+  uuid: "string",
+  string: "string",
+  code: "string",
+  markdown: "string",
+  id: "string",
+  xhtml: "string"
+};
+var RESERVED_TYPE_NAMES = ["Reference", "Expression"];
+var getFieldModifiers = (field) => {
+  return field.required ? ["required"] : [];
+};
+var formatClassName = (schema) => {
+  const name = prefixReservedTypeName(getResourceName(schema.identifier));
+  return uppercaseFirstLetter(name);
+};
+var formatBaseClass = (schema) => {
+  return schema.base ? `: ${schema.base.name}` : "";
+};
+var canonicalToName = (canonical, dropFragment = true) => {
+  if (!canonical) return void 0;
+  let localName = canonical.split("/").pop();
+  if (!localName) return void 0;
+  if (dropFragment && localName.includes("#")) localName = localName.split("#")[0];
+  if (!localName) return void 0;
+  if (/^\d/.test(localName)) {
+    localName = `number_${localName}`;
+  }
+  return formatName(localName);
+};
+var getResourceName = (id) => {
+  if (id.kind === "nested") {
+    const url = id.url;
+    const path = canonicalToName(url, false);
+    if (!path) return "";
+    const [resourceName, fragment] = path.split("#");
+    const name = uppercaseFirstLetterOfEach((fragment ?? "").split(".")).join("");
+    return formatName([resourceName, name].join(""));
+  }
+  return formatName(id.name);
+};
+var isReservedTypeName = (name) => RESERVED_TYPE_NAMES.includes(name);
+var prefixReservedTypeName = (name) => isReservedTypeName(name) ? `Resource${name}` : name;
+var CSharp = class extends Writer {
+  enums = {};
+  staticSourceDir;
+  targetNamespace;
+  constructor(options) {
+    super({
+      outputDir: options.outputDir,
+      tabSize: 4,
+      withDebugComment: false,
+      commentLinePrefix: "//",
+      logger: options.logger
+    });
+    this.staticSourceDir = options.staticSourceDir;
+    this.targetNamespace = options.targetNamespace;
+  }
+  generate(typeSchemaIndex) {
+    const complexTypes = typeSchemaIndex.collectComplexTypes();
+    const resources = typeSchemaIndex.collectResources();
+    const packages = Array.from(new Set(resources.map((r) => formatName(r.identifier.package))));
+    this.generateAllFiles(complexTypes, resources, packages);
+    this.copyStaticFiles();
+  }
+  generateAllFiles(complexTypes, resources, packages) {
+    this.generateUsingFile(packages);
+    this.generateBaseTypes(complexTypes);
+    this.generateResources(resources);
+    this.generateEnumFiles(packages);
+    this.generateResourceDictionaries(resources, packages);
+    this.generateHelperFile();
+  }
+  generateType(schema, packageName) {
+    const className = formatClassName(schema);
+    const baseClass = formatBaseClass(schema);
+    this.curlyBlock(["public", "class", className, baseClass], () => {
+      this.generateFields(schema, packageName);
+      this.generateNestedTypes(schema, packageName);
+      this.line();
+      this.includeHelperMethods();
+    });
+    this.line();
+  }
+  generateFields(schema, packageName) {
+    if (!schema.fields) return;
+    const sortedFields = Object.entries(schema.fields).sort(([a], [b]) => a.localeCompare(b));
+    for (const [fieldName, field] of sortedFields) {
+      this.generateField(fieldName, field, packageName);
+    }
+  }
+  generateNestedTypes(schema, packageName) {
+    if (!("nested" in schema) || !schema.nested) return;
+    this.line();
+    for (const subtype of schema.nested) {
+      this.generateType(subtype, packageName);
+    }
+  }
+  generateField(fieldName, field, packageName) {
+    try {
+      if (isChoiceDeclarationField(field)) return;
+      const fieldDeclaration = this.buildFieldDeclaration(fieldName, field, packageName);
+      this.line(...fieldDeclaration);
+    } catch (error) {
+      this.logger()?.error(`Error processing field ${fieldName}: ${error.message}`);
+    }
+  }
+  buildFieldDeclaration(fieldName, field, packageName) {
+    const fieldType = this.determineFieldType(fieldName, field, packageName);
+    const modifiers = getFieldModifiers(field);
+    const propertyName = pascalCase(fieldName);
+    const accessors = "{ get; set; }";
+    return ["public", ...modifiers, fieldType, propertyName, accessors].filter(Boolean);
+  }
+  determineFieldType(fieldName, field, packageName) {
+    let typeName = this.getBaseTypeName(field);
+    if ("enum" in field && field.enum) {
+      typeName = this.registerAndGetEnumType(fieldName, field, packageName);
+    }
+    typeName = prefixReservedTypeName(typeName);
+    const baseNamespacePrefix = "";
+    const nullable = field.required ? "" : "?";
+    const arraySpecifier = field.array ? "[]" : "";
+    return `${baseNamespacePrefix}${typeName}${arraySpecifier}${nullable}`;
+  }
+  getBaseTypeName(field) {
+    if ("type" in field) {
+      let typeName = field.type.name.toString();
+      if (field.type.kind === "nested") {
+        typeName = getResourceName(field.type);
+      } else if (field.type.kind === "primitive-type") typeName = PRIMITIVE_TYPE_MAP[field.type.name] ?? "string";
+      return typeName;
+    }
+    return "";
+  }
+  registerAndGetEnumType(fieldName, field, packageName) {
+    const enumName = formatName(field.binding?.name ?? fieldName);
+    const enumTypeName = `${enumName}Enum`;
+    if (!this.enums[packageName]) this.enums[packageName] = {};
+    if (field.enum) this.enums[packageName][enumTypeName] = field.enum;
+    return enumTypeName;
+  }
+  includeHelperMethods() {
+    this.line("public override string ToString() => ");
+    this.line("    JsonSerializer.Serialize(this, Helper.JsonSerializerOptions);");
+    this.line();
+  }
+  generateUsingFile(packages) {
+    this.cd("/", async () => {
+      this.cat("Usings.cs", () => {
+        this.generateDisclaimer();
+        this.generateGlobalUsings(packages);
+      });
+    });
+  }
+  generateGlobalUsings(packages) {
+    const globalUsings = [
+      "CSharpSDK",
+      "System.Text.Json",
+      "System.Text.Json.Serialization",
+      this.targetNamespace,
+      ...packages.map((pkg) => `${this.targetNamespace}.${pkg}`)
+    ];
+    for (const using of globalUsings) this.lineSM("global", "using", using);
+  }
+  generateBaseTypes(complexTypes) {
+    this.cd("/", async () => {
+      this.cat("base.cs", () => {
+        this.generateDisclaimer();
+        this.line();
+        this.lineSM("namespace", this.targetNamespace);
+        for (const schema of complexTypes) {
+          const packageName = formatName(schema.identifier.package);
+          this.generateType(schema, packageName);
+        }
+      });
+    });
+  }
+  generateResources(resources) {
+    for (const schema of resources) this.generateResourceFile(schema);
+  }
+  generateResourceFile(schema) {
+    const packageName = formatName(schema.identifier.package);
+    this.cd(`/${packageName}`, async () => {
+      this.cat(`${schema.identifier.name}.cs`, () => {
+        this.generateDisclaimer();
+        this.line();
+        this.lineSM("namespace", `${this.targetNamespace}.${packageName}`);
+        this.line();
+        this.generateType(schema, packageName);
+      });
+    });
+  }
+  generateEnumFiles(packages) {
+    for (const packageName of packages) {
+      this.generatePackageEnums(packageName);
+    }
+  }
+  generatePackageEnums(packageName) {
+    const packageEnums = this.enums[packageName];
+    if (!packageEnums || Object.keys(packageEnums).length === 0) return;
+    this.cd(`/${packageName}`, async () => {
+      this.cat(`${packageName}Enums.cs`, () => {
+        this.generateDisclaimer();
+        this.generateEnumFileContent(packageName, packageEnums);
+      });
+    });
+  }
+  generateEnumFileContent(packageName, enums) {
+    this.lineSM("using", "System.ComponentModel");
+    this.line();
+    this.lineSM(`namespace ${this.targetNamespace}.${packageName}`);
+    for (const [enumName, values] of Object.entries(enums)) {
+      this.generateEnum(enumName, values);
+    }
+  }
+  generateEnum(enumName, values) {
+    this.curlyBlock(["public", "enum", enumName], () => {
+      for (const value of values) {
+        this.line(`[Description("${value}")]`);
+        this.line(`${formatEnumEntry(value)},`);
+      }
+    });
+    this.line();
+  }
+  generateResourceDictionaries(resources, packages) {
+    this.cd("/", async () => {
+      for (const packageName of packages) {
+        const packageResources = resources.filter((r) => formatName(r.identifier.package) === packageName);
+        if (packageResources.length === 0) return;
+        this.cat(`${packageName}ResourceDictionary.cs`, () => {
+          this.generateDisclaimer();
+          this.line();
+          this.lineSM(`namespace ${this.targetNamespace}`);
+          this.generateResourceDictionaryClass(packageName, packageResources);
+        });
+      }
+    });
+  }
+  generateResourceDictionaryClass(packageName, resources) {
+    this.curlyBlock(["public", "static", "class", "ResourceDictionary"], () => {
+      this.curlyBlock(["public static readonly Dictionary<Type, string> Map = new()"], () => {
+        for (const schema of resources) {
+          const typeName = schema.identifier.name;
+          this.line(`{ typeof(${packageName}.${typeName}), "${typeName}" },`);
+        }
+      });
+      this.lineSM();
+    });
+  }
+  copyStaticFiles() {
+    if (!this.staticSourceDir) return;
+    const sourcePath = Path4__default.resolve(this.staticSourceDir);
+    fs__default.cpSync(sourcePath, this.opts.outputDir, { recursive: true });
+  }
+  generateHelperFile() {
+    const sourceFile = "src/api/writer-generator/csharp/Helper.cs";
+    const destFile = Path4__default.join(this.opts.outputDir, "Helper.cs");
+    fs__default.copyFileSync(sourceFile, destFile);
+  }
+};
 
 // src/typeschema/utils.ts
 var groupByPackages = (typeSchemas) => {
@@ -5205,127 +5688,6 @@ ${nestedInterfaces}`;
     );
   }
 };
-var FileSystemWriter = class {
-  opts;
-  currentDir;
-  currentFileDescriptor;
-  writtenFilesSet = /* @__PURE__ */ new Set();
-  constructor(opts) {
-    this.opts = opts;
-    this.currentDir = opts.outputDir;
-  }
-  logger() {
-    return this.opts.logger;
-  }
-  cd(path, gen) {
-    this.currentDir = path.startsWith("/") ? Path2.join(this.opts.outputDir, path) : Path2.join(this.currentDir, path);
-    if (!fs.existsSync(this.currentDir)) {
-      fs.mkdirSync(this.currentDir, { recursive: true });
-    }
-    this.logger()?.debug(`cd '${this.currentDir}'`);
-    gen();
-  }
-  cat(fn, gen) {
-    if (this.currentFileDescriptor) throw new Error("Can't open file in file");
-    if (fn.includes("/")) throw new Error(`Change file path separatly: ${fn}`);
-    const fullFn = `${this.currentDir}/${fn}`;
-    try {
-      this.currentFileDescriptor = fs.openSync(fullFn, "w");
-      this.writtenFilesSet.add(fn);
-      this.logger()?.debug(`cat > '${fullFn}'`);
-      gen();
-    } finally {
-      if (this.currentFileDescriptor) {
-        fs.closeSync(this.currentFileDescriptor);
-      }
-      this.currentFileDescriptor = void 0;
-    }
-  }
-  write(str) {
-    if (!this.currentFileDescriptor) throw new Error("No file opened");
-    fs.writeSync(this.currentFileDescriptor, str);
-  }
-  generate(_tsIndex) {
-    throw new Error("Not implemented");
-  }
-  writtenFiles() {
-    return Array.from(this.writtenFilesSet);
-  }
-};
-var Writer = class extends FileSystemWriter {
-  currentIndent = 0;
-  indent() {
-    this.currentIndent += this.opts.tabSize;
-  }
-  deindent() {
-    this.currentIndent -= this.opts.tabSize;
-  }
-  writeIndent() {
-    this.write(" ".repeat(this.currentIndent));
-  }
-  line(...tokens) {
-    if (tokens.length === 0) {
-      this.write("\n");
-    } else {
-      this.writeIndent();
-      this.write(`${tokens.join(" ")}
-`);
-    }
-  }
-  lineSM(...tokens) {
-    this.writeIndent();
-    this.write(`${tokens.join(" ")};
-`);
-  }
-  comment(...tokens) {
-    const lines = tokens.join(" ").split("\n");
-    for (const line of lines) {
-      this.line(this.opts.commentLinePrefix, line);
-    }
-  }
-  debugComment(...tokens) {
-    if (this.opts.withDebugComment) {
-      tokens = tokens.map((token) => {
-        if (typeof token === "string") {
-          return token;
-        } else {
-          return JSON.stringify(token, null, 2);
-        }
-      });
-      this.comment(...tokens);
-    }
-  }
-  disclaimer() {
-    return [
-      "WARNING: This file is autogenerated by @atomic-ehr/codegen.",
-      "GitHub: https://github.com/orgs/atomic-ehr/repositories",
-      "Any manual changes made to this file may be overwritten."
-    ];
-  }
-  generateDisclaimer() {
-    this.disclaimer().forEach((e) => this.comment(e));
-    this.line();
-  }
-  indentBlock(gencontent) {
-    this.indent();
-    gencontent();
-    this.deindent();
-  }
-  curlyBlock(tokens, gencontent, endTokens) {
-    this.line(`${tokens.filter(Boolean).join(" ")} {`);
-    this.indent();
-    gencontent();
-    this.deindent();
-    this.line(`}${endTokens?.filter(Boolean).join(" ") ?? ""}`);
-  }
-  squareBlock(tokens, gencontent, endTokens) {
-    this.line(`${tokens.filter(Boolean).join(" ")} [`);
-    this.indent();
-    gencontent();
-    this.deindent();
-    this.line(`]${endTokens?.filter(Boolean).join(" ") ?? ""}`);
-  }
-};
 
 // src/api/writer-generator/typescript.ts
 var primitiveType2tsType = {
@@ -5366,7 +5728,7 @@ var tsModuleName = (id) => {
 var tsModuleFileName = (id) => {
   return `${tsModuleName(id)}.ts`;
 };
-var canonicalToName = (canonical, dropFragment = true) => {
+var canonicalToName2 = (canonical, dropFragment = true) => {
   if (!canonical) return void 0;
   let localName = canonical.split("/").pop();
   if (!localName) return void 0;
@@ -5382,7 +5744,7 @@ var canonicalToName = (canonical, dropFragment = true) => {
 var tsResourceName = (id) => {
   if (id.kind === "nested") {
     const url = id.url;
-    const path = canonicalToName(url, false);
+    const path = canonicalToName2(url, false);
     if (!path) return "";
     const [resourceName, fragment] = path.split("#");
     const name = uppercaseFirstLetterOfEach((fragment ?? "").split(".")).join("");
@@ -5436,7 +5798,7 @@ var TypeScript = class extends Writer {
           });
         } else if (isNestedIdentifier(dep)) {
           imports.push({
-            tsPackage: `../${kebabCase(dep.package)}/${pascalCase(canonicalToName(dep.url) ?? "")}`,
+            tsPackage: `../${kebabCase(dep.package)}/${pascalCase(canonicalToName2(dep.url) ?? "")}`,
             name: tsResourceName(dep)
           });
         } else {
@@ -5481,7 +5843,7 @@ var TypeScript = class extends Writer {
       name = tsResourceName(schema.identifier);
     }
     let extendsClause;
-    if (schema.base) extendsClause = `extends ${canonicalToName(schema.base.url)}`;
+    if (schema.base) extendsClause = `extends ${canonicalToName2(schema.base.url)}`;
     this.debugComment(schema.identifier);
     this.curlyBlock(["export", "interface", name, extendsClause], () => {
       if (isResourceTypeSchema(schema)) {
@@ -5721,7 +6083,7 @@ var writerToGenerator = (writerGen) => {
   const getGeneratedFiles = () => {
     return writerGen.writtenFiles().map((fn) => {
       return {
-        path: Path2.normalize(Path2.join(writerGen.opts.outputDir, fn)),
+        path: Path4.normalize(Path4.join(writerGen.opts.outputDir, fn)),
         filename: fn.replace(/^.*[\\/]/, ""),
         content: "",
         exports: [],
@@ -5821,7 +6183,7 @@ var APIBuilder = class _APIBuilder {
   }
   typescript2(opts) {
     const writerOpts = {
-      outputDir: Path2.join(this.options.outputDir, "/types"),
+      outputDir: Path4.join(this.options.outputDir, "/types"),
       tabSize: 4,
       withDebugComment: false,
       commentLinePrefix: "//"
@@ -5832,6 +6194,24 @@ var APIBuilder = class _APIBuilder {
     this.logger.debug(`Configured TypeScript2 generator (${JSON.stringify(effectiveOpts, void 0, 2)})`);
     return this;
   }
+  csharp(namespace, staticSourceDir) {
+    const generator = writerToGenerator(
+      new CSharp({
+        outputDir: Path4.join(this.options.outputDir, "/types"),
+        staticSourceDir: staticSourceDir ?? void 0,
+        targetNamespace: namespace,
+        logger: new CodegenLogger({
+          prefix: "C#",
+          timestamp: true,
+          verbose: true,
+          suppressLoggingLevel: []
+        })
+      })
+    );
+    this.generators.set("C#", generator);
+    this.logger.debug(`Configured C# generator`);
+    return this;
+  }
   /**
    * Set a progress callback for monitoring generation
    */
@@ -5870,22 +6250,22 @@ var APIBuilder = class _APIBuilder {
     return this;
   }
   static async isIdenticalTo(path, tsJSON) {
-    if (!await afs.exists(path)) return false;
-    const json = await afs.readFile(path);
+    if (!await afs2.exists(path)) return false;
+    const json = await afs2.readFile(path);
     const ts1 = JSON.parse(json.toString());
     const ts2 = JSON.parse(tsJSON);
     return deepEqual(ts1, ts2);
   }
   async writeTypeSchemasToSeparateFiles(typeSchemas, outputDir) {
     if (this.options.cleanOutput) fs.rmSync(outputDir, { recursive: true, force: true });
-    await afs.mkdir(outputDir, { recursive: true });
+    await afs2.mkdir(outputDir, { recursive: true });
     const usedNames = {};
     this.logger.info(`Writing TypeSchema files to ${outputDir}...`);
     for (const ts of typeSchemas) {
       const package_name = camelCase(ts.identifier.package.replaceAll("/", "-"));
       const name = normalizeFileName(ts.identifier.name.toString());
       const json = JSON.stringify(ts, null, 2);
-      const baseName = Path2.join(outputDir, package_name, name);
+      const baseName = Path4.join(outputDir, package_name, name);
       let fullName;
       if (usedNames[baseName] !== void 0) {
         usedNames[baseName]++;
@@ -5895,24 +6275,24 @@ var APIBuilder = class _APIBuilder {
         fullName = `${baseName}.typeschema.json`;
       }
       if (await _APIBuilder.isIdenticalTo(fullName, json)) continue;
-      await afs.mkdir(Path2.dirname(fullName), { recursive: true });
-      await afs.writeFile(fullName, json);
+      await afs2.mkdir(Path4.dirname(fullName), { recursive: true });
+      await afs2.writeFile(fullName, json);
     }
   }
   async writeTypeSchemasToSingleFile(typeSchemas, outputFile) {
     if (this.options.cleanOutput && fs.existsSync(outputFile)) fs.rmSync(outputFile);
-    await afs.mkdir(Path2.dirname(outputFile), { recursive: true });
+    await afs2.mkdir(Path4.dirname(outputFile), { recursive: true });
     this.logger.info(`Writing TypeSchemas to one file ${outputFile}...`);
     for (const ts of typeSchemas) {
       const json = JSON.stringify(ts, null, 2);
-      await afs.appendFile(outputFile, json + "\n");
+      await afs2.appendFile(outputFile, json + "\n");
     }
   }
   async tryWriteTypeSchema(typeSchemas) {
     if (!this.options.typeSchemaOutputDir) return;
     try {
       this.logger.info(`Starting writing TypeSchema files.`);
-      if (Path2.extname(this.options.typeSchemaOutputDir) === ".ndjson")
+      if (Path4.extname(this.options.typeSchemaOutputDir) === ".ndjson")
         await this.writeTypeSchemasToSingleFile(typeSchemas, this.options.typeSchemaOutputDir);
       else await this.writeTypeSchemasToSeparateFiles(typeSchemas, this.options.typeSchemaOutputDir);
       this.logger.info(`Finished writing TypeSchema files.`);