@atomic-ehr/codegen 0.0.1-canary.20250929141928.699688c → 0.0.1-canary.20250930124137.175bd5f

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

@@ -1,6 +1,10 @@
-// @ts-nocheck
-import { buildField, buildNestedField, isNestedElement } from "./field-builder";
-import { buildNestedIdentifier } from "./identifier";
+/**
+ * Nested Types (BackboneElement) Handling
+ *
+ * Functions for extracting and transforming nested types from FHIRSchema
+ */
+import { buildField, isNestedElement, mkNestedField } from "./field-builder";
+import { mkNestedIdentifier } from "./identifier";
 /**
  * Collect all nested elements from a FHIRSchema
  */
@@ -19,20 +23,17 @@ export function collectNestedElements(fhirSchema, parentPath, elements) {
     }
     return nested;
 }
-/**
- * Transform elements into fields for a nested type
- */
-export async function transformNestedElements(fhirSchema, parentPath, elements, manager, 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] = buildNestedField(fhirSchema, path, element, manager, packageInfo);
+            fields[key] = mkNestedField(fhirSchema, path, element, register, packageInfo);
         }
         else {
             // Regular field
-            fields[key] = await buildField(fhirSchema, path, element, manager, packageInfo);
+            fields[key] = await buildField(fhirSchema, path, element, register, packageInfo);
         }
     }
     return fields;
@@ -40,15 +41,15 @@ export async function transformNestedElements(fhirSchema, parentPath, elements,
 /**
  * Build TypeSchema for all nested types in a FHIRSchema
  */
-export async function buildNestedTypes(fhirSchema, manager, packageInfo) {
+export async function buildNestedTypes(fhirSchema, register, packageInfo) {
     if (!fhirSchema.elements)
-        return [];
+        return undefined;
     const nestedTypes = [];
     const nestedElements = collectNestedElements(fhirSchema, [], fhirSchema.elements);
     // Filter to only include elements that have sub-elements (actual nested types)
     const actualNested = nestedElements.filter(([_, element]) => element.elements && Object.keys(element.elements).length > 0);
     for (const [path, element] of actualNested) {
-        const identifier = buildNestedIdentifier(fhirSchema, path, packageInfo);
+        const identifier = mkNestedIdentifier(fhirSchema, path);
         // Base is usually BackboneElement - ensure all nested types have a base
         // biome-ignore lint/suspicious/noImplicitAnyLet: <explanation>
         let base;
@@ -73,7 +74,7 @@ export async function buildNestedTypes(fhirSchema, manager, packageInfo) {
             };
         }
         // Transform sub-elements into fields
-        const fields = await transformNestedElements(fhirSchema, path, element.elements, manager, packageInfo);
+        const fields = await transformNestedElements(fhirSchema, path, element.elements, register, packageInfo);
         const nestedType = {
             identifier,
             base, // Always include base
@@ -98,7 +99,7 @@ export function extractNestedDependencies(nestedTypes) {
             deps.push(nested.base);
         }
         // Add field type dependencies
-        for (const field of Object.values(nested.fields)) {
+        for (const field of Object.values(nested.fields || {})) {
             if ("type" in field && field.type) {
                 deps.push(field.type);
             }

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

@@ -3,16 +3,8 @@
  *
  * Core transformation logic for converting FHIRSchema to TypeSchema format
  */
-import type { CanonicalManager } from "@atomic-ehr/fhir-canonical-manager";
-import type { FHIRSchema, FHIRSchemaElement } from "@atomic-ehr/fhirschema";
-import type { TypeSchema, TypeSchemaField, RichFHIRSchema } from "@typeschema/types";
-import type { PackageInfo } from "../types";
-/**
- * Transform elements into fields
- */
-export declare function transformElements(fhirSchema: FHIRSchema, parentPath: string[], elements: Record<string, FHIRSchemaElement>, manager: ReturnType<typeof CanonicalManager>, packageInfo?: PackageInfo): Promise<Record<string, TypeSchemaField>>;
-/**
- * Transform a single FHIRSchema to TypeSchema(s) with enhanced categorization
- * Returns the main schema plus any binding schemas
- */
-export declare function transformFHIRSchema(manager: ReturnType<typeof CanonicalManager>, fhirSchema: RichFHIRSchema): Promise<TypeSchema[]>;
+import type { FHIRSchemaElement } from "@atomic-ehr/fhirschema";
+import type { Register } from "@typeschema/register";
+import type { RichFHIRSchema, TypeSchema, TypeSchemaField } from "@typeschema/types";
+export declare function transformElements(register: Register, fhirSchema: RichFHIRSchema, parentPath: string[], elements: Record<string, FHIRSchemaElement> | undefined): Promise<Record<string, TypeSchemaField> | undefined>;
+export declare function transformFHIRSchema(register: Register, fhirSchema: RichFHIRSchema): Promise<TypeSchema[]>;

package/dist/typeschema/core/transformer.js

@@ -1,33 +1,30 @@
-// @ts-nocheck
+/**
+ * Main FHIRSchema to TypeSchema Transformer
+ *
+ * Core transformation logic for converting FHIRSchema to TypeSchema format
+ */
 import { transformProfile } from "../profile/processor";
 import { collectBindingSchemas } from "./binding";
-import { buildField, buildNestedField, getElementHierarchy, isNestedElement, mergeElementHierarchy, } from "./field-builder";
-import { buildSchemaIdentifier } from "./identifier";
+import { buildField, getElementHierarchy, isNestedElement, mergeElementHierarchy, mkNestedField, } from "./field-builder";
+import { mkIdentifier } from "./identifier";
 import { buildNestedTypes, extractNestedDependencies } from "./nested-types";
-/**
- * Transform elements into fields
- */
-export async function transformElements(fhirSchema, parentPath, elements, manager, packageInfo) {
+export async function transformElements(register, fhirSchema, parentPath, elements) {
+    if (!elements)
+        return undefined;
     const fields = {};
     for (const [key, element] of Object.entries(elements)) {
         const path = [...parentPath, key];
-        // Get element snapshot from hierarchy
-        const hierarchy = getElementHierarchy(fhirSchema, path, manager);
+        const hierarchy = getElementHierarchy(fhirSchema, path, register);
         const snapshot = hierarchy.length > 0 ? mergeElementHierarchy(hierarchy) : element;
         if (isNestedElement(snapshot)) {
-            // Reference to nested type
-            fields[key] = buildNestedField(fhirSchema, path, snapshot, manager, packageInfo);
+            fields[key] = mkNestedField(fhirSchema, path, snapshot, register, fhirSchema.package_meta);
         }
         else {
-            // Regular field
-            fields[key] = await buildField(fhirSchema, path, snapshot, manager, packageInfo);
+            fields[key] = buildField(fhirSchema, path, snapshot, register, fhirSchema.package_meta);
         }
     }
     return fields;
 }
-/**
- * Extract dependencies from fields
- */
 function extractFieldDependencies(fields) {
     const deps = [];
     for (const field of Object.values(fields)) {
@@ -40,9 +37,6 @@ function extractFieldDependencies(fields) {
     }
     return deps;
 }
-/**
- * Remove duplicate dependencies
- */
 function deduplicateDependencies(deps) {
     const seen = new Set();
     const unique = [];
@@ -62,13 +56,11 @@ function deduplicateDependencies(deps) {
  */
 function isExtensionSchema(fhirSchema, _identifier) {
     // Check if this is based on Extension
-    if (fhirSchema.base === "Extension" ||
-        fhirSchema.base === "http://hl7.org/fhir/StructureDefinition/Extension") {
+    if (fhirSchema.base === "Extension" || fhirSchema.base === "http://hl7.org/fhir/StructureDefinition/Extension") {
         return true;
     }
     // Check if the URL indicates this is an extension
-    if (fhirSchema.url?.includes("/extension/") ||
-        fhirSchema.url?.includes("-extension")) {
+    if (fhirSchema.url?.includes("/extension/") || fhirSchema.url?.includes("-extension")) {
         return true;
     }
     // Check if the name indicates this is an extension
@@ -84,12 +76,12 @@ function isExtensionSchema(fhirSchema, _identifier) {
 /**
  * Transform a ValueSet FHIRSchema to TypeSchemaValueSet
  */
-async function transformValueSet(fhirSchema, _manager, packageInfo) {
+async function transformValueSet(fhirSchema, _register, _packageInfo) {
     try {
-        const identifier = buildSchemaIdentifier(fhirSchema);
-        identifier.kind = "value-set"; // Ensure correct kind
+        const identifier = mkIdentifier(fhirSchema);
+        identifier.kind = "value-set";
         const valueSetSchema = {
-            identifier,
+            identifier: identifier,
             description: fhirSchema.description,
         };
         // If there are elements that represent concepts
@@ -121,9 +113,9 @@ async function transformValueSet(fhirSchema, _manager, packageInfo) {
 /**
  * Transform an Extension FHIRSchema to TypeSchema with extension metadata
  */
-async function transformExtension(fhirSchema, manager, packageInfo) {
+async function transformExtension(fhirSchema, register, packageInfo) {
     try {
-        const identifier = buildSchemaIdentifier(fhirSchema);
+        const identifier = mkIdentifier(fhirSchema);
         // Build base identifier if present
         let base;
         if (fhirSchema.base && fhirSchema.base !== "Extension") {
@@ -164,15 +156,15 @@ async function transformExtension(fhirSchema, manager, packageInfo) {
         }
         // Transform elements into fields if present
         if (fhirSchema.elements) {
-            const fields = await transformElements(fhirSchema, [], fhirSchema.elements, manager, packageInfo);
-            if (Object.keys(fields).length > 0) {
+            const fields = await transformElements(register, fhirSchema, [], fhirSchema.elements);
+            if (fields && Object.keys(fields).length > 0) {
                 extensionSchema.fields = fields;
                 extensionSchema.dependencies.push(...extractFieldDependencies(fields));
             }
         }
         // Build nested types
-        const nestedTypes = await buildNestedTypes(fhirSchema, manager, packageInfo);
-        if (nestedTypes.length > 0) {
+        const nestedTypes = await buildNestedTypes(fhirSchema, register, packageInfo);
+        if (nestedTypes && nestedTypes.length > 0) {
             extensionSchema.nested = nestedTypes;
             extensionSchema.dependencies.push(...extractNestedDependencies(nestedTypes));
         }
@@ -187,25 +179,59 @@ async function transformExtension(fhirSchema, manager, packageInfo) {
         return null;
     }
 }
-/**
- * Transform a single FHIRSchema to TypeSchema(s) with enhanced categorization
- * Returns the main schema plus any binding schemas
- */
-export async function transformFHIRSchema(manager, fhirSchema) {
+function extractDependencies(identifier, base, fields, nestedTypes) {
+    const deps = [];
+    if (base)
+        deps.push(base);
+    if (fields)
+        deps.push(...extractFieldDependencies(fields));
+    if (nestedTypes)
+        deps.push(...extractNestedDependencies(nestedTypes));
+    const uniqDeps = {};
+    for (const dep of deps) {
+        if (dep.url === identifier.url)
+            continue;
+        uniqDeps[dep.url] = dep;
+    }
+    const result = Object.values(uniqDeps).sort((a, b) => a.name.localeCompare(b.name));
+    return result.length > 0 ? result : undefined;
+}
+async function transformResource(register, fhirSchema) {
+    const identifier = mkIdentifier(fhirSchema);
+    let base;
+    if (fhirSchema.base && fhirSchema.type !== "Element") {
+        const baseFs = register.resolveFs(register.ensureCanonicalUrl(fhirSchema.base));
+        base = mkIdentifier(baseFs);
+    }
+    const fields = await transformElements(register, fhirSchema, [], fhirSchema.elements);
+    const nested = await buildNestedTypes(fhirSchema, register, fhirSchema.package_meta);
+    const dependencies = extractDependencies(identifier, base, fields, nested);
+    const typeSchema = {
+        identifier,
+        base,
+        fields,
+        nested,
+        description: fhirSchema.description,
+        dependencies,
+    };
+    const bindingSchemas = await collectBindingSchemas(fhirSchema, register);
+    return [typeSchema, ...bindingSchemas];
+}
+export async function transformFHIRSchema(register, fhirSchema) {
     const results = [];
-    const identifier = buildSchemaIdentifier(fhirSchema);
+    const identifier = mkIdentifier(fhirSchema);
     // Handle profiles with specialized processor
     if (identifier.kind === "profile") {
-        const profileSchema = await transformProfile(fhirSchema, manager, fhirSchema.package_meta);
+        const profileSchema = await transformProfile(register, fhirSchema);
         results.push(profileSchema);
         // Collect binding schemas for profiles too
-        const bindingSchemas = await collectBindingSchemas(fhirSchema, manager, fhirSchema.package_meta);
+        const bindingSchemas = await collectBindingSchemas(fhirSchema, register);
         results.push(...bindingSchemas);
         return results;
     }
     // Handle value sets specially
     if (identifier.kind === "value-set" || fhirSchema.kind === "value-set") {
-        const valueSetSchema = await transformValueSet(fhirSchema, manager, fhirSchema.package_meta);
+        const valueSetSchema = await transformValueSet(fhirSchema, register, fhirSchema.package_meta);
         if (valueSetSchema) {
             results.push(valueSetSchema);
         }
@@ -213,114 +239,11 @@ export async function transformFHIRSchema(manager, fhirSchema) {
     }
     // Handle extensions specially
     if (isExtensionSchema(fhirSchema, identifier)) {
-        const extensionSchema = await transformExtension(fhirSchema, manager, fhirSchema.package_meta);
+        const extensionSchema = await transformExtension(fhirSchema, register, fhirSchema.package_meta);
         if (extensionSchema) {
             results.push(extensionSchema);
         }
         return results;
     }
-    // Build base identifier if present
-    let base;
-    if (fhirSchema.base && fhirSchema.type !== "Element") {
-        // Create base identifier directly
-        const baseUrl = fhirSchema.base.includes("/")
-            ? fhirSchema.base
-            : `http://hl7.org/fhir/StructureDefinition/${fhirSchema.base}`;
-        const baseName = fhirSchema.base.split("/").pop() || fhirSchema.base;
-        // Check if this is a known complex type by looking at common FHIR complex types
-        const complexTypes = new Set([
-            "Element",
-            "BackboneElement",
-            "Quantity",
-            "Duration",
-            "Distance",
-            "Count",
-            "Age",
-            "Address",
-            "Annotation",
-            "Attachment",
-            "CodeableConcept",
-            "Coding",
-            "ContactPoint",
-            "HumanName",
-            "Identifier",
-            "Period",
-            "Range",
-            "Ratio",
-            "Reference",
-            "Timing",
-            "Money",
-            "SampledData",
-            "Signature",
-            "ContactDetail",
-            "Contributor",
-            "DataRequirement",
-            "Expression",
-            "ParameterDefinition",
-            "RelatedArtifact",
-            "TriggerDefinition",
-            "UsageContext",
-            "Dosage",
-            "Meta",
-            "Extension",
-        ]);
-        const kind = complexTypes.has(baseName) ? "complex-type" : "resource";
-        // For standard FHIR types, use the standard package even if no package info
-        const isStandardFhir = baseUrl.startsWith("http://hl7.org/fhir/");
-        base = {
-            kind: kind,
-            package: isStandardFhir
-                ? "hl7.fhir.r4.core"
-                : fhirSchema.package_meta.name || "undefined",
-            version: isStandardFhir
-                ? "4.0.1"
-                : fhirSchema.package_meta.version || "undefined",
-            name: baseName,
-            url: baseUrl,
-        };
-    }
-    // Initialize the main schema
-    const mainSchema = {
-        identifier,
-        dependencies: [],
-    };
-    // Collect dependencies in the same order as Clojure implementation
-    const allDependencies = [];
-    // Add base if present (first in dependencies)
-    if (base) {
-        mainSchema.base = base;
-        allDependencies.push(base);
-    }
-    // Add description if present
-    if (fhirSchema.description) {
-        mainSchema.description = fhirSchema.description;
-    }
-    // Transform elements into fields (for non-primitive types)
-    if (fhirSchema.kind !== "primitive-type" && fhirSchema.elements) {
-        const fields = await transformElements(fhirSchema, [], fhirSchema.elements, manager, fhirSchema.package_meta);
-        if (Object.keys(fields).length > 0) {
-            mainSchema.fields = fields;
-        }
-        // Extract field dependencies (types and bindings)
-        allDependencies.push(...extractFieldDependencies(fields));
-        // Build nested types
-        const nestedTypes = await buildNestedTypes(fhirSchema, manager, fhirSchema.package_meta);
-        if (nestedTypes.length > 0) {
-            mainSchema.nested = nestedTypes;
-            // Add nested type dependencies
-            allDependencies.push(...extractNestedDependencies(nestedTypes));
-        }
-    }
-    // Set all dependencies at once
-    mainSchema.dependencies = allDependencies;
-    // Deduplicate and sort dependencies
-    mainSchema.dependencies = deduplicateDependencies(mainSchema.dependencies);
-    // Remove self-reference from dependencies
-    mainSchema.dependencies = mainSchema.dependencies.filter((dep) => dep.url !== identifier.url);
-    // Add main schema to results
-    results.push(mainSchema);
-    // Collect and add binding schemas
-    const bindingSchemas = await collectBindingSchemas(fhirSchema, manager, fhirSchema.package_meta);
-    results.push(...bindingSchemas);
-    return results;
+    return await transformResource(register, fhirSchema);
 }

package/dist/typeschema/generator.d.ts

@@ -4,9 +4,10 @@
  * Generates TypeSchema documents from FHIR packages using fhrischema.
  * Provides high-level API for converting FHIR Structure Definitions to TypeSchema format.
  */
-import { type FHIRSchema, type StructureDefinition } from "@atomic-ehr/fhirschema";
+import type { FHIRSchema, StructureDefinition } from "@atomic-ehr/fhirschema";
 import type { TypeSchemaConfig } from "@root/config";
-import type { PackageInfo, RichFHIRSchema, TypeSchema, TypeschemaGeneratorOptions } from "./types";
+import type { Register } from "@typeschema/register";
+import type { PackageMeta, TypeSchema, TypeschemaGeneratorOptions } from "./types";
 /**
  * TypeSchema Generator class
  *
@@ -21,14 +22,10 @@ export declare class TypeSchemaGenerator {
     private logger;
     constructor(options?: TypeschemaGeneratorOptions, cacheConfig?: TypeSchemaConfig);
     private initializeCache;
-    fetchPackage(packageName: string, packageVersion?: string): Promise<{
-        structureDefinitions: StructureDefinition[];
-        valueSets: any[];
-    }>;
+    registerFromPackageMetas(packageMetas: PackageMeta[]): Promise<Register>;
     generateFhirSchemas(structureDefinitions: StructureDefinition[]): FHIRSchema[];
-    generateValueSetSchemas(valueSets: any[], packageInfo: PackageInfo): Promise<TypeSchema[]>;
+    generateValueSetSchemas(valueSets: any[], packageInfo: PackageMeta): Promise<TypeSchema[]>;
     generateFromPackage(packageName: string, packageVersion?: string): Promise<TypeSchema[]>;
-    generateResourceTypeSchemas(fhirSchemas: RichFHIRSchema[]): Promise<TypeSchema[]>;
     /**
      * Apply treeshaking to StructureDefinitions before FHIR schema transformation
      * This is more efficient and includes smart reference handling

package/dist/typeschema/generator.js

@@ -7,9 +7,9 @@
 import { CanonicalManager } from "@atomic-ehr/fhir-canonical-manager";
 import * as fhirschema from "@atomic-ehr/fhirschema";
 import { createLogger } from "@root/utils/codegen-logger";
+import { registerFromManager } from "@typeschema/register";
 import { TypeSchemaCache } from "./cache";
 import { transformFHIRSchema } from "./core/transformer";
-import { enrichFHIRSchema } from "./types";
 import { transformValueSet } from "./value-set/processor";
 /**
  * TypeSchema Generator class
@@ -25,8 +25,7 @@ export class TypeSchemaGenerator {
     logger;
     constructor(options = {}, cacheConfig) {
         this.options = { verbose: false, ...options };
-        this.manager = options.manager ||
-            CanonicalManager({ packages: [], workingDir: "tmp/fhir" });
+        this.manager = options.manager || CanonicalManager({ packages: [], workingDir: "tmp/fhir" });
         this.cacheConfig = cacheConfig;
         this.logger =
             options.logger ||
@@ -41,14 +40,11 @@ export class TypeSchemaGenerator {
             await this.cache.initialize();
         }
     }
-    async fetchPackage(packageName, packageVersion) {
-        this.logger.step(`Loading FHIR package: ${packageName}${packageVersion ? `@${packageVersion}` : ""}`);
-        await this.manager.addPackages(`${packageName}${packageVersion ? `@${packageVersion}` : ""}`);
-        const allResources = await this.manager.search({});
-        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 };
+    async registerFromPackageMetas(packageMetas) {
+        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);
     }
     generateFhirSchemas(structureDefinitions) {
         this.logger.progress(`Converting ${structureDefinitions.length} StructureDefinitions to FHIRSchemas`);
@@ -113,11 +109,11 @@ export class TypeSchemaGenerator {
             name: packageName,
             version: packageVersion || "latest",
         };
-        const { valueSets, structureDefinitions } = await this.fetchPackage(packageName, packageVersion);
-        const fhirSchemas = this.generateFhirSchemas(structureDefinitions).map(enrichFHIRSchema);
-        const valueSetSchemas = await this.generateValueSetSchemas(valueSets, packageInfo);
-        const schemas = await this.generateResourceTypeSchemas(fhirSchemas);
-        const allSchemas = [...schemas, ...valueSetSchemas];
+        const register = await this.registerFromPackageMetas([packageInfo]);
+        const allSchemas = [
+            ...(await Promise.all(register.allFs().map(async (fs) => await transformFHIRSchema(register, fs)))).flat(),
+            ...(await this.generateValueSetSchemas(register.allVs(), packageInfo)),
+        ];
         if (this.cache) {
             for (const schema of allSchemas) {
                 await this.cache.set(schema);
@@ -125,14 +121,20 @@ export class TypeSchemaGenerator {
         }
         return allSchemas;
     }
-    async generateResourceTypeSchemas(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)));
-        }
-        return typeSchemas;
-    }
+    // async generateResourceTypeSchemas(
+    //   fhirSchemas: RichFHIRSchema[],
+    // ): Promise<TypeSchema[]> {
+    //   this.logger.info(
+    //     `Transforming ${fhirSchemas.length} FHIR schemas to Type Schema`,
+    //   );
+    //   const typeSchemas: TypeSchema[] = [];
+    //   for (const fhirSchema of fhirSchemas) {
+    //     typeSchemas.push(
+    //       ...(await transformFHIRSchema(this.manager, fhirSchema)),
+    //     );
+    //   }
+    //   return typeSchemas;
+    // }
     /**
      * Apply treeshaking to StructureDefinitions before FHIR schema transformation
      * This is more efficient and includes smart reference handling

package/dist/typeschema/parser.d.ts

@@ -1,5 +1,10 @@
-import type { TypeSchema, Identifier } from "@typeschema/types";
-import type { TypeschemaParserOptions } from "./types";
+/**
+ * TypeSchema Parser
+ *
+ * Parser for reading and manipulating TypeSchema documents from various formats.
+ * Supports both NDJSON and JSON formats with automatic format detection.
+ */
+import type { Identifier, TypeSchema, TypeschemaParserOptions } from "@typeschema/types";
 /**
  * TypeSchema Parser class
  *
@@ -44,11 +49,9 @@ export declare class TypeSchemaParser {
     /**
      * Get all dependencies from a schema
      */
-    getDependencies(schema: TypeSchema): Identifier[];
     /**
      * Resolve schema dependencies
      */
-    resolveDependencies(schemas: TypeSchema[], targetSchema: TypeSchema): TypeSchema[];
     /**
      * Detect format from content or filename
      */
@@ -73,10 +76,6 @@ export declare class TypeSchemaParser {
      * Check if identifier matches criteria
      */
     private matchesIdentifier;
-    /**
-     * Remove duplicate dependencies
-     */
-    private deduplicateDependencies;
 }
 /**
  * Convenience function to parse TypeSchema from file