@atomic-ehr/codegen 0.0.1-canary.20251106145509.e3b1f82 → 0.0.1-canary.20251107091824.7605d36

package/dist/index.d.ts

@@ -291,6 +291,16 @@ type ValueSetCompose = {
         filter?: {}[];
     }[];
 };
+type CodeSystem = {
+    resourceType: "CodeSystem";
+    url: CanonicalUrl;
+    concept: CodeSystemConcept[];
+};
+type CodeSystemConcept = {
+    concept: CodeSystemConcept[];
+    code: string;
+    display: string;
+};
 type RichValueSet = Omit<ValueSet, "name" | "url"> & {
     package_meta: PackageMeta;
     name: Name;
@@ -304,8 +314,8 @@ interface TypeschemaGeneratorOptions {
 }
 
 type Register = {
-    unsafeAppendFs(fs: FHIRSchema): void;
-    ensureSpecializationCanonicalUrl(pkg: PackageMeta, name: string | Name | CanonicalUrl): CanonicalUrl;
+    testAppendFs(fs: FHIRSchema): void;
+    ensureSpecializationCanonicalUrl(name: string | Name | CanonicalUrl): CanonicalUrl;
     resolveSd(pkg: PackageMeta, canonicalUrl: CanonicalUrl): StructureDefinition | undefined;
     resolveFs(pkg: PackageMeta, canonicalUrl: CanonicalUrl): RichFHIRSchema | undefined;
     resolveFsGenealogy(pkg: PackageMeta, canonicalUrl: CanonicalUrl): RichFHIRSchema[];
@@ -316,7 +326,23 @@ type Register = {
     resolveAny(canonicalUrl: CanonicalUrl): any | undefined;
     resolveElementSnapshot(fhirSchema: RichFHIRSchema, path: string[]): FHIRSchemaElement;
     getAllElementKeys(elems: Record<string, FHIRSchemaElement>): string[];
+    resolver: PackageAwareResolver;
 } & ReturnType<typeof CanonicalManager>;
+type PkgId = string;
+type FocusedResource = StructureDefinition | ValueSet | CodeSystem;
+type CanonicalResolution<T> = {
+    deep: number;
+    pkg: PackageMeta;
+    pkgId: PkgId;
+    resource: T;
+};
+type PackageIndex = {
+    pkg: PackageMeta;
+    canonicalResolution: Record<CanonicalUrl, CanonicalResolution<FocusedResource>[]>;
+    fhirSchemas: Record<CanonicalUrl, RichFHIRSchema>;
+    valueSets: Record<CanonicalUrl, RichValueSet>;
+};
+type PackageAwareResolver = Record<PkgId, PackageIndex>;
 
 /**
  * New Config Schema for High-Level API
@@ -731,11 +757,35 @@ declare class TypeSchemaParser {
     private matchesIdentifier;
 }
 
+interface TypeRelation {
+    parent: Identifier;
+    child: Identifier;
+}
+type PackageName = string;
+type TypeSchemaIndex = {
+    _schemaIndex: Record<CanonicalUrl, Record<PackageName, TypeSchema>>;
+    _relations: TypeRelation[];
+    collectComplexTypes: () => RegularTypeSchema[];
+    collectResources: () => RegularTypeSchema[];
+    collectLogicalModels: () => RegularTypeSchema[];
+    collectProfiles: () => ProfileTypeSchema[];
+    resolve: (id: Identifier) => TypeSchema | undefined;
+    resourceChildren: (id: Identifier) => Identifier[];
+    tryHierarchy: (schema: TypeSchema) => TypeSchema[] | undefined;
+    hierarchy: (schema: TypeSchema) => TypeSchema[];
+    findLastSpecialization: (schema: TypeSchema) => TypeSchema;
+    findLastSpecializationByIdentifier: (id: Identifier) => Identifier;
+    flatProfile: (schema: ProfileTypeSchema) => ProfileTypeSchema;
+    isWithMetaField: (profile: ProfileTypeSchema) => boolean;
+    exportTree: (filename: string) => Promise<void>;
+};
+
 interface WriterOptions {
     outputDir: string;
     tabSize: number;
     withDebugComment?: boolean;
     commentLinePrefix: string;
+    writeTypeTree?: string;
     logger?: CodegenLogger;
 }
 
@@ -760,6 +810,7 @@ interface APIBuilderOptions {
     manager?: ReturnType<typeof CanonicalManager> | null;
     typeSchemaOutputDir?: string /** if .ndjson -- put in one file, else -- split into separated files*/;
     throwException?: boolean;
+    exportTypeTree?: string;
 }
 /**
  * Progress callback for long-running operations
@@ -795,15 +846,9 @@ declare class APIBuilder {
     private typeSchemaConfig?;
     constructor(options?: APIBuilderOptions);
     fromPackage(packageName: string, version?: string): APIBuilder;
-    /**
-     * Load TypeSchema from files
-     */
     fromFiles(...filePaths: string[]): APIBuilder;
-    /**
-     * Load TypeSchema from TypeSchema objects
-     */
     fromSchemas(schemas: TypeSchema[]): APIBuilder;
-    typescript(options?: {
+    typescriptDepricated(options?: {
         moduleFormat?: "esm" | "cjs";
         generateIndex?: boolean;
         includeDocuments?: boolean;
@@ -816,7 +861,7 @@ declare class APIBuilder {
         valueSetMode?: "all" | "required-only" | "custom";
         valueSetDirectory?: string;
     }): APIBuilder;
-    typescript2(opts: Partial<WriterOptions>): this;
+    typescript(opts: Partial<WriterOptions>): this;
     csharp(namespace: string, staticSourceDir?: string | undefined): APIBuilder;
     /**
      * Set a progress callback for monitoring generation
@@ -829,8 +874,8 @@ declare class APIBuilder {
     verbose(enabled?: boolean): APIBuilder;
     throwException(enabled?: boolean): APIBuilder;
     cleanOutput(enabled?: boolean): APIBuilder;
+    writeTypeTree(filename: string): this;
     writeTypeSchemas(target: string): this;
-    private static isIdenticalTo;
     private writeTypeSchemasToSeparateFiles;
     private writeTypeSchemasToSingleFile;
     private tryWriteTypeSchema;
@@ -1759,6 +1804,10 @@ declare class GeneratorErrorBoundary {
     }): Promise<T[]>;
 }
 
+type GeneratorInput = {
+    schemas: TypeSchema[];
+    index: TypeSchemaIndex;
+};
 /**
  * Abstract base generator class with comprehensive functionality
  *
@@ -1841,7 +1890,7 @@ declare abstract class BaseGenerator<TOptions extends BaseGeneratorOptions = Bas
      * This is the main method that orchestrates the entire generation process
      * @param schemas - Array of TypeSchema documents
      */
-    generate(schemas: TypeSchema[]): Promise<TResult>;
+    generate({ schemas }: GeneratorInput): Promise<TResult>;
     /**
      * Generate and return content without writing files (useful for testing)
      * @param schemas - Array of TypeSchema documents
@@ -2136,7 +2185,7 @@ declare class TypeScriptGenerator extends BaseGenerator<TypeScriptGeneratorOptio
     /**
      * Override generate to clean directory first
      */
-    generate(schemas: TypeSchema[]): Promise<GeneratedFile[]>;
+    generate(input: GeneratorInput): Promise<GeneratedFile[]>;
     /**
      * Run post-generation hooks - generate utility files
      */