@atomic-ehr/codegen 0.0.1-canary.20250831211734.bb1536b → 0.0.1-canary.20250924082247.588e04a

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

@@ -15,8 +15,4 @@ export declare function transformElements(fhirSchema: FHIRSchema, parentPath: st
  * Transform a single FHIRSchema to TypeSchema(s) with enhanced categorization
  * Returns the main schema plus any binding schemas
  */
-export declare function transformFHIRSchema(fhirSchema: FHIRSchema, manager: ReturnType<typeof CanonicalManager>, packageInfo?: PackageInfo): Promise<TypeSchema[]>;
-/**
- * Transform multiple FHIRSchemas
- */
-export declare function transformFHIRSchemas(fhirSchemas: FHIRSchema[], manager: ReturnType<typeof CanonicalManager>, packageInfo?: PackageInfo): Promise<TypeSchema[]>;
+export declare function transformFHIRSchema(manager: ReturnType<typeof CanonicalManager>, fhirSchema: FHIRSchema, packageInfo: PackageInfo): Promise<TypeSchema[]>;

package/dist/typeschema/core/transformer.js

@@ -191,7 +191,7 @@ async function transformExtension(fhirSchema, manager, packageInfo) {
  * Transform a single FHIRSchema to TypeSchema(s) with enhanced categorization
  * Returns the main schema plus any binding schemas
  */
-export async function transformFHIRSchema(fhirSchema, manager, packageInfo) {
+export async function transformFHIRSchema(manager, fhirSchema, packageInfo) {
     const results = [];
     // Extract package info from schema if not provided
     if (!packageInfo && (fhirSchema.package_name || fhirSchema.package_id)) {
@@ -332,14 +332,3 @@ export async function transformFHIRSchema(fhirSchema, manager, packageInfo) {
     results.push(...bindingSchemas);
     return results;
 }
-/**
- * Transform multiple FHIRSchemas
- */
-export async function transformFHIRSchemas(fhirSchemas, manager, packageInfo) {
-    const allResults = [];
-    for (const fhirSchema of fhirSchemas) {
-        const results = await transformFHIRSchema(fhirSchema, manager, packageInfo);
-        allResults.push(...results);
-    }
-    return allResults;
-}

package/dist/typeschema/generator.d.ts

@@ -4,7 +4,7 @@
  * Generates TypeSchema documents from FHIR packages using fhrischema.
  * Provides high-level API for converting FHIR Structure Definitions to TypeSchema format.
  */
-import { type FHIRSchema } from "@atomic-ehr/fhirschema";
+import { type FHIRSchema, type StructureDefinition } from "@atomic-ehr/fhirschema";
 import type { TypeSchemaConfig } from "../config.js";
 import type { TypeSchema } from "./type-schema.types.js";
 import type { PackageInfo, TypeschemaGeneratorOptions } from "./types.js";
@@ -17,31 +17,19 @@ import type { PackageInfo, TypeschemaGeneratorOptions } from "./types.js";
 export declare class TypeSchemaGenerator {
     private manager;
     private options;
-    private cache;
     private cacheConfig?;
+    private cache?;
     private logger;
     constructor(options?: TypeschemaGeneratorOptions, cacheConfig?: TypeSchemaConfig);
-    /**
-     * Initialize the cache if configured
-     */
     private initializeCache;
-    /**
-     * Generate TypeSchema from a FHIR package name
-     */
+    fetchPackage(packageName: string, packageVersion?: string): Promise<{
+        structureDefinitions: StructureDefinition[];
+        valueSets: any[];
+    }>;
+    generateFhirSchemas(structureDefinitions: StructureDefinition[]): FHIRSchema[];
+    generateValueSetSchemas(valueSets: any[], packageInfo: PackageInfo): Promise<TypeSchema[]>;
     generateFromPackage(packageName: string, packageVersion?: string): Promise<TypeSchema[]>;
-    /**
-     * Generate TypeSchema from individual FHIR schema
-     */
-    generateFromSchema(fhirSchema: FHIRSchema, packageInfo?: PackageInfo): Promise<TypeSchema[]>;
-    /**
-     * Generate TypeSchema from multiple FHIR schemas with FHIR-specific enhancements
-     */
-    generateFromSchemas(fhirSchemas: FHIRSchema[], packageInfo?: PackageInfo): Promise<TypeSchema[]>;
-    private groupTypeSchemas;
-    private enhanceProfiles;
-    private enhanceExtensions;
-    private enhanceValueSets;
-    private enhanceCodeSystems;
+    generateFromSchemas(packageInfo: PackageInfo, fhirSchemas: FHIRSchema[]): Promise<TypeSchema[]>;
     /**
      * Apply treeshaking to StructureDefinitions before FHIR schema transformation
      * This is more efficient and includes smart reference handling
@@ -57,15 +45,3 @@ export declare class TypeSchemaGenerator {
      */
     private extractResourceNameFromUrl;
 }
-/**
- * Convenience function to generate TypeSchema from a package
- */
-export declare function generateTypeSchemaFromPackage(packageName: string, options?: TypeschemaGeneratorOptions): Promise<TypeSchema[]>;
-/**
- * Convenience function to generate TypeSchema from FHIR schemas
- */
-export declare function generateTypeSchemaFromSchemas(fhirSchemas: FHIRSchema[], packageInfo?: PackageInfo, options?: TypeschemaGeneratorOptions): Promise<TypeSchema[]>;
-/**
- * Convenience function to generate TypeSchema from a single FHIR schema
- */
-export declare function generateTypeSchemaFromSchema(fhirSchema: FHIRSchema, packageInfo?: PackageInfo, options?: TypeschemaGeneratorOptions): Promise<TypeSchema[]>;

package/dist/typeschema/generator.js

@@ -5,10 +5,10 @@
  * Provides high-level API for converting FHIR Structure Definitions to TypeSchema format.
  */
 import { CanonicalManager } from "@atomic-ehr/fhir-canonical-manager";
-import { translate, } from "@atomic-ehr/fhirschema";
+import * as fhirschema from "@atomic-ehr/fhirschema";
 import { createLogger } from "../utils/codegen-logger.js";
 import { TypeSchemaCache } from "./cache.js";
-import { transformFHIRSchema, transformFHIRSchemas, } from "./core/transformer.js";
+import { transformFHIRSchema } from "./core/transformer.js";
 import { transformValueSet } from "./value-set/processor.js";
 /**
  * TypeSchema Generator class
@@ -19,16 +19,11 @@ import { transformValueSet } from "./value-set/processor.js";
 export class TypeSchemaGenerator {
     manager;
     options;
-    cache = null;
     cacheConfig;
+    cache;
     logger;
     constructor(options = {}, cacheConfig) {
-        this.options = {
-            resourceTypes: [],
-            maxDepth: 10,
-            verbose: false,
-            ...options,
-        };
+        this.options = { verbose: false, ...options };
         this.manager = CanonicalManager({ packages: [], workingDir: "tmp/fhir" });
         this.cacheConfig = cacheConfig;
         this.logger =
@@ -38,28 +33,13 @@ export class TypeSchemaGenerator {
                     prefix: "TypeSchema",
                 });
     }
-    /**
-     * Initialize the cache if configured
-     */
     async initializeCache() {
         if (this.cacheConfig && !this.cache) {
             this.cache = new TypeSchemaCache(this.cacheConfig);
             await this.cache.initialize();
         }
     }
-    /**
-     * Generate TypeSchema from a FHIR package name
-     */
-    async generateFromPackage(packageName, packageVersion) {
-        await this.initializeCache();
-        const forceRegenerate = this.cacheConfig?.forceRegenerate ?? false;
-        if (this.cache && !forceRegenerate) {
-            const cachedSchemas = this.cache.getByPackage(packageName);
-            if (cachedSchemas.length > 0) {
-                this.logger.info(`Using cached TypeSchemas for package: ${packageName} (${cachedSchemas.length} schemas)`);
-                return cachedSchemas;
-            }
-        }
+    async fetchPackage(packageName, packageVersion) {
         this.logger.step(`Loading FHIR package: ${packageName}${packageVersion ? `@${packageVersion}` : ""}`);
         this.manager = CanonicalManager({
             packages: [`${packageName}${packageVersion ? `@${packageVersion}` : ""}`],
@@ -70,14 +50,18 @@ export class TypeSchemaGenerator {
         const structureDefinitions = allResources.filter((resource) => resource.resourceType === "StructureDefinition");
         const valueSets = allResources.filter((resource) => resource.resourceType === "ValueSet");
         this.logger.info(`Found ${structureDefinitions.length} StructureDefinitions and ${valueSets.length} ValueSets in package`);
+        return { structureDefinitions, valueSets };
+    }
+    generateFhirSchemas(structureDefinitions) {
         this.logger.progress(`Converting ${structureDefinitions.length} StructureDefinitions to FHIRSchemas`);
+        // TODO: do it on the TypeSchema
         const filteredStructureDefinitions = this.applyStructureDefinitionTreeshaking(structureDefinitions);
         const fhirSchemas = [];
         let convertedCount = 0;
         let failedCount = 0;
         for (const sd of filteredStructureDefinitions) {
             try {
-                const fhirSchema = translate(sd);
+                const fhirSchema = fhirschema.translate(sd);
                 fhirSchemas.push(fhirSchema);
                 convertedCount++;
                 this.logger.debug(`Converted StructureDefinition: ${sd.name || sd.id} (${sd.resourceType})`);
@@ -87,14 +71,13 @@ export class TypeSchemaGenerator {
                 this.logger.warn(`Failed to convert StructureDefinition ${sd.name || sd.id}: ${error instanceof Error ? error.message : String(error)}`);
             }
         }
-        this.logger.success(`Schema conversion completed: ${convertedCount}/${filteredStructureDefinitions.length} successful, ${failedCount} failed`);
+        this.logger.success(`FHIR Schema conversion completed: ${convertedCount}/${filteredStructureDefinitions.length} successful, ${failedCount} failed`);
+        return fhirSchemas;
+    }
+    async generateValueSetSchemas(valueSets, packageInfo) {
         if (valueSets.length > 0) {
             this.logger.debug(`${valueSets.length} ValueSets available for enum extraction`);
         }
-        const packageInfo = {
-            name: packageName,
-            version: packageVersion || "latest",
-        };
         // Process ValueSets separately to add to TypeSchema output
         const valueSetSchemas = [];
         if (valueSets.length > 0) {
@@ -117,114 +100,40 @@ export class TypeSchemaGenerator {
             }
             this.logger.success(`ValueSet conversion completed: ${valueSetConvertedCount}/${valueSets.length} successful, ${valueSetFailedCount} failed`);
         }
-        const schemas = await this.generateFromSchemas(fhirSchemas, packageInfo);
-        // Add the converted ValueSets to the final results
+        return valueSetSchemas;
+    }
+    async generateFromPackage(packageName, packageVersion) {
+        await this.initializeCache();
+        if (this.cache && !(this.cacheConfig?.forceRegenerate ?? false)) {
+            const cachedSchemas = this.cache.getByPackage(packageName);
+            if (cachedSchemas.length > 0) {
+                this.logger.info(`Using cached TypeSchemas for package: ${packageName} (${cachedSchemas.length} schemas)`);
+                return cachedSchemas;
+            }
+        }
+        const packageInfo = {
+            name: packageName,
+            version: packageVersion || "latest",
+        };
+        const { valueSets, structureDefinitions } = await this.fetchPackage(packageName, packageVersion);
+        const fhirSchemas = this.generateFhirSchemas(structureDefinitions);
+        const valueSetSchemas = await this.generateValueSetSchemas(valueSets, packageInfo);
+        const schemas = await this.generateFromSchemas(packageInfo, fhirSchemas);
         const allSchemas = [...schemas, ...valueSetSchemas];
-        if (this.cache && allSchemas.length > 0) {
-            this.logger.info(`Caching ${allSchemas.length} generated schemas for package: ${packageName}`);
+        if (this.cache) {
             for (const schema of allSchemas) {
                 await this.cache.set(schema);
             }
-            this.logger.success(`Cached ${allSchemas.length} TypeSchemas for package: ${packageName}`);
         }
         return allSchemas;
     }
-    /**
-     * Generate TypeSchema from individual FHIR schema
-     */
-    async generateFromSchema(fhirSchema, packageInfo) {
-        this.logger.info("Transforming FHIR schema to TypeSchema");
-        return transformFHIRSchema(fhirSchema, this.manager, packageInfo);
-    }
-    /**
-     * Generate TypeSchema from multiple FHIR schemas with FHIR-specific enhancements
-     */
-    async generateFromSchemas(fhirSchemas, packageInfo) {
-        this.logger.info(`Transforming ${fhirSchemas.length} FHIR schemas to TypeSchema`);
-        const baseSchemas = await transformFHIRSchemas(fhirSchemas, this.manager, packageInfo);
-        const results = [];
-        const groupedSchemas = this.groupTypeSchemas(baseSchemas);
-        results.push(...groupedSchemas.resources);
-        results.push(...groupedSchemas.complexTypes);
-        results.push(...groupedSchemas.primitives);
-        if (groupedSchemas.profiles.length > 0) {
-            this.logger.info(`Enhancing ${groupedSchemas.profiles.length} profiles`);
-            const profileResults = await this.enhanceProfiles(groupedSchemas.profiles);
-            results.push(...profileResults);
-        }
-        if (groupedSchemas.extensions.length > 0) {
-            this.logger.info(`Enhancing ${groupedSchemas.extensions.length} extensions`);
-            const extensionResults = await this.enhanceExtensions(groupedSchemas.extensions);
-            results.push(...extensionResults);
-        }
-        if (groupedSchemas.valueSets.length > 0) {
-            this.logger.info(`Enhancing ${groupedSchemas.valueSets.length} value sets`);
-            const valueSetResults = await this.enhanceValueSets(groupedSchemas.valueSets);
-            results.push(...valueSetResults);
-        }
-        if (groupedSchemas.codeSystems.length > 0) {
-            this.logger.info(`Enhancing ${groupedSchemas.codeSystems.length} code systems`);
-            const codeSystemResults = await this.enhanceCodeSystems(groupedSchemas.codeSystems);
-            results.push(...codeSystemResults);
-        }
-        this.logger.success(`Generated ${results.length} enhanced FHIR type schemas: ${groupedSchemas.resources.length} resources, ${groupedSchemas.complexTypes.length} complex types, ${groupedSchemas.primitives.length} primitives`);
-        return results;
-    }
-    groupTypeSchemas(schemas) {
-        const groups = {
-            resources: [],
-            complexTypes: [],
-            primitives: [],
-            profiles: [],
-            extensions: [],
-            valueSets: [],
-            codeSystems: [],
-        };
-        for (const schema of schemas) {
-            switch (schema.identifier.kind) {
-                case "resource":
-                    groups.resources.push(schema);
-                    break;
-                case "complex-type":
-                    groups.complexTypes.push(schema);
-                    break;
-                case "primitive-type":
-                    groups.primitives.push(schema);
-                    break;
-                case "binding":
-                    if ("metadata" in schema && schema.metadata?.isExtension) {
-                        groups.extensions.push(schema);
-                    }
-                    else {
-                        groups.complexTypes.push(schema);
-                    }
-                    break;
-                case "value-set":
-                    groups.valueSets.push(schema);
-                    break;
-                default:
-                    if ("metadata" in schema && schema.metadata?.isCodeSystem) {
-                        groups.codeSystems.push(schema);
-                    }
-                    else {
-                        groups.complexTypes.push(schema);
-                    }
-                    break;
-            }
+    async generateFromSchemas(packageInfo, fhirSchemas) {
+        this.logger.info(`Transforming ${fhirSchemas.length} FHIR schemas to Type Schema`);
+        const typeSchemas = [];
+        for (const fhirSchema of fhirSchemas) {
+            typeSchemas.push(...(await transformFHIRSchema(this.manager, fhirSchema, packageInfo)));
         }
-        return groups;
-    }
-    async enhanceProfiles(schemas) {
-        return schemas;
-    }
-    async enhanceExtensions(schemas) {
-        return schemas;
-    }
-    async enhanceValueSets(schemas) {
-        return schemas;
-    }
-    async enhanceCodeSystems(schemas) {
-        return schemas;
+        return typeSchemas;
     }
     /**
      * Apply treeshaking to StructureDefinitions before FHIR schema transformation
@@ -354,24 +263,3 @@ export class TypeSchemaGenerator {
         return match ? (match[1] ?? null) : null;
     }
 }
-/**
- * Convenience function to generate TypeSchema from a package
- */
-export async function generateTypeSchemaFromPackage(packageName, options = {}) {
-    const generator = new TypeSchemaGenerator(options);
-    return await generator.generateFromPackage(packageName);
-}
-/**
- * Convenience function to generate TypeSchema from FHIR schemas
- */
-export async function generateTypeSchemaFromSchemas(fhirSchemas, packageInfo, options = {}) {
-    const generator = new TypeSchemaGenerator(options);
-    return await generator.generateFromSchemas(fhirSchemas, packageInfo);
-}
-/**
- * Convenience function to generate TypeSchema from a single FHIR schema
- */
-export async function generateTypeSchemaFromSchema(fhirSchema, packageInfo, options = {}) {
-    const generator = new TypeSchemaGenerator(options);
-    return await generator.generateFromSchema(fhirSchema, packageInfo);
-}

package/dist/typeschema/index.d.ts

@@ -9,58 +9,8 @@
  * - Reading TypeSchema documents
  * - Validating TypeSchema documents
  */
-import type { TypeSchema } from "./type-schema.types.js";
-import type { TypeschemaParserOptions } from "./types.js";
-export { CanonicalManager } from "@atomic-ehr/fhir-canonical-manager";
-export type { FHIRSchema, FHIRSchemaElement } from "@atomic-ehr/fhirschema";
-export { cacheSchema, clearGlobalCache, getCachedSchema, getGlobalCache, initializeGlobalCache, isCached, TypeSchemaCache, } from "./cache.js";
-export { buildEnum, collectBindingSchemas, extractValueSetConcepts, generateBindingSchema, } from "./core/binding.js";
-export { buildField, buildNestedField, getElementHierarchy, isExcluded, isNestedElement, isRequired, mergeElementHierarchy, } from "./core/field-builder.js";
-export { buildBindingIdentifier, buildNestedIdentifier, buildSchemaIdentifier, buildValueSetIdentifier, dropVersionFromUrl, } from "./core/identifier.js";
-export { buildNestedTypes, collectNestedElements, extractNestedDependencies, } from "./core/nested-types.js";
-export { transformFHIRSchema, transformFHIRSchemas, } from "./core/transformer.js";
-export { generateTypeSchemaFromPackage, generateTypeSchemaFromSchema, generateTypeSchemaFromSchemas, TypeSchemaGenerator, } from "./generator.js";
-export { parseTypeSchemaFromFile, parseTypeSchemaFromFiles, parseTypeSchemaFromString, TypeSchemaParser, } from "./parser.js";
+export type { FHIRSchema } from "@atomic-ehr/fhirschema";
+export { TypeSchemaCache } from "./cache.js";
+export { TypeSchemaGenerator } from "./generator.js";
+export { TypeSchemaParser } from "./parser.js";
 export * from "./type-schema.types.js";
-export type { PackageInfo, TypeschemaGeneratorOptions, TypeschemaParserOptions, } from "./types.js";
-export { isTypeSchemaBinding, isTypeSchemaForResourceComplexTypeLogical, isTypeSchemaValueSet, } from "./utils.js";
-export { transformValueSet } from "./value-set/processor.js";
-/**
- * TypeSchema Core API class
- *
- * Provides core TypeSchema functionality: convert, read, and validate.
- * Does NOT include target-specific generation (like TypeScript generation).
- * Use target generators in src/api/generators/ for output generation.
- */
-export declare class TypeSchemaAPI {
-    private generator;
-    private parser;
-    private cache;
-    constructor(options?: {
-        generator?: any;
-        parser?: TypeschemaParserOptions;
-        validator?: {
-            strict?: boolean;
-        };
-    });
-    /**
-     * Convert FHIR package to TypeSchema
-     */
-    generateFromPackage(packageName: string, packageVersion?: string): Promise<TypeSchema[]>;
-    /**
-     * Parse TypeSchema from files
-     */
-    parseFromFiles(inputFiles: string[]): Promise<TypeSchema[]>;
-}
-/**
- * Create a new TypeSchema API instance
- */
-export declare function createTypeSchemaAPI(options?: ConstructorParameters<typeof TypeSchemaAPI>[0]): TypeSchemaAPI;
-/**
- * Convenience function to convert FHIR package to TypeSchema
- */
-export declare function generateTypeSchemaFromPackageCore(packageName: string, packageVersion?: string): Promise<TypeSchema[]>;
-/**
- * Convenience function to parse TypeSchema from files
- */
-export declare function parseTypeSchemaFromFilesCore(inputFiles: string[]): Promise<TypeSchema[]>;

package/dist/typeschema/index.js

@@ -9,84 +9,7 @@
  * - Reading TypeSchema documents
  * - Validating TypeSchema documents
  */
-import { TypeSchemaCache } from "./cache.js";
-import { TypeSchemaGenerator } from "./generator.js";
-import { TypeSchemaParser } from "./parser.js";
-// Re-export core dependencies
-export { CanonicalManager } from "@atomic-ehr/fhir-canonical-manager";
-// Export cache functionality
-export { cacheSchema, clearGlobalCache, getCachedSchema, getGlobalCache, initializeGlobalCache, isCached, TypeSchemaCache, } from "./cache.js";
-// Re-export utility functions for FHIR processing
-export { buildEnum, collectBindingSchemas, extractValueSetConcepts, generateBindingSchema, } from "./core/binding.js";
-export { buildField, buildNestedField, getElementHierarchy, isExcluded, isNestedElement, isRequired, mergeElementHierarchy, } from "./core/field-builder.js";
-export { buildBindingIdentifier, buildNestedIdentifier, buildSchemaIdentifier, buildValueSetIdentifier, dropVersionFromUrl, } from "./core/identifier.js";
-export { buildNestedTypes, collectNestedElements, extractNestedDependencies, } from "./core/nested-types.js";
-// Re-export FHIR transformation utilities
-export { transformFHIRSchema, transformFHIRSchemas, } from "./core/transformer.js";
-// Export generator functionality (FHIR -> TypeSchema)
-export { generateTypeSchemaFromPackage, generateTypeSchemaFromSchema, generateTypeSchemaFromSchemas, TypeSchemaGenerator, } from "./generator.js";
-// Export parser functionality (Read TypeSchema)
-export { parseTypeSchemaFromFile, parseTypeSchemaFromFiles, parseTypeSchemaFromString, TypeSchemaParser, } from "./parser.js";
-// Profile processing temporarily disabled (not in core TypeSchema spec)
-// export { transformProfile } from "./profile/processor";
-// Export new comprehensive types (preferred)
+export { TypeSchemaCache } from "./cache.js";
+export { TypeSchemaGenerator } from "./generator.js";
+export { TypeSchemaParser } from "./parser.js";
 export * from "./type-schema.types.js";
-// Export typeschema-specific utils (renamed to avoid conflicts)
-export { isTypeSchemaBinding, isTypeSchemaForResourceComplexTypeLogical, isTypeSchemaValueSet, } from "./utils.js";
-// Export value set processing
-export { transformValueSet } from "./value-set/processor.js";
-/**
- * TypeSchema Core API class
- *
- * Provides core TypeSchema functionality: convert, read, and validate.
- * Does NOT include target-specific generation (like TypeScript generation).
- * Use target generators in src/api/generators/ for output generation.
- */
-export class TypeSchemaAPI {
-    generator;
-    parser;
-    cache;
-    constructor(options = {}) {
-        this.generator = new TypeSchemaGenerator(options.generator);
-        this.parser = new TypeSchemaParser(options.parser);
-        this.cache = new TypeSchemaCache();
-    }
-    /**
-     * Convert FHIR package to TypeSchema
-     */
-    async generateFromPackage(packageName, packageVersion) {
-        const schemas = await this.generator.generateFromPackage(packageName, packageVersion);
-        // Cache generated schemas
-        this.cache.setMany(schemas);
-        return schemas;
-    }
-    /**
-     * Parse TypeSchema from files
-     */
-    async parseFromFiles(inputFiles) {
-        const schemas = await this.parser.parseFromFiles(inputFiles);
-        // Cache parsed schemas
-        this.cache.setMany(schemas);
-        return schemas;
-    }
-}
-/**
- * Create a new TypeSchema API instance
- */
-export function createTypeSchemaAPI(options) {
-    return new TypeSchemaAPI(options);
-}
-/**
- * Convenience function to convert FHIR package to TypeSchema
- */
-export async function generateTypeSchemaFromPackageCore(packageName, packageVersion) {
-    const api = createTypeSchemaAPI();
-    return await api.generateFromPackage(packageName, packageVersion);
-}
-/**
- * Convenience function to parse TypeSchema from files
- */
-export async function parseTypeSchemaFromFilesCore(inputFiles) {
-    const api = createTypeSchemaAPI();
-    return await api.parseFromFiles(inputFiles);
-}

package/dist/typeschema/types.d.ts

@@ -480,9 +480,7 @@ export interface TypeSchemaForBinding {
 }
 export type TypeSchemaField = RegularField | PolymorphicValueXFieldDeclaration | PolymorphicValueXFieldInstance;
 export interface TypeschemaGeneratorOptions {
-    resourceTypes?: string[];
     verbose?: boolean;
-    maxDepth?: number;
     logger?: import("../utils/codegen-logger").CodegenLogger;
     treeshake?: string[];
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atomic-ehr/codegen",
-  "version": "0.0.1-canary.20250831211734.bb1536b",
+  "version": "0.0.1-canary.20250924082247.588e04a",
   "description": "Code generation tools for FHIR resources and TypeSchema definitions",
   "keywords": [
     "fhir",
@@ -46,6 +46,7 @@
     "build": "rm -rf dist && bunx tsc --project tsconfig.build.json && bun build src/cli/index.ts --outfile dist/cli/atomic-codegen.js --target node --format esm --minify --external typescript && tail -n +2 dist/cli/atomic-codegen.js > dist/cli/temp.js && echo '#!/usr/bin/env node' > dist/cli/index.js && cat dist/cli/temp.js >> dist/cli/index.js && chmod +x dist/cli/index.js && rm dist/cli/atomic-codegen.js dist/cli/temp.js",
     "typecheck": "bunx tsc --noEmit",
     "lint": "biome check --write",
+    "format": "biome format --write",
     "quality": "bun run typecheck && bun run lint && bun run test:unit",
     "cli": "bun run src/cli/index.ts",
     "codegen": "bun run src/cli/index.ts",