@atomic-ehr/codegen 0.0.1-canary.20250929141928.699688c → 0.0.1-canary.20250930075344.1c0b689

package/dist/cli/utils/spinner.js

@@ -231,16 +231,12 @@ export async function withSpinner(promise, options) {
     }).start();
     try {
         const result = await promise;
-        const successMessage = typeof options.success === "function"
-            ? options.success(result)
-            : options.success || options.start;
+        const successMessage = typeof options.success === "function" ? options.success(result) : options.success || options.start;
         spinner.succeed(successMessage);
         return result;
     }
     catch (error) {
-        const failMessage = typeof options.fail === "function"
-            ? options.fail(error)
-            : options.fail || `Failed: ${options.start}`;
+        const failMessage = typeof options.fail === "function" ? options.fail(error) : options.fail || `Failed: ${options.start}`;
         spinner.fail(failMessage);
         throw error;
     }

package/dist/config.js

@@ -393,11 +393,7 @@ export class ConfigValidator {
             });
         }
         // Validate boolean fields
-        const booleanFields = [
-            "includeConstraints",
-            "includeDocumentation",
-            "strictMode",
-        ];
+        const booleanFields = ["includeConstraints", "includeDocumentation", "strictMode"];
         for (const field of booleanFields) {
             if (cfg[field] !== undefined && typeof cfg[field] !== "boolean") {
                 errors.push({
@@ -421,12 +417,7 @@ export class ConfigValidator {
         }
         const cfg = config;
         // Validate boolean fields
-        const booleanFields = [
-            "enablePersistence",
-            "validateCached",
-            "forceRegenerate",
-            "shareCache",
-        ];
+        const booleanFields = ["enablePersistence", "validateCached", "forceRegenerate", "shareCache"];
         for (const field of booleanFields) {
             if (cfg[field] !== undefined && typeof cfg[field] !== "boolean") {
                 errors.push({
@@ -469,8 +460,7 @@ export class ConfigValidator {
             else {
                 const profiles = cfg.profiles;
                 // Validate autoDetect
-                if (profiles.autoDetect !== undefined &&
-                    typeof profiles.autoDetect !== "boolean") {
+                if (profiles.autoDetect !== undefined && typeof profiles.autoDetect !== "boolean") {
                     errors.push({
                         path: "typeSchema.profiles.autoDetect",
                         message: "autoDetect must be a boolean",
@@ -517,9 +507,7 @@ export class ConfigLoader {
             }
             const validation = this.validator.validate(config);
             if (!validation.valid) {
-                const errorMessages = validation.errors
-                    .map((e) => `${e.path}: ${e.message}`)
-                    .join("\n");
+                const errorMessages = validation.errors.map((e) => `${e.path}: ${e.message}`).join("\n");
                 throw new Error(`Configuration validation failed:\n${errorMessages}`);
             }
             // Merge with defaults

package/dist/logger.js

@@ -23,9 +23,7 @@ export class ConsoleOutput {
         this.useStderr = useStderr;
     }
     write(entry, formatted) {
-        const output = this.useStderr || entry.level >= LogLevel.WARN
-            ? console.error
-            : console.log;
+        const output = this.useStderr || entry.level >= LogLevel.WARN ? console.error : console.log;
         output(formatted);
     }
 }
@@ -229,9 +227,7 @@ export class Logger {
     child(component, context) {
         const childLogger = new Logger({
             ...this.config,
-            component: this.config.component
-                ? `${this.config.component}.${component}`
-                : component,
+            component: this.config.component ? `${this.config.component}.${component}` : component,
         });
         // If context is provided, wrap all logging methods to include it
         if (context) {
@@ -268,14 +264,9 @@ export function createLoggerFromConfig(config) {
         : config?.verbose
             ? LogLevel.INFO
             : config?.logLevel
-                ? (LogLevel[config.logLevel.toUpperCase()] ??
-                    LogLevel.INFO)
+                ? (LogLevel[config.logLevel.toUpperCase()] ?? LogLevel.INFO)
                 : LogLevel.INFO;
-    const format = config?.logFormat === "json"
-        ? "json"
-        : config?.logFormat === "compact"
-            ? "compact"
-            : "pretty";
+    const format = config?.logFormat === "json" ? "json" : config?.logFormat === "compact" ? "compact" : "pretty";
     const outputs = [new ConsoleOutput()];
     if (config?.logFile) {
         outputs.push(new FileOutput(config.logFile));

package/dist/typeschema/cache.d.ts

@@ -4,7 +4,7 @@
  * Caching system for TypeSchema documents with both in-memory and persistent file-based storage.
  */
 import type { TypeSchemaConfig } from "@root/config";
-import type { TypeSchema, Identifier } from "@typeschema/types";
+import type { Identifier, TypeSchema } from "@typeschema/types";
 /**
  * TypeSchema Cache with optional persistent storage
  */

package/dist/typeschema/core/binding.d.ts

@@ -4,8 +4,8 @@
  * Functions for processing value set bindings and generating enums
  */
 import type { CanonicalManager } from "@atomic-ehr/fhir-canonical-manager";
-import type { FHIRSchema, FHIRSchemaElement } from "@atomic-ehr/fhirschema";
-import type { PackageInfo, TypeSchemaForBinding } from "../types";
+import type { FHIRSchemaElement } from "@atomic-ehr/fhirschema";
+import type { PackageMeta, RichFHIRSchema, TypeSchemaForBinding } from "../types";
 /**
  * Extract concepts from a ValueSet
  */
@@ -18,11 +18,8 @@ export declare function extractValueSetConcepts(valueSetUrl: string, manager: Re
  * Build enum values from binding if applicable
  */
 export declare function buildEnum(element: FHIRSchemaElement, manager: ReturnType<typeof CanonicalManager>): Promise<string[] | undefined>;
-/**
- * Generate a binding TypeSchema
- */
-export declare function generateBindingSchema(fhirSchema: FHIRSchema, path: string[], element: FHIRSchemaElement, manager: ReturnType<typeof CanonicalManager>, packageInfo?: PackageInfo): Promise<TypeSchemaForBinding | undefined>;
+export declare function generateBindingSchema(fhirSchema: RichFHIRSchema, path: string[], element: FHIRSchemaElement, manager: ReturnType<typeof CanonicalManager>, packageInfo?: PackageMeta): Promise<TypeSchemaForBinding | undefined>;
 /**
  * Collect all binding schemas from a FHIRSchema
  */
-export declare function collectBindingSchemas(fhirSchema: FHIRSchema, manager: ReturnType<typeof CanonicalManager>, packageInfo?: PackageInfo): Promise<TypeSchemaForBinding[]>;
+export declare function collectBindingSchemas(fhirSchema: RichFHIRSchema, manager: ReturnType<typeof CanonicalManager>): Promise<TypeSchemaForBinding[]>;

package/dist/typeschema/core/binding.js

@@ -1,11 +1,10 @@
-// @ts-nocheck
 /**
  * Binding and Enum Handling
  *
  * Functions for processing value set bindings and generating enums
  */
 import { buildFieldType } from "./field-builder";
-import { buildBindingIdentifier, buildValueSetIdentifier, dropVersionFromUrl, } from "./identifier";
+import { dropVersionFromUrl, mkBindingIdentifier, mkValueSetIdentifier } from "./identifier";
 /**
  * Extract concepts from a ValueSet
  */
@@ -86,10 +85,8 @@ export async function buildEnum(element, manager) {
     // 3. Preferred bindings on code types (for common usage patterns)
     // 4. Extensible bindings on Coding types (broader coverage)
     const shouldGenerateEnum = strength === "required" ||
-        (strength === "extensible" &&
-            (element.type === "code" || element.type === "Coding")) ||
-        (strength === "preferred" &&
-            (element.type === "code" || element.type === "Coding"));
+        (strength === "extensible" && (element.type === "code" || element.type === "Coding")) ||
+        (strength === "preferred" && (element.type === "code" || element.type === "Coding"));
     if (!shouldGenerateEnum) {
         return undefined;
     }
@@ -115,39 +112,32 @@ export async function buildEnum(element, manager) {
         return undefined;
     }
 }
-/**
- * Generate a binding TypeSchema
- */
 export async function generateBindingSchema(fhirSchema, path, element, manager, packageInfo) {
     if (!element.binding?.valueSet)
         return undefined;
-    const identifier = buildBindingIdentifier(fhirSchema, path, element.binding.bindingName, packageInfo);
+    const identifier = mkBindingIdentifier(fhirSchema, path, element.binding.bindingName, packageInfo);
     const fieldType = buildFieldType(fhirSchema, path, element, manager, packageInfo);
-    const valueSetIdentifier = buildValueSetIdentifier(element.binding.valueSet, undefined, packageInfo);
-    const binding = {
+    const valueSetIdentifier = mkValueSetIdentifier(element.binding.valueSet, undefined, packageInfo);
+    const dependencies = [];
+    if (fieldType) {
+        dependencies.push(fieldType);
+    }
+    dependencies.push(valueSetIdentifier);
+    const enumValues = await buildEnum(element, manager);
+    return {
         identifier,
         type: fieldType,
         valueset: valueSetIdentifier,
         strength: element.binding.strength,
-        dependencies: [],
+        enum: enumValues,
+        dependencies,
     };
-    // Add dependencies in specific order: type first, then value set
-    if (fieldType) {
-        binding.dependencies.push(fieldType);
-    }
-    binding.dependencies.push(valueSetIdentifier);
-    // Add enum if applicable
-    const enumValues = await buildEnum(element, manager);
-    if (enumValues) {
-        binding.enum = enumValues;
-    }
-    // Don't sort dependencies - keep them in the order: type, then value set
-    return binding;
 }
 /**
  * Collect all binding schemas from a FHIRSchema
  */
-export async function collectBindingSchemas(fhirSchema, manager, packageInfo) {
+export async function collectBindingSchemas(fhirSchema, manager) {
+    const packageInfo = fhirSchema.package_meta;
     const bindings = [];
     const processedPaths = new Set();
     // Recursive function to process elements
@@ -166,19 +156,15 @@ export async function collectBindingSchemas(fhirSchema, manager, packageInfo) {
                     bindings.push(binding);
                 }
             }
-            // Process nested elements
             if (element.elements) {
                 await processElement(element.elements, path);
             }
         }
     }
-    // Start processing from root elements
     if (fhirSchema.elements) {
         await processElement(fhirSchema.elements, []);
     }
-    // Sort bindings by identifier name for consistent output
     bindings.sort((a, b) => a.identifier.name.localeCompare(b.identifier.name));
-    // Remove duplicates (same identifier URL)
     const uniqueBindings = [];
     const seenUrls = new Set();
     for (const binding of bindings) {

package/dist/typeschema/core/field-builder.d.ts

@@ -5,7 +5,8 @@
  */
 import type { CanonicalManager } from "@atomic-ehr/fhir-canonical-manager";
 import type { FHIRSchema, FHIRSchemaElement } from "@atomic-ehr/fhirschema";
-import type { PackageInfo, TypeSchemaField, Identifier } from "../types";
+import type { Register } from "@root/typeschema/register";
+import type { Identifier, PackageMeta, RichFHIRSchema, TypeSchemaField } from "../types";
 /**
  * Get the full element hierarchy for a given path
  */
@@ -22,23 +23,14 @@ export declare function isRequired(fhirSchema: FHIRSchema, path: string[], _mana
  * Check if a field is excluded
  */
 export declare function isExcluded(fhirSchema: FHIRSchema, path: string[], _manager: ReturnType<typeof CanonicalManager>): boolean;
-/**
- * Build reference array from element refers
- */
-export declare function buildReferences(element: FHIRSchemaElement, manager: ReturnType<typeof CanonicalManager>, packageInfo?: PackageInfo): Promise<Identifier[] | undefined>;
+export declare const buildReferences: (element: FHIRSchemaElement, register: Register, _packageInfo?: PackageMeta) => Identifier[] | undefined;
 /**
  * Build field type identifier
  */
-export declare function buildFieldType(fhirSchema: FHIRSchema, _path: string[], element: FHIRSchemaElement, _manager: ReturnType<typeof CanonicalManager>, packageInfo?: PackageInfo): Identifier | undefined;
-/**
- * Build a TypeSchema field from a FHIRSchema element
- */
-export declare function buildField(fhirSchema: FHIRSchema, path: string[], element: FHIRSchemaElement, manager: ReturnType<typeof CanonicalManager>, packageInfo?: PackageInfo): Promise<TypeSchemaField>;
+export declare function buildFieldType(fhirSchema: RichFHIRSchema, _path: string[], element: FHIRSchemaElement, _manager: ReturnType<typeof CanonicalManager>, packageInfo?: PackageMeta): Identifier | undefined;
+export declare const buildField: (fhirSchema: RichFHIRSchema, path: string[], element: FHIRSchemaElement, register: Register, packageInfo?: PackageMeta) => TypeSchemaField;
 /**
  * Check if an element represents a nested type (BackboneElement)
  */
 export declare function isNestedElement(element: FHIRSchemaElement): boolean;
-/**
- * Build a field reference to a nested type
- */
-export declare function buildNestedField(fhirSchema: FHIRSchema, path: string[], element: FHIRSchemaElement, manager: ReturnType<typeof CanonicalManager>, packageInfo?: PackageInfo): TypeSchemaField;
+export declare function mkNestedField(fhirSchema: RichFHIRSchema, path: string[], element: FHIRSchemaElement, manager: ReturnType<typeof CanonicalManager>, _packageInfo?: PackageMeta): TypeSchemaField;

package/dist/typeschema/core/field-builder.js

@@ -1,6 +1,10 @@
-// @ts-nocheck
+/**
+ * Field Building Utilities
+ *
+ * Functions for transforming FHIRSchema elements into TypeSchema fields
+ */
 import { buildEnum } from "./binding";
-import { buildBindingIdentifier, buildNestedIdentifier, buildSchemaIdentifier, } from "./identifier";
+import { mkBindingIdentifier, mkIdentifier, mkNestedIdentifier } from "./identifier";
 /**
  * Get the full element hierarchy for a given path
  */
@@ -60,8 +64,7 @@ export function mergeElementHierarchy(hierarchy) {
     // Override with specific properties from the first element
     for (const prop of ["choices", "binding", "refers", "elementReference"]) {
         // @ts-ignore
-        if (hierarchy[0] &&
-            hierarchy[0][prop] !== undefined) {
+        if (hierarchy[0] && hierarchy[0][prop] !== undefined) {
             // @ts-ignore
             snapshot[prop] = hierarchy[0][prop];
         }
@@ -88,9 +91,7 @@ export function isRequired(fhirSchema, path, _manager) {
         return true;
     }
     // Also check at root level
-    if (parentPath.length === 0 &&
-        fieldName &&
-        fhirSchema.required?.includes(fieldName)) {
+    if (parentPath.length === 0 && fieldName && fhirSchema.required?.includes(fieldName)) {
         return true;
     }
     return false;
@@ -115,32 +116,20 @@ export function isExcluded(fhirSchema, path, _manager) {
         return true;
     }
     // Also check at root level
-    if (parentPath.length === 0 &&
-        fieldName &&
-        fhirSchema.excluded?.includes(fieldName)) {
+    if (parentPath.length === 0 && fieldName && fhirSchema.excluded?.includes(fieldName)) {
         return true;
     }
     return false;
 }
-/**
- * Build reference array from element refers
- */
-export async function buildReferences(element, manager, packageInfo) {
-    if (!element.refers || element.refers.length === 0) {
+export const buildReferences = (element, register, _packageInfo) => {
+    if (!element.refers)
         return undefined;
-    }
-    const references = [];
-    for (const ref of element.refers) {
-        try {
-            const resource = await manager.resolve(ref);
-            if (resource) {
-                references.push(buildSchemaIdentifier(resource));
-            }
-        }
-        catch { }
-    }
-    return references;
-}
+    return element.refers.map((ref) => {
+        const curl = register.ensureCanonicalUrl(ref);
+        const fs = register.resolveFS(curl);
+        return mkIdentifier(fs);
+    });
+};
 /**
  * Build field type identifier
  */
@@ -153,7 +142,7 @@ export function buildFieldType(fhirSchema, _path, element, _manager, packageInfo
             .filter((p) => p !== "elements"); // Remove 'elements' which is just a container
         // Only return nested identifier if we have a non-empty path
         if (refPath.length > 0) {
-            return buildNestedIdentifier(fhirSchema, refPath, packageInfo);
+            return mkNestedIdentifier(fhirSchema, refPath);
         }
     }
     // Handle normal type
@@ -162,15 +151,11 @@ export function buildFieldType(fhirSchema, _path, element, _manager, packageInfo
             ? element.type
             : `http://hl7.org/fhir/StructureDefinition/${element.type}`;
         // Always create a type identifier, even if we can't resolve
-        const kind = element.type.match(/^[a-z]/)
-            ? "primitive-type"
-            : "complex-type";
+        const kind = element.type.match(/^[a-z]/) ? "primitive-type" : "complex-type";
         const isStandardFhir = typeUrl.startsWith("http://hl7.org/fhir/");
         return {
             kind: kind,
-            package: isStandardFhir
-                ? "hl7.fhir.r4.core"
-                : packageInfo?.name || "undefined",
+            package: isStandardFhir ? "hl7.fhir.r4.core" : packageInfo?.name || "undefined",
             version: isStandardFhir ? "4.0.1" : packageInfo?.version || "undefined",
             name: element.type,
             url: typeUrl,
@@ -178,55 +163,29 @@ export function buildFieldType(fhirSchema, _path, element, _manager, packageInfo
     }
     return undefined;
 }
-/**
- * Build a TypeSchema field from a FHIRSchema element
- */
-export async function buildField(fhirSchema, path, element, manager, packageInfo) {
-    const field = {
-        array: element.array || false,
-        required: isRequired(fhirSchema, path, manager),
-        excluded: isExcluded(fhirSchema, path, manager),
-    };
-    // Add type if present
-    const type = buildFieldType(fhirSchema, path, element, manager, packageInfo);
-    if (type) {
-        field.type = type;
-    }
-    // Add cardinality
-    if (element.min !== undefined)
-        field.min = element.min;
-    if (element.max !== undefined)
-        field.max = element.max;
-    // Add choices
-    // @ts-ignore
-    if (element.choices)
-        field.choices = element.choices;
-    // @ts-ignore
-    if (element.choiceOf)
-        field.choiceOf = element.choiceOf;
-    // Add binding if present
+export const buildField = (fhirSchema, path, element, register, packageInfo) => {
+    let binding;
+    let _enumValues;
     if (element.binding) {
-        field.binding = buildBindingIdentifier(fhirSchema, path, element.binding.bindingName, packageInfo);
-        // Add enum for required bindings on code types
+        binding = mkBindingIdentifier(fhirSchema, path, element.binding.bindingName, packageInfo);
         if (element.binding.strength === "required" && element.type === "code") {
-            const enumValues = await buildEnum(element, manager);
-            if (enumValues && enumValues.length > 0) {
-                field.enum = enumValues;
-            }
+            _enumValues = buildEnum(element, register);
         }
     }
-    // Add references
-    const references = await buildReferences(element, manager, packageInfo);
-    if (references) {
-        field.reference = references;
-    }
-    // Remove empty/default values
-    return removeEmptyValues(field);
-}
-/**
- * Remove empty values from an object
- */
-function removeEmptyValues(obj) {
+    return {
+        type: buildFieldType(fhirSchema, path, element, register, packageInfo),
+        required: isRequired(fhirSchema, path, register),
+        excluded: isExcluded(fhirSchema, path, register),
+        reference: buildReferences(element, register, packageInfo),
+        array: element.array || false,
+        min: element.min,
+        max: element.max,
+        choices: element.choices,
+        choiceOf: element.choiceOf,
+        binding: binding,
+    };
+};
+function _removeEmptyValues(obj) {
     const result = {};
     for (const [key, value] of Object.entries(obj)) {
         if (value !== undefined && value !== null) {
@@ -242,16 +201,11 @@ function removeEmptyValues(obj) {
  * Check if an element represents a nested type (BackboneElement)
  */
 export function isNestedElement(element) {
-    return (element.type === "BackboneElement" ||
-        (element.elements && Object.keys(element.elements).length > 0) ||
-        false);
+    return (element.type === "BackboneElement" || (element.elements && Object.keys(element.elements).length > 0) || false);
 }
-/**
- * Build a field reference to a nested type
- */
-export function buildNestedField(fhirSchema, path, element, manager, packageInfo) {
+export function mkNestedField(fhirSchema, path, element, manager, _packageInfo) {
     return {
-        type: buildNestedIdentifier(fhirSchema, path, packageInfo),
+        type: mkNestedIdentifier(fhirSchema, path),
         array: element.array || false,
         required: isRequired(fhirSchema, path, manager),
         excluded: isExcluded(fhirSchema, path, manager),

package/dist/typeschema/core/identifier.d.ts

@@ -4,12 +4,9 @@
  * Functions for creating TypeSchema identifiers from FHIRSchema entities
  */
 import type { FHIRSchema } from "@atomic-ehr/fhirschema";
-import type { PackageInfo, TypeSchemaForValueSet, Identifier, RichFHIRSchema } from "../types";
+import type { BindingIdentifier, Identifier, NestedIdentifier, PackageMeta, RichFHIRSchema, TypeSchemaForValueSet } from "../types";
 export declare function dropVersionFromUrl(url: string | undefined): string | undefined;
-export declare function buildSchemaIdentifier(fhirSchema: RichFHIRSchema): Identifier;
-export declare function buildNestedIdentifier(fhirSchema: FHIRSchema, path: string[], packageInfo?: PackageInfo): Identifier;
-export declare function buildValueSetIdentifier(valueSetUrl: string, valueSet: any, packageInfo?: PackageInfo): TypeSchemaForValueSet["identifier"];
-/**
- * Build binding identifier for an element with value set binding
- */
-export declare function buildBindingIdentifier(fhirSchema: FHIRSchema, path: string[], bindingName?: string, packageInfo?: PackageInfo): Identifier;
+export declare function mkIdentifier(fhirSchema: RichFHIRSchema): Identifier;
+export declare function mkNestedIdentifier(fhirSchema: RichFHIRSchema, path: string[]): NestedIdentifier;
+export declare function mkValueSetIdentifier(valueSetUrl: string, valueSet: any, packageInfo?: PackageMeta): TypeSchemaForValueSet["identifier"];
+export declare function mkBindingIdentifier(fhirSchema: FHIRSchema, path: string[], bindingName?: string, packageInfo?: PackageMeta): BindingIdentifier;

package/dist/typeschema/core/identifier.js

@@ -19,7 +19,7 @@ function determineKind(fhirSchema) {
         return "resource";
     return "resource";
 }
-export function buildSchemaIdentifier(fhirSchema) {
+export function mkIdentifier(fhirSchema) {
     return {
         kind: determineKind(fhirSchema),
         package: fhirSchema.package_meta.name,
@@ -28,17 +28,17 @@ export function buildSchemaIdentifier(fhirSchema) {
         url: fhirSchema.url,
     };
 }
-export function buildNestedIdentifier(fhirSchema, path, packageInfo) {
+export function mkNestedIdentifier(fhirSchema, path) {
     const nestedName = path.join(".");
     return {
         kind: "nested",
-        package: packageInfo?.name || fhirSchema.package_meta.name || "undefined",
-        version: packageInfo?.version || fhirSchema.package_meta.version || "undefined",
+        package: fhirSchema.package_meta.name,
+        version: fhirSchema.package_meta.version,
         name: nestedName,
         url: `${fhirSchema.url}#${nestedName}`,
     };
 }
-export function buildValueSetIdentifier(valueSetUrl, valueSet, packageInfo) {
+export function mkValueSetIdentifier(valueSetUrl, valueSet, packageInfo) {
     const cleanUrl = dropVersionFromUrl(valueSetUrl) || valueSetUrl;
     // Generate a meaningful name from the URL instead of using potentially hash-like IDs
     let name = "unknown";
@@ -54,9 +54,7 @@ export function buildValueSetIdentifier(valueSetUrl, valueSet, packageInfo) {
     }
     // Only fall back to valueSet.id if we couldn't extract a meaningful name from URL
     // and the ID doesn't look like a hash (no long alphanumeric strings)
-    if (name === "unknown" &&
-        valueSet?.id &&
-        !/^[a-zA-Z0-9_-]{20,}$/.test(valueSet.id)) {
+    if (name === "unknown" && valueSet?.id && !/^[a-zA-Z0-9_-]{20,}$/.test(valueSet.id)) {
         name = valueSet.id;
     }
     return {
@@ -67,10 +65,7 @@ export function buildValueSetIdentifier(valueSetUrl, valueSet, packageInfo) {
         url: cleanUrl,
     };
 }
-/**
- * Build binding identifier for an element with value set binding
- */
-export function buildBindingIdentifier(fhirSchema, path, bindingName, packageInfo) {
+export function mkBindingIdentifier(fhirSchema, path, bindingName, packageInfo) {
     const pathStr = path.join(".");
     const name = bindingName || `${fhirSchema.name}.${pathStr}_binding`;
     return {
@@ -78,8 +73,6 @@ export function buildBindingIdentifier(fhirSchema, path, bindingName, packageInf
         package: packageInfo?.name || fhirSchema.package_meta.name || "undefined",
         version: packageInfo?.version || fhirSchema.package_meta.version || "undefined",
         name,
-        url: bindingName
-            ? `urn:fhir:binding:${name}`
-            : `${fhirSchema.url}#${pathStr}_binding`,
+        url: bindingName ? `urn:fhir:binding:${name}` : `${fhirSchema.url}#${pathStr}_binding`,
     };
 }

package/dist/typeschema/core/nested-types.d.ts

@@ -3,21 +3,18 @@
  *
  * Functions for extracting and transforming nested types from FHIRSchema
  */
-import type { CanonicalManager } from "@atomic-ehr/fhir-canonical-manager";
 import type { FHIRSchema, FHIRSchemaElement } from "@atomic-ehr/fhirschema";
-import type { PackageInfo, TypeSchemaField, Identifier } from "../types";
+import type { Register } from "@root/typeschema/register";
+import type { Identifier, PackageMeta, RichFHIRSchema, TypeSchemaField, TypeSchemaNestedType } from "../types";
 /**
  * Collect all nested elements from a FHIRSchema
  */
 export declare function collectNestedElements(fhirSchema: FHIRSchema, parentPath: string[], elements: Record<string, FHIRSchemaElement>): Array<[string[], FHIRSchemaElement]>;
-/**
- * Transform elements into fields for a nested type
- */
-export declare function transformNestedElements(fhirSchema: FHIRSchema, parentPath: string[], elements: Record<string, FHIRSchemaElement>, manager: ReturnType<typeof CanonicalManager>, packageInfo?: PackageInfo): Promise<Record<string, TypeSchemaField>>;
+export declare function transformNestedElements(fhirSchema: RichFHIRSchema, parentPath: string[], elements: Record<string, FHIRSchemaElement>, register: Register, packageInfo?: PackageMeta): Promise<Record<string, TypeSchemaField>>;
 /**
  * Build TypeSchema for all nested types in a FHIRSchema
  */
-export declare function buildNestedTypes(fhirSchema: FHIRSchema, manager: ReturnType<typeof CanonicalManager>, packageInfo?: PackageInfo): Promise<any[]>;
+export declare function buildNestedTypes(fhirSchema: RichFHIRSchema, register: Register, packageInfo?: PackageMeta): Promise<any[] | undefined>;
 /**
  * Extract dependencies from nested types
  */