@atomic-ehr/codegen 0.0.1 → 0.0.2-canary.20251114095108.8d8e927

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,40 @@ declare class TypeSchemaParser {
     private matchesIdentifier;
 }
 
+type TypeSchemaShakeRule = {
+    ignoreFields?: string[];
+};
+type TreeShake = Record<string, Record<string, TypeSchemaShakeRule>>;
+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;
+    resolveByUrl: (pkgName: PackageName, url: CanonicalUrl) => 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;
+    generateProfile?: boolean;
     logger?: CodegenLogger;
 }
 
@@ -760,6 +815,8 @@ interface APIBuilderOptions {
     manager?: ReturnType<typeof CanonicalManager> | null;
     typeSchemaOutputDir?: string /** if .ndjson -- put in one file, else -- split into separated files*/;
     throwException?: boolean;
+    exportTypeTree?: string;
+    treeShake?: TreeShake;
 }
 /**
  * Progress callback for long-running operations
@@ -795,15 +852,10 @@ declare class APIBuilder {
     private typeSchemaConfig?;
     constructor(options?: APIBuilderOptions);
     fromPackage(packageName: string, version?: string): APIBuilder;
-    /**
-     * Load TypeSchema from files
-     */
+    fromPackageRef(packageRef: string): APIBuilder;
     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 +868,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,11 +881,9 @@ declare class APIBuilder {
     verbose(enabled?: boolean): APIBuilder;
     throwException(enabled?: boolean): APIBuilder;
     cleanOutput(enabled?: boolean): APIBuilder;
+    writeTypeTree(filename: string): this;
+    treeShake(tree: TreeShake): this;
     writeTypeSchemas(target: string): this;
-    private static isIdenticalTo;
-    private writeTypeSchemasToSeparateFiles;
-    private writeTypeSchemasToSingleFile;
-    private tryWriteTypeSchema;
     generate(): Promise<GenerationResult>;
     /**
      * Generate and return the results without writing to files
@@ -859,29 +909,10 @@ declare class APIBuilder {
     private loadFromFiles;
     private executeGenerators;
 }
-/**
- * Create a new API builder instance
- */
-declare function createAPI(options?: APIBuilderOptions): APIBuilder;
 /**
  * Create an API builder instance from a configuration object
  */
 declare function createAPIFromConfig(config: Config): APIBuilder;
-/**
- * Convenience function for quick TypeScript generation from a package
- */
-declare function generateTypesFromPackage(packageName: string, outputDir: string, options?: {
-    version?: string;
-    verbose?: boolean;
-    validate?: boolean;
-}): Promise<GenerationResult>;
-/**
- * Convenience function for quick TypeScript generation from files
- */
-declare function generateTypesFromFiles(inputFiles: string[], outputDir: string, options?: {
-    verbose?: boolean;
-    validate?: boolean;
-}): Promise<GenerationResult>;
 
 /**
  * Core types and interfaces for the base generator system
@@ -1759,6 +1790,10 @@ declare class GeneratorErrorBoundary {
     }): Promise<T[]>;
 }
 
+type GeneratorInput = {
+    schemas: TypeSchema[];
+    index: TypeSchemaIndex;
+};
 /**
  * Abstract base generator class with comprehensive functionality
  *
@@ -1841,7 +1876,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 +2171,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
      */
@@ -2163,4 +2198,4 @@ declare class TypeScriptGenerator extends BaseGenerator<TypeScriptGeneratorOptio
     private generateMainIndexFile;
 }
 
-export { APIBuilder, type APIBuilderOptions, CONFIG_FILE_NAMES, type Config, ConfigLoader, type ConfigValidationError, type ConfigValidationResult, ConfigValidator, DEFAULT_CONFIG, type GeneratedFile, type GenerationResult, type PackageMeta as PackageInfo, type ProgressCallback$1 as ProgressCallback, type TypeSchema, TypeSchemaCache, type TypeSchemaConfig, type Field as TypeSchemaField, TypeSchemaGenerator, type Identifier as TypeSchemaIdentifier, TypeSchemaParser, TypeScriptGenerator, type TypeScriptGeneratorConfig, type TypeScriptGeneratorOptions, configLoader, createAPI, createAPIFromConfig, defineConfig, generateTypesFromFiles, generateTypesFromPackage, isConfig, loadConfig };
+export { APIBuilder, type APIBuilderOptions, CONFIG_FILE_NAMES, type Config, ConfigLoader, type ConfigValidationError, type ConfigValidationResult, ConfigValidator, DEFAULT_CONFIG, type GeneratedFile, type GenerationResult, type PackageMeta as PackageInfo, type ProgressCallback$1 as ProgressCallback, type TypeSchema, TypeSchemaCache, type TypeSchemaConfig, type Field as TypeSchemaField, TypeSchemaGenerator, type Identifier as TypeSchemaIdentifier, TypeSchemaParser, TypeScriptGenerator, type TypeScriptGeneratorConfig, type TypeScriptGeneratorOptions, configLoader, createAPIFromConfig, defineConfig, isConfig, loadConfig };