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

package/dist/index.js

@@ -1,8 +1,10 @@
+import { CanonicalManager } from '@atomic-ehr/fhir-canonical-manager';
+import * as fhirschema from '@atomic-ehr/fhirschema';
+import * as fs from 'fs';
 import { existsSync, mkdirSync } from 'fs';
 import { readdir, stat, unlink, readFile, writeFile, access, mkdir, rm } from 'fs/promises';
+import * as Path2 from 'path';
 import { join, resolve, dirname, relative } from 'path';
-import { CanonicalManager } from '@atomic-ehr/fhir-canonical-manager';
-import * as fhirschema from '@atomic-ehr/fhirschema';
 import pc from 'picocolors';
 
 var __defProp = Object.defineProperty;
@@ -1391,424 +1393,127 @@ var init_IndexBuilder = __esm({
     };
   }
 });
-var TypeSchemaCache = class {
-  cache = /* @__PURE__ */ new Map();
-  config;
-  cacheDir;
-  constructor(config) {
-    this.config = {
-      enablePersistence: true,
-      cacheDir: ".typeschema-cache",
-      maxAge: 24 * 60 * 60 * 1e3,
-      // 24 hours
-      validateCached: true,
-      ...config
-    };
-    if (this.config.enablePersistence && this.config.cacheDir) {
-      this.cacheDir = this.config.cacheDir;
-    }
-  }
-  /**
-   * Store a schema in the cache
-   */
-  async set(schema) {
-    const key = this.generateKey(schema.identifier);
-    this.cache.set(key, schema);
-    if (this.config.enablePersistence && this.cacheDir) {
-      await this.persistSchema(schema);
-    }
-  }
-  /**
-   * Retrieve a schema by identifier
-   */
-  get(identifier) {
-    const key = this.generateKey(identifier);
-    return this.cache.get(key) || null;
-  }
-  /**
-   * Retrieve a schema by URL
-   */
-  getByUrl(url) {
-    for (const schema of this.cache.values()) {
-      if (schema.identifier.url === url) {
-        return schema;
-      }
-    }
-    return null;
-  }
-  /**
-   * Check if a schema exists in cache
-   */
-  has(identifier) {
-    const key = this.generateKey(identifier);
-    return this.cache.has(key);
-  }
-  /**
-   * Check if a schema exists by URL
-   */
-  hasByUrl(url) {
-    for (const schema of this.cache.values()) {
-      if (schema.identifier.url === url) {
-        return true;
-      }
-    }
-    return false;
-  }
-  /**
-   * Delete a schema from cache
-   */
-  delete(identifier) {
-    const key = this.generateKey(identifier);
-    return this.cache.delete(key);
-  }
-  /**
-   * Delete a schema by URL
-   */
-  deleteByUrl(url) {
-    for (const [key, schema] of this.cache.entries()) {
-      if (schema.identifier.url === url) {
-        return this.cache.delete(key);
-      }
-    }
-    return false;
-  }
-  /**
-   * Get schemas by package
-   */
-  getByPackage(packageName) {
-    const results = [];
-    for (const schema of this.cache.values()) {
-      if (schema.identifier.package === packageName) {
-        results.push(schema);
-      }
-    }
-    return results;
-  }
-  /**
-   * Get schemas by kind
-   */
-  getByKind(kind) {
-    const results = [];
-    for (const schema of this.cache.values()) {
-      if (schema.identifier.kind === kind) {
-        results.push(schema);
-      }
-    }
-    return results;
-  }
-  /**
-   * Store multiple schemas
-   */
-  setMany(schemas) {
-    for (const schema of schemas) {
-      this.set(schema);
-    }
-  }
-  /**
-   * Clear all cached schemas
-   */
-  clear() {
-    this.cache.clear();
-  }
-  /**
-   * Generate cache key for identifier
-   */
-  generateKey(identifier) {
-    return `${identifier.package}:${identifier.version}:${identifier.kind}:${identifier.name}`;
+
+// src/typeschema/types.ts
+var packageMetaToFhir = (packageMeta) => `${packageMeta.name}#${packageMeta.version}`;
+var packageMetaToNpm = (packageMeta) => `${packageMeta.name}@${packageMeta.version}`;
+var enrichFHIRSchema = (schema, packageMeta) => {
+  if (!packageMeta) {
+    packageMeta = { name: "undefined", version: "undefined" };
   }
-  /**
-   * Initialize cache directory if persistence is enabled
-   */
-  async initialize() {
-    if (this.config.enablePersistence && this.cacheDir) {
-      if (!existsSync(this.cacheDir)) {
-        mkdirSync(this.cacheDir, { recursive: true });
-      }
-      await this.loadFromDisk();
+  return {
+    ...schema,
+    package_meta: schema.package_meta || packageMeta,
+    name: schema.name,
+    url: schema.url,
+    base: schema.base
+  };
+};
+function isBindingSchema(schema) {
+  return schema.identifier.kind === "binding";
+}
+
+// src/typeschema/register.ts
+var registerFromManager = async (manager, logger) => {
+  const packages = await manager.packages();
+  const flatRawIndex = {};
+  const indexByPackages = [];
+  for (const pkg of packages) {
+    const resources = await manager.search({ package: pkg });
+    const index = {};
+    for (const resource of resources) {
+      const url = resource.url;
+      if (!url) continue;
+      index[url] = resource;
+      flatRawIndex[url] = resource;
     }
+    indexByPackages.push({
+      package_meta: pkg,
+      index
+    });
   }
-  /**
-   * Load all cached schemas from disk
-   */
-  async loadFromDisk() {
-    if (!this.cacheDir || !existsSync(this.cacheDir)) {
-      return;
-    }
-    try {
-      const files = await readdir(this.cacheDir);
-      const schemaFiles = files.filter((f) => f.endsWith(".typeschema.json"));
-      for (const file of schemaFiles) {
-        const filePath = join(this.cacheDir, file);
-        const stats = await stat(filePath);
-        if (this.config.maxAge) {
-          const age = Date.now() - stats.mtimeMs;
-          if (age > this.config.maxAge) {
-            await unlink(filePath);
-            continue;
-          }
-        }
+  const sdIndex = {};
+  const vsIndex = {};
+  const fsIndex = {};
+  const nameToCanonical = {};
+  let [fsSuccess, fsFailed] = [0, 0];
+  for (const resourcesByPackage of indexByPackages) {
+    const packageMeta = resourcesByPackage.package_meta;
+    for (const [surl, resource] of Object.entries(resourcesByPackage.index)) {
+      const url = surl;
+      if (resource.resourceType === "StructureDefinition") {
+        const sd = resource;
+        sdIndex[url] = sd;
         try {
-          const content = await readFile(filePath, "utf-8");
-          const metadata = JSON.parse(content);
-          if (this.config.validateCached) {
-            if (!metadata.schema?.identifier) {
-              continue;
-            }
-          }
-          const key = this.generateKey(metadata.schema.identifier);
-          this.cache.set(key, metadata.schema);
+          const rfs = enrichFHIRSchema(fhirschema.translate(sd), packageMeta);
+          fsIndex[rfs.url] = rfs;
+          nameToCanonical[rfs.name] = rfs.url;
+          fsSuccess++;
         } catch (error) {
-          console.warn(`Failed to load cached schema from ${file}:`, error);
+          logger?.warn(
+            `Failed to convert StructureDefinition ${sd.name || sd.id}: ${error instanceof Error ? error.message : String(error)}`
+          );
+          fsFailed++;
         }
       }
-    } catch (error) {
-      console.warn("Failed to load cached schemas from disk:", error);
-    }
-  }
-  /**
-   * Persist a schema to disk
-   */
-  async persistSchema(schema) {
-    if (!this.cacheDir) {
-      return;
-    }
-    if (!existsSync(this.cacheDir)) {
-      mkdirSync(this.cacheDir, { recursive: true });
+      if (resource.resourceType === "ValueSet") {
+        if (!resource.package_meta) {
+          resource.package_meta = packageMeta;
+        }
+        vsIndex[resource.url] = resource;
+      }
     }
-    const metadata = {
-      schema,
-      timestamp: Date.now(),
-      version: schema.identifier.version
-    };
-    const fileName = `${schema.identifier.package}-${schema.identifier.version}-${schema.identifier.kind}-${schema.identifier.name}.typeschema.json`.replace(
-      /[^a-zA-Z0-9.-]/g,
-      "_"
+    logger?.success(
+      `FHIR Schema conversion for '${packageMetaToFhir(packageMeta)}' completed: ${fsSuccess} successful, ${fsFailed} failed`
     );
-    const filePath = join(this.cacheDir, fileName);
-    try {
-      await writeFile(filePath, JSON.stringify(metadata, null, 2), "utf-8");
-    } catch (error) {
-      console.warn(`Failed to persist schema to ${filePath}:`, error);
+  }
+  const complexTypes = {};
+  for (const fs2 of Object.values(fsIndex)) {
+    if (fs2.kind === "complex-type") {
+      complexTypes[fs2.url] = fs2;
     }
   }
-  /**
-   * Clear cache directory
-   */
-  async clearDisk() {
-    if (!this.cacheDir || !existsSync(this.cacheDir)) {
-      return;
+  const resolveFsGenealogy = (canonicalUrl) => {
+    let fs2 = fsIndex[canonicalUrl];
+    if (fs2 === void 0) throw new Error(`Failed to resolve FHIR Schema genealogy for '${canonicalUrl}'`);
+    const genealogy = [fs2];
+    while (fs2?.base) {
+      fs2 = fsIndex[fs2.base] || fsIndex[nameToCanonical[fs2.base]];
+      genealogy.push(fs2);
+      if (fs2 === void 0) throw new Error(`Failed to resolve FHIR Schema genealogy for '${canonicalUrl}'`);
     }
-    try {
-      const files = await readdir(this.cacheDir);
-      const schemaFiles = files.filter((f) => f.endsWith(".typeschema.json"));
-      for (const file of schemaFiles) {
-        await unlink(join(this.cacheDir, file));
-      }
-    } catch (error) {
-      console.warn("Failed to clear cache directory:", error);
+    return genealogy;
+  };
+  return {
+    ...manager,
+    appendFs(fs2) {
+      const rfs = enrichFHIRSchema(fs2);
+      fsIndex[rfs.url] = rfs;
+      nameToCanonical[rfs.name] = rfs.url;
+    },
+    resolveFs: (canonicalUrl) => fsIndex[canonicalUrl],
+    resolveFsGenealogy,
+    ensureCanonicalUrl: (name) => nameToCanonical[name] || name,
+    allSd: () => Object.values(sdIndex),
+    resolveSd: (canonicalUrl) => sdIndex[canonicalUrl],
+    allFs: () => Object.values(fsIndex),
+    allVs: () => Object.values(vsIndex),
+    resolveVs: (canonicalUrl) => vsIndex[canonicalUrl],
+    complexTypeDict: () => complexTypes,
+    resolveAny: (canonicalUrl) => flatRawIndex[canonicalUrl]
+  };
+};
+var resolveFsElementGenealogy = (genealogy, path) => {
+  const [top, ...rest] = path;
+  if (top === void 0) return [];
+  return genealogy.map((fs2) => {
+    if (!fs2.elements) return void 0;
+    let elem = fs2.elements?.[top];
+    for (const k of rest) {
+      elem = elem?.elements?.[k];
     }
-  }
-};
-var CodegenLogger = class _CodegenLogger {
-  options;
-  constructor(options = {}) {
-    this.options = {
-      timestamp: false,
-      verbose: false,
-      ...options
-    };
-  }
-  formatMessage(level, message, color) {
-    const timestamp = this.options.timestamp ? `${pc.gray((/* @__PURE__ */ new Date()).toLocaleTimeString())} ` : "";
-    const prefix = this.options.prefix ? `${pc.cyan(`[${this.options.prefix}]`)} ` : "";
-    return `${timestamp}${color(level)} ${prefix}${message}`;
-  }
-  /**
-   * Success message with checkmark
-   */
-  success(message) {
-    console.log(this.formatMessage("\u2705", message, pc.green));
-  }
-  /**
-   * Error message with X mark
-   */
-  error(message, error) {
-    console.error(this.formatMessage("\u274C", message, pc.red));
-    if (error && this.options.verbose) {
-      console.error(pc.red(`   ${error.message}`));
-      if (error.stack) {
-        console.error(pc.gray(error.stack));
-      }
-    }
-  }
-  /**
-   * Warning message with warning sign
-   */
-  warn(message) {
-    console.warn(this.formatMessage("\u26A0\uFE0F", message, pc.yellow));
-  }
-  /**
-   * Info message with info icon
-   */
-  info(message) {
-    console.log(this.formatMessage("\u2139\uFE0F", message, pc.blue));
-  }
-  /**
-   * Debug message (only shows in verbose mode)
-   */
-  debug(message) {
-    if (this.options.verbose) {
-      console.log(this.formatMessage("\u{1F41B}", message, pc.magenta));
-    }
-  }
-  /**
-   * Step message with rocket
-   */
-  step(message) {
-    console.log(this.formatMessage("\u{1F680}", message, pc.cyan));
-  }
-  /**
-   * Progress message with clock
-   */
-  progress(message) {
-    console.log(this.formatMessage("\u23F3", message, pc.blue));
-  }
-  /**
-   * Plain message (no icon, just colored text)
-   */
-  plain(message, color = (s) => s) {
-    const timestamp = this.options.timestamp ? `${pc.gray((/* @__PURE__ */ new Date()).toLocaleTimeString())} ` : "";
-    const prefix = this.options.prefix ? `${pc.cyan(`[${this.options.prefix}]`)} ` : "";
-    console.log(`${timestamp}${prefix}${color(message)}`);
-  }
-  /**
-   * Dimmed/gray text for less important info
-   */
-  dim(message) {
-    this.plain(message, pc.gray);
-  }
-  /**
-   * Create a child logger with a prefix
-   */
-  child(prefix) {
-    return new _CodegenLogger({
-      ...this.options,
-      prefix: this.options.prefix ? `${this.options.prefix}:${prefix}` : prefix
-    });
-  }
-  /**
-   * Update options
-   */
-  configure(options) {
-    this.options = { ...this.options, ...options };
-  }
-};
-new CodegenLogger();
-function createLogger(options = {}) {
-  return new CodegenLogger(options);
-}
-
-// src/typeschema/types.ts
-var enrichFHIRSchema = (schema, packageMeta) => {
-  if (!packageMeta) {
-    packageMeta = { name: "undefined", version: "undefined" };
-  }
-  return {
-    ...schema,
-    package_meta: schema.package_meta || packageMeta,
-    name: schema.name,
-    url: schema.url,
-    base: schema.base
-  };
-};
-function isBindingSchema(schema) {
-  return schema.identifier.kind === "binding";
-}
-
-// src/typeschema/register.ts
-var registerFromManager = async (manager, logger, packageInfo) => {
-  const resources = await manager.search({});
-  const any = {};
-  for (const resource of resources) {
-    const url = resource.url;
-    if (!url) continue;
-    any[url] = resource;
-  }
-  const structureDefinitions = {};
-  for (const resource of resources) {
-    if (resource.resourceType === "StructureDefinition") {
-      const url = resource.url;
-      structureDefinitions[url] = resource;
-    }
-  }
-  const fhirSchemas = {};
-  const nameDict = {};
-  let [success] = [0, 0];
-  for (const sd of Object.values(structureDefinitions)) {
-    try {
-      const rfs = enrichFHIRSchema(fhirschema.translate(sd), packageInfo);
-      fhirSchemas[rfs.url] = rfs;
-      nameDict[rfs.name] = rfs.url;
-      success++;
-    } catch (error) {
-    }
-  }
-  const valueSets = {};
-  for (const resource of resources) {
-    if (resource.resourceType === "ValueSet") {
-      if (!resource.package_meta) {
-        resource.package_meta = packageInfo;
-      }
-      valueSets[resource.url] = resource;
-    }
-  }
-  const complexTypes = {};
-  for (const fs of Object.values(fhirSchemas)) {
-    if (fs.kind === "complex-type") {
-      complexTypes[fs.url] = fs;
-    }
-  }
-  const resolveFsGenealogy = (canonicalUrl) => {
-    let fs = fhirSchemas[canonicalUrl];
-    if (fs === void 0) throw new Error(`Failed to resolve FHIR Schema genealogy for '${canonicalUrl}'`);
-    const genealogy = [fs];
-    while (fs?.base) {
-      fs = fhirSchemas[fs.base] || fhirSchemas[nameDict[fs.base]];
-      genealogy.push(fs);
-      if (fs === void 0) throw new Error(`Failed to resolve FHIR Schema genealogy for '${canonicalUrl}'`);
-    }
-    return genealogy;
-  };
-  return {
-    ...manager,
-    appendFs(fs) {
-      const rfs = enrichFHIRSchema(fs);
-      fhirSchemas[rfs.url] = rfs;
-      nameDict[rfs.name] = rfs.url;
-    },
-    resolveFs: (canonicalUrl) => fhirSchemas[canonicalUrl],
-    resolveFsGenealogy,
-    ensureCanonicalUrl: (name) => nameDict[name] || name,
-    allSd: () => Object.values(structureDefinitions),
-    resolveSd: (canonicalUrl) => structureDefinitions[canonicalUrl],
-    allFs: () => Object.values(fhirSchemas),
-    allVs: () => Object.values(valueSets),
-    resolveVs: (canonicalUrl) => valueSets[canonicalUrl],
-    complexTypeDict: () => complexTypes,
-    resolveAny: (canonicalUrl) => any[canonicalUrl]
-  };
-};
-var resolveFsElementGenealogy = (genealogy, path) => {
-  const [top, ...rest] = path;
-  if (top === void 0) return [];
-  return genealogy.map((fs) => {
-    if (!fs.elements) return void 0;
-    let elem = fs.elements?.[top];
-    for (const k of rest) {
-      elem = elem?.elements?.[k];
-    }
-    return elem;
-  }).filter((elem) => elem !== void 0);
+    return elem;
+  }).filter((elem) => elem !== void 0);
 };
 function fsElementSnapshot(genealogy) {
   const snapshot = genealogy.reverse().reduce((snapshot2, elem) => ({ ...snapshot2, ...elem }), {});
@@ -1872,8 +1577,8 @@ function mkValueSetIdentifierByUrl(register, fullValueSetUrl) {
   const valueSetName = valueSet?.id && !/^[a-zA-Z0-9_-]{20,}$/.test(valueSet.id) ? valueSet.id : valueSetNameFallback;
   return {
     kind: "value-set",
-    package: valueSet?.package_meta.name,
-    version: valueSet?.package_meta.version,
+    package: valueSet.package_meta.name,
+    version: valueSet.package_meta.version,
     name: valueSetName,
     url: valueSetUrl
   };
@@ -1891,7 +1596,7 @@ function mkBindingIdentifier(fhirSchema, path, bindingName) {
 }
 
 // src/typeschema/profile/processor.ts
-async function transformProfile(register, fhirSchema) {
+async function transformProfile(register, fhirSchema, logger) {
   const identifier = mkIdentifier(fhirSchema);
   if (identifier.kind !== "profile") {
     throw new Error(`Expected profile, got ${identifier.kind} for ${fhirSchema.name}`);
@@ -1923,7 +1628,7 @@ async function transformProfile(register, fhirSchema) {
     profileSchema.metadata = metadata;
   }
   if (fhirSchema.elements) {
-    const fields = await mkFields(register, fhirSchema, [], fhirSchema.elements);
+    const fields = await mkFields(register, fhirSchema, [], fhirSchema.elements, logger);
     if (fields && Object.keys(fields).length > 0) {
       profileSchema.fields = fields;
     }
@@ -2062,10 +1767,10 @@ function extractValidationRules(fhirSchema) {
 function isRequired(register, fhirSchema, path) {
   const fieldName = path[path.length - 1];
   const parentPath = path.slice(0, -1);
-  const requires = register.resolveFsGenealogy(fhirSchema.url).flatMap((fs) => {
-    if (parentPath.length === 0) return fs.required || [];
-    if (!fs.elements) return [];
-    let elem = fs;
+  const requires = register.resolveFsGenealogy(fhirSchema.url).flatMap((fs2) => {
+    if (parentPath.length === 0) return fs2.required || [];
+    if (!fs2.elements) return [];
+    let elem = fs2;
     for (const k of parentPath) {
       elem = elem?.elements?.[k];
     }
@@ -2077,10 +1782,10 @@ function isExcluded(register, fhirSchema, path) {
   const fieldName = path[path.length - 1];
   if (!fieldName) throw new Error(`Internal error: fieldName is missing for path ${path.join("/")}`);
   const parentPath = path.slice(0, -1);
-  const requires = register.resolveFsGenealogy(fhirSchema.url).flatMap((fs) => {
-    if (parentPath.length === 0) return fs.excluded || [];
-    if (!fs.elements) return [];
-    let elem = fs;
+  const requires = register.resolveFsGenealogy(fhirSchema.url).flatMap((fs2) => {
+    if (parentPath.length === 0) return fs2.excluded || [];
+    if (!fs2.elements) return [];
+    let elem = fs2;
     for (const k of parentPath) {
       elem = elem?.elements?.[k];
     }
@@ -2092,8 +1797,8 @@ var buildReferences = (element, register, _packageInfo) => {
   if (!element.refers) return void 0;
   return element.refers.map((ref) => {
     const curl = register.ensureCanonicalUrl(ref);
-    const fs = register.resolveFs(curl);
-    return mkIdentifier(fs);
+    const fs2 = register.resolveFs(curl);
+    return mkIdentifier(fs2);
   });
 };
 function buildFieldType(register, fhirSchema, element) {
@@ -2120,13 +1825,13 @@ function buildFieldType(register, fhirSchema, element) {
   }
   return void 0;
 }
-var mkField = (register, fhirSchema, path, element) => {
+var mkField = (register, fhirSchema, path, element, logger) => {
   let binding;
   let enumValues;
   if (element.binding) {
     binding = mkBindingIdentifier(fhirSchema, path, element.binding.bindingName);
     if (element.binding.strength === "required" && element.type === "code") {
-      enumValues = buildEnum(register, element);
+      enumValues = buildEnum(register, element, logger);
     }
   }
   return {
@@ -2159,13 +1864,13 @@ function mkNestedField(register, fhirSchema, path, element) {
 }
 
 // src/typeschema/core/binding.ts
-function extractValueSetConceptsByUrl(register, valueSetUrl) {
+function extractValueSetConceptsByUrl(register, valueSetUrl, logger) {
   const cleanUrl = dropVersionFromUrl(valueSetUrl) || valueSetUrl;
   const valueSet = register.resolveVs(cleanUrl);
   if (!valueSet) return void 0;
   return extractValueSetConcepts(register, valueSet);
 }
-function extractValueSetConcepts(register, valueSet) {
+function extractValueSetConcepts(register, valueSet, _logger) {
   if (valueSet.expansion?.contains) return valueSet.expansion.contains;
   const concepts = [];
   if (valueSet.compose?.include) {
@@ -2204,7 +1909,7 @@ function extractValueSetConcepts(register, valueSet) {
   return concepts.length > 0 ? concepts : void 0;
 }
 var MAX_ENUM_LENGTH = 100;
-function buildEnum(register, element) {
+function buildEnum(register, element, logger) {
   if (!element.binding) return void 0;
   const strength = element.binding.strength;
   const valueSetUrl = element.binding.valueSet;
@@ -2215,14 +1920,14 @@ function buildEnum(register, element) {
   if (!concepts || concepts.length === 0) return void 0;
   const codes = concepts.map((c) => c.code).filter((code) => code && typeof code === "string" && code.trim().length > 0);
   if (codes.length > MAX_ENUM_LENGTH) {
-    console.warn(
-      `Value set ${valueSetUrl} has more than ${MAX_ENUM_LENGTH} codes, which may cause issues with code generation.`
+    logger?.dry_warn(
+      `Value set ${valueSetUrl} has ${codes.length} which is more than ${MAX_ENUM_LENGTH} codes, which may cause issues with code generation.`
     );
     return void 0;
   }
   return codes.length > 0 ? codes : void 0;
 }
-function generateBindingSchema(register, fhirSchema, path, element) {
+function generateBindingSchema(register, fhirSchema, path, element, logger) {
   if (!element.binding?.valueSet) return void 0;
   const identifier = mkBindingIdentifier(fhirSchema, path, element.binding.bindingName);
   const fieldType = buildFieldType(register, fhirSchema, element);
@@ -2232,7 +1937,7 @@ function generateBindingSchema(register, fhirSchema, path, element) {
     dependencies.push(fieldType);
   }
   dependencies.push(valueSetIdentifier);
-  const enumValues = buildEnum(register, element);
+  const enumValues = buildEnum(register, element, logger);
   return {
     identifier,
     type: fieldType,
@@ -2242,7 +1947,7 @@ function generateBindingSchema(register, fhirSchema, path, element) {
     dependencies
   };
 }
-function collectBindingSchemas(register, fhirSchema) {
+function collectBindingSchemas(register, fhirSchema, logger) {
   const processedPaths = /* @__PURE__ */ new Set();
   if (!fhirSchema.elements) return [];
   const bindings = [];
@@ -2253,7 +1958,7 @@ function collectBindingSchemas(register, fhirSchema) {
       if (processedPaths.has(pathKey)) continue;
       processedPaths.add(pathKey);
       if (element.binding) {
-        const binding = generateBindingSchema(register, fhirSchema, path, element);
+        const binding = generateBindingSchema(register, fhirSchema, path, element, logger);
         if (binding) {
           bindings.push(binding);
         }
@@ -2290,19 +1995,19 @@ function collectNestedElements(fhirSchema, parentPath, elements) {
   }
   return nested;
 }
-function transformNestedElements(fhirSchema, parentPath, elements, register) {
+function transformNestedElements(fhirSchema, parentPath, elements, register, logger) {
   const fields = {};
   for (const [key, element] of Object.entries(elements)) {
     const path = [...parentPath, key];
     if (isNestedElement(element)) {
       fields[key] = mkNestedField(register, fhirSchema, path, element);
     } else {
-      fields[key] = mkField(register, fhirSchema, path, element);
+      fields[key] = mkField(register, fhirSchema, path, element, logger);
     }
   }
   return fields;
 }
-function mkNestedTypes(register, fhirSchema) {
+function mkNestedTypes(register, fhirSchema, logger) {
   if (!fhirSchema.elements) return void 0;
   const nestedElements = collectNestedElements(fhirSchema, [], fhirSchema.elements);
   const actualNested = nestedElements.filter(
@@ -2329,7 +2034,7 @@ function mkNestedTypes(register, fhirSchema) {
         url: `http://hl7.org/fhir/StructureDefinition/${element.type}`
       };
     }
-    const fields = transformNestedElements(fhirSchema, path, element.elements, register);
+    const fields = transformNestedElements(fhirSchema, path, element.elements, register, logger);
     const nestedType = {
       identifier,
       base,
@@ -2359,7 +2064,7 @@ function extractNestedDependencies(nestedTypes) {
 }
 
 // src/typeschema/core/transformer.ts
-function mkFields(register, fhirSchema, parentPath, elements) {
+function mkFields(register, fhirSchema, parentPath, elements, logger) {
   if (!elements) return void 0;
   const geneology = register.resolveFsGenealogy(fhirSchema.url);
   const elems = {};
@@ -2384,7 +2089,7 @@ function mkFields(register, fhirSchema, parentPath, elements) {
     if (isNestedElement(elemSnapshot)) {
       fields[key] = mkNestedField(register, fhirSchema, path, elemSnapshot);
     } else {
-      fields[key] = mkField(register, fhirSchema, path, elemSnapshot);
+      fields[key] = mkField(register, fhirSchema, path, elemSnapshot, logger);
     }
   }
   return fields;
@@ -2429,7 +2134,7 @@ function isExtensionSchema(fhirSchema, _identifier) {
   }
   return false;
 }
-async function transformValueSet(register, valueSet) {
+async function transformValueSet(register, valueSet, logger) {
   if (!valueSet.url) throw new Error("ValueSet URL is required");
   const identifier = mkValueSetIdentifierByUrl(register, valueSet.url);
   const concept = extractValueSetConceptsByUrl(register, valueSet.url);
@@ -2440,7 +2145,7 @@ async function transformValueSet(register, valueSet) {
     compose: !concept ? valueSet.compose : void 0
   };
 }
-async function transformExtension(fhirSchema, register, _packageInfo) {
+async function transformExtension(fhirSchema, register, logger) {
   try {
     const identifier = mkIdentifier(fhirSchema);
     let base;
@@ -2477,13 +2182,13 @@ async function transformExtension(fhirSchema, register, _packageInfo) {
       extensionSchema.dependencies.push(base);
     }
     if (fhirSchema.elements) {
-      const fields = mkFields(register, fhirSchema, [], fhirSchema.elements);
+      const fields = mkFields(register, fhirSchema, [], fhirSchema.elements, logger);
       if (fields && Object.keys(fields).length > 0) {
         extensionSchema.fields = fields;
         extensionSchema.dependencies.push(...extractFieldDependencies(fields));
       }
     }
-    const nestedTypes = mkNestedTypes(register, fhirSchema);
+    const nestedTypes = mkNestedTypes(register, fhirSchema, logger);
     if (nestedTypes && nestedTypes.length > 0) {
       extensionSchema.nested = nestedTypes;
       extensionSchema.dependencies.push(...extractNestedDependencies(nestedTypes));
@@ -2495,63 +2200,386 @@ async function transformExtension(fhirSchema, register, _packageInfo) {
     console.warn(`Failed to transform extension ${fhirSchema.name}: ${error}`);
     return null;
   }
-}
-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;
+}
+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 localNestedTypeUrls = new Set(nestedTypes?.map((nt) => nt.identifier.url));
+  const result = Object.values(uniqDeps).filter((e) => !(e.kind === "nested" && localNestedTypeUrls.has(e.url))).sort((a, b) => a.url.localeCompare(b.url));
+  return result.length > 0 ? result : void 0;
+}
+function transformFhirSchemaResource(register, fhirSchema, logger) {
+  const identifier = mkIdentifier(fhirSchema);
+  let base;
+  if (fhirSchema.base && fhirSchema.type !== "Element") {
+    const baseFs = register.resolveFs(register.ensureCanonicalUrl(fhirSchema.base));
+    if (!baseFs) {
+      throw new Error(`Base resource not found '${fhirSchema.base}' for '${fhirSchema.url}'`);
+    }
+    base = mkIdentifier(baseFs);
+  }
+  const fields = mkFields(register, fhirSchema, [], fhirSchema.elements, logger);
+  const nested = mkNestedTypes(register, fhirSchema, logger);
+  const dependencies = extractDependencies(identifier, base, fields, nested);
+  const typeSchema = {
+    identifier,
+    base,
+    fields,
+    nested,
+    description: fhirSchema.description,
+    dependencies
+  };
+  const bindingSchemas = collectBindingSchemas(register, fhirSchema, logger);
+  return [typeSchema, ...bindingSchemas];
+}
+async function transformFhirSchema(register, fhirSchema, logger) {
+  const results = [];
+  const identifier = mkIdentifier(fhirSchema);
+  if (identifier.kind === "profile") {
+    const profileSchema = await transformProfile(register, fhirSchema, logger);
+    results.push(profileSchema);
+    const bindingSchemas = collectBindingSchemas(register, fhirSchema, logger);
+    results.push(...bindingSchemas);
+    return results;
+  }
+  if (isExtensionSchema(fhirSchema)) {
+    const extensionSchema = await transformExtension(fhirSchema, register, logger);
+    if (extensionSchema) {
+      results.push(extensionSchema);
+    }
+    return results;
+  }
+  return transformFhirSchemaResource(register, fhirSchema, logger);
+}
+var TypeSchemaCache = class {
+  cache = /* @__PURE__ */ new Map();
+  config;
+  cacheDir;
+  constructor(config) {
+    this.config = {
+      enablePersistence: true,
+      cacheDir: ".typeschema-cache",
+      maxAge: 24 * 60 * 60 * 1e3,
+      // 24 hours
+      validateCached: true,
+      ...config
+    };
+    if (this.config.enablePersistence && this.config.cacheDir) {
+      this.cacheDir = this.config.cacheDir;
+    }
+  }
+  /**
+   * Store a schema in the cache
+   */
+  async set(schema) {
+    const key = this.generateKey(schema.identifier);
+    this.cache.set(key, schema);
+    if (this.config.enablePersistence && this.cacheDir) {
+      await this.persistSchema(schema);
+    }
+  }
+  /**
+   * Retrieve a schema by identifier
+   */
+  get(identifier) {
+    const key = this.generateKey(identifier);
+    return this.cache.get(key) || null;
+  }
+  /**
+   * Retrieve a schema by URL
+   */
+  getByUrl(url) {
+    for (const schema of this.cache.values()) {
+      if (schema.identifier.url === url) {
+        return schema;
+      }
+    }
+    return null;
+  }
+  /**
+   * Check if a schema exists in cache
+   */
+  has(identifier) {
+    const key = this.generateKey(identifier);
+    return this.cache.has(key);
+  }
+  /**
+   * Check if a schema exists by URL
+   */
+  hasByUrl(url) {
+    for (const schema of this.cache.values()) {
+      if (schema.identifier.url === url) {
+        return true;
+      }
+    }
+    return false;
+  }
+  /**
+   * Delete a schema from cache
+   */
+  delete(identifier) {
+    const key = this.generateKey(identifier);
+    return this.cache.delete(key);
+  }
+  /**
+   * Delete a schema by URL
+   */
+  deleteByUrl(url) {
+    for (const [key, schema] of this.cache.entries()) {
+      if (schema.identifier.url === url) {
+        return this.cache.delete(key);
+      }
+    }
+    return false;
+  }
+  /**
+   * Get schemas by package
+   */
+  getByPackage(packageName) {
+    const results = [];
+    for (const schema of this.cache.values()) {
+      if (schema.identifier.package === packageName) {
+        results.push(schema);
+      }
+    }
+    return results;
+  }
+  /**
+   * Get schemas by kind
+   */
+  getByKind(kind) {
+    const results = [];
+    for (const schema of this.cache.values()) {
+      if (schema.identifier.kind === kind) {
+        results.push(schema);
+      }
+    }
+    return results;
+  }
+  /**
+   * Store multiple schemas
+   */
+  setMany(schemas) {
+    for (const schema of schemas) {
+      this.set(schema);
+    }
+  }
+  /**
+   * Clear all cached schemas
+   */
+  clear() {
+    this.cache.clear();
+  }
+  /**
+   * Generate cache key for identifier
+   */
+  generateKey(identifier) {
+    return `${identifier.package}:${identifier.version}:${identifier.kind}:${identifier.name}`;
+  }
+  /**
+   * Initialize cache directory if persistence is enabled
+   */
+  async initialize() {
+    if (this.config.enablePersistence && this.cacheDir) {
+      if (!existsSync(this.cacheDir)) {
+        mkdirSync(this.cacheDir, { recursive: true });
+      }
+      await this.loadFromDisk();
+    }
+  }
+  /**
+   * Load all cached schemas from disk
+   */
+  async loadFromDisk() {
+    if (!this.cacheDir || !existsSync(this.cacheDir)) {
+      return;
+    }
+    try {
+      const files = await readdir(this.cacheDir);
+      const schemaFiles = files.filter((f) => f.endsWith(".typeschema.json"));
+      for (const file of schemaFiles) {
+        const filePath = join(this.cacheDir, file);
+        const stats = await stat(filePath);
+        if (this.config.maxAge) {
+          const age = Date.now() - stats.mtimeMs;
+          if (age > this.config.maxAge) {
+            await unlink(filePath);
+            continue;
+          }
+        }
+        try {
+          const content = await readFile(filePath, "utf-8");
+          const metadata = JSON.parse(content);
+          if (this.config.validateCached) {
+            if (!metadata.schema?.identifier) {
+              continue;
+            }
+          }
+          const key = this.generateKey(metadata.schema.identifier);
+          this.cache.set(key, metadata.schema);
+        } catch (error) {
+          console.warn(`Failed to load cached schema from ${file}:`, error);
+        }
+      }
+    } catch (error) {
+      console.warn("Failed to load cached schemas from disk:", error);
+    }
+  }
+  /**
+   * Persist a schema to disk
+   */
+  async persistSchema(schema) {
+    if (!this.cacheDir) {
+      return;
+    }
+    if (!existsSync(this.cacheDir)) {
+      mkdirSync(this.cacheDir, { recursive: true });
+    }
+    const metadata = {
+      schema,
+      timestamp: Date.now(),
+      version: schema.identifier.version
+    };
+    const fileName = `${schema.identifier.package}-${schema.identifier.version}-${schema.identifier.kind}-${schema.identifier.name}.typeschema.json`.replace(
+      /[^a-zA-Z0-9.-]/g,
+      "_"
+    );
+    const filePath = join(this.cacheDir, fileName);
+    try {
+      await writeFile(filePath, JSON.stringify(metadata, null, 2), "utf-8");
+    } catch (error) {
+      console.warn(`Failed to persist schema to ${filePath}:`, error);
+    }
+  }
+  /**
+   * Clear cache directory
+   */
+  async clearDisk() {
+    if (!this.cacheDir || !existsSync(this.cacheDir)) {
+      return;
+    }
+    try {
+      const files = await readdir(this.cacheDir);
+      const schemaFiles = files.filter((f) => f.endsWith(".typeschema.json"));
+      for (const file of schemaFiles) {
+        await unlink(join(this.cacheDir, file));
+      }
+    } catch (error) {
+      console.warn("Failed to clear cache directory:", error);
+    }
+  }
+};
+var CodegenLogger = class _CodegenLogger {
+  options;
+  dryWarnSet = /* @__PURE__ */ new Set();
+  constructor(options = {}) {
+    this.options = {
+      timestamp: false,
+      verbose: false,
+      ...options
+    };
+  }
+  formatMessage(level, message, color) {
+    const timestamp = this.options.timestamp ? `${pc.gray((/* @__PURE__ */ new Date()).toLocaleTimeString())} ` : "";
+    const prefix = this.options.prefix ? `${pc.cyan(`[${this.options.prefix}]`)} ` : "";
+    return `${timestamp}${color(level)} ${prefix}${message}`;
+  }
+  /**
+   * Success message with checkmark
+   */
+  success(message) {
+    console.log(this.formatMessage("\u2705", message, pc.green));
+  }
+  /**
+   * Error message with X mark
+   */
+  error(message, error) {
+    console.error(this.formatMessage("\u274C", message, pc.red));
+    if (error && this.options.verbose) {
+      console.error(pc.red(`   ${error.message}`));
+      if (error.stack) {
+        console.error(pc.gray(error.stack));
+      }
+    }
+  }
+  /**
+   * Warning message with warning sign
+   */
+  warn(message) {
+    console.warn(this.formatMessage("!", message, pc.yellow));
   }
-  const localNestedTypeUrls = new Set(nestedTypes?.map((nt) => nt.identifier.url));
-  const result = Object.values(uniqDeps).filter((e) => !(e.kind === "nested" && localNestedTypeUrls.has(e.url))).sort((a, b) => a.url.localeCompare(b.url));
-  return result.length > 0 ? result : void 0;
-}
-function transformFhirSchemaResource(register, fhirSchema) {
-  const identifier = mkIdentifier(fhirSchema);
-  let base;
-  if (fhirSchema.base && fhirSchema.type !== "Element") {
-    const baseFs = register.resolveFs(register.ensureCanonicalUrl(fhirSchema.base));
-    if (!baseFs) {
-      throw new Error(`Base resource not found '${fhirSchema.base}' for '${fhirSchema.url}'`);
+  dry_warn(message) {
+    if (!this.dryWarnSet.has(message)) {
+      this.warn(message);
+      this.dryWarnSet.add(message);
     }
-    base = mkIdentifier(baseFs);
   }
-  const fields = mkFields(register, fhirSchema, [], fhirSchema.elements);
-  const nested = mkNestedTypes(register, fhirSchema);
-  const dependencies = extractDependencies(identifier, base, fields, nested);
-  const typeSchema = {
-    identifier,
-    base,
-    fields,
-    nested,
-    description: fhirSchema.description,
-    dependencies
-  };
-  const bindingSchemas = collectBindingSchemas(register, fhirSchema);
-  return [typeSchema, ...bindingSchemas];
-}
-async function transformFhirSchema(register, fhirSchema) {
-  const results = [];
-  const identifier = mkIdentifier(fhirSchema);
-  if (identifier.kind === "profile") {
-    const profileSchema = await transformProfile(register, fhirSchema);
-    results.push(profileSchema);
-    const bindingSchemas = collectBindingSchemas(register, fhirSchema);
-    results.push(...bindingSchemas);
-    return results;
+  /**
+   * Info message with info icon
+   */
+  info(message) {
+    console.log(this.formatMessage("i", message, pc.blue));
   }
-  if (isExtensionSchema(fhirSchema)) {
-    const extensionSchema = await transformExtension(fhirSchema, register, fhirSchema.package_meta);
-    if (extensionSchema) {
-      results.push(extensionSchema);
+  /**
+   * Debug message (only shows in verbose mode)
+   */
+  debug(message) {
+    if (this.options.verbose) {
+      console.log(this.formatMessage("\u{1F41B}", message, pc.magenta));
     }
-    return results;
   }
-  return transformFhirSchemaResource(register, fhirSchema);
+  /**
+   * Step message with rocket
+   */
+  step(message) {
+    console.log(this.formatMessage("\u{1F680}", message, pc.cyan));
+  }
+  /**
+   * Progress message with clock
+   */
+  progress(message) {
+    console.log(this.formatMessage("\u23F3", message, pc.blue));
+  }
+  /**
+   * Plain message (no icon, just colored text)
+   */
+  plain(message, color = (s) => s) {
+    const timestamp = this.options.timestamp ? `${pc.gray((/* @__PURE__ */ new Date()).toLocaleTimeString())} ` : "";
+    const prefix = this.options.prefix ? `${pc.cyan(`[${this.options.prefix}]`)} ` : "";
+    console.log(`${timestamp}${prefix}${color(message)}`);
+  }
+  /**
+   * Dimmed/gray text for less important info
+   */
+  dim(message) {
+    this.plain(message, pc.gray);
+  }
+  /**
+   * Create a child logger with a prefix
+   */
+  child(prefix) {
+    return new _CodegenLogger({
+      ...this.options,
+      prefix: this.options.prefix ? `${this.options.prefix}:${prefix}` : prefix
+    });
+  }
+  /**
+   * Update options
+   */
+  configure(options) {
+    this.options = { ...this.options, ...options };
+  }
+};
+new CodegenLogger();
+function createLogger(options = {}) {
+  return new CodegenLogger(options);
 }
 
 // src/typeschema/generator.ts
@@ -2578,12 +2606,12 @@ var TypeSchemaGenerator = class {
   }
   async registerFromPackageMetas(packageMetas) {
     const packageNames = packageMetas.map((meta) => `${meta.name}${meta.version}`);
-    this.logger.step(`Loading FHIR packages: ${packageNames.join(", ")}`);
+    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`);
+    this.logger?.progress(`Converting ${structureDefinitions.length} StructureDefinitions to FHIRSchemas`);
     const filteredStructureDefinitions = this.applyStructureDefinitionTreeshaking(structureDefinitions);
     const fhirSchemas = [];
     let convertedCount = 0;
@@ -2593,55 +2621,56 @@ var TypeSchemaGenerator = class {
         const fhirSchema = fhirschema.translate(sd);
         fhirSchemas.push(fhirSchema);
         convertedCount++;
-        this.logger.debug(`Converted StructureDefinition: ${sd.name || sd.id} (${sd.resourceType})`);
+        this.logger?.debug(`Converted StructureDefinition: ${sd.name || sd.id} (${sd.resourceType})`);
       } catch (error) {
         failedCount++;
-        this.logger.warn(
+        this.logger?.warn(
           `Failed to convert StructureDefinition ${sd.name || sd.id}: ${error instanceof Error ? error.message : String(error)}`
         );
       }
     }
-    this.logger.success(
+    this.logger?.success(
       `FHIR Schema conversion completed: ${convertedCount}/${filteredStructureDefinitions.length} successful, ${failedCount} failed`
     );
     return fhirSchemas;
   }
-  async generateValueSetSchemas(valueSets, _packageInfo) {
+  async generateValueSetSchemas(valueSets, logger) {
     if (valueSets.length > 0) {
-      this.logger.debug(`${valueSets.length} ValueSets available for enum extraction`);
+      this.logger?.debug(`${valueSets.length} ValueSets available for enum extraction`);
     }
+    const register = await registerFromManager(this.manager, logger);
     const valueSetSchemas = [];
     if (valueSets.length > 0) {
-      this.logger.progress(`Converting ${valueSets.length} ValueSets to TypeSchema`);
+      this.logger?.progress(`Converting ${valueSets.length} ValueSets to TypeSchema`);
       let valueSetConvertedCount = 0;
       let valueSetFailedCount = 0;
       for (const vs of valueSets) {
         try {
-          const valueSetSchema = await transformValueSet(await registerFromManager(this.manager), vs);
+          const valueSetSchema = await transformValueSet(register, vs, logger);
           if (valueSetSchema) {
             valueSetSchemas.push(valueSetSchema);
             valueSetConvertedCount++;
-            this.logger.debug(`Converted ValueSet: ${vs.name || vs.id}`);
+            this.logger?.debug(`Converted ValueSet: ${vs.name || vs.id}`);
           }
         } catch (error) {
           valueSetFailedCount++;
-          this.logger.warn(
+          this.logger?.warn(
             `Failed to convert ValueSet ${vs.name || vs.id}: ${error instanceof Error ? error.message : String(error)}`
           );
         }
       }
-      this.logger.success(
+      this.logger?.success(
         `ValueSet conversion completed: ${valueSetConvertedCount}/${valueSets.length} successful, ${valueSetFailedCount} failed`
       );
     }
     return valueSetSchemas;
   }
-  async generateFromPackage(packageName, packageVersion) {
+  async generateFromPackage(packageName, packageVersion, logger) {
     await this.initializeCache();
     if (this.cache && !(this.cacheConfig?.forceRegenerate ?? false)) {
       const cachedSchemas = this.cache.getByPackage(packageName);
       if (cachedSchemas.length > 0) {
-        this.logger.info(
+        this.logger?.info(
           `Using cached TypeSchemas for package: ${packageName} (${cachedSchemas.length} schemas)`
         );
         return cachedSchemas;
@@ -2652,10 +2681,9 @@ var TypeSchemaGenerator = class {
       version: packageVersion || "latest"
     };
     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)
-    ];
+    const valueSets = await this.generateValueSetSchemas(register.allVs(), logger);
+    const fhirSchemas = (await Promise.all(register.allFs().map(async (fs2) => await transformFhirSchema(register, fs2, logger)))).flat();
+    const allSchemas = [...fhirSchemas, ...valueSets];
     if (this.cache) {
       for (const schema of allSchemas) {
         await this.cache.set(schema);
@@ -2672,7 +2700,7 @@ var TypeSchemaGenerator = class {
     if (!treeshakeList || treeshakeList.length === 0) {
       return structureDefinitions;
     }
-    this.logger.info(`Applying treeshaking filter for ResourceTypes: ${treeshakeList.join(", ")}`);
+    this.logger?.info(`Applying treeshaking filter for ResourceTypes: ${treeshakeList.join(", ")}`);
     const allStructureDefinitions = /* @__PURE__ */ new Map();
     const realDependencies = /* @__PURE__ */ new Map();
     const referenceTargets = /* @__PURE__ */ new Map();
@@ -2696,7 +2724,7 @@ var TypeSchemaGenerator = class {
       if (allStructureDefinitions.has(resourceType)) {
         structureDefinitionsToKeep.add(resourceType);
       } else {
-        this.logger.warn(`ResourceType '${resourceType}' not found in structure definitions`);
+        this.logger?.warn(`ResourceType '${resourceType}' not found in structure definitions`);
       }
     }
     const addRealDependenciesRecursively = (name, visited = /* @__PURE__ */ new Set()) => {
@@ -2732,9 +2760,9 @@ var TypeSchemaGenerator = class {
       }
     }
     if (excludedReferenceTargets.size > 0) {
-      this.logger.info(`Excluded reference-only targets: ${Array.from(excludedReferenceTargets).join(", ")}`);
+      this.logger?.info(`Excluded reference-only targets: ${Array.from(excludedReferenceTargets).join(", ")}`);
     }
-    this.logger.success(
+    this.logger?.success(
       `Treeshaking completed: kept ${filteredStructureDefinitions.length}/${structureDefinitions.length} structure definitions`
     );
     return filteredStructureDefinitions;
@@ -3022,6 +3050,18 @@ var TypeSchemaParser = class {
   }
 };
 
+// src/typeschema/index.ts
+var generateTypeSchemas = async (register, logger) => {
+  const fhirSchemas = [];
+  for (const fhirSchema of register.allFs()) {
+    fhirSchemas.push(...await transformFhirSchema(register, fhirSchema, logger));
+  }
+  for (const vsSchema of register.allVs()) {
+    fhirSchemas.push(await transformValueSet(register, vsSchema));
+  }
+  return fhirSchemas;
+};
+
 // src/api/generators/base/error-handler.ts
 init_errors();
 var ErrorHandler = class {
@@ -5046,26 +5086,456 @@ ${nestedInterfaces}`;
   }
 };
 
+// src/api/writer-generator/utils.ts
+var words = (s) => {
+  return s.split(/(?<=[a-z])(?=[A-Z])|[-_.\s]/).filter(Boolean);
+};
+var kebabCase = (s) => {
+  return words(s).map((s2) => s2.toLowerCase()).join("-");
+};
+var capitalCase = (s) => {
+  if (s.length === 0) throw new Error("Empty string");
+  return s[0]?.toUpperCase() + s.substring(1).toLowerCase();
+};
+var pascalCase = (s) => {
+  return words(s).map(capitalCase).join("");
+};
+var uppercaseFirstLetter = (str) => {
+  if (!str || str.length === 0) return str;
+  return str.charAt(0).toUpperCase() + str.slice(1);
+};
+var uppercaseFirstLetterOfEach = (strings) => {
+  return strings.map((str) => uppercaseFirstLetter(str));
+};
+var FileSystemWriter = class {
+  opts;
+  currentDir;
+  currentFileDescriptor;
+  writtenFilesSet = /* @__PURE__ */ new Set();
+  constructor(opts) {
+    this.opts = opts;
+    this.currentDir = opts.outputDir;
+  }
+  logger() {
+    return this.opts.logger;
+  }
+  cd(path, gen) {
+    this.currentDir = path.startsWith("/") ? Path2.join(this.opts.outputDir, path) : Path2.join(this.currentDir, path);
+    if (!fs.existsSync(this.currentDir)) {
+      fs.mkdirSync(this.currentDir, { recursive: true });
+    }
+    this.logger()?.debug(`cd '${this.currentDir}'`);
+    gen();
+  }
+  cat(fn, gen) {
+    if (this.currentFileDescriptor) throw new Error("Can't open file in file");
+    if (fn.includes("/")) throw new Error(`Change file path separatly: ${fn}`);
+    const fullFn = `${this.currentDir}/${fn}`;
+    try {
+      this.currentFileDescriptor = fs.openSync(fullFn, "w");
+      this.writtenFilesSet.add(fn);
+      this.logger()?.debug(`cat > '${fullFn}'`);
+      gen();
+    } finally {
+      if (this.currentFileDescriptor) {
+        fs.closeSync(this.currentFileDescriptor);
+      }
+      this.currentFileDescriptor = void 0;
+    }
+  }
+  write(str) {
+    if (!this.currentFileDescriptor) throw new Error("No file opened");
+    fs.writeSync(this.currentFileDescriptor, str);
+  }
+  generate(_schemas) {
+    throw new Error("Not implemented");
+  }
+  writtenFiles() {
+    return Array.from(this.writtenFilesSet);
+  }
+};
+var Writer = class extends FileSystemWriter {
+  currentIndent = 0;
+  indent() {
+    this.currentIndent += this.opts.tabSize;
+  }
+  deindent() {
+    this.currentIndent -= this.opts.tabSize;
+  }
+  writeIndent() {
+    this.write(" ".repeat(this.currentIndent));
+  }
+  line(...tokens) {
+    this.writeIndent();
+    this.write(`${tokens.join(" ")}
+`);
+  }
+  lineSM(...tokens) {
+    this.writeIndent();
+    this.write(`${tokens.join(" ")};
+`);
+  }
+  comment(...tokens) {
+    const lines = tokens.join(" ").split("\n");
+    for (const line of lines) {
+      this.line(this.opts.commentLinePrefix, line);
+    }
+  }
+  debugComment(...tokens) {
+    if (this.opts.withDebugComment) {
+      tokens = tokens.map((token) => {
+        if (typeof token === "string") {
+          return token;
+        } else {
+          return JSON.stringify(token, null, 2);
+        }
+      });
+      this.comment(...tokens);
+    }
+  }
+  disclaimer() {
+    return [
+      "WARNING: This file is autogenerated by FHIR Schema Codegen.",
+      "https://github.com/fhir-schema/fhir-schema-codegen",
+      "Any manual changes made to this file may be overwritten."
+    ];
+  }
+  generateDisclaimer() {
+    this.disclaimer().forEach((e) => this.comment(e));
+    this.line();
+  }
+  curlyBlock(tokens, gencontent, endTokens) {
+    this.line(`${tokens.filter(Boolean).join(" ")} {`);
+    this.indent();
+    gencontent();
+    this.deindent();
+    this.line(`}${endTokens?.filter(Boolean).join(" ") ?? ""}`);
+  }
+  squareBlock(tokens, gencontent, endTokens) {
+    this.line(`${tokens.filter(Boolean).join(" ")} [`);
+    this.indent();
+    gencontent();
+    this.deindent();
+    this.line(`]${endTokens?.filter(Boolean).join(" ") ?? ""}`);
+  }
+};
+
+// src/typeschema/utils.ts
+var groupByPackages = (typeSchemas) => {
+  const grouped = {};
+  for (const ts of typeSchemas) {
+    const packageName = ts.identifier.package;
+    if (!grouped[packageName]) {
+      grouped[packageName] = [];
+    }
+    grouped[packageName].push(ts);
+  }
+  for (const [_packageName, typeSchemas2] of Object.entries(grouped)) {
+    typeSchemas2.sort((a, b) => a.identifier.name.localeCompare(b.identifier.name));
+  }
+  return grouped;
+};
+var collectComplexTypes = (tss) => tss.filter((t) => t.identifier.kind === "complex-type");
+var collectResources = (tss) => tss.filter((t) => t.identifier.kind === "resource");
+var notChoiceDeclaration = (field) => {
+  if (field.choices) return void 0;
+  if (field.choiceOf) return field;
+  return field;
+};
+var resourceRelatives = (schemas) => {
+  const regularSchemas = collectResources(schemas);
+  const directPairs = [];
+  for (const schema of regularSchemas) {
+    if (schema.base) {
+      directPairs.push({ parent: schema.base, child: schema.identifier });
+    }
+  }
+  const allPairs = [...directPairs];
+  const findTransitiveRelatives = (parentRef) => {
+    const directChildren = directPairs.filter((pair) => pair.parent.name === parentRef.name).map((pair) => pair.child);
+    const transitiveChildren = [];
+    for (const child of directChildren) {
+      transitiveChildren.push(...findTransitiveRelatives(child));
+    }
+    return [...directChildren, ...transitiveChildren];
+  };
+  for (const pair of directPairs) {
+    const transitiveChildren = findTransitiveRelatives(pair.child);
+    for (const transitiveChild of transitiveChildren) {
+      if (!directPairs.some((dp) => dp.parent.name === pair.parent.name && dp.child.name === transitiveChild.name)) {
+        allPairs.push({ parent: pair.parent, child: transitiveChild });
+      }
+    }
+  }
+  return allPairs;
+};
+var resourceChildren = (relatives, id) => {
+  return relatives.filter((relative2) => relative2.parent.name === id.name).map((relative2) => relative2.child);
+};
+
+// src/api/writer-generator/typescript.ts
+var primitiveType2tsType = {
+  boolean: "boolean",
+  instant: "string",
+  time: "string",
+  date: "string",
+  dateTime: "string",
+  decimal: "number",
+  integer: "number",
+  unsignedInt: "number",
+  positiveInt: "number",
+  integer64: "number",
+  base64Binary: "string",
+  uri: "string",
+  url: "string",
+  canonical: "string",
+  oid: "string",
+  uuid: "string",
+  string: "string",
+  code: "string",
+  markdown: "string",
+  id: "string",
+  xhtml: "string"
+};
+var canonicalToName = (canonical, dropFragment = true) => {
+  if (!canonical) return void 0;
+  let localName = canonical.split("/").pop();
+  if (dropFragment && localName?.includes("#")) {
+    localName = localName.split("#")[0];
+  }
+  if (/^\d/.test(localName ?? "")) {
+    localName = `number_${localName}`;
+  }
+  return localName?.replace(/[- ]/g, "_");
+};
+var tsBaseFileName = (id) => {
+  return pascalCase(id.name);
+};
+var tsFileName = (id) => {
+  return `${tsBaseFileName(id)}.ts`;
+};
+var normalizeName = (n) => {
+  if (n === "extends") {
+    return "extends_";
+  }
+  return n.replace(/[- ]/g, "_");
+};
+var resourceName = (id) => {
+  return normalizeName(id.name);
+};
+var deriveNestedSchemaName = (url) => {
+  const path = canonicalToName(url, false);
+  if (!path) {
+    return "";
+  }
+  const [resourceName2, fragment] = path.split("#");
+  const name = uppercaseFirstLetterOfEach((fragment ?? "").split(".")).join("");
+  return [resourceName2, name].join("");
+};
+var TypeScript = class extends Writer {
+  resourceRelatives = [];
+  tsImport(tsPackageName, ...entities) {
+    this.lineSM(`import { ${entities.join(", ")} } from '${tsPackageName}'`);
+  }
+  generateFhirPackageIndexFile(schemas) {
+    this.cat("index.ts", () => {
+      let exports = schemas.map((schema) => ({
+        identifier: schema.identifier,
+        tsPackageName: tsBaseFileName(schema.identifier),
+        resourceName: resourceName(schema.identifier)
+      })).sort((a, b) => a.resourceName.localeCompare(b.resourceName));
+      exports = Array.from(new Map(exports.map((exp) => [exp.resourceName.toLowerCase(), exp])).values()).sort(
+        (a, b) => a.resourceName.localeCompare(b.resourceName)
+      );
+      for (const exp of exports) {
+        this.debugComment(exp.identifier);
+        this.tsImport(`./${exp.tsPackageName}`, exp.resourceName);
+      }
+      this.lineSM(`export { ${exports.map((e) => e.resourceName).join(", ")} }`);
+      this.line("");
+      this.curlyBlock(["export type ResourceTypeMap = "], () => {
+        this.lineSM("User: Record<string, any>");
+        exports.forEach((exp) => {
+          this.debugComment(exp.identifier);
+          this.lineSM(`${exp.resourceName}: ${exp.resourceName}`);
+        });
+      });
+      this.lineSM("export type ResourceType = keyof ResourceTypeMap");
+      this.squareBlock(["export const resourceList: readonly ResourceType[] = "], () => {
+        exports.forEach((exp) => {
+          this.debugComment(exp.identifier);
+          this.line(`'${exp.resourceName}', `);
+        });
+      });
+    });
+  }
+  generateDependenciesImports(schema) {
+    if (schema.dependencies) {
+      const deps = [
+        ...schema.dependencies.filter((dep) => ["complex-type", "resource", "logical"].includes(dep.kind)).map((dep) => ({
+          tsPackage: `../${kebabCase(dep.package)}/${pascalCase(dep.name)}`,
+          name: uppercaseFirstLetter(dep.name)
+        })),
+        ...schema.dependencies.filter((dep) => ["nested"].includes(dep.kind)).map((dep) => ({
+          tsPackage: `../${kebabCase(dep.package)}/${pascalCase(canonicalToName(dep.url) ?? "")}`,
+          name: deriveNestedSchemaName(dep.url)
+        }))
+      ].sort((a, b) => a.name.localeCompare(b.name));
+      for (const dep of deps) {
+        this.tsImport(dep.tsPackage, dep.name);
+      }
+    }
+  }
+  addFieldExtension(fieldName, field) {
+    if (field.type.kind === "primitive-type") {
+      this.lineSM(`_${normalizeName(fieldName)}?: Element`);
+    }
+  }
+  generateType(schema) {
+    var name;
+    if (schema.identifier.name === "Reference") {
+      name = "Reference<T extends string = string>";
+    } else if (schema.identifier.kind === "nested") {
+      name = normalizeName(deriveNestedSchemaName(schema.identifier.url));
+    } else {
+      name = normalizeName(schema.identifier.name);
+    }
+    const parent = canonicalToName(schema.base?.url);
+    const extendsClause = parent && `extends ${parent}`;
+    this.debugComment(schema.identifier);
+    this.curlyBlock(["export", "interface", name, extendsClause], () => {
+      if (!schema.fields) {
+        return;
+      }
+      if (schema.identifier.kind === "resource") {
+        const possibleResourceTypes = [schema.identifier];
+        possibleResourceTypes.push(...resourceChildren(this.resourceRelatives, schema.identifier));
+        this.lineSM(`resourceType: ${possibleResourceTypes.map((e) => `'${e.name}'`).join(" | ")}`);
+        this.line();
+      }
+      const fields = Object.entries(schema.fields).sort((a, b) => a[0].localeCompare(b[0]));
+      for (const [fieldName, anyField] of fields) {
+        const field = notChoiceDeclaration(anyField);
+        if (field === void 0) continue;
+        this.debugComment(fieldName, ":", field);
+        const fieldNameFixed = normalizeName(fieldName);
+        const optionalSymbol = field.required ? "" : "?";
+        const arraySymbol = field.array ? "[]" : "";
+        if (field.type === void 0) {
+          continue;
+        }
+        let type = field.type.name;
+        if (field.type.kind === "nested") {
+          type = deriveNestedSchemaName(field.type.url);
+        }
+        if (field.type.kind === "primitive-type") {
+          type = primitiveType2tsType[field.type.name] ?? "string";
+        }
+        if (schema.identifier.name === "Reference" && fieldNameFixed === "reference") {
+          type = "`${T}/${string}`";
+        }
+        if (field.reference?.length) {
+          const references = field.reference.map((ref) => `'${ref.name}'`).join(" | ");
+          type = `Reference<${references}>`;
+        }
+        if (field.enum) {
+          type = field.enum.map((e) => `'${e}'`).join(" | ");
+        }
+        this.lineSM(`${fieldNameFixed}${optionalSymbol}:`, `${type}${arraySymbol}`);
+        if (["resource", "complex-type"].includes(schema.identifier.kind)) {
+          this.addFieldExtension(fieldName, field);
+        }
+      }
+    });
+    this.line();
+  }
+  generateNestedTypes(schema) {
+    if (schema.nested) {
+      this.line();
+      for (const subtype of schema.nested) {
+        this.generateType(subtype);
+      }
+    }
+  }
+  generateResourceModule(schema) {
+    this.cat(`${tsFileName(schema.identifier)}`, () => {
+      this.generateDisclaimer();
+      if (["complex-type", "resource", "logical", "nested"].includes(schema.identifier.kind)) {
+        this.generateDependenciesImports(schema);
+        this.line();
+        this.generateNestedTypes(schema);
+        this.generateType(schema);
+      } else {
+        throw new Error(`Profile generation not implemented for kind: ${schema.identifier.kind}`);
+      }
+    });
+  }
+  generate(schemas) {
+    this.resourceRelatives = resourceRelatives(schemas);
+    const typesToGenerate = [
+      ...collectComplexTypes(schemas),
+      ...collectResources(schemas)
+      // ...collectLogicalModels(typeSchemas),
+      // ...collectProfiles(typeSchemas),
+    ];
+    const grouped = groupByPackages(typesToGenerate);
+    this.cd("/", () => {
+      for (const [packageName, packageSchemas] of Object.entries(grouped)) {
+        const tsPackageName = kebabCase(packageName);
+        this.cd(tsPackageName, () => {
+          for (const schema of packageSchemas) {
+            this.generateResourceModule(schema);
+          }
+          this.generateFhirPackageIndexFile(packageSchemas);
+        });
+      }
+    });
+  }
+};
+
 // src/api/builder.ts
+var writerToGenerator = (writerGen) => {
+  const getGeneratedFiles = () => {
+    return writerGen.writtenFiles().map((fn) => {
+      return {
+        path: Path2.normalize(Path2.join(writerGen.opts.outputDir, fn)),
+        filename: fn.replace(/^.*[\\/]/, ""),
+        content: "",
+        exports: [],
+        size: 0,
+        timestamp: /* @__PURE__ */ new Date()
+      };
+    });
+  };
+  return {
+    generate: async (schemas) => {
+      writerGen.generate(schemas);
+      return getGeneratedFiles();
+    },
+    setOutputDir: (outputDir) => writerGen.opts.outputDir = outputDir,
+    build: async (_schemas) => getGeneratedFiles()
+  };
+};
 var APIBuilder = class {
   schemas = [];
   options;
   generators = /* @__PURE__ */ new Map();
-  progressCallback;
   cache;
   pendingOperations = [];
   typeSchemaGenerator;
   logger;
+  packages = [];
+  progressCallback;
   typeSchemaConfig;
   constructor(options = {}) {
     this.options = {
       outputDir: options.outputDir || "./generated",
       verbose: options.verbose ?? false,
       overwrite: options.overwrite ?? true,
-      validate: options.validate ?? true,
       cache: options.cache ?? true,
       typeSchemaConfig: options.typeSchemaConfig,
-      manager: options.manager || null
+      manager: options.manager || null,
+      throwException: options.throwException || false
     };
     this.typeSchemaConfig = options.typeSchemaConfig;
     this.logger = options.logger || createLogger({
@@ -5076,13 +5546,8 @@ var APIBuilder = class {
       this.cache = new TypeSchemaCache(this.typeSchemaConfig);
     }
   }
-  /**
-   * Load TypeSchema from a FHIR package
-   */
   fromPackage(packageName, version) {
-    this.logger.debug(`Loading from FHIR package: ${packageName}@${version || "latest"}`);
-    const operation = this.loadFromPackage(packageName, version);
-    this.pendingOperations.push(operation);
+    this.packages.push(packageMetaToNpm({ name: packageName, version: version || "latest" }));
     return this;
   }
   /**
@@ -5102,9 +5567,6 @@ var APIBuilder = class {
     this.schemas = [...this.schemas, ...schemas];
     return this;
   }
-  /**
-   * Configure TypeScript generation
-   */
   typescript(options = {}) {
     const typesOutputDir = `${this.options.outputDir}/types`;
     const generator = new TypeScriptGenerator({
@@ -5130,6 +5592,19 @@ var APIBuilder = class {
     this.logger.debug(`Configured TypeScript generator (${options.moduleFormat || "esm"})`);
     return this;
   }
+  typescript2(opts) {
+    const writerOpts = {
+      outputDir: Path2.join(this.options.outputDir, "/types"),
+      tabSize: 2,
+      withDebugComment: false,
+      commentLinePrefix: "//"
+    };
+    const effectiveOpts = { logger: this.logger, ...writerOpts, ...opts };
+    const generator = writerToGenerator(new TypeScript(effectiveOpts));
+    this.generators.set("typescript2", generator);
+    this.logger.debug(`Configured TypeScript2 generator (${JSON.stringify(effectiveOpts, void 0, 2)})`);
+    return this;
+  }
   /**
    * Set a progress callback for monitoring generation
    */
@@ -5150,23 +5625,15 @@ var APIBuilder = class {
     }
     return this;
   }
-  /**
-   * Enable/disable verbose logging
-   */
   verbose(enabled = true) {
     this.options.verbose = enabled;
+    this.logger?.configure({ verbose: enabled });
     return this;
   }
-  /**
-   * Enable/disable validation
-   */
-  validate(enabled = true) {
-    this.options.validate = enabled;
+  throwException(enabled = true) {
+    this.options.throwException = enabled;
     return this;
   }
-  /**
-   * Execute the generation process
-   */
   async generate() {
     const startTime = performance.now();
     const result = {
@@ -5179,35 +5646,33 @@ var APIBuilder = class {
     };
     this.logger.debug(`Starting generation with ${this.generators.size} generators`);
     try {
-      this.reportProgress("Loading", 0, 4, "Loading TypeSchema data...");
-      await this.resolveSchemas();
-      this.logger.debug(`Resolved ${this.schemas.length} schemas`);
-      this.reportProgress("Validating", 1, 4, "Validating TypeSchema documents...");
-      if (this.options.validate) {
-        this.logger.debug("Starting schema validation");
-        await this.validateSchemas(result);
-        this.logger.debug("Schema validation completed");
-      }
-      this.reportProgress("Generating", 2, 4, "Generating code...");
+      this.logger.info("Initialize Canonical Manager");
+      const manager = CanonicalManager({
+        packages: this.packages,
+        workingDir: "tmp/fhir"
+      });
+      await manager.init();
+      const register = await registerFromManager(manager, this.logger);
+      const typeSchemas = await generateTypeSchemas(register, this.logger);
       this.logger.debug(`Executing ${this.generators.size} generators`);
-      await this.executeGenerators(result);
-      this.reportProgress("Complete", 4, 4, "Generation completed successfully");
+      await this.executeGenerators(result, typeSchemas);
+      this.logger.info("Generation completed successfully");
       result.success = result.errors.length === 0;
       this.logger.debug(`Generation completed: ${result.filesGenerated.length} files`);
     } catch (error) {
       this.logger.error("Code generation failed", error instanceof Error ? error : new Error(String(error)));
       result.errors.push(error instanceof Error ? error.message : String(error));
-      result.success = false;
-    } finally {
-      result.duration = performance.now() - startTime;
     }
-    return result;
+    return {
+      ...result,
+      success: result.errors.length === 0,
+      duration: performance.now() - startTime
+    };
   }
   /**
    * Generate and return the results without writing to files
    */
   async build() {
-    await this.resolveSchemas();
     const results = {};
     for (const [type, generator] of this.generators.entries()) {
       if (generator.build) {
@@ -5237,24 +5702,6 @@ var APIBuilder = class {
   getGenerators() {
     return Array.from(this.generators.keys());
   }
-  // Private implementation methods
-  async loadFromPackage(packageName, version) {
-    const generator = new TypeSchemaGenerator(
-      {
-        verbose: this.options.verbose,
-        logger: this.logger.child("Schema"),
-        treeshake: this.typeSchemaConfig?.treeshake,
-        manager: this.options.manager
-      },
-      this.typeSchemaConfig
-    );
-    this.typeSchemaGenerator = generator;
-    const schemas = await generator.generateFromPackage(packageName, version);
-    this.schemas = [...this.schemas, ...schemas];
-    if (this.cache) {
-      this.cache.setMany(schemas);
-    }
-  }
   async loadFromFiles(filePaths) {
     if (!this.typeSchemaGenerator) {
       this.typeSchemaGenerator = new TypeSchemaGenerator(
@@ -5267,8 +5714,7 @@ var APIBuilder = class {
       );
     }
     const parser = new TypeSchemaParser({
-      format: "auto",
-      validate: this.options.validate
+      format: "auto"
     });
     const schemas = await parser.parseFromFiles(filePaths);
     this.schemas = [...this.schemas, ...schemas];
@@ -5276,37 +5722,18 @@ var APIBuilder = class {
       this.cache.setMany(schemas);
     }
   }
-  async resolveSchemas() {
-    if (this.pendingOperations.length > 0) {
-      await Promise.all(this.pendingOperations);
-      this.pendingOperations = [];
-    }
-  }
-  async validateSchemas(_result) {
-    return;
-  }
-  async executeGenerators(result) {
-    const generatorCount = this.generators.size;
-    let current = 0;
+  async executeGenerators(result, typeSchemas) {
     for (const [type, generator] of this.generators.entries()) {
-      this.reportProgress("Generating", 2 + current / generatorCount, 4, `Generating ${type}...`);
+      this.logger.info(`Generating ${type}...`);
       try {
-        const files = await generator.generate(this.schemas);
+        const files = await generator.generate(typeSchemas);
         result.filesGenerated.push(...files.map((f) => f.path || f.filename));
+        this.logger.info(`Generating ${type} finished successfully`);
       } catch (error) {
         result.errors.push(
           `${type} generator failed: ${error instanceof Error ? error.message : String(error)}`
         );
       }
-      current++;
-    }
-  }
-  reportProgress(phase, current, total, message) {
-    if (this.progressCallback) {
-      this.progressCallback(phase, current, total, message);
-    }
-    if (this.options.verbose && message) {
-      this.logger.debug(`[${phase}] ${message}`);
     }
   }
 };
@@ -5318,7 +5745,6 @@ function createAPIFromConfig(config) {
     outputDir: config.outputDir,
     verbose: config.verbose,
     overwrite: config.overwrite,
-    validate: config.validate,
     cache: config.cache,
     typeSchemaConfig: config.typeSchema
   });
@@ -5338,15 +5764,13 @@ function createAPIFromConfig(config) {
 async function generateTypesFromPackage(packageName, outputDir, options = {}) {
   return createAPI({
     outputDir,
-    verbose: options.verbose,
-    validate: options.validate
+    verbose: options.verbose
   }).fromPackage(packageName, options.version).typescript().generate();
 }
 async function generateTypesFromFiles(inputFiles, outputDir, options = {}) {
   return createAPI({
     outputDir,
-    verbose: options.verbose,
-    validate: options.validate
+    verbose: options.verbose
   }).fromFiles(...inputFiles).typescript().generate();
 }
 var DEFAULT_CONFIG = {