@atomic-ehr/codegen 0.0.1-canary.20251001124254.ddbda7d → 0.0.1-canary.20251002074252.e71a294

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

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

package/dist/typeschema/core/binding.js

@@ -8,10 +8,10 @@ import { dropVersionFromUrl, mkBindingIdentifier, mkValueSetIdentifier } from ".
 /**
  * Extract concepts from a ValueSet
  */
-export async function extractValueSetConcepts(valueSetUrl, manager) {
+export function extractValueSetConcepts(valueSetUrl, register) {
     try {
         const cleanUrl = dropVersionFromUrl(valueSetUrl) || valueSetUrl;
-        const valueSet = await manager.resolve(cleanUrl);
+        const valueSet = register.resolveVs(cleanUrl);
         if (!valueSet)
             return undefined;
         // If expansion is available, use it
@@ -39,7 +39,7 @@ export async function extractValueSetConcepts(valueSetUrl, manager) {
                 else if (include.system && !include.filter) {
                     // Include all from CodeSystem
                     try {
-                        const codeSystem = await manager.resolve(include.system);
+                        const codeSystem = register.resolveAny(include.system);
                         if (codeSystem?.concept) {
                             const extractConcepts = (conceptList, system) => {
                                 for (const concept of conceptList) {
@@ -72,7 +72,7 @@ export async function extractValueSetConcepts(valueSetUrl, manager) {
 /**
  * Build enum values from binding if applicable
  */
-export async function buildEnum(element, manager) {
+export function buildEnum(element, register) {
     if (!element.binding)
         return undefined;
     const { strength, valueSet } = element.binding;
@@ -90,12 +90,8 @@ export async function buildEnum(element, manager) {
     if (!shouldGenerateEnum) {
         return undefined;
     }
-    // Check if manager is available and functional
-    if (!manager.resolve) {
-        return undefined;
-    }
     try {
-        const concepts = await extractValueSetConcepts(valueSet, manager);
+        const concepts = extractValueSetConcepts(valueSet, register);
         if (!concepts || concepts.length === 0)
             return undefined;
         // Extract just the codes and filter out any empty/invalid ones
@@ -112,18 +108,18 @@ export async function buildEnum(element, manager) {
         return undefined;
     }
 }
-export async function generateBindingSchema(fhirSchema, path, element, manager, packageInfo) {
+export async function generateBindingSchema(fhirSchema, path, element, register, packageInfo) {
     if (!element.binding?.valueSet)
         return undefined;
     const identifier = mkBindingIdentifier(fhirSchema, path, element.binding.bindingName, packageInfo);
-    const fieldType = buildFieldType(fhirSchema, path, element, manager, packageInfo);
+    const fieldType = buildFieldType(fhirSchema, path, element, register, packageInfo);
     const valueSetIdentifier = mkValueSetIdentifier(element.binding.valueSet, undefined, packageInfo);
     const dependencies = [];
     if (fieldType) {
         dependencies.push(fieldType);
     }
     dependencies.push(valueSetIdentifier);
-    const enumValues = await buildEnum(element, manager);
+    const enumValues = await buildEnum(element, register);
     return {
         identifier,
         type: fieldType,
@@ -136,7 +132,7 @@ export async function generateBindingSchema(fhirSchema, path, element, manager,
 /**
  * Collect all binding schemas from a FHIRSchema
  */
-export async function collectBindingSchemas(fhirSchema, manager) {
+export async function collectBindingSchemas(fhirSchema, register) {
     const packageInfo = fhirSchema.package_meta;
     const bindings = [];
     const processedPaths = new Set();
@@ -151,7 +147,7 @@ export async function collectBindingSchemas(fhirSchema, manager) {
             processedPaths.add(pathKey);
             // Generate binding if present
             if (element.binding) {
-                const binding = await generateBindingSchema(fhirSchema, path, element, manager, packageInfo);
+                const binding = await generateBindingSchema(fhirSchema, path, element, register, packageInfo);
                 if (binding) {
                     bindings.push(binding);
                 }

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

@@ -4,16 +4,13 @@
  * Functions for transforming FHIRSchema elements into TypeSchema fields
  */
 import type { CanonicalManager } from "@atomic-ehr/fhir-canonical-manager";
-import type { FHIRSchema, FHIRSchemaElement } from "@atomic-ehr/fhirschema";
+import type { FHIRSchemaElement } from "@atomic-ehr/fhirschema";
 import type { Register } from "@root/typeschema/register";
 import type { Field, Identifier, PackageMeta, RegularField, RichFHIRSchema } from "../types";
-export declare function isRequired(fhirSchema: FHIRSchema, path: string[]): boolean;
-export declare function isExcluded(fhirSchema: FHIRSchema, path: string[]): boolean;
+export declare function isRequired(register: Register, fhirSchema: RichFHIRSchema, path: string[]): boolean;
+export declare function isExcluded(register: Register, fhirSchema: RichFHIRSchema, path: string[]): boolean;
 export declare const buildReferences: (element: FHIRSchemaElement, register: Register, _packageInfo?: PackageMeta) => Identifier[] | undefined;
-/**
- * Build field type identifier
- */
 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) => Field;
+export declare const mkField: (register: Register, fhirSchema: RichFHIRSchema, path: string[], element: FHIRSchemaElement) => Field;
 export declare function isNestedElement(element: FHIRSchemaElement): boolean;
-export declare function mkNestedField(_register: Register, fhirSchema: RichFHIRSchema, path: string[], element: FHIRSchemaElement): RegularField;
+export declare function mkNestedField(register: Register, fhirSchema: RichFHIRSchema, path: string[], element: FHIRSchemaElement): RegularField;

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

@@ -5,49 +5,37 @@
  */
 import { buildEnum } from "./binding";
 import { mkBindingIdentifier, mkIdentifier, mkNestedIdentifier } from "./identifier";
-export function isRequired(fhirSchema, path) {
-    if (path.length === 0)
-        return false;
+export function isRequired(register, fhirSchema, path) {
     const fieldName = path[path.length - 1];
     const parentPath = path.slice(0, -1);
-    // Navigate to parent element
-    let parentElement = fhirSchema;
-    for (const key of parentPath) {
-        parentElement = parentElement.elements?.[key];
-        if (!parentElement)
-            break;
-    }
-    // Check if field is in required array
-    if (parentElement?.required?.includes(fieldName)) {
-        return true;
-    }
-    // Also check at root level
-    if (parentPath.length === 0 && fieldName && fhirSchema.required?.includes(fieldName)) {
-        return true;
-    }
-    return false;
+    const requires = register.resolveFsGenealogy(fhirSchema.url).flatMap((fs) => {
+        if (parentPath.length === 0)
+            return fs.required || [];
+        if (!fs.elements)
+            return [];
+        let elem = fs;
+        for (const k of parentPath) {
+            elem = elem?.elements?.[k];
+        }
+        return elem?.required || [];
+    });
+    return new Set(requires).has(fieldName);
 }
-export function isExcluded(fhirSchema, path) {
-    if (path.length === 0)
-        return false;
+export function isExcluded(register, fhirSchema, path) {
     const fieldName = path[path.length - 1];
     const parentPath = path.slice(0, -1);
-    // Navigate to parent element
-    let parentElement = fhirSchema;
-    for (const key of parentPath) {
-        parentElement = parentElement.elements?.[key];
-        if (!parentElement)
-            break;
-    }
-    // Check if field is in excluded array
-    if (parentElement?.excluded?.includes(fieldName)) {
-        return true;
-    }
-    // Also check at root level
-    if (parentPath.length === 0 && fieldName && fhirSchema.excluded?.includes(fieldName)) {
-        return true;
-    }
-    return false;
+    const requires = register.resolveFsGenealogy(fhirSchema.url).flatMap((fs) => {
+        if (parentPath.length === 0)
+            return fs.excluded || [];
+        if (!fs.elements)
+            return [];
+        let elem = fs;
+        for (const k of parentPath) {
+            elem = elem?.elements?.[k];
+        }
+        return elem?.excluded || [];
+    });
+    return new Set(requires).has(fieldName);
 }
 export const buildReferences = (element, register, _packageInfo) => {
     if (!element.refers)
@@ -58,9 +46,6 @@ export const buildReferences = (element, register, _packageInfo) => {
         return mkIdentifier(fs);
     });
 };
-/**
- * Build field type identifier
- */
 export function buildFieldType(fhirSchema, _path, element, _manager, packageInfo) {
     // Handle element reference (for slicing)
     if (element.elementReference) {
@@ -91,46 +76,47 @@ export function buildFieldType(fhirSchema, _path, element, _manager, packageInfo
     }
     return undefined;
 }
-export const buildField = (fhirSchema, path, element, register, packageInfo) => {
+export const mkField = (register, fhirSchema, path, element) => {
     let binding;
-    let _enumValues;
+    let enumValues;
     if (element.binding) {
-        binding = mkBindingIdentifier(fhirSchema, path, element.binding.bindingName, packageInfo);
+        binding = mkBindingIdentifier(fhirSchema, path, element.binding.bindingName, fhirSchema.package_meta);
         if (element.binding.strength === "required" && element.type === "code") {
-            _enumValues = buildEnum(element, register);
+            enumValues = buildEnum(element, register);
         }
     }
     return {
-        type: buildFieldType(fhirSchema, path, element, register, packageInfo),
-        required: isRequired(fhirSchema, path),
-        excluded: isExcluded(fhirSchema, path),
-        reference: buildReferences(element, register, packageInfo),
+        type: buildFieldType(fhirSchema, path, element, register, fhirSchema.package_meta),
+        required: isRequired(register, fhirSchema, path),
+        excluded: isExcluded(register, fhirSchema, path),
+        reference: buildReferences(element, register, fhirSchema.package_meta),
         array: element.array || false,
         min: element.min,
         max: element.max,
         choices: element.choices,
         choiceOf: element.choiceOf,
         binding: binding,
+        enum: enumValues,
     };
 };
 export function isNestedElement(element) {
     const isBackbone = element.type === "BackboneElement";
     const isElement = element.type === "Element" && element.elements !== undefined && Object.keys(element.elements).length > 0;
-    //     ;; TODO: Observation <- vitalsigns <- bodyweight
-    //     ;; In Observation we have value[x] with choices
-    //     ;; In bodyweight we have valueQuantity with additional constaraints on it's elements
-    //     ;; So we need to build nested type from Quantity for here, but don't do that right now.
+    // TODO: Observation <- vitalsigns <- bodyweight
+    // In Observation we have value[x] with choices
+    // In bodyweight we have valueQuantity with additional constaraints on it's elements
+    // So we need to build nested type from Quantity for here, but don't do that right now.
     const elementsWithoutType = element.type === undefined &&
         element.choiceOf === undefined &&
         element.elements !== undefined &&
         Object.keys(element.elements).length > 0;
     return isBackbone || isElement || elementsWithoutType;
 }
-export function mkNestedField(_register, fhirSchema, path, element) {
+export function mkNestedField(register, fhirSchema, path, element) {
     return {
         type: mkNestedIdentifier(fhirSchema, path),
         array: element.array || false,
-        required: isRequired(fhirSchema, path),
-        excluded: isExcluded(fhirSchema, path),
+        required: isRequired(register, fhirSchema, path),
+        excluded: isExcluded(register, fhirSchema, path),
     };
 }

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

@@ -4,9 +4,9 @@
  * Functions for creating TypeSchema identifiers from FHIRSchema entities
  */
 import type { FHIRSchema } from "@atomic-ehr/fhirschema";
-import type { BindingIdentifier, Identifier, NestedIdentifier, PackageMeta, RichFHIRSchema, TypeSchemaForValueSet } from "@typeschema/types";
-export declare function dropVersionFromUrl(url: string | undefined): string | undefined;
+import type { BindingIdentifier, CanonicalUrl, Identifier, NestedIdentifier, PackageMeta, RichFHIRSchema, TypeSchemaForValueSet } from "@typeschema/types";
+export declare function dropVersionFromUrl(url: CanonicalUrl | undefined): CanonicalUrl | undefined;
 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 mkValueSetIdentifier(valueSetUrl: CanonicalUrl, valueSet: any, packageInfo?: PackageMeta): TypeSchemaForValueSet["identifier"];
 export declare function mkBindingIdentifier(fhirSchema: FHIRSchema, path: string[], bindingName?: string, _packageInfo?: PackageMeta): BindingIdentifier;

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

@@ -7,6 +7,6 @@ import type { FHIRSchema, FHIRSchemaElement } from "@atomic-ehr/fhirschema";
 import type { Register } from "@root/typeschema/register";
 import type { Field, Identifier, NestedType, PackageMeta, RichFHIRSchema } from "../types";
 export declare function collectNestedElements(fhirSchema: FHIRSchema, parentPath: string[], elements: Record<string, FHIRSchemaElement>): Array<[string[], FHIRSchemaElement]>;
-export declare function transformNestedElements(fhirSchema: RichFHIRSchema, parentPath: string[], elements: Record<string, FHIRSchemaElement>, register: Register, packageInfo?: PackageMeta): Promise<Record<string, Field>>;
+export declare function transformNestedElements(fhirSchema: RichFHIRSchema, parentPath: string[], elements: Record<string, FHIRSchemaElement>, register: Register, _packageInfo?: PackageMeta): Promise<Record<string, Field>>;
 export declare function mkNestedTypes(register: Register, fhirSchema: RichFHIRSchema): Promise<NestedType[] | undefined>;
 export declare function extractNestedDependencies(nestedTypes: NestedType[]): Identifier[];

package/dist/typeschema/core/nested-types.js

@@ -3,7 +3,7 @@
  *
  * Functions for extracting and transforming nested types from FHIRSchema
  */
-import { buildField, isNestedElement, mkNestedField } from "./field-builder";
+import { isNestedElement, mkField, mkNestedField } from "./field-builder";
 import { mkNestedIdentifier } from "./identifier";
 export function collectNestedElements(fhirSchema, parentPath, elements) {
     const nested = [];
@@ -18,17 +18,15 @@ export function collectNestedElements(fhirSchema, parentPath, elements) {
     }
     return nested;
 }
-export async function transformNestedElements(fhirSchema, parentPath, elements, register, packageInfo) {
+export async function transformNestedElements(fhirSchema, parentPath, elements, register, _packageInfo) {
     const fields = {};
     for (const [key, element] of Object.entries(elements)) {
         const path = [...parentPath, key];
         if (isNestedElement(element)) {
-            // Reference to another nested type
             fields[key] = mkNestedField(register, fhirSchema, path, element);
         }
         else {
-            // Regular field
-            fields[key] = await buildField(fhirSchema, path, element, register, packageInfo);
+            fields[key] = mkField(register, fhirSchema, path, element);
         }
     }
     return fields;
@@ -75,7 +73,7 @@ export async function mkNestedTypes(register, fhirSchema) {
     }
     // Sort by URL for consistent output
     nestedTypes.sort((a, b) => a.identifier.url.localeCompare(b.identifier.url));
-    return nestedTypes;
+    return nestedTypes.length === 0 ? undefined : nestedTypes;
 }
 export function extractNestedDependencies(nestedTypes) {
     const deps = [];

package/dist/typeschema/core/transformer.js

@@ -6,23 +6,37 @@
 import { fsElementSnapshot, resolveFsElementGenealogy } from "@typeschema/register";
 import { transformProfile } from "../profile/processor";
 import { collectBindingSchemas } from "./binding";
-import { buildField, isNestedElement, mkNestedField } from "./field-builder";
+import { isNestedElement, mkField, mkNestedField } from "./field-builder";
 import { mkIdentifier } from "./identifier";
 import { extractNestedDependencies, mkNestedTypes } from "./nested-types";
 export async function mkFields(register, fhirSchema, parentPath, elements) {
     if (!elements)
         return undefined;
     const geneology = register.resolveFsGenealogy(fhirSchema.url);
-    const fields = {};
-    for (const [key, _element] of Object.entries(elements)) {
+    const elems = {};
+    for (const [key, elem] of Object.entries(elements)) {
         const path = [...parentPath, key];
         const elemGeneology = resolveFsElementGenealogy(geneology, path);
         const elemSnapshot = fsElementSnapshot(elemGeneology);
+        elems[key] = { elem, elemSnapshot, path };
+    }
+    for (const [_key, { elem, elemSnapshot, path }] of Object.entries(elems)) {
+        for (const choiceKey of elem?.choices || []) {
+            if (!elems[choiceKey]) {
+                const path = [...parentPath, choiceKey];
+                const elemGeneology = resolveFsElementGenealogy(geneology, path);
+                const elemSnapshot = fsElementSnapshot(elemGeneology);
+                elems[choiceKey] = { elem: undefined, elemSnapshot, path };
+            }
+        }
+    }
+    const fields = {};
+    for (const [key, { elem, elemSnapshot, path }] of Object.entries(elems)) {
         if (isNestedElement(elemSnapshot)) {
             fields[key] = mkNestedField(register, fhirSchema, path, elemSnapshot);
         }
         else {
-            fields[key] = buildField(fhirSchema, path, elemSnapshot, register, fhirSchema.package_meta);
+            fields[key] = mkField(register, fhirSchema, path, elemSnapshot);
         }
     }
     return fields;
@@ -196,17 +210,13 @@ function extractDependencies(identifier, base, fields, nestedTypes) {
         uniqDeps[dep.url] = dep;
     }
     const localNestedTypeUrls = new Set(nestedTypes?.map((nt) => nt.identifier.url));
-    console.log(1, Object.values(uniqDeps));
-    console.log(2, localNestedTypeUrls);
     const result = Object.values(uniqDeps)
         .filter((e) => !(e.kind === "nested" && localNestedTypeUrls.has(e.url)))
         .sort((a, b) => a.name.localeCompare(b.name));
-    console.log(3, result);
     return result.length > 0 ? result : undefined;
 }
 async function transformResource(register, fhirSchema) {
     const identifier = mkIdentifier(fhirSchema);
-    console.log(6, fhirSchema.name);
     let base;
     if (fhirSchema.base && fhirSchema.type !== "Element") {
         const baseFs = register.resolveFs(register.ensureCanonicalUrl(fhirSchema.base));
@@ -216,7 +226,6 @@ async function transformResource(register, fhirSchema) {
         base = mkIdentifier(baseFs);
     }
     const fields = await mkFields(register, fhirSchema, [], fhirSchema.elements);
-    console.log(0, fields);
     const nested = await mkNestedTypes(register, fhirSchema);
     const dependencies = extractDependencies(identifier, base, fields, nested);
     const typeSchema = {
@@ -233,7 +242,6 @@ async function transformResource(register, fhirSchema) {
 export async function transformFHIRSchema(register, fhirSchema) {
     const results = [];
     const identifier = mkIdentifier(fhirSchema);
-    console.log(5, fhirSchema.name);
     // Handle profiles with specialized processor
     if (identifier.kind === "profile") {
         const profileSchema = await transformProfile(register, fhirSchema);

package/dist/typeschema/register.d.ts

@@ -11,7 +11,9 @@ export type Register = {
     allSd(): StructureDefinition[];
     allFs(): RichFHIRSchema[];
     allVs(): any[];
+    resolveVs(canonicalUrl: CanonicalUrl): any | undefined;
     complexTypeDict(): Record<string, RichFHIRSchema>;
+    resolveAny(canonicalUrl: CanonicalUrl): any | undefined;
 } & ReturnType<typeof CanonicalManager>;
 export declare const registerFromManager: (manager: ReturnType<typeof CanonicalManager>, logger?: CodegenLogger, packageInfo?: PackageMeta) => Promise<Register>;
 export declare const registerFromPackageMetas: (packageMetas: PackageMeta[], logger?: CodegenLogger) => Promise<Register>;

package/dist/typeschema/register.js

@@ -3,6 +3,13 @@ import * as fhirschema from "@atomic-ehr/fhirschema";
 import { enrichFHIRSchema } from "@typeschema/types";
 export const registerFromManager = async (manager, logger, packageInfo) => {
     const resources = await manager.search({});
+    const any = {};
+    for (const resource of resources) {
+        const url = resource.url;
+        if (!url)
+            continue;
+        any[url] = resource;
+    }
     const structureDefinitions = {};
     for (const resource of resources) {
         if (resource.resourceType === "StructureDefinition") {
@@ -65,7 +72,9 @@ export const registerFromManager = async (manager, logger, packageInfo) => {
         resolveSd: (canonicalUrl) => structureDefinitions[canonicalUrl],
         allFs: () => Object.values(fhirSchemas),
         allVs: () => Object.values(valueSets),
+        resolveVs: (canonicalUrl) => valueSets[canonicalUrl],
         complexTypeDict: () => complexTypes,
+        resolveAny: (canonicalUrl) => any[canonicalUrl],
     };
 };
 export const registerFromPackageMetas = async (packageMetas, logger) => {

package/dist/typeschema/types.d.ts

@@ -142,7 +142,7 @@ export interface RegularField {
     min?: number;
     max?: number;
 }
-export interface PolymorphicDeclarationField {
+export interface ChoiceFieldDeclaration {
     choices: string[];
     required?: boolean;
     excluded?: boolean;
@@ -150,7 +150,7 @@ export interface PolymorphicDeclarationField {
     min?: number;
     max?: number;
 }
-export interface PolymorphicInstanceField {
+export interface ChoiceFieldInstance {
     choiceOf: string;
     type: Identifier;
     required?: boolean;
@@ -183,7 +183,7 @@ export interface TypeSchemaForBinding {
     valueset?: ValueSetIdentifier;
     dependencies?: Identifier[];
 }
-export type Field = RegularField | PolymorphicDeclarationField | PolymorphicInstanceField;
+export type Field = RegularField | ChoiceFieldDeclaration | ChoiceFieldInstance;
 export interface TypeschemaGeneratorOptions {
     verbose?: boolean;
     logger?: import("../utils/codegen-logger").CodegenLogger;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atomic-ehr/codegen",
-  "version": "0.0.1-canary.20251001124254.ddbda7d",
+  "version": "0.0.1-canary.20251002074252.e71a294",
   "description": "Code generation tools for FHIR resources and TypeSchema definitions",
   "keywords": [
     "fhir",