@atomic-ehr/codegen 0.0.1-canary.20251006094042.7f0be72 → 0.0.1-canary.20251007114955.88a8afc

package/dist/index.d.ts

@@ -2,224 +2,6 @@ import { CanonicalManager } from '@atomic-ehr/fhir-canonical-manager';
 import * as FS from '@atomic-ehr/fhirschema';
 import { FHIRSchema, StructureDefinition } from '@atomic-ehr/fhirschema';
 
-/**
- * New Config Schema for High-Level API
- *
- * Simple configuration system compatible ONLY with the new high-level APIBuilder.
- * All legacy config functionality has been removed.
- */
-/**
- * TypeScript generator configuration options
- */
-interface TypeScriptGeneratorConfig {
-    moduleFormat?: "esm" | "cjs";
-    generateIndex?: boolean;
-    includeDocuments?: boolean;
-    namingConvention?: "PascalCase" | "camelCase";
-    strictMode?: boolean;
-    includeProfiles?: boolean;
-    includeExtensions?: boolean;
-    includeCodeSystems?: boolean;
-    includeOperations?: boolean;
-    /** Generate individual TypeScript files for value sets (default: false) */
-    generateValueSets?: boolean;
-    /** Include helper validation functions in value set files (default: false) */
-    includeValueSetHelpers?: boolean;
-    /** Which binding strengths to generate value sets for (default: ['required']) */
-    valueSetStrengths?: ("required" | "preferred" | "extensible" | "example")[];
-    /** Directory name for value set files (relative to outputDir) (default: 'valuesets') */
-    valueSetDirectory?: string;
-    /** Value set generation mode (default: 'required-only') */
-    valueSetMode?: "all" | "required-only" | "custom";
-    fhirVersion?: "R4" | "R5";
-    resourceTypes?: string[];
-    maxDepth?: number;
-    profileOptions?: {
-        generateKind?: "interface" | "type" | "both";
-        includeConstraints?: boolean;
-        includeDocumentation?: boolean;
-        strictMode?: boolean;
-        subfolder?: string;
-    };
-    generateBuilders?: boolean;
-    builderOptions?: {
-        includeValidation?: boolean;
-        includeFactoryMethods?: boolean;
-        includeInterfaces?: boolean;
-        generateNestedBuilders?: boolean;
-        includeHelperMethods?: boolean;
-        supportPartialBuild?: boolean;
-        includeJSDoc?: boolean;
-        generateFactories?: boolean;
-        includeTypeGuards?: boolean;
-        handleChoiceTypes?: boolean;
-        generateArrayHelpers?: boolean;
-    };
-    validatorOptions?: {
-        includeCardinality?: boolean;
-        includeTypes?: boolean;
-        includeConstraints?: boolean;
-        includeInvariants?: boolean;
-        validateRequired?: boolean;
-        allowAdditional?: boolean;
-        strictValidation?: boolean;
-        collectMetrics?: boolean;
-        generateAssertions?: boolean;
-        generatePartialValidators?: boolean;
-        optimizePerformance?: boolean;
-        includeJSDoc?: boolean;
-        generateCompositeValidators?: boolean;
-    };
-    guardOptions?: {
-        includeRuntimeValidation?: boolean;
-        includeErrorMessages?: boolean;
-        treeShakeable?: boolean;
-        targetTSVersion?: "3.8" | "4.0" | "4.5" | "5.0";
-        strictGuards?: boolean;
-        includeNullChecks?: boolean;
-        verbose?: boolean;
-    };
-}
-/**
- * TypeSchema Configuration
- * Controls TypeSchema generation and caching behavior
- */
-interface TypeSchemaConfig {
-    /** Enable persistent caching of generated TypeSchemas */
-    enablePersistence?: boolean;
-    /** Directory to store cached TypeSchemas (relative to outputDir) */
-    cacheDir?: string;
-    /** Maximum age of cached schemas in milliseconds before regeneration */
-    maxAge?: number;
-    /** Whether to validate cached schemas before reuse */
-    validateCached?: boolean;
-    /** Force regeneration of schemas even if cached */
-    forceRegenerate?: boolean;
-    /** Share cache across multiple codegen runs */
-    shareCache?: boolean;
-    /** Cache key prefix for namespacing */
-    cacheKeyPrefix?: string;
-    /** Only generate TypeSchemas for specific ResourceTypes (treeshaking) */
-    treeshake?: string[];
-    /** Generate single TypeSchema file instead of multiple files */
-    singleFile?: boolean;
-    /** Profile packages configuration */
-    profiles?: {
-        /** Auto-detect profiles in packages */
-        autoDetect?: boolean;
-    };
-}
-/**
- * Main configuration schema for the new high-level API
- */
-interface Config {
-    outputDir?: string;
-    verbose?: boolean;
-    overwrite?: boolean;
-    validate?: boolean;
-    cache?: boolean;
-    typescript?: TypeScriptGeneratorConfig;
-    typeSchema?: TypeSchemaConfig;
-    packages?: string[];
-    files?: string[];
-    $schema?: string;
-}
-/**
- * Default configuration values
- */
-declare const DEFAULT_CONFIG: Required<Config>;
-/**
- * Configuration file names to search for
- */
-declare const CONFIG_FILE_NAMES: string[];
-/**
- * Validation error interface
- */
-interface ConfigValidationError {
-    path: string;
-    message: string;
-    value?: unknown;
-}
-/**
- * Configuration validation result
- */
-interface ConfigValidationResult {
-    valid: boolean;
-    errors: ConfigValidationError[];
-    warnings: string[];
-    config?: Config;
-}
-/**
- * Simple configuration validator
- */
-declare class ConfigValidator {
-    /**
-     * Validate a configuration object
-     */
-    validate(config: unknown): ConfigValidationResult;
-    private validateTypeScriptConfig;
-    private validateValidatorOptions;
-    private validateGuardOptions;
-    private validateProfileOptions;
-    private validateTypeSchemaConfig;
-}
-/**
- * Configuration loader with autoloading capabilities
- */
-declare class ConfigLoader {
-    private validator;
-    /**
-     * Auto-load configuration from the current working directory
-     */
-    autoload(workingDir?: string): Promise<Config>;
-    /**
-     * Load configuration from a specific file
-     */
-    loadFromFile(filePath: string): Promise<Config>;
-    /**
-     * Find configuration file in the given directory
-     */
-    private findConfigFile;
-    /**
-     * Merge user config with defaults
-     */
-    private mergeWithDefaults;
-}
-/**
- * Global config loader instance
- */
-declare const configLoader: ConfigLoader;
-/**
- * Convenience function to auto-load configuration
- */
-declare function loadConfig(workingDir?: string): Promise<Config>;
-/**
- * Type guard to check if an object is a valid Config
- */
-declare function isConfig(obj: unknown): obj is Config;
-/**
- * Define configuration with type safety and IntelliSense support.
- * Similar to Vite's defineConfig function pattern.
- *
- * @example
- * ```typescript
- * import { defineConfig } from "@atomic-ehr/codegen";
- *
- * export default defineConfig({
- *   outputDir: "./generated",
- *   packages: [
- *     "hl7.fhir.r4.core@4.0.1",
- *     "hl7.fhir.us.core@6.1.0"
- *   ],
- *   typescript: {
- *     generateIndex: true,
- *     strictMode: true
- *   }
- * });
- * ```
- */
-declare function defineConfig(config: Config): Config;
-
 /**
  * CodeGen Logger
  *
@@ -235,6 +17,7 @@ interface LogOptions {
  */
 declare class CodegenLogger {
     private options;
+    private dryWarnSet;
     constructor(options?: LogOptions);
     private formatMessage;
     /**
@@ -249,6 +32,7 @@ declare class CodegenLogger {
      * Warning message with warning sign
      */
     warn(message: string): void;
+    dry_warn(message: string): void;
     /**
      * Info message with info icon
      */
@@ -507,6 +291,238 @@ type RichValueSet = Omit<ValueSet, "name" | "url"> & {
     url?: CanonicalUrl;
 };
 
+type Register = {
+    appendFs(fs: FHIRSchema): void;
+    ensureCanonicalUrl(name: string | Name | CanonicalUrl): CanonicalUrl;
+    resolveSd(canonicalUrl: CanonicalUrl): StructureDefinition | undefined;
+    resolveFs(canonicalUrl: CanonicalUrl): RichFHIRSchema | undefined;
+    resolveFsGenealogy(canonicalUrl: CanonicalUrl): RichFHIRSchema[];
+    allSd(): StructureDefinition[];
+    allFs(): RichFHIRSchema[];
+    allVs(): RichValueSet[];
+    resolveVs(canonicalUrl: CanonicalUrl): RichValueSet | undefined;
+    complexTypeDict(): Record<string, RichFHIRSchema>;
+    resolveAny(canonicalUrl: CanonicalUrl): any | undefined;
+} & ReturnType<typeof CanonicalManager>;
+
+/**
+ * New Config Schema for High-Level API
+ *
+ * Simple configuration system compatible ONLY with the new high-level APIBuilder.
+ * All legacy config functionality has been removed.
+ */
+/**
+ * TypeScript generator configuration options
+ */
+interface TypeScriptGeneratorConfig {
+    moduleFormat?: "esm" | "cjs";
+    generateIndex?: boolean;
+    includeDocuments?: boolean;
+    namingConvention?: "PascalCase" | "camelCase";
+    strictMode?: boolean;
+    includeProfiles?: boolean;
+    includeExtensions?: boolean;
+    includeCodeSystems?: boolean;
+    includeOperations?: boolean;
+    /** Generate individual TypeScript files for value sets (default: false) */
+    generateValueSets?: boolean;
+    /** Include helper validation functions in value set files (default: false) */
+    includeValueSetHelpers?: boolean;
+    /** Which binding strengths to generate value sets for (default: ['required']) */
+    valueSetStrengths?: ("required" | "preferred" | "extensible" | "example")[];
+    /** Directory name for value set files (relative to outputDir) (default: 'valuesets') */
+    valueSetDirectory?: string;
+    /** Value set generation mode (default: 'required-only') */
+    valueSetMode?: "all" | "required-only" | "custom";
+    fhirVersion?: "R4" | "R5";
+    resourceTypes?: string[];
+    maxDepth?: number;
+    profileOptions?: {
+        generateKind?: "interface" | "type" | "both";
+        includeConstraints?: boolean;
+        includeDocumentation?: boolean;
+        strictMode?: boolean;
+        subfolder?: string;
+    };
+    generateBuilders?: boolean;
+    builderOptions?: {
+        includeValidation?: boolean;
+        includeFactoryMethods?: boolean;
+        includeInterfaces?: boolean;
+        generateNestedBuilders?: boolean;
+        includeHelperMethods?: boolean;
+        supportPartialBuild?: boolean;
+        includeJSDoc?: boolean;
+        generateFactories?: boolean;
+        includeTypeGuards?: boolean;
+        handleChoiceTypes?: boolean;
+        generateArrayHelpers?: boolean;
+    };
+    validatorOptions?: {
+        includeCardinality?: boolean;
+        includeTypes?: boolean;
+        includeConstraints?: boolean;
+        includeInvariants?: boolean;
+        validateRequired?: boolean;
+        allowAdditional?: boolean;
+        strictValidation?: boolean;
+        collectMetrics?: boolean;
+        generateAssertions?: boolean;
+        generatePartialValidators?: boolean;
+        optimizePerformance?: boolean;
+        includeJSDoc?: boolean;
+        generateCompositeValidators?: boolean;
+    };
+    guardOptions?: {
+        includeRuntimeValidation?: boolean;
+        includeErrorMessages?: boolean;
+        treeShakeable?: boolean;
+        targetTSVersion?: "3.8" | "4.0" | "4.5" | "5.0";
+        strictGuards?: boolean;
+        includeNullChecks?: boolean;
+        verbose?: boolean;
+    };
+}
+/**
+ * TypeSchema Configuration
+ * Controls TypeSchema generation and caching behavior
+ */
+interface TypeSchemaConfig {
+    /** Enable persistent caching of generated TypeSchemas */
+    enablePersistence?: boolean;
+    /** Directory to store cached TypeSchemas (relative to outputDir) */
+    cacheDir?: string;
+    /** Maximum age of cached schemas in milliseconds before regeneration */
+    maxAge?: number;
+    /** Whether to validate cached schemas before reuse */
+    validateCached?: boolean;
+    /** Force regeneration of schemas even if cached */
+    forceRegenerate?: boolean;
+    /** Share cache across multiple codegen runs */
+    shareCache?: boolean;
+    /** Cache key prefix for namespacing */
+    cacheKeyPrefix?: string;
+    /** Only generate TypeSchemas for specific ResourceTypes (treeshaking) */
+    treeshake?: string[];
+    /** Generate single TypeSchema file instead of multiple files */
+    singleFile?: boolean;
+    /** Profile packages configuration */
+    profiles?: {
+        /** Auto-detect profiles in packages */
+        autoDetect?: boolean;
+    };
+}
+/**
+ * Main configuration schema for the new high-level API
+ */
+interface Config {
+    outputDir?: string;
+    verbose?: boolean;
+    overwrite?: boolean;
+    validate?: boolean;
+    cache?: boolean;
+    typescript?: TypeScriptGeneratorConfig;
+    typeSchema?: TypeSchemaConfig;
+    packages?: string[];
+    files?: string[];
+    $schema?: string;
+}
+/**
+ * Default configuration values
+ */
+declare const DEFAULT_CONFIG: Required<Config>;
+/**
+ * Configuration file names to search for
+ */
+declare const CONFIG_FILE_NAMES: string[];
+/**
+ * Validation error interface
+ */
+interface ConfigValidationError {
+    path: string;
+    message: string;
+    value?: unknown;
+}
+/**
+ * Configuration validation result
+ */
+interface ConfigValidationResult {
+    valid: boolean;
+    errors: ConfigValidationError[];
+    warnings: string[];
+    config?: Config;
+}
+/**
+ * Simple configuration validator
+ */
+declare class ConfigValidator {
+    /**
+     * Validate a configuration object
+     */
+    validate(config: unknown): ConfigValidationResult;
+    private validateTypeScriptConfig;
+    private validateValidatorOptions;
+    private validateGuardOptions;
+    private validateProfileOptions;
+    private validateTypeSchemaConfig;
+}
+/**
+ * Configuration loader with autoloading capabilities
+ */
+declare class ConfigLoader {
+    private validator;
+    /**
+     * Auto-load configuration from the current working directory
+     */
+    autoload(workingDir?: string): Promise<Config>;
+    /**
+     * Load configuration from a specific file
+     */
+    loadFromFile(filePath: string): Promise<Config>;
+    /**
+     * Find configuration file in the given directory
+     */
+    private findConfigFile;
+    /**
+     * Merge user config with defaults
+     */
+    private mergeWithDefaults;
+}
+/**
+ * Global config loader instance
+ */
+declare const configLoader: ConfigLoader;
+/**
+ * Convenience function to auto-load configuration
+ */
+declare function loadConfig(workingDir?: string): Promise<Config>;
+/**
+ * Type guard to check if an object is a valid Config
+ */
+declare function isConfig(obj: unknown): obj is Config;
+/**
+ * Define configuration with type safety and IntelliSense support.
+ * Similar to Vite's defineConfig function pattern.
+ *
+ * @example
+ * ```typescript
+ * import { defineConfig } from "@atomic-ehr/codegen";
+ *
+ * export default defineConfig({
+ *   outputDir: "./generated",
+ *   packages: [
+ *     "hl7.fhir.r4.core@4.0.1",
+ *     "hl7.fhir.us.core@6.1.0"
+ *   ],
+ *   typescript: {
+ *     generateIndex: true,
+ *     strictMode: true
+ *   }
+ * });
+ * ```
+ */
+declare function defineConfig(config: Config): Config;
+
 /**
  * TypeSchema Cache System
  *
@@ -587,20 +603,6 @@ declare class TypeSchemaCache {
     clearDisk(): Promise<void>;
 }
 
-type Register = {
-    appendFs(fs: FHIRSchema): void;
-    ensureCanonicalUrl(name: string | Name | CanonicalUrl): CanonicalUrl;
-    resolveSd(canonicalUrl: CanonicalUrl): StructureDefinition | undefined;
-    resolveFs(canonicalUrl: CanonicalUrl): RichFHIRSchema | undefined;
-    resolveFsGenealogy(canonicalUrl: CanonicalUrl): RichFHIRSchema[];
-    allSd(): StructureDefinition[];
-    allFs(): RichFHIRSchema[];
-    allVs(): RichValueSet[];
-    resolveVs(canonicalUrl: CanonicalUrl): RichValueSet | undefined;
-    complexTypeDict(): Record<string, RichFHIRSchema>;
-    resolveAny(canonicalUrl: CanonicalUrl): any | undefined;
-} & ReturnType<typeof CanonicalManager>;
-
 /**
  * TypeSchema Generator
  *
@@ -619,13 +621,13 @@ declare class TypeSchemaGenerator {
     private options;
     private cacheConfig?;
     private cache?;
-    private logger;
+    private logger?;
     constructor(options?: TypeschemaGeneratorOptions, cacheConfig?: TypeSchemaConfig);
     private initializeCache;
     registerFromPackageMetas(packageMetas: PackageMeta[]): Promise<Register>;
     generateFhirSchemas(structureDefinitions: StructureDefinition[]): FHIRSchema[];
-    generateValueSetSchemas(valueSets: any[], _packageInfo: PackageMeta): Promise<TypeSchema[]>;
-    generateFromPackage(packageName: string, packageVersion?: string): Promise<TypeSchema[]>;
+    generateValueSetSchemas(valueSets: RichValueSet[], logger?: CodegenLogger): Promise<TypeSchema[]>;
+    generateFromPackage(packageName: string, packageVersion: string | undefined, logger?: CodegenLogger): Promise<TypeSchema[]>;
     /**
      * Apply treeshaking to StructureDefinitions before FHIR schema transformation
      * This is more efficient and includes smart reference handling
@@ -715,6 +717,14 @@ declare class TypeSchemaParser {
     private matchesIdentifier;
 }
 
+interface WriterOptions {
+    outputDir: string;
+    tabSize: number;
+    withDebugComment?: boolean;
+    commentLinePrefix: string;
+    logger?: CodegenLogger;
+}
+
 /**
  * High-Level API Builder
  *
@@ -729,11 +739,11 @@ interface APIBuilderOptions {
     outputDir?: string;
     verbose?: boolean;
     overwrite?: boolean;
-    validate?: boolean;
     cache?: boolean;
     typeSchemaConfig?: TypeSchemaConfig;
     logger?: CodegenLogger;
     manager?: ReturnType<typeof CanonicalManager> | null;
+    throwException?: boolean;
 }
 /**
  * Progress callback for long-running operations
@@ -760,16 +770,14 @@ declare class APIBuilder {
     private schemas;
     private options;
     private generators;
-    private progressCallback?;
     private cache?;
     private pendingOperations;
     private typeSchemaGenerator?;
     private logger;
+    private packages;
+    progressCallback: any;
     private typeSchemaConfig?;
     constructor(options?: APIBuilderOptions);
-    /**
-     * Load TypeSchema from a FHIR package
-     */
     fromPackage(packageName: string, version?: string): APIBuilder;
     /**
      * Load TypeSchema from files
@@ -779,9 +787,6 @@ declare class APIBuilder {
      * Load TypeSchema from TypeSchema objects
      */
     fromSchemas(schemas: TypeSchema[]): APIBuilder;
-    /**
-     * Configure TypeScript generation
-     */
     typescript(options?: {
         moduleFormat?: "esm" | "cjs";
         generateIndex?: boolean;
@@ -795,6 +800,7 @@ declare class APIBuilder {
         valueSetMode?: "all" | "required-only" | "custom";
         valueSetDirectory?: string;
     }): APIBuilder;
+    typescript2(opts: Partial<WriterOptions>): this;
     /**
      * Set a progress callback for monitoring generation
      */
@@ -803,17 +809,8 @@ declare class APIBuilder {
      * Set the output directory for all generators
      */
     outputTo(directory: string): APIBuilder;
-    /**
-     * Enable/disable verbose logging
-     */
     verbose(enabled?: boolean): APIBuilder;
-    /**
-     * Enable/disable validation
-     */
-    validate(enabled?: boolean): APIBuilder;
-    /**
-     * Execute the generation process
-     */
+    throwException(enabled?: boolean): APIBuilder;
     generate(): Promise<GenerationResult>;
     /**
      * Generate and return the results without writing to files
@@ -836,12 +833,8 @@ declare class APIBuilder {
      * Get configured generators (for inspection)
      */
     getGenerators(): string[];
-    private loadFromPackage;
     private loadFromFiles;
-    private resolveSchemas;
-    private validateSchemas;
     private executeGenerators;
-    private reportProgress;
 }
 /**
  * Create a new API builder instance