@atomic-ehr/codegen 0.0.1-canary.20250808231821.ab61009

package/dist/index.js

@@ -0,0 +1,4008 @@
+// src/typeschema/cache.ts
+import { existsSync, mkdirSync } from "node:fs";
+import { readdir, readFile, stat, unlink, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+
+class TypeSchemaCache {
+  cache = new Map;
+  config;
+  cacheDir;
+  constructor(config) {
+    this.config = {
+      enablePersistence: true,
+      cacheDir: ".typeschema-cache",
+      maxAge: 24 * 60 * 60 * 1000,
+      validateCached: true,
+      ...config
+    };
+    if (this.config.enablePersistence && this.config.cacheDir) {
+      this.cacheDir = this.config.cacheDir;
+    }
+  }
+  async set(schema) {
+    const key = this.generateKey(schema.identifier);
+    this.cache.set(key, schema);
+    if (this.config.enablePersistence && this.cacheDir) {
+      await this.persistSchema(schema);
+    }
+  }
+  get(identifier) {
+    const key = this.generateKey(identifier);
+    return this.cache.get(key) || null;
+  }
+  getByUrl(url) {
+    for (const schema of this.cache.values()) {
+      if (schema.identifier.url === url) {
+        return schema;
+      }
+    }
+    return null;
+  }
+  has(identifier) {
+    const key = this.generateKey(identifier);
+    return this.cache.has(key);
+  }
+  hasByUrl(url) {
+    for (const schema of this.cache.values()) {
+      if (schema.identifier.url === url) {
+        return true;
+      }
+    }
+    return false;
+  }
+  delete(identifier) {
+    const key = this.generateKey(identifier);
+    return this.cache.delete(key);
+  }
+  deleteByUrl(url) {
+    for (const [key, schema] of this.cache.entries()) {
+      if (schema.identifier.url === url) {
+        return this.cache.delete(key);
+      }
+    }
+    return false;
+  }
+  getByPackage(packageName) {
+    const results = [];
+    for (const schema of this.cache.values()) {
+      if (schema.identifier.package === packageName) {
+        results.push(schema);
+      }
+    }
+    return results;
+  }
+  getByKind(kind) {
+    const results = [];
+    for (const schema of this.cache.values()) {
+      if (schema.identifier.kind === kind) {
+        results.push(schema);
+      }
+    }
+    return results;
+  }
+  setMany(schemas) {
+    for (const schema of schemas) {
+      this.set(schema);
+    }
+  }
+  clear() {
+    this.cache.clear();
+  }
+  generateKey(identifier) {
+    return `${identifier.package}:${identifier.version}:${identifier.kind}:${identifier.name}`;
+  }
+  async initialize() {
+    if (this.config.enablePersistence && this.cacheDir) {
+      if (!existsSync(this.cacheDir)) {
+        mkdirSync(this.cacheDir, { recursive: true });
+      }
+      await this.loadFromDisk();
+    }
+  }
+  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);
+    }
+  }
+  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);
+    }
+  }
+  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);
+    }
+  }
+}
+// node_modules/@atomic-ehr/fhir-canonical-manager/dist/reference/store.js
+import { createHash } from "crypto";
+var generateReferenceId = (metadata) => {
+  const input = `${metadata.packageName}@${metadata.packageVersion}:${metadata.filePath}`;
+  return createHash("sha256").update(input).digest("base64url");
+};
+// node_modules/@atomic-ehr/fhir-canonical-manager/dist/reference/manager.js
+var createReferenceManager = () => {
+  const references = {};
+  const urlToIds = {};
+  const set = (id, metadata) => {
+    references[id] = metadata;
+    if (metadata.url) {
+      if (!urlToIds[metadata.url]) {
+        urlToIds[metadata.url] = [];
+      }
+      const ids = urlToIds[metadata.url];
+      if (ids && !ids.includes(id)) {
+        ids.push(id);
+      }
+    }
+  };
+  const clear = () => {
+    Object.keys(references).forEach((key) => delete references[key]);
+    Object.keys(urlToIds).forEach((key) => delete urlToIds[key]);
+  };
+  return {
+    generateId: generateReferenceId,
+    get: (id) => references[id],
+    set,
+    has: (id) => (id in references),
+    clear,
+    size: () => Object.keys(references).length,
+    getIdsByUrl: (url) => urlToIds[url] || [],
+    createReference: (id, metadata) => ({
+      id,
+      resourceType: metadata.resourceType
+    }),
+    getAllReferences: () => references
+  };
+};
+// node_modules/@atomic-ehr/fhir-canonical-manager/dist/manager/canonical.js
+import * as path8 from "path";
+import * as fs8 from "fs/promises";
+
+// node_modules/@atomic-ehr/fhir-canonical-manager/dist/constants.js
+var DEFAULT_REGISTRY = "https://fs.get-ig.org/pkgs/";
+
+// node_modules/@atomic-ehr/fhir-canonical-manager/dist/fs/utils.js
+import * as fs from "fs/promises";
+import * as path from "path";
+var fileExists = async (filePath) => {
+  try {
+    await fs.access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+};
+var ensureDir = async (dirPath) => {
+  try {
+    await fs.mkdir(dirPath, { recursive: true });
+  } catch {}
+};
+var isFhirPackage = async (dirPath) => {
+  const indexPath = path.join(dirPath, ".index.json");
+  return fileExists(indexPath);
+};
+// node_modules/@atomic-ehr/fhir-canonical-manager/dist/package/detector.js
+import { exec } from "child_process";
+import { promisify } from "util";
+var execAsync = promisify(exec);
+async function detectPackageManager() {
+  try {
+    await execAsync("bun --version");
+    return "bun";
+  } catch {
+    try {
+      await execAsync("npm --version");
+      return "npm";
+    } catch {
+      return null;
+    }
+  }
+}
+// node_modules/@atomic-ehr/fhir-canonical-manager/dist/package/installer.js
+import * as fs2 from "fs/promises";
+import * as path2 from "path";
+import { exec as exec2 } from "child_process";
+import { promisify as promisify2 } from "util";
+var execAsync2 = promisify2(exec2);
+var installPackages = async (packages, workingDir, registry) => {
+  await ensureDir(workingDir);
+  const packageJsonPath = path2.join(workingDir, "package.json");
+  if (!await fileExists(packageJsonPath)) {
+    const minimalPackageJson = {
+      name: "fhir-canonical-manager-workspace",
+      version: "1.0.0",
+      private: true,
+      dependencies: {}
+    };
+    await fs2.writeFile(packageJsonPath, JSON.stringify(minimalPackageJson, null, 2));
+  }
+  const packageManager = await detectPackageManager();
+  if (!packageManager) {
+    throw new Error("No package manager found. Please install npm or bun.");
+  }
+  for (const pkg of packages) {
+    try {
+      if (packageManager === "bun") {
+        const env = {
+          ...process.env,
+          HOME: workingDir,
+          NPM_CONFIG_USERCONFIG: "/dev/null"
+        };
+        const cmd = registry ? `cd ${workingDir} && bun add ${pkg} --registry ${registry}` : `cd ${workingDir} && bun add ${pkg}`;
+        await execAsync2(cmd, {
+          env,
+          maxBuffer: 10 * 1024 * 1024
+        });
+      } else {
+        const cmd = registry ? `cd ${workingDir} && npm add ${pkg} --registry ${registry}` : `cd ${workingDir} && npm add ${pkg}`;
+        await execAsync2(cmd, {
+          maxBuffer: 10 * 1024 * 1024
+        });
+      }
+    } catch (err) {
+      console.error(`Failed to install package ${pkg}:`, err);
+      throw err;
+    }
+  }
+};
+// node_modules/@atomic-ehr/fhir-canonical-manager/dist/cache/core.js
+var createCache = () => {
+  const referenceManager = createReferenceManager();
+  return {
+    entries: {},
+    packages: {},
+    references: {},
+    referenceManager
+  };
+};
+// node_modules/@atomic-ehr/fhir-canonical-manager/dist/cache/persistence.js
+import * as fs4 from "fs/promises";
+import * as path4 from "path";
+
+// node_modules/@atomic-ehr/fhir-canonical-manager/dist/cache/validation.js
+import * as fs3 from "fs/promises";
+import * as path3 from "path";
+import { createHash as createHash2 } from "crypto";
+var computePackageLockHash = async (workingDir) => {
+  try {
+    const packageLockPath = path3.join(workingDir, "package-lock.json");
+    try {
+      const content = await fs3.readFile(packageLockPath, "utf-8");
+      return createHash2("sha256").update(content).digest("hex");
+    } catch {
+      const bunLockPath = path3.join(workingDir, "bun.lock");
+      const content = await fs3.readFile(bunLockPath, "utf-8");
+      return createHash2("sha256").update(content).digest("hex");
+    }
+  } catch {
+    return null;
+  }
+};
+
+// node_modules/@atomic-ehr/fhir-canonical-manager/dist/cache/persistence.js
+var saveCacheToDisk = async (cache, cacheDir, workingDir) => {
+  const packageLockHash = await computePackageLockHash(workingDir);
+  const cacheData = {
+    entries: cache.entries,
+    packages: cache.packages,
+    references: cache.referenceManager.getAllReferences(),
+    packageLockHash: packageLockHash || undefined
+  };
+  const cachePath = path4.join(cacheDir, "index.json");
+  await fs4.writeFile(cachePath, JSON.stringify(cacheData, null, 2));
+};
+var loadCacheFromDisk = async (cacheDir) => {
+  try {
+    const cachePath = path4.join(cacheDir, "index.json");
+    const content = await fs4.readFile(cachePath, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return null;
+  }
+};
+// node_modules/@atomic-ehr/fhir-canonical-manager/dist/scanner/parser.js
+var isValidFileEntry = (entry) => {
+  if (!entry || typeof entry !== "object")
+    return false;
+  if (!entry.filename || typeof entry.filename !== "string")
+    return false;
+  if (!entry.resourceType || typeof entry.resourceType !== "string")
+    return false;
+  if (!entry.id || typeof entry.id !== "string")
+    return false;
+  const optionalStringFields = ["url", "version", "kind", "type"];
+  for (const field of optionalStringFields) {
+    if (entry[field] !== undefined && typeof entry[field] !== "string") {
+      return false;
+    }
+  }
+  return true;
+};
+var isValidIndexFile = (data) => {
+  if (!data || typeof data !== "object")
+    return false;
+  if (!data["index-version"] || typeof data["index-version"] !== "number")
+    return false;
+  if (!Array.isArray(data.files))
+    return false;
+  return data.files.every((file) => isValidFileEntry(file));
+};
+var parseIndex = (content, filePath) => {
+  try {
+    const data = JSON.parse(content);
+    if (!isValidIndexFile(data)) {
+      return null;
+    }
+    return data;
+  } catch {
+    return null;
+  }
+};
+// node_modules/@atomic-ehr/fhir-canonical-manager/dist/scanner/processor.js
+import * as fs5 from "fs/promises";
+import * as path5 from "path";
+var processIndex = async (basePath, packageJson, cache) => {
+  const indexPath = path5.join(basePath, ".index.json");
+  try {
+    const indexContent = await fs5.readFile(indexPath, "utf-8");
+    const index = parseIndex(indexContent, indexPath);
+    if (!index)
+      return;
+    for (const file of index.files) {
+      if (!file.url)
+        continue;
+      const filePath = path5.join(basePath, file.filename);
+      const id = cache.referenceManager.generateId({
+        packageName: packageJson.name,
+        packageVersion: packageJson.version,
+        filePath
+      });
+      cache.referenceManager.set(id, {
+        packageName: packageJson.name,
+        packageVersion: packageJson.version,
+        filePath,
+        resourceType: file.resourceType,
+        url: file.url,
+        version: file.version
+      });
+      const entry = {
+        id,
+        resourceType: file.resourceType,
+        indexVersion: index["index-version"],
+        url: file.url,
+        version: file.version,
+        kind: file.kind,
+        type: file.type,
+        package: {
+          name: packageJson.name,
+          version: packageJson.version
+        }
+      };
+      if (!cache.entries[file.url]) {
+        cache.entries[file.url] = [];
+      }
+      const entries = cache.entries[file.url];
+      if (entries) {
+        entries.push(entry);
+      }
+    }
+  } catch {}
+};
+// node_modules/@atomic-ehr/fhir-canonical-manager/dist/scanner/package.js
+import * as fs6 from "fs/promises";
+import * as path6 from "path";
+var scanPackage = async (packagePath, cache) => {
+  try {
+    const packageJsonPath = path6.join(packagePath, "package.json");
+    const packageJsonContent = await fs6.readFile(packageJsonPath, "utf-8");
+    const packageJson = JSON.parse(packageJsonContent);
+    const packageInfo = {
+      id: { name: packageJson.name, version: packageJson.version },
+      path: packagePath,
+      canonical: packageJson.canonical,
+      fhirVersions: packageJson.fhirVersions
+    };
+    cache.packages[packageJson.name] = packageInfo;
+    await processIndex(packagePath, packageJson, cache);
+    const examplesPath = path6.join(packagePath, "examples");
+    if (await fileExists(path6.join(examplesPath, ".index.json"))) {
+      await processIndex(examplesPath, packageJson, cache);
+    }
+  } catch {}
+};
+// node_modules/@atomic-ehr/fhir-canonical-manager/dist/scanner/directory.js
+import * as fs7 from "fs/promises";
+import * as path7 from "path";
+var scanDirectory = async (dirPath, cache) => {
+  try {
+    const entries = await fs7.readdir(dirPath, { withFileTypes: true });
+    for (const entry of entries) {
+      if (!entry.isDirectory())
+        continue;
+      const fullPath = path7.join(dirPath, entry.name);
+      if (entry.name.startsWith("@")) {
+        const scopedEntries = await fs7.readdir(fullPath, {
+          withFileTypes: true
+        });
+        for (const scopedEntry of scopedEntries) {
+          if (!scopedEntry.isDirectory())
+            continue;
+          const scopedPath = path7.join(fullPath, scopedEntry.name);
+          if (await isFhirPackage(scopedPath)) {
+            await scanPackage(scopedPath, cache);
+          }
+        }
+      } else if (await isFhirPackage(fullPath)) {
+        await scanPackage(fullPath, cache);
+      }
+    }
+  } catch {}
+};
+// node_modules/@atomic-ehr/fhir-canonical-manager/dist/resolver/context.js
+var resolveWithContext = async (url, context, cache, resolveEntry) => {
+  if (context.package) {
+    try {
+      return await resolveEntry(url, {
+        package: context.package.name,
+        version: context.package.version
+      });
+    } catch {}
+  }
+  return null;
+};
+// node_modules/@atomic-ehr/fhir-canonical-manager/dist/search/terms.js
+var expandedTerms = {
+  str: ["structure"],
+  struct: ["structure"],
+  def: ["definition"],
+  pati: ["patient"],
+  obs: ["observation"],
+  org: ["organization"],
+  pract: ["practitioner"],
+  med: ["medication", "medicinal"],
+  req: ["request"],
+  resp: ["response"],
+  ref: ["reference"],
+  val: ["value"],
+  code: ["codesystem", "code"],
+  cs: ["codesystem"],
+  vs: ["valueset"],
+  sd: ["structuredefinition"]
+};
+// node_modules/@atomic-ehr/fhir-canonical-manager/dist/search/smart.js
+var filterBySmartSearch = (results, searchTerms) => {
+  if (searchTerms.length === 0) {
+    return results;
+  }
+  const terms = searchTerms.map((t) => t.toLowerCase());
+  return results.filter((entry) => {
+    if (!entry.url)
+      return false;
+    const urlLower = entry.url.toLowerCase();
+    const fullText = [
+      urlLower,
+      entry.type?.toLowerCase() || "",
+      entry.resourceType?.toLowerCase() || ""
+    ].join(" ");
+    return terms.every((term) => {
+      const allParts = fullText.split(/[\/\-_\.\s]+/);
+      const directMatch = allParts.some((part) => part.startsWith(term));
+      if (directMatch)
+        return true;
+      const expansions = expandedTerms[term] || [];
+      for (const expansion of expansions) {
+        if (allParts.some((part) => part.startsWith(expansion))) {
+          return true;
+        }
+      }
+      return fullText.includes(term);
+    });
+  });
+};
+// node_modules/@atomic-ehr/fhir-canonical-manager/dist/manager/canonical.js
+var createCanonicalManager = (config) => {
+  const { packages, workingDir } = config;
+  const registry = config.registry ? config.registry.endsWith("/") ? config.registry : `${config.registry}/` : DEFAULT_REGISTRY;
+  const nodeModulesPath = path8.join(workingDir, "node_modules");
+  const cacheDir = path8.join(workingDir, ".fcm", "cache");
+  let cache = createCache();
+  let initialized = false;
+  const searchParamsCache = new Map;
+  const ensureInitialized = () => {
+    if (!initialized) {
+      throw new Error("CanonicalManager not initialized. Call init() first.");
+    }
+  };
+  const init = async () => {
+    if (initialized)
+      return;
+    await ensureDir(workingDir);
+    await ensureDir(cacheDir);
+    const currentPackageLockHash = await computePackageLockHash(workingDir);
+    const cachedData = await loadCacheFromDisk(cacheDir);
+    const cacheValid = cachedData && cachedData.packageLockHash === currentPackageLockHash && currentPackageLockHash !== null;
+    if (cacheValid) {
+      cache.entries = cachedData.entries;
+      cache.packages = cachedData.packages;
+      Object.entries(cachedData.references).forEach(([id, metadata]) => {
+        cache.referenceManager.set(id, metadata);
+      });
+    } else {
+      if (cachedData && cachedData.packageLockHash !== currentPackageLockHash) {
+        console.log("Package dependencies have changed, rebuilding index...");
+      }
+      await installPackages(packages, workingDir, registry);
+      cache = createCache();
+      await scanDirectory(nodeModulesPath, cache);
+      await saveCacheToDisk(cache, cacheDir, workingDir);
+    }
+    initialized = true;
+  };
+  const destroy = async () => {
+    cache.entries = {};
+    cache.packages = {};
+    cache.referenceManager.clear();
+    searchParamsCache.clear();
+    initialized = false;
+  };
+  const getPackages = async () => {
+    ensureInitialized();
+    return Object.values(cache.packages).map((p) => p.id);
+  };
+  const resolveEntry = async (canonicalUrl, options) => {
+    ensureInitialized();
+    if (options?.sourceContext) {
+      const contextResolved = await resolveWithContext(canonicalUrl, options.sourceContext, cache, resolveEntry);
+      if (contextResolved) {
+        return contextResolved;
+      }
+    }
+    const entries = cache.entries[canonicalUrl] || [];
+    if (entries.length === 0) {
+      throw new Error(`Cannot resolve canonical URL: ${canonicalUrl}`);
+    }
+    let filtered = [...entries];
+    if (options?.package) {
+      filtered = filtered.filter((e) => e.package?.name === options.package);
+    }
+    if (options?.version) {
+      filtered = filtered.filter((e) => e.version === options.version);
+    }
+    if (filtered.length === 0) {
+      throw new Error(`No matching resource found for ${canonicalUrl} with given options`);
+    }
+    return filtered[0];
+  };
+  const resolve = async (canonicalUrl, options) => {
+    const entry = await resolveEntry(canonicalUrl, options);
+    return read(entry);
+  };
+  const read = async (reference) => {
+    ensureInitialized();
+    const metadata = cache.referenceManager.get(reference.id);
+    if (!metadata) {
+      throw new Error(`Invalid reference ID: ${reference.id}`);
+    }
+    try {
+      const content = await fs8.readFile(metadata.filePath, "utf-8");
+      const resource = JSON.parse(content);
+      return {
+        ...resource,
+        id: reference.id,
+        resourceType: reference.resourceType
+      };
+    } catch (err) {
+      throw new Error(`Failed to read resource: ${err}`);
+    }
+  };
+  const searchEntries = async (params) => {
+    ensureInitialized();
+    let results = [];
+    if (params.url) {
+      results = cache.entries[params.url] || [];
+    } else {
+      for (const entries of Object.values(cache.entries)) {
+        results.push(...entries);
+      }
+    }
+    if (params.kind !== undefined) {
+      results = results.filter((e) => e.kind === params.kind);
+    }
+    if (params.type !== undefined) {
+      results = results.filter((e) => e.type === params.type);
+    }
+    if (params.version !== undefined) {
+      results = results.filter((e) => e.version === params.version);
+    }
+    if (params.package) {
+      const pkg = params.package;
+      results = results.filter((e) => e.package?.name === pkg.name && e.package?.version === pkg.version);
+    }
+    return results;
+  };
+  const search = async (params) => {
+    const entries = await searchEntries(params);
+    const resources = await Promise.all(entries.map((entry) => read(entry)));
+    return resources;
+  };
+  const smartSearch = async (searchTerms, filters) => {
+    ensureInitialized();
+    let results = await searchEntries({
+      kind: filters?.kind,
+      package: filters?.package
+    });
+    if (filters?.resourceType) {
+      results = results.filter((entry) => entry.resourceType === filters.resourceType);
+    }
+    if (filters?.type) {
+      results = results.filter((entry) => entry.type === filters.type);
+    }
+    return filterBySmartSearch(results, searchTerms);
+  };
+  const getSearchParametersForResource = async (resourceType) => {
+    ensureInitialized();
+    if (searchParamsCache.has(resourceType)) {
+      return searchParamsCache.get(resourceType);
+    }
+    const allEntries = await searchEntries({});
+    const searchParamEntries = allEntries.filter((entry) => entry.resourceType === "SearchParameter");
+    const results = [];
+    for (const entry of searchParamEntries) {
+      const resource = await read(entry);
+      const bases = resource.base || [];
+      if (Array.isArray(bases) && bases.includes(resourceType)) {
+        results.push(resource);
+      }
+    }
+    results.sort((a, b) => {
+      const codeA = a.code || "";
+      const codeB = b.code || "";
+      return codeA.localeCompare(codeB);
+    });
+    searchParamsCache.set(resourceType, results);
+    return results;
+  };
+  return {
+    init,
+    destroy,
+    packages: getPackages,
+    resolveEntry,
+    resolve,
+    read,
+    searchEntries,
+    search,
+    smartSearch,
+    getSearchParametersForResource
+  };
+};
+// node_modules/@atomic-ehr/fhirschema/dist/converter/path-parser.js
+function parsePath(element) {
+  const pathParts = element.path.split(".");
+  const relevantParts = pathParts.slice(1);
+  const path9 = relevantParts.map((part) => ({ el: part }));
+  if (path9.length === 0) {
+    return [];
+  }
+  const lastIndex = path9.length - 1;
+  const pathItem = {};
+  if (element.slicing) {
+    pathItem.slicing = {
+      ...element.slicing
+    };
+    if (element.min !== undefined) {
+      pathItem.slicing.min = element.min;
+    }
+    if (element.max && element.max !== "*") {
+      pathItem.slicing.max = parseInt(element.max);
+    }
+  }
+  if (element.sliceName) {
+    pathItem.slice = {};
+    if (element.min !== undefined) {
+      pathItem.slice.min = element.min;
+    }
+    if (element.max && element.max !== "*") {
+      pathItem.slice.max = parseInt(element.max);
+    }
+    pathItem.sliceName = element.sliceName;
+  }
+  path9[lastIndex] = { ...path9[lastIndex], ...pathItem };
+  return path9;
+}
+function getCommonPath(path1, path22) {
+  const common = [];
+  const minLength = Math.min(path1.length, path22.length);
+  for (let i = 0;i < minLength; i++) {
+    if (path1[i].el === path22[i].el) {
+      common.push({ el: path1[i].el });
+    } else {
+      break;
+    }
+  }
+  return common;
+}
+function enrichPath(prevPath, newPath) {
+  const enriched = [];
+  for (let i = 0;i < newPath.length; i++) {
+    if (i < prevPath.length && prevPath[i].el === newPath[i].el) {
+      enriched.push({
+        ...prevPath[i],
+        ...newPath[i],
+        ...prevPath[i].slicing && !newPath[i].slicing && { slicing: prevPath[i].slicing }
+      });
+    } else {
+      enriched.push(newPath[i]);
+    }
+  }
+  return enriched;
+}
+
+// node_modules/@atomic-ehr/fhirschema/dist/converter/action-calculator.js
+function sliceChanged(prevItem, newItem) {
+  return !!(prevItem.sliceName && newItem.sliceName && prevItem.sliceName !== newItem.sliceName);
+}
+function exitSliceAction(item) {
+  return {
+    type: "exit-slice",
+    sliceName: item.sliceName,
+    ...item.slicing && { slicing: item.slicing },
+    ...item.slice && { slice: item.slice }
+  };
+}
+function calculateExits(prevLength, commonLength, prevPath, newPath) {
+  const exits = [];
+  for (let i = prevLength - 1;i >= commonLength; i--) {
+    const prevItem = prevPath[i];
+    if (prevItem.sliceName) {
+      exits.push(exitSliceAction(prevItem));
+    }
+    exits.push({ type: "exit", el: prevItem.el });
+  }
+  if (commonLength > 0) {
+    const prevItem = prevPath[commonLength - 1];
+    const newItem = newPath[commonLength - 1];
+    if (sliceChanged(prevItem, newItem)) {
+      exits.push(exitSliceAction(prevItem));
+    }
+  }
+  return exits;
+}
+function calculateEnters(commonLength, newLength, prevPath, newPath) {
+  const enters = [];
+  if (commonLength > 0 && commonLength <= newLength) {
+    const prevItem = prevPath[commonLength - 1] || {};
+    const newItem = newPath[commonLength - 1];
+    if (newItem.sliceName && (!prevItem.sliceName || prevItem.sliceName !== newItem.sliceName)) {
+      enters.push({ type: "enter-slice", sliceName: newItem.sliceName });
+    }
+    if (commonLength === newLength) {
+      return enters;
+    }
+  }
+  for (let i = commonLength;i < newLength; i++) {
+    const newItem = newPath[i];
+    enters.push({ type: "enter", el: newItem.el });
+    if (newItem.sliceName) {
+      enters.push({ type: "enter-slice", sliceName: newItem.sliceName });
+    }
+  }
+  return enters;
+}
+function calculateActions(prevPath, newPath) {
+  const prevLength = prevPath.length;
+  const newLength = newPath.length;
+  const commonPath = getCommonPath(prevPath, newPath);
+  const commonLength = commonPath.length;
+  const exits = calculateExits(prevLength, commonLength, prevPath, newPath);
+  const enters = calculateEnters(commonLength, newLength, prevPath, newPath);
+  return [...exits, ...enters];
+}
+
+// node_modules/@atomic-ehr/fhirschema/dist/converter/element-transformer.js
+var BINDING_NAME_EXT = "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName";
+var DEFAULT_TYPE_EXT = "http://hl7.org/fhir/StructureDefinition/elementdefinition-defaulttype";
+var FHIR_TYPE_EXT = "http://hl7.org/fhir/StructureDefinition/structuredefinition-fhir-type";
+function getExtension(extensions, url) {
+  if (!extensions)
+    return;
+  return extensions.find((ext) => ext.url === url);
+}
+function patternTypeNormalize(typeName) {
+  const typeMap = {
+    Instant: "instant",
+    Time: "time",
+    Date: "date",
+    DateTime: "dateTime",
+    Decimal: "decimal",
+    Boolean: "boolean",
+    Integer: "integer",
+    String: "string",
+    Uri: "uri",
+    Base64Binary: "base64Binary",
+    Code: "code",
+    Id: "id",
+    Oid: "oid",
+    UnsignedInt: "unsignedInt",
+    PositiveInt: "positiveInt",
+    Markdown: "markdown",
+    Url: "url",
+    Canonical: "canonical",
+    Uuid: "uuid"
+  };
+  return typeMap[typeName] || typeName;
+}
+function processPatterns(element) {
+  const result = {};
+  for (const [key, value] of Object.entries(element)) {
+    if (typeof key === "string" && key.startsWith("pattern")) {
+      const type = patternTypeNormalize(key.replace(/^pattern/, ""));
+      result.pattern = { type, value };
+    } else if (typeof key === "string" && key.startsWith("fixed")) {
+      const type = patternTypeNormalize(key.replace(/^fixed/, ""));
+      result.pattern = { type, value };
+    } else {
+      result[key] = value;
+    }
+  }
+  if (result.pattern?.type && !result.type) {
+    result.type = result.pattern.type;
+  }
+  return result;
+}
+function buildReferenceTargets(types2) {
+  const refers = [];
+  for (const type of types2) {
+    if (type.targetProfile) {
+      const profiles = Array.isArray(type.targetProfile) ? type.targetProfile : [type.targetProfile];
+      refers.push(...profiles);
+    }
+  }
+  return refers.length > 0 ? [...new Set(refers)].sort() : undefined;
+}
+function preprocessElement(element) {
+  if (!element.type || element.type.length === 0) {
+    return element;
+  }
+  const firstType = element.type[0];
+  if (firstType.code === "Reference") {
+    const refers = buildReferenceTargets(element.type);
+    return {
+      ...element,
+      type: [{ code: "Reference" }],
+      ...refers && { refers }
+    };
+  }
+  return element;
+}
+function buildElementBinding(element, structureDefinition) {
+  const normalizeBinding = (binding2) => {
+    const result = {
+      strength: binding2.strength,
+      ...binding2.valueSet && { valueSet: binding2.valueSet }
+    };
+    const bindingNameExt = getExtension(binding2.extension, BINDING_NAME_EXT);
+    if (bindingNameExt?.valueString) {
+      result.bindingName = bindingNameExt.valueString;
+    }
+    return result;
+  };
+  if (element.choices) {
+    const { binding: binding2, ...rest2 } = element;
+    return rest2;
+  }
+  if (element.choiceOf && structureDefinition.snapshot) {
+    const declPath = `${structureDefinition.id}.${element.choiceOf}[x]`;
+    const decl = structureDefinition.snapshot.element.find((e) => e.path === declPath);
+    if (decl?.binding) {
+      return { ...element, binding: normalizeBinding(decl.binding) };
+    }
+  }
+  if (element.binding?.valueSet) {
+    return { ...element, binding: normalizeBinding(element.binding) };
+  }
+  const { binding, ...rest } = element;
+  return rest;
+}
+function buildElementConstraints(element) {
+  if (!element.constraint || element.constraint.length === 0) {
+    return element;
+  }
+  const constraints = {};
+  for (const constraint of element.constraint) {
+    constraints[constraint.key] = {
+      expression: constraint.expression,
+      human: constraint.human,
+      severity: constraint.severity
+    };
+  }
+  return { ...element, constraint: constraints };
+}
+function buildElementType(element, structureDefinition) {
+  if (!element.type || element.type.length === 0) {
+    return element;
+  }
+  const typeFromExt = element.type[0]?.extension?.[0];
+  if (typeFromExt?.url === FHIR_TYPE_EXT && typeFromExt.valueUrl) {
+    return { ...element, type: typeFromExt.valueUrl };
+  }
+  const typeCode = element.type[0].code;
+  const result = { ...element, type: typeCode };
+  if (structureDefinition.kind === "logical") {
+    const defaultTypeExt = getExtension(element.extension, DEFAULT_TYPE_EXT);
+    if (defaultTypeExt?.valueCanonical) {
+      result.defaultType = defaultTypeExt.valueCanonical;
+    }
+  }
+  return result;
+}
+function buildElementExtension(element) {
+  const type = element.type?.[0]?.code;
+  if (type !== "Extension") {
+    return element;
+  }
+  const extUrl = element.type[0]?.profile?.[0];
+  if (!extUrl) {
+    return element;
+  }
+  return {
+    ...element,
+    url: extUrl,
+    ...element.min && { min: element.min },
+    ...element.max && element.max !== "*" && { max: parseInt(element.max) }
+  };
+}
+function buildElementCardinality(element) {
+  if (element.url) {
+    return element;
+  }
+  const isArray = element.max === "*" || element.min && element.min >= 2 || element.max && parseInt(element.max) >= 2;
+  const isRequired = element.min === 1;
+  let result = { ...element };
+  delete result.min;
+  delete result.max;
+  if (isArray) {
+    result.array = true;
+    if (element.min && element.min > 0) {
+      result.min = element.min;
+    }
+    if (element.max && element.max !== "*") {
+      result.max = parseInt(element.max);
+    }
+  }
+  if (isRequired) {
+    result._required = true;
+  }
+  return result;
+}
+function contentReferenceToElementReference(ref, structureDefinition) {
+  const pathParts = ref.substring(1).split(".");
+  const result = [structureDefinition.url];
+  for (const part of pathParts.slice(1)) {
+    result.push("elements", part);
+  }
+  return result;
+}
+function buildElementContentReference(element, structureDefinition) {
+  if (!element.contentReference) {
+    return element;
+  }
+  const { contentReference, ...rest } = element;
+  return {
+    ...rest,
+    elementReference: contentReferenceToElementReference(contentReference, structureDefinition)
+  };
+}
+function clearElement(element) {
+  const { path: path9, slicing, sliceName, id, mapping, example, alias, condition, comment, definition, requirements, extension, ...rest } = element;
+  return rest;
+}
+function transformElement(element, structureDefinition) {
+  let transformed = preprocessElement(element);
+  transformed = clearElement(transformed);
+  transformed = buildElementBinding(transformed, structureDefinition);
+  transformed = buildElementConstraints(transformed);
+  transformed = buildElementContentReference(transformed, structureDefinition);
+  transformed = buildElementExtension(transformed);
+  transformed = buildElementCardinality(transformed);
+  transformed = buildElementType(transformed, structureDefinition);
+  transformed = processPatterns(transformed);
+  return transformed;
+}
+
+// node_modules/@atomic-ehr/fhirschema/dist/converter/choice-handler.js
+function isChoiceElement(element) {
+  if (element.path.endsWith("[x]")) {
+    return true;
+  }
+  if (element.type && element.type.length > 1) {
+    const uniqueCodes = new Set(element.type.map((t) => t.code));
+    return uniqueCodes.size > 1;
+  }
+  return false;
+}
+function capitalize(str) {
+  if (!str)
+    return str;
+  return str.charAt(0).toUpperCase() + str.slice(1);
+}
+function canonicalToName(url) {
+  const parts = url.split("/");
+  return parts[parts.length - 1];
+}
+function expandChoiceElement(element) {
+  const basePath = element.path.replace(/\[x\]$/, "");
+  const fieldName = basePath.split(".").pop() || "";
+  if (!element.type) {
+    return [];
+  }
+  const expanded = [];
+  const choices = element.type.map((t) => fieldName + capitalize(canonicalToName(t.code)));
+  const { type, binding, ...restElement } = element;
+  const parentElement = {
+    ...restElement,
+    path: basePath,
+    choices
+  };
+  expanded.push(parentElement);
+  for (const type2 of element.type) {
+    const typeName = capitalize(canonicalToName(type2.code));
+    const typedElement = {
+      ...element,
+      path: basePath + typeName,
+      type: [type2],
+      choiceOf: fieldName
+    };
+    if (element.binding) {
+      delete typedElement.binding;
+    }
+    expanded.push(typedElement);
+  }
+  return expanded;
+}
+
+// node_modules/@atomic-ehr/fhirschema/dist/converter/stack-processor.js
+function popAndUpdate(stack, updateFn) {
+  const child = stack[stack.length - 1];
+  const newStack = stack.slice(0, -1);
+  const parent = newStack[newStack.length - 1];
+  const updatedParent = updateFn(parent, child);
+  return [...newStack.slice(0, -1), updatedParent];
+}
+function buildMatchForSlice(slicing, sliceSchema) {
+  if (!slicing.discriminator) {
+    return {};
+  }
+  const match = {};
+  for (const discriminator of slicing.discriminator) {
+    if (!discriminator.type || !["pattern", "value", undefined].includes(discriminator.type)) {
+      continue;
+    }
+    const path9 = discriminator.path.trim();
+    if (path9 === "$this") {
+      if (sliceSchema.pattern?.value) {
+        Object.assign(match, sliceSchema.pattern.value);
+      }
+    } else {
+      const pathParts = path9.split(".").filter((p) => p);
+      const patternKeys = Object.keys(sliceSchema).filter((k) => k.startsWith("pattern"));
+      for (const patternKey of patternKeys) {
+        const fieldName = patternKey.replace("pattern", "").toLowerCase();
+        if (pathParts.length === 1 && pathParts[0] === fieldName) {
+          match[fieldName] = sliceSchema[patternKey];
+        }
+      }
+      let currentPath = ["elements"];
+      for (const part of pathParts) {
+        currentPath.push(part);
+        if (pathParts.indexOf(part) < pathParts.length - 1) {
+          currentPath.push("elements");
+        }
+      }
+      currentPath.push("pattern");
+      let value = sliceSchema;
+      for (const segment of currentPath) {
+        value = value?.[segment];
+      }
+      if (value?.value !== undefined) {
+        let matchTarget = match;
+        for (let i = 0;i < pathParts.length - 1; i++) {
+          if (!matchTarget[pathParts[i]]) {
+            matchTarget[pathParts[i]] = {};
+          }
+          matchTarget = matchTarget[pathParts[i]];
+        }
+        matchTarget[pathParts[pathParts.length - 1]] = value.value;
+      }
+    }
+  }
+  return match;
+}
+function buildSliceNode(sliceSchema, match, slice) {
+  const node = {
+    match,
+    schema: sliceSchema
+  };
+  if (slice?.min !== undefined && slice.min !== 0) {
+    node.min = slice.min;
+  }
+  if (slice?.max !== undefined) {
+    node.max = slice.max;
+  }
+  return node;
+}
+function buildSlice(action, parent, sliceSchema) {
+  const slicingInfo = parent.slicing || action.slicing || {};
+  const match = buildMatchForSlice(slicingInfo, sliceSchema);
+  const sliceNode = buildSliceNode(sliceSchema, match, action.slice);
+  if (!parent.slicing) {
+    parent.slicing = {};
+  }
+  if (action.slicing) {
+    parent.slicing = { ...parent.slicing, ...action.slicing };
+  }
+  if (!parent.slicing.slices) {
+    parent.slicing.slices = {};
+  }
+  parent.slicing.slices[action.sliceName] = sliceNode;
+  return parent;
+}
+function slicingToExtensions(slicingElement) {
+  if (!slicingElement.slicing?.slices) {
+    return {};
+  }
+  const extensions = {};
+  for (const [sliceName, slice] of Object.entries(slicingElement.slicing.slices)) {
+    const { match, schema, ...sliceProps } = slice;
+    const { slicing, elements, type, min, ...cleanSchema } = schema || {};
+    const extension = {};
+    if (match?.url) {
+      extension.url = match.url;
+    }
+    if (sliceProps.min !== undefined && sliceProps.min !== 0) {
+      extension.min = sliceProps.min;
+    }
+    if (sliceProps.max !== undefined) {
+      extension.max = sliceProps.max;
+    }
+    Object.assign(extension, cleanSchema);
+    if (min !== undefined && min !== 0 && extension.min === undefined) {
+      extension.min = min;
+    }
+    extensions[sliceName] = extension;
+  }
+  return extensions;
+}
+function addElement(elementName, parent, child) {
+  const updated = { ...parent };
+  if (elementName === "extension") {
+    updated.extensions = slicingToExtensions(child);
+  }
+  if (!updated.elements) {
+    updated.elements = {};
+  }
+  const actualElementName = child.choiceOf || elementName;
+  const { _required, ...cleanChild } = child;
+  updated.elements[elementName] = cleanChild;
+  if (_required) {
+    if (!updated.required) {
+      updated.required = [];
+    }
+    if (!updated.required.includes(actualElementName)) {
+      updated.required.push(actualElementName);
+    }
+  }
+  return updated;
+}
+function applyActions(stack, actions, value) {
+  let currentStack = [...stack];
+  for (let i = 0;i < actions.length; i++) {
+    const action = actions[i];
+    const nextAction = actions[i + 1];
+    const valueToUse = nextAction?.type === "enter" ? {} : value;
+    switch (action.type) {
+      case "enter":
+        currentStack.push(valueToUse);
+        break;
+      case "enter-slice":
+        currentStack.push(valueToUse);
+        break;
+      case "exit":
+        currentStack = popAndUpdate(currentStack, (parent, child) => addElement(action.el, parent, child));
+        break;
+      case "exit-slice":
+        currentStack = popAndUpdate(currentStack, (parent, child) => buildSlice(action, parent, child));
+        break;
+    }
+  }
+  return currentStack;
+}
+
+// node_modules/@atomic-ehr/fhirschema/dist/converter/index.js
+function buildResourceHeader(structureDefinition, context) {
+  const header = {};
+  header.name = structureDefinition.name;
+  header.type = structureDefinition.type;
+  if (structureDefinition.url)
+    header.url = structureDefinition.url;
+  if (structureDefinition.version)
+    header.version = structureDefinition.version;
+  if (structureDefinition.description)
+    header.description = structureDefinition.description;
+  if (structureDefinition.package_name)
+    header.package_name = structureDefinition.package_name;
+  if (structureDefinition.package_version)
+    header.package_version = structureDefinition.package_version;
+  if (structureDefinition.package_id)
+    header.package_id = structureDefinition.package_id;
+  header.kind = structureDefinition.kind;
+  if (structureDefinition.derivation)
+    header.derivation = structureDefinition.derivation;
+  if (structureDefinition.baseDefinition && structureDefinition.type !== "Element") {
+    header.base = structureDefinition.baseDefinition;
+  }
+  if (structureDefinition.abstract)
+    header.abstract = structureDefinition.abstract;
+  header.class = determineClass(structureDefinition);
+  if (context?.package_meta)
+    header.package_meta = context.package_meta;
+  return header;
+}
+function determineClass(structureDefinition) {
+  if (structureDefinition.kind === "resource" && structureDefinition.derivation === "constraint") {
+    return "profile";
+  }
+  if (structureDefinition.type === "Extension") {
+    return "extension";
+  }
+  return structureDefinition.kind || "unknown";
+}
+function getDifferential(structureDefinition) {
+  const elements = structureDefinition.differential?.element || [];
+  return elements.filter((e) => e.path.includes("."));
+}
+function sortElementsByIndex(elements) {
+  const entries = Object.entries(elements);
+  const sorted = entries.sort((a, b) => {
+    const indexA = a[1].index ?? Infinity;
+    const indexB = b[1].index ?? Infinity;
+    return indexA - indexB;
+  });
+  const result = {};
+  for (const [key, value] of sorted) {
+    if (value.elements) {
+      result[key] = {
+        ...value,
+        elements: sortElementsByIndex(value.elements)
+      };
+    } else {
+      result[key] = value;
+    }
+  }
+  return result;
+}
+function normalizeSchema(schema, visited = new WeakSet) {
+  if (Array.isArray(schema)) {
+    return schema.map((item) => normalizeSchema(item, visited));
+  }
+  if (schema && typeof schema === "object") {
+    if (visited.has(schema)) {
+      return "[Circular Reference]";
+    }
+    visited.add(schema);
+    const normalized = {};
+    const keys = Object.keys(schema);
+    for (const key of keys) {
+      if (key === "elements" && schema[key]) {
+        normalized[key] = sortElementsByIndex(normalizeSchema(schema[key], visited));
+      } else if (key === "required" && Array.isArray(schema[key])) {
+        normalized[key] = [...schema[key]].sort();
+      } else {
+        normalized[key] = normalizeSchema(schema[key], visited);
+      }
+    }
+    return normalized;
+  }
+  return schema;
+}
+function translate(structureDefinition, context) {
+  if (structureDefinition.kind === "primitive-type") {
+    return normalizeSchema(buildResourceHeader(structureDefinition, context));
+  }
+  const header = buildResourceHeader(structureDefinition, context);
+  const elements = getDifferential(structureDefinition);
+  let stack = [header];
+  let prevPath = [];
+  let elementQueue = [...elements];
+  let index = 0;
+  while (elementQueue.length > 0) {
+    const element = elementQueue.shift();
+    if (isChoiceElement(element)) {
+      const expanded = expandChoiceElement(element);
+      elementQueue.unshift(...expanded);
+      index++;
+      continue;
+    }
+    const parsedPath = parsePath(element);
+    const enrichedPath = enrichPath(prevPath, parsedPath);
+    const actions = calculateActions(prevPath, enrichedPath);
+    const transformedElement = transformElement(element, structureDefinition);
+    const elementWithIndex = { ...transformedElement, index: index++ };
+    stack = applyActions(stack, actions, elementWithIndex);
+    prevPath = enrichedPath;
+  }
+  const finalActions = calculateActions(prevPath, []);
+  stack = applyActions(stack, finalActions, { index });
+  if (stack.length !== 1) {
+    throw new Error(`Invalid stack state: expected 1 element, got ${stack.length}`);
+  }
+  return normalizeSchema(stack[0]);
+}
+// src/logger.ts
+var LogLevel;
+((LogLevel2) => {
+  LogLevel2[LogLevel2["DEBUG"] = 0] = "DEBUG";
+  LogLevel2[LogLevel2["INFO"] = 1] = "INFO";
+  LogLevel2[LogLevel2["WARN"] = 2] = "WARN";
+  LogLevel2[LogLevel2["ERROR"] = 3] = "ERROR";
+  LogLevel2[LogLevel2["SILENT"] = 4] = "SILENT";
+})(LogLevel ||= {});
+
+class ConsoleOutput {
+  useStderr;
+  constructor(useStderr = false) {
+    this.useStderr = useStderr;
+  }
+  write(entry, formatted) {
+    const output = this.useStderr || entry.level >= 2 /* WARN */ ? console.error : console.log;
+    output(formatted);
+  }
+}
+class Logger {
+  config;
+  constructor(config = {}) {
+    this.config = {
+      level: 1 /* INFO */,
+      format: "pretty",
+      includeTimestamp: true,
+      includeContext: true,
+      colorize: true,
+      outputs: [new ConsoleOutput],
+      ...config
+    };
+  }
+  configure(config) {
+    this.config = { ...this.config, ...config };
+  }
+  shouldLog(level) {
+    return level >= this.config.level;
+  }
+  createEntry(level, message, context, error, operation) {
+    const entry = {
+      timestamp: new Date().toISOString(),
+      level,
+      levelName: LogLevel[level],
+      message,
+      component: this.config.component
+    };
+    if (context && this.config.includeContext) {
+      entry.context = context;
+    }
+    if (operation) {
+      entry.operation = operation;
+    }
+    if (error) {
+      entry.error = {
+        name: error.name,
+        message: error.message,
+        stack: error.stack
+      };
+    }
+    return entry;
+  }
+  formatEntry(entry) {
+    switch (this.config.format) {
+      case "json":
+        return JSON.stringify(entry);
+      case "compact":
+        return this.formatCompact(entry);
+      default:
+        return this.formatPretty(entry);
+    }
+  }
+  formatCompact(entry) {
+    const timestamp = this.config.includeTimestamp ? `${entry.timestamp} ` : "";
+    const component = entry.component ? `[${entry.component}] ` : "";
+    const operation = entry.operation ? `(${entry.operation}) ` : "";
+    const level = this.colorizeLevel(entry.levelName, entry.level);
+    return `${timestamp}${level} ${component}${operation}${entry.message}`;
+  }
+  formatPretty(entry) {
+    let formatted = "";
+    const timestamp = this.config.includeTimestamp ? `${entry.timestamp} ` : "";
+    const component = entry.component ? `[${entry.component}] ` : "";
+    const operation = entry.operation ? `(${entry.operation}) ` : "";
+    const level = this.colorizeLevel(entry.levelName.padEnd(5), entry.level);
+    formatted += `${timestamp}${level} ${component}${operation}${entry.message}`;
+    if (entry.context && Object.keys(entry.context).length > 0) {
+      formatted += `
+  Context: ${JSON.stringify(entry.context, null, 2).split(`
+`).join(`
+  `)}`;
+    }
+    if (entry.error) {
+      formatted += `
+  Error: [${entry.error.code || entry.error.name}] ${entry.error.message}`;
+      if (entry.error.context && Object.keys(entry.error.context).length > 0) {
+        formatted += `
+  Error Context: ${JSON.stringify(entry.error.context, null, 2).split(`
+`).join(`
+  `)}`;
+      }
+      if (entry.error.suggestions && entry.error.suggestions.length > 0) {
+        formatted += `
+  Suggestions:
+${entry.error.suggestions.map((s) => `    • ${s}`).join(`
+`)}`;
+      }
+      if (entry.level === 0 /* DEBUG */ && entry.error.stack) {
+        formatted += `
+  Stack: ${entry.error.stack.split(`
+`).join(`
+  `)}`;
+      }
+    }
+    return formatted;
+  }
+  colorizeLevel(levelName, level) {
+    if (!this.config.colorize) {
+      return levelName;
+    }
+    const colors = {
+      [0 /* DEBUG */]: "\x1B[36m",
+      [1 /* INFO */]: "\x1B[32m",
+      [2 /* WARN */]: "\x1B[33m",
+      [3 /* ERROR */]: "\x1B[31m"
+    };
+    const reset = "\x1B[0m";
+    const color = colors[level] || "";
+    return `${color}${levelName}${reset}`;
+  }
+  async writeEntry(entry) {
+    if (!this.shouldLog(entry.level)) {
+      return;
+    }
+    const formatted = this.formatEntry(entry);
+    for (const output of this.config.outputs) {
+      try {
+        await output.write(entry, formatted);
+      } catch (error) {
+        console.error("Logger output failed:", error);
+        console.error(formatted);
+      }
+    }
+  }
+  async debug(message, context, operation) {
+    const entry = this.createEntry(0 /* DEBUG */, message, context, undefined, operation);
+    await this.writeEntry(entry);
+  }
+  async info(message, context, operation) {
+    const entry = this.createEntry(1 /* INFO */, message, context, undefined, operation);
+    await this.writeEntry(entry);
+  }
+  async warn(message, context, operation) {
+    const entry = this.createEntry(2 /* WARN */, message, context, undefined, operation);
+    await this.writeEntry(entry);
+  }
+  async error(message, error, context, operation) {
+    const entry = this.createEntry(3 /* ERROR */, message, context, error, operation);
+    await this.writeEntry(entry);
+  }
+  child(component, context) {
+    const childLogger = new Logger({
+      ...this.config,
+      component: this.config.component ? `${this.config.component}.${component}` : component
+    });
+    if (context) {
+      const originalMethods = {
+        debug: childLogger.debug.bind(childLogger),
+        info: childLogger.info.bind(childLogger),
+        warn: childLogger.warn.bind(childLogger),
+        error: childLogger.error.bind(childLogger)
+      };
+      childLogger.debug = (message, additionalContext, operation) => originalMethods.debug(message, { ...context, ...additionalContext }, operation);
+      childLogger.info = (message, additionalContext, operation) => originalMethods.info(message, { ...context, ...additionalContext }, operation);
+      childLogger.warn = (message, additionalContext, operation) => originalMethods.warn(message, { ...context, ...additionalContext }, operation);
+      childLogger.error = (message, error, additionalContext, operation) => originalMethods.error(message, error, { ...context, ...additionalContext }, operation);
+    }
+    return childLogger;
+  }
+}
+var logger = new Logger;
+
+// src/typeschema/core/identifier.ts
+function dropVersionFromUrl(url) {
+  if (!url)
+    return;
+  return url.split("|")[0];
+}
+function determineKind(fhirSchema) {
+  if (fhirSchema.derivation === "constraint") {
+    if (fhirSchema.base && (fhirSchema.type === "Resource" || fhirSchema.kind === "resource" || fhirSchema.kind === "complex-type")) {
+      return "profile";
+    }
+    return "profile";
+  }
+  if (fhirSchema.kind) {
+    switch (fhirSchema.kind) {
+      case "primitive-type":
+        return "primitive-type";
+      case "complex-type":
+        return "complex-type";
+      case "resource":
+        return "resource";
+    }
+  }
+  return "resource";
+}
+function buildSchemaIdentifier(fhirSchema, packageInfo) {
+  const kind = determineKind(fhirSchema);
+  return {
+    kind,
+    package: packageInfo?.name || fhirSchema.package_name || "undefined",
+    version: packageInfo?.version || fhirSchema.package_version || "undefined",
+    name: fhirSchema.name,
+    url: fhirSchema.url
+  };
+}
+function buildNestedIdentifier(fhirSchema, path9, packageInfo) {
+  const nestedName = path9.join(".");
+  return {
+    kind: "nested",
+    package: packageInfo?.name || fhirSchema.package_name || "undefined",
+    version: packageInfo?.version || fhirSchema.package_version || "undefined",
+    name: nestedName,
+    url: `${fhirSchema.url}#${nestedName}`
+  };
+}
+function buildValueSetIdentifier(valueSetUrl, valueSet, packageInfo) {
+  const cleanUrl = dropVersionFromUrl(valueSetUrl) || valueSetUrl;
+  let name = "unknown";
+  const urlParts = cleanUrl.split("/");
+  const lastSegment = urlParts[urlParts.length - 1];
+  if (lastSegment && lastSegment.length > 0) {
+    name = lastSegment.split(/[-_]/).map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase()).join("");
+  }
+  if (name === "unknown" && valueSet?.id && !/^[a-zA-Z0-9_-]{20,}$/.test(valueSet.id)) {
+    name = valueSet.id;
+  }
+  return {
+    kind: "value-set",
+    package: packageInfo?.name || valueSet?.package_name || "undefined",
+    version: packageInfo?.version || valueSet?.package_version || "undefined",
+    name,
+    url: cleanUrl
+  };
+}
+function buildBindingIdentifier(fhirSchema, path9, bindingName, packageInfo) {
+  const pathStr = path9.join(".");
+  const name = bindingName || `${fhirSchema.name}.${pathStr}_binding`;
+  return {
+    kind: "binding",
+    package: packageInfo?.name || fhirSchema.package_name || "undefined",
+    version: packageInfo?.version || fhirSchema.package_version || "undefined",
+    name,
+    url: bindingName ? `urn:fhir:binding:${name}` : `${fhirSchema.url}#${pathStr}_binding`
+  };
+}
+
+// src/typeschema/profile/processor.ts
+async function transformProfile(fhirSchema, manager, packageInfo) {
+  const identifier = buildSchemaIdentifier(fhirSchema, packageInfo);
+  if (identifier.kind !== "profile") {
+    throw new Error(`Expected profile, got ${identifier.kind} for ${fhirSchema.name}`);
+  }
+  let base;
+  if (fhirSchema.base) {
+    const baseUrl = fhirSchema.base.includes("/") ? fhirSchema.base : `http://hl7.org/fhir/StructureDefinition/${fhirSchema.base}`;
+    const baseName = fhirSchema.base.split("/").pop() || fhirSchema.base;
+    const baseKind = await determineBaseKind(baseUrl, manager);
+    const isStandardFhir = baseUrl.startsWith("http://hl7.org/fhir/");
+    base = {
+      kind: baseKind,
+      package: isStandardFhir ? "hl7.fhir.r4.core" : packageInfo?.name || fhirSchema.package_name || "undefined",
+      version: isStandardFhir ? "4.0.1" : packageInfo?.version || fhirSchema.package_version || "undefined",
+      name: baseName,
+      url: baseUrl
+    };
+  }
+  const profileSchema = {
+    identifier,
+    base,
+    dependencies: base ? [base] : []
+  };
+  if (fhirSchema.description) {
+    profileSchema.description = fhirSchema.description;
+  }
+  const metadata = extractProfileMetadata(fhirSchema);
+  if (Object.keys(metadata).length > 0) {
+    profileSchema.metadata = metadata;
+  }
+  const constraints = await processProfileConstraints(fhirSchema, manager);
+  if (Object.keys(constraints).length > 0) {
+    profileSchema.constraints = constraints;
+  }
+  const extensions = await processProfileExtensions(fhirSchema, manager);
+  if (extensions.length > 0) {
+    profileSchema.extensions = extensions;
+  }
+  const validationRules = extractValidationRules(fhirSchema);
+  if (validationRules.length > 0) {
+    profileSchema.validation = validationRules;
+  }
+  return profileSchema;
+}
+async function determineBaseKind(baseUrl, manager) {
+  try {
+    const baseSchema = await manager.resolve(baseUrl);
+    if (baseSchema) {
+      if (baseSchema.derivation === "constraint") {
+        return "profile";
+      }
+      if (baseSchema.kind === "resource")
+        return "resource";
+      if (baseSchema.kind === "complex-type")
+        return "complex-type";
+    }
+  } catch (error) {
+    console.warn(`Could not resolve base schema ${baseUrl}:`, error);
+  }
+  if (baseUrl.includes("/us/core/") || baseUrl.includes("StructureDefinition/us-core-")) {
+    return "profile";
+  }
+  if (baseUrl.includes("StructureDefinition/") && !baseUrl.startsWith("http://hl7.org/fhir/StructureDefinition/")) {
+    return "profile";
+  }
+  return "resource";
+}
+function extractProfileMetadata(fhirSchema) {
+  const metadata = {};
+  if (fhirSchema.publisher)
+    metadata.publisher = fhirSchema.publisher;
+  if (fhirSchema.contact)
+    metadata.contact = fhirSchema.contact;
+  if (fhirSchema.copyright)
+    metadata.copyright = fhirSchema.copyright;
+  if (fhirSchema.purpose)
+    metadata.purpose = fhirSchema.purpose;
+  if (fhirSchema.experimental !== undefined) {
+    metadata.experimental = fhirSchema.experimental;
+  }
+  if (fhirSchema.date)
+    metadata.date = fhirSchema.date;
+  if (fhirSchema.jurisdiction)
+    metadata.jurisdiction = fhirSchema.jurisdiction;
+  if (fhirSchema.url) {
+    if (fhirSchema.url.includes("/us/core/")) {
+      metadata.package = "hl7.fhir.us.core";
+    } else if (fhirSchema.url.includes("hl7.org/fhir/")) {
+      metadata.package = "hl7.fhir.r4.core";
+    }
+  }
+  return metadata;
+}
+async function processProfileConstraints(fhirSchema, _manager) {
+  const constraints = {};
+  if (!fhirSchema.elements)
+    return constraints;
+  for (const [path9, element] of Object.entries(fhirSchema.elements)) {
+    const elementConstraints = {};
+    if (element.min !== undefined)
+      elementConstraints.min = element.min;
+    if (element.max !== undefined)
+      elementConstraints.max = element.max;
+    if (element.mustSupport)
+      elementConstraints.mustSupport = true;
+    if (element.fixedValue !== undefined)
+      elementConstraints.fixedValue = element.fixedValue;
+    if (element.patternValue !== undefined)
+      elementConstraints.patternValue = element.patternValue;
+    if (element.binding) {
+      elementConstraints.binding = {
+        strength: element.binding.strength,
+        valueSet: element.binding.valueSet
+      };
+    }
+    if (element.type && Array.isArray(element.type) && element.type.length > 0) {
+      elementConstraints.types = element.type.map((t) => {
+        const typeConstraint = { code: t.code };
+        if (t.profile)
+          typeConstraint.profile = t.profile;
+        if (t.targetProfile)
+          typeConstraint.targetProfile = t.targetProfile;
+        return typeConstraint;
+      });
+    }
+    if (element.slicing) {
+      elementConstraints.slicing = {
+        discriminator: element.slicing.discriminator,
+        rules: element.slicing.rules,
+        ordered: element.slicing.ordered
+      };
+    }
+    if (Object.keys(elementConstraints).length > 0) {
+      constraints[path9] = elementConstraints;
+    }
+  }
+  return constraints;
+}
+async function processProfileExtensions(fhirSchema, _manager) {
+  const extensions = [];
+  if (!fhirSchema.elements)
+    return extensions;
+  for (const [path9, element] of Object.entries(fhirSchema.elements)) {
+    if (path9.includes("extension") && element.type && Array.isArray(element.type)) {
+      for (const type of element.type) {
+        if (type.code === "Extension" && type.profile) {
+          extensions.push({
+            path: path9,
+            profile: type.profile,
+            min: element.min,
+            max: element.max,
+            mustSupport: element.mustSupport
+          });
+        }
+      }
+    }
+  }
+  return extensions;
+}
+function extractValidationRules(fhirSchema) {
+  const rules = [];
+  if (!fhirSchema.elements)
+    return rules;
+  for (const [path9, element] of Object.entries(fhirSchema.elements)) {
+    if (element.constraint && Array.isArray(element.constraint)) {
+      for (const constraint of element.constraint) {
+        rules.push({
+          path: path9,
+          key: constraint.key,
+          severity: constraint.severity,
+          human: constraint.human,
+          expression: constraint.expression
+        });
+      }
+    }
+  }
+  return rules;
+}
+
+// src/typeschema/core/field-builder.ts
+function getElementHierarchy(fhirSchema, path9, _manager) {
+  const hierarchy = [];
+  let element = fhirSchema.elements;
+  for (const key of path9) {
+    element = element?.[key];
+    if (!element)
+      break;
+  }
+  if (element) {
+    hierarchy.push(element);
+  }
+  return hierarchy;
+}
+function mergeElementHierarchy(hierarchy) {
+  if (hierarchy.length === 0) {
+    return {};
+  }
+  const snapshot = { ...hierarchy[0] };
+  for (let i = hierarchy.length - 1;i >= 0; i--) {
+    const element = hierarchy[i];
+    const specificProps = [
+      "choices",
+      "short",
+      "index",
+      "elements",
+      "required",
+      "excluded",
+      "binding",
+      "refers",
+      "elementReference",
+      "mustSupport",
+      "slices",
+      "slicing",
+      "url",
+      "extensions"
+    ];
+    for (const [key, value] of Object.entries(element)) {
+      if (!specificProps.includes(key) && value !== undefined) {
+        snapshot[key] = value;
+      }
+    }
+  }
+  for (const prop of ["choices", "binding", "refers", "elementReference"]) {
+    if (hierarchy[0] && hierarchy[0][prop] !== undefined) {
+      snapshot[prop] = hierarchy[0][prop];
+    }
+  }
+  return snapshot;
+}
+function isRequired(fhirSchema, path9, _manager) {
+  if (path9.length === 0)
+    return false;
+  const fieldName = path9[path9.length - 1];
+  const parentPath = path9.slice(0, -1);
+  let parentElement = fhirSchema;
+  for (const key of parentPath) {
+    parentElement = parentElement.elements?.[key];
+    if (!parentElement)
+      break;
+  }
+  if (parentElement?.required?.includes(fieldName)) {
+    return true;
+  }
+  if (parentPath.length === 0 && fieldName && fhirSchema.required?.includes(fieldName)) {
+    return true;
+  }
+  return false;
+}
+function isExcluded(fhirSchema, path9, _manager) {
+  if (path9.length === 0)
+    return false;
+  const fieldName = path9[path9.length - 1];
+  const parentPath = path9.slice(0, -1);
+  let parentElement = fhirSchema;
+  for (const key of parentPath) {
+    parentElement = parentElement.elements?.[key];
+    if (!parentElement)
+      break;
+  }
+  if (parentElement?.excluded?.includes(fieldName)) {
+    return true;
+  }
+  if (parentPath.length === 0 && fieldName && fhirSchema.excluded?.includes(fieldName)) {
+    return true;
+  }
+  return false;
+}
+async function buildReferences(element, manager, packageInfo) {
+  if (!element.refers || element.refers.length === 0) {
+    return;
+  }
+  const references = [];
+  for (const ref of element.refers) {
+    try {
+      const resource = await manager.resolve(ref);
+      if (resource) {
+        references.push(buildSchemaIdentifier(resource, packageInfo));
+      }
+    } catch {}
+  }
+  return references;
+}
+function buildFieldType(fhirSchema, _path, element, _manager, packageInfo) {
+  if (element.elementReference) {
+    const refPath = element.elementReference.filter((_, i) => i % 2 === 1).map((p) => p).filter((p) => p !== "elements");
+    if (refPath.length > 0) {
+      return buildNestedIdentifier(fhirSchema, refPath, packageInfo);
+    }
+  }
+  if (element.type) {
+    const typeUrl = element.type.includes("/") ? element.type : `http://hl7.org/fhir/StructureDefinition/${element.type}`;
+    const kind = element.type.match(/^[a-z]/) ? "primitive-type" : "complex-type";
+    const isStandardFhir = typeUrl.startsWith("http://hl7.org/fhir/");
+    return {
+      kind,
+      package: isStandardFhir ? "hl7.fhir.r4.core" : packageInfo?.name || "undefined",
+      version: isStandardFhir ? "4.0.1" : packageInfo?.version || "undefined",
+      name: element.type,
+      url: typeUrl
+    };
+  }
+  return;
+}
+async function buildField(fhirSchema, path9, element, manager, packageInfo) {
+  const field = {
+    array: element.array || false,
+    required: isRequired(fhirSchema, path9, manager),
+    excluded: isExcluded(fhirSchema, path9, manager)
+  };
+  const type = buildFieldType(fhirSchema, path9, element, manager, packageInfo);
+  if (type) {
+    field.type = type;
+  }
+  if (element.min !== undefined)
+    field.min = element.min;
+  if (element.max !== undefined)
+    field.max = element.max;
+  if (element.choices)
+    field.choices = element.choices;
+  if (element.choiceOf)
+    field.choiceOf = element.choiceOf;
+  if (element.binding) {
+    field.binding = buildBindingIdentifier(fhirSchema, path9, element.binding.bindingName, packageInfo);
+    if (element.binding.strength === "required" && element.type === "code") {
+      const enumValues = await buildEnum(element, manager);
+      if (enumValues && enumValues.length > 0) {
+        field.enum = enumValues;
+      }
+    }
+  }
+  const references = await buildReferences(element, manager, packageInfo);
+  if (references) {
+    field.reference = references;
+  }
+  return removeEmptyValues(field);
+}
+function removeEmptyValues(obj) {
+  const result = {};
+  for (const [key, value] of Object.entries(obj)) {
+    if (value !== undefined && value !== null) {
+      if (Array.isArray(value) && value.length === 0) {
+        continue;
+      }
+      result[key] = value;
+    }
+  }
+  return result;
+}
+function isNestedElement(element) {
+  return element.type === "BackboneElement" || element.elements && Object.keys(element.elements).length > 0 || false;
+}
+function buildNestedField(fhirSchema, path9, element, manager, packageInfo) {
+  return {
+    type: buildNestedIdentifier(fhirSchema, path9, packageInfo),
+    array: element.array || false,
+    required: isRequired(fhirSchema, path9, manager),
+    excluded: isExcluded(fhirSchema, path9, manager)
+  };
+}
+
+// src/typeschema/core/binding.ts
+async function extractValueSetConcepts(valueSetUrl, manager) {
+  try {
+    const cleanUrl = dropVersionFromUrl(valueSetUrl) || valueSetUrl;
+    const valueSet = await manager.resolve(cleanUrl);
+    if (!valueSet)
+      return;
+    if (valueSet.expansion?.contains) {
+      return valueSet.expansion.contains.map((concept) => ({
+        system: concept.system,
+        code: concept.code,
+        display: concept.display
+      }));
+    }
+    const concepts = [];
+    if (valueSet.compose?.include) {
+      for (const include of valueSet.compose.include) {
+        if (include.concept) {
+          for (const concept of include.concept) {
+            concepts.push({
+              system: include.system,
+              code: concept.code,
+              display: concept.display
+            });
+          }
+        } else if (include.system && !include.filter) {
+          try {
+            const codeSystem = await manager.resolve(include.system);
+            if (codeSystem?.concept) {
+              const extractConcepts = (conceptList, system) => {
+                for (const concept of conceptList) {
+                  concepts.push({
+                    system,
+                    code: concept.code,
+                    display: concept.display
+                  });
+                  if (concept.concept) {
+                    extractConcepts(concept.concept, system);
+                  }
+                }
+              };
+              extractConcepts(codeSystem.concept, include.system);
+            }
+          } catch {}
+        }
+      }
+    }
+    return concepts.length > 0 ? concepts : undefined;
+  } catch {
+    return;
+  }
+}
+async function buildEnum(element, manager) {
+  if (!element.binding)
+    return;
+  const { strength, valueSet } = element.binding;
+  if (!valueSet)
+    return;
+  const shouldGenerateEnum = strength === "required" || strength === "extensible" && element.type === "code" || strength === "preferred" && element.type === "code";
+  if (!shouldGenerateEnum) {
+    return;
+  }
+  if (!manager.resolve) {
+    return;
+  }
+  try {
+    const concepts = await extractValueSetConcepts(valueSet, manager);
+    if (!concepts || concepts.length === 0)
+      return;
+    const codes = concepts.map((c) => c.code).filter((code) => code && typeof code === "string" && code.trim().length > 0);
+    return codes.length > 0 && codes.length <= 50 ? codes : undefined;
+  } catch (error) {
+    console.debug(`Failed to extract enum values for ${valueSet}: ${error}`);
+    return;
+  }
+}
+async function generateBindingSchema(fhirSchema, path9, element, manager, packageInfo) {
+  if (!element.binding?.valueSet)
+    return;
+  const identifier = buildBindingIdentifier(fhirSchema, path9, element.binding.bindingName, packageInfo);
+  const fieldType = buildFieldType(fhirSchema, path9, element, manager, packageInfo);
+  const valueSetIdentifier = buildValueSetIdentifier(element.binding.valueSet, undefined, packageInfo);
+  const binding = {
+    identifier,
+    type: fieldType,
+    valueset: valueSetIdentifier,
+    strength: element.binding.strength,
+    dependencies: []
+  };
+  if (fieldType) {
+    binding.dependencies.push(fieldType);
+  }
+  binding.dependencies.push(valueSetIdentifier);
+  const enumValues = await buildEnum(element, manager);
+  if (enumValues) {
+    binding.enum = enumValues;
+  }
+  return binding;
+}
+async function collectBindingSchemas(fhirSchema, manager, packageInfo) {
+  const bindings = [];
+  const processedPaths = new Set;
+  async function processElement(elements, parentPath) {
+    for (const [key, element] of Object.entries(elements)) {
+      const path9 = [...parentPath, key];
+      const pathKey = path9.join(".");
+      if (processedPaths.has(pathKey))
+        continue;
+      processedPaths.add(pathKey);
+      if (element.binding) {
+        const binding = await generateBindingSchema(fhirSchema, path9, element, manager, packageInfo);
+        if (binding) {
+          bindings.push(binding);
+        }
+      }
+      if (element.elements) {
+        await processElement(element.elements, path9);
+      }
+    }
+  }
+  if (fhirSchema.elements) {
+    await processElement(fhirSchema.elements, []);
+  }
+  bindings.sort((a, b) => a.identifier.name.localeCompare(b.identifier.name));
+  const uniqueBindings = [];
+  const seenUrls = new Set;
+  for (const binding of bindings) {
+    if (!seenUrls.has(binding.identifier.url)) {
+      seenUrls.add(binding.identifier.url);
+      uniqueBindings.push(binding);
+    }
+  }
+  return uniqueBindings;
+}
+
+// src/typeschema/core/nested-types.ts
+function collectNestedElements(fhirSchema, parentPath, elements) {
+  const nested = [];
+  for (const [key, element] of Object.entries(elements)) {
+    const path9 = [...parentPath, key];
+    if (isNestedElement(element)) {
+      nested.push([path9, element]);
+    }
+    if (element.elements) {
+      nested.push(...collectNestedElements(fhirSchema, path9, element.elements));
+    }
+  }
+  return nested;
+}
+async function transformNestedElements(fhirSchema, parentPath, elements, manager, packageInfo) {
+  const fields = {};
+  for (const [key, element] of Object.entries(elements)) {
+    const path9 = [...parentPath, key];
+    if (isNestedElement(element)) {
+      fields[key] = buildNestedField(fhirSchema, path9, element, manager, packageInfo);
+    } else {
+      fields[key] = await buildField(fhirSchema, path9, element, manager, packageInfo);
+    }
+  }
+  return fields;
+}
+async function buildNestedTypes(fhirSchema, manager, packageInfo) {
+  if (!fhirSchema.elements)
+    return [];
+  const nestedTypes = [];
+  const nestedElements = collectNestedElements(fhirSchema, [], fhirSchema.elements);
+  const actualNested = nestedElements.filter(([_, element]) => element.elements && Object.keys(element.elements).length > 0);
+  for (const [path9, element] of actualNested) {
+    const identifier = buildNestedIdentifier(fhirSchema, path9, packageInfo);
+    let base;
+    if (element.type === "BackboneElement" || !element.type) {
+      base = {
+        kind: "complex-type",
+        package: packageInfo?.name || "hl7.fhir.r4.core",
+        version: packageInfo?.version || "4.0.1",
+        name: "BackboneElement",
+        url: "http://hl7.org/fhir/StructureDefinition/BackboneElement"
+      };
+    } else {
+      base = {
+        kind: "complex-type",
+        package: packageInfo?.name || "hl7.fhir.r4.core",
+        version: packageInfo?.version || "4.0.1",
+        name: element.type,
+        url: `http://hl7.org/fhir/StructureDefinition/${element.type}`
+      };
+    }
+    const fields = await transformNestedElements(fhirSchema, path9, element.elements, manager, packageInfo);
+    const nestedType = {
+      identifier,
+      base,
+      fields
+    };
+    nestedTypes.push(nestedType);
+  }
+  nestedTypes.sort((a, b) => a.identifier.url.localeCompare(b.identifier.url));
+  return nestedTypes;
+}
+function extractNestedDependencies(nestedTypes) {
+  const deps = [];
+  for (const nested of nestedTypes) {
+    deps.push(nested.identifier);
+    if (nested.base) {
+      deps.push(nested.base);
+    }
+    for (const field of Object.values(nested.fields)) {
+      if ("type" in field && field.type) {
+        deps.push(field.type);
+      }
+      if ("binding" in field && field.binding) {
+        deps.push(field.binding);
+      }
+    }
+  }
+  return deps;
+}
+
+// src/typeschema/core/transformer.ts
+async function transformElements(fhirSchema, parentPath, elements, manager, packageInfo) {
+  const fields = {};
+  for (const [key, element] of Object.entries(elements)) {
+    const path9 = [...parentPath, key];
+    const hierarchy = getElementHierarchy(fhirSchema, path9, manager);
+    const snapshot = hierarchy.length > 0 ? mergeElementHierarchy(hierarchy) : element;
+    if (isNestedElement(snapshot)) {
+      fields[key] = buildNestedField(fhirSchema, path9, snapshot, manager, packageInfo);
+    } else {
+      fields[key] = await buildField(fhirSchema, path9, snapshot, manager, packageInfo);
+    }
+  }
+  return fields;
+}
+function extractFieldDependencies(fields) {
+  const deps = [];
+  for (const field of Object.values(fields)) {
+    if ("type" in field && field.type) {
+      deps.push(field.type);
+    }
+    if ("binding" in field && field.binding) {
+      deps.push(field.binding);
+    }
+  }
+  return deps;
+}
+function deduplicateDependencies(deps) {
+  const seen = new Set;
+  const unique = [];
+  for (const dep of deps) {
+    const key = dep.url;
+    if (!seen.has(key)) {
+      seen.add(key);
+      unique.push(dep);
+    }
+  }
+  unique.sort((a, b) => a.name.localeCompare(b.name));
+  return unique;
+}
+function isExtensionSchema(fhirSchema, _identifier) {
+  if (fhirSchema.base === "Extension" || fhirSchema.base === "http://hl7.org/fhir/StructureDefinition/Extension") {
+    return true;
+  }
+  if (fhirSchema.url?.includes("/extension/") || fhirSchema.url?.includes("-extension")) {
+    return true;
+  }
+  if (fhirSchema.name?.toLowerCase().includes("extension")) {
+    return true;
+  }
+  if (fhirSchema.type === "Extension") {
+    return true;
+  }
+  return false;
+}
+async function transformValueSet(fhirSchema, _manager, packageInfo) {
+  try {
+    const identifier = buildSchemaIdentifier(fhirSchema, packageInfo);
+    identifier.kind = "value-set";
+    const valueSetSchema = {
+      identifier,
+      description: fhirSchema.description
+    };
+    if (fhirSchema.elements) {
+      const concepts = [];
+      for (const [_key, element] of Object.entries(fhirSchema.elements)) {
+        if ("code" in element && element.code) {
+          concepts.push({
+            code: element.code,
+            display: element.short || element.definition,
+            system: element.system
+          });
+        }
+      }
+      if (concepts.length > 0) {
+        valueSetSchema.concept = concepts;
+      }
+    }
+    return valueSetSchema;
+  } catch (error) {
+    console.warn(`Failed to transform value set ${fhirSchema.name}: ${error}`);
+    return null;
+  }
+}
+async function transformExtension(fhirSchema, manager, packageInfo) {
+  try {
+    const identifier = buildSchemaIdentifier(fhirSchema, packageInfo);
+    let base;
+    if (fhirSchema.base && fhirSchema.base !== "Extension") {
+      const baseUrl = fhirSchema.base.includes("/") ? fhirSchema.base : `http://hl7.org/fhir/StructureDefinition/${fhirSchema.base}`;
+      const baseName = fhirSchema.base.split("/").pop() || fhirSchema.base;
+      base = {
+        kind: "complex-type",
+        package: packageInfo?.name || "hl7.fhir.r4.core",
+        version: packageInfo?.version || "4.0.1",
+        name: baseName,
+        url: baseUrl
+      };
+    } else {
+      base = {
+        kind: "complex-type",
+        package: "hl7.fhir.r4.core",
+        version: "4.0.1",
+        name: "Extension",
+        url: "http://hl7.org/fhir/StructureDefinition/Extension"
+      };
+    }
+    const extensionSchema = {
+      identifier,
+      base,
+      description: fhirSchema.description,
+      dependencies: [],
+      metadata: {
+        isExtension: true
+      }
+    };
+    if (base) {
+      extensionSchema.dependencies.push(base);
+    }
+    if (fhirSchema.elements) {
+      const fields = await transformElements(fhirSchema, [], fhirSchema.elements, manager, packageInfo);
+      if (Object.keys(fields).length > 0) {
+        extensionSchema.fields = fields;
+        extensionSchema.dependencies.push(...extractFieldDependencies(fields));
+      }
+    }
+    const nestedTypes = await buildNestedTypes(fhirSchema, manager, packageInfo);
+    if (nestedTypes.length > 0) {
+      extensionSchema.nested = nestedTypes;
+      extensionSchema.dependencies.push(...extractNestedDependencies(nestedTypes));
+    }
+    extensionSchema.dependencies = deduplicateDependencies(extensionSchema.dependencies);
+    extensionSchema.dependencies = extensionSchema.dependencies.filter((dep) => dep.url !== identifier.url);
+    return extensionSchema;
+  } catch (error) {
+    console.warn(`Failed to transform extension ${fhirSchema.name}: ${error}`);
+    return null;
+  }
+}
+async function transformFHIRSchema(fhirSchema, manager, packageInfo) {
+  const results = [];
+  if (!packageInfo && (fhirSchema.package_name || fhirSchema.package_id)) {
+    packageInfo = {
+      name: fhirSchema.package_name || fhirSchema.package_id || "undefined",
+      version: fhirSchema.package_version || "undefined"
+    };
+  }
+  const identifier = buildSchemaIdentifier(fhirSchema, packageInfo);
+  if (identifier.kind === "profile") {
+    const profileSchema = await transformProfile(fhirSchema, manager, packageInfo);
+    results.push(profileSchema);
+    const bindingSchemas2 = await collectBindingSchemas(fhirSchema, manager, packageInfo);
+    results.push(...bindingSchemas2);
+    return results;
+  }
+  if (identifier.kind === "value-set" || fhirSchema.kind === "value-set") {
+    const valueSetSchema = await transformValueSet(fhirSchema, manager, packageInfo);
+    if (valueSetSchema) {
+      results.push(valueSetSchema);
+    }
+    return results;
+  }
+  if (isExtensionSchema(fhirSchema, identifier)) {
+    const extensionSchema = await transformExtension(fhirSchema, manager, packageInfo);
+    if (extensionSchema) {
+      results.push(extensionSchema);
+    }
+    return results;
+  }
+  let base;
+  if (fhirSchema.base && fhirSchema.type !== "Element") {
+    const baseUrl = fhirSchema.base.includes("/") ? fhirSchema.base : `http://hl7.org/fhir/StructureDefinition/${fhirSchema.base}`;
+    const baseName = fhirSchema.base.split("/").pop() || fhirSchema.base;
+    const complexTypes = new Set([
+      "Element",
+      "BackboneElement",
+      "Quantity",
+      "Duration",
+      "Distance",
+      "Count",
+      "Age",
+      "Address",
+      "Annotation",
+      "Attachment",
+      "CodeableConcept",
+      "Coding",
+      "ContactPoint",
+      "HumanName",
+      "Identifier",
+      "Period",
+      "Range",
+      "Ratio",
+      "Reference",
+      "Timing",
+      "Money",
+      "SampledData",
+      "Signature",
+      "ContactDetail",
+      "Contributor",
+      "DataRequirement",
+      "Expression",
+      "ParameterDefinition",
+      "RelatedArtifact",
+      "TriggerDefinition",
+      "UsageContext",
+      "Dosage",
+      "Meta",
+      "Extension"
+    ]);
+    const kind = complexTypes.has(baseName) ? "complex-type" : "resource";
+    const isStandardFhir = baseUrl.startsWith("http://hl7.org/fhir/");
+    base = {
+      kind,
+      package: isStandardFhir ? "hl7.fhir.r4.core" : packageInfo?.name || fhirSchema.package_name || "undefined",
+      version: isStandardFhir ? "4.0.1" : packageInfo?.version || fhirSchema.package_version || "undefined",
+      name: baseName,
+      url: baseUrl
+    };
+  }
+  const mainSchema = {
+    identifier,
+    dependencies: []
+  };
+  const allDependencies = [];
+  if (base) {
+    mainSchema.base = base;
+    allDependencies.push(base);
+  }
+  if (fhirSchema.description) {
+    mainSchema.description = fhirSchema.description;
+  }
+  if (fhirSchema.kind !== "primitive-type" && fhirSchema.elements) {
+    const fields = await transformElements(fhirSchema, [], fhirSchema.elements, manager, packageInfo);
+    if (Object.keys(fields).length > 0) {
+      mainSchema.fields = fields;
+    }
+    allDependencies.push(...extractFieldDependencies(fields));
+    const nestedTypes = await buildNestedTypes(fhirSchema, manager, packageInfo);
+    if (nestedTypes.length > 0) {
+      mainSchema.nested = nestedTypes;
+      allDependencies.push(...extractNestedDependencies(nestedTypes));
+    }
+  }
+  mainSchema.dependencies = allDependencies;
+  mainSchema.dependencies = deduplicateDependencies(mainSchema.dependencies);
+  mainSchema.dependencies = mainSchema.dependencies.filter((dep) => dep.url !== identifier.url);
+  results.push(mainSchema);
+  const bindingSchemas = await collectBindingSchemas(fhirSchema, manager, packageInfo);
+  results.push(...bindingSchemas);
+  return results;
+}
+async function transformFHIRSchemas(fhirSchemas, manager, packageInfo) {
+  const allResults = [];
+  for (const fhirSchema of fhirSchemas) {
+    const results = await transformFHIRSchema(fhirSchema, manager, packageInfo);
+    allResults.push(...results);
+  }
+  return allResults;
+}
+
+// src/typeschema/generator.ts
+class TypeSchemaGenerator {
+  manager;
+  options;
+  cache = null;
+  cacheConfig;
+  logger;
+  constructor(options = {}, cacheConfig) {
+    this.options = {
+      resourceTypes: [],
+      maxDepth: 10,
+      verbose: false,
+      ...options
+    };
+    this.manager = createCanonicalManager({ packages: [], workingDir: "tmp/fhir" });
+    this.cacheConfig = cacheConfig;
+    this.logger = new Logger({
+      component: "TypeSchemaGenerator",
+      level: this.options.verbose ? 0 : 1
+    });
+  }
+  async initializeCache() {
+    if (this.cacheConfig && !this.cache) {
+      this.cache = new TypeSchemaCache(this.cacheConfig);
+      await this.cache.initialize();
+    }
+  }
+  async generateFromPackage(packageName, packageVersion) {
+    await this.initializeCache();
+    const forceRegenerate = this.cacheConfig?.forceRegenerate ?? false;
+    if (this.cache && !forceRegenerate) {
+      const cachedSchemas = this.cache.getByPackage(packageName);
+      if (cachedSchemas.length > 0) {
+        await this.logger.info(`Using cached TypeSchemas for package: ${packageName}`, { schemasCount: cachedSchemas.length });
+        return cachedSchemas;
+      }
+    }
+    await this.logger.info(`Loading FHIR package: ${packageName}${packageVersion ? `@${packageVersion}` : ""}`, { packageName, packageVersion: packageVersion || "latest" }, "loadPackage");
+    this.manager = createCanonicalManager({
+      packages: [`${packageName}${packageVersion ? `@${packageVersion}` : ""}`],
+      workingDir: "tmp/fhir"
+    });
+    await this.manager.init();
+    const allResources = await this.manager.search({});
+    const structureDefinitions = allResources.filter((resource) => resource.resourceType === "StructureDefinition");
+    const valueSets = allResources.filter((resource) => resource.resourceType === "ValueSet");
+    await this.logger.info(`Found resources in package`, {
+      structureDefinitions: structureDefinitions.length,
+      valueSets: valueSets.length
+    }, "scanPackage");
+    await this.logger.info("Converting StructureDefinitions to FHIRSchemas", { total: structureDefinitions.length }, "convertSchemas");
+    const fhirSchemas = [];
+    let convertedCount = 0;
+    let failedCount = 0;
+    for (const sd of structureDefinitions) {
+      try {
+        const fhirSchema = translate(sd);
+        fhirSchemas.push(fhirSchema);
+        convertedCount++;
+        await this.logger.debug(`Converted StructureDefinition: ${sd.name || sd.id}`, { resourceType: sd.resourceType, url: sd.url });
+      } catch (error) {
+        failedCount++;
+        await this.logger.warn(`Failed to convert StructureDefinition`, {
+          name: sd.name || sd.id,
+          resourceType: sd.resourceType,
+          error: error instanceof Error ? error.message : String(error)
+        });
+      }
+    }
+    await this.logger.info("Schema conversion completed", {
+      converted: convertedCount,
+      failed: failedCount,
+      total: structureDefinitions.length
+    }, "convertSchemas");
+    if (valueSets.length > 0) {
+      await this.logger.debug("ValueSets available for enum extraction", {
+        count: valueSets.length,
+        valueSets: valueSets.map((vs) => vs.name || vs.id).slice(0, 10)
+      });
+    }
+    const packageInfo = {
+      name: packageName,
+      version: packageVersion || "latest"
+    };
+    const schemas = await this.generateFromSchemas(fhirSchemas, packageInfo);
+    if (this.cache && schemas.length > 0) {
+      await this.logger.info("Caching generated schemas", { count: schemas.length, packageName }, "cacheSchemas");
+      for (const schema of schemas) {
+        await this.cache.set(schema);
+      }
+      await this.logger.info(`Cached TypeSchemas for package: ${packageName}`, {
+        count: schemas.length
+      });
+    }
+    return schemas;
+  }
+  async generateFromSchema(fhirSchema, packageInfo) {
+    await this.logger.info("Transforming FHIR schema to TypeSchema", {
+      url: fhirSchema.url,
+      name: fhirSchema.name || "unnamed",
+      schemaType: fhirSchema.type
+    }, "transformSchema");
+    return await transformFHIRSchema(fhirSchema, this.manager, packageInfo);
+  }
+  async generateFromSchemas(fhirSchemas, packageInfo) {
+    await this.logger.info(`Transforming multiple FHIR schemas to TypeSchema`, { count: fhirSchemas.length }, "transformSchemas");
+    const baseSchemas = await transformFHIRSchemas(fhirSchemas, this.manager, packageInfo);
+    const results = [];
+    const groupedSchemas = this.groupTypeSchemas(baseSchemas);
+    results.push(...groupedSchemas.resources);
+    results.push(...groupedSchemas.complexTypes);
+    results.push(...groupedSchemas.primitives);
+    if (groupedSchemas.profiles.length > 0) {
+      await this.logger.info("Enhancing profiles", { count: groupedSchemas.profiles.length }, "enhanceProfiles");
+      const profileResults = await this.enhanceProfiles(groupedSchemas.profiles);
+      results.push(...profileResults);
+    }
+    if (groupedSchemas.extensions.length > 0) {
+      await this.logger.info("Enhancing extensions", { count: groupedSchemas.extensions.length }, "enhanceExtensions");
+      const extensionResults = await this.enhanceExtensions(groupedSchemas.extensions);
+      results.push(...extensionResults);
+    }
+    if (groupedSchemas.valueSets.length > 0) {
+      await this.logger.info("Enhancing value sets", { count: groupedSchemas.valueSets.length }, "enhanceValueSets");
+      const valueSetResults = await this.enhanceValueSets(groupedSchemas.valueSets);
+      results.push(...valueSetResults);
+    }
+    if (groupedSchemas.codeSystems.length > 0) {
+      await this.logger.info("Enhancing code systems", { count: groupedSchemas.codeSystems.length }, "enhanceCodeSystems");
+      const codeSystemResults = await this.enhanceCodeSystems(groupedSchemas.codeSystems);
+      results.push(...codeSystemResults);
+    }
+    await this.logger.info("Generated enhanced FHIR type schemas", {
+      totalSchemas: results.length,
+      resources: groupedSchemas.resources.length,
+      complexTypes: groupedSchemas.complexTypes.length,
+      primitives: groupedSchemas.primitives.length,
+      profiles: groupedSchemas.profiles.length,
+      extensions: groupedSchemas.extensions.length,
+      valueSets: groupedSchemas.valueSets.length,
+      codeSystems: groupedSchemas.codeSystems.length
+    });
+    return results;
+  }
+  groupTypeSchemas(schemas) {
+    const groups = {
+      resources: [],
+      complexTypes: [],
+      primitives: [],
+      profiles: [],
+      extensions: [],
+      valueSets: [],
+      codeSystems: []
+    };
+    for (const schema of schemas) {
+      switch (schema.identifier.kind) {
+        case "resource":
+          groups.resources.push(schema);
+          break;
+        case "complex-type":
+          groups.complexTypes.push(schema);
+          break;
+        case "primitive-type":
+          groups.primitives.push(schema);
+          break;
+        case "binding":
+          if ("metadata" in schema && schema.metadata?.isExtension) {
+            groups.extensions.push(schema);
+          } else {
+            groups.complexTypes.push(schema);
+          }
+          break;
+        case "value-set":
+          groups.valueSets.push(schema);
+          break;
+        default:
+          if ("metadata" in schema && schema.metadata?.isCodeSystem) {
+            groups.codeSystems.push(schema);
+          } else {
+            groups.complexTypes.push(schema);
+          }
+          break;
+      }
+    }
+    return groups;
+  }
+  async enhanceProfiles(schemas) {
+    return schemas;
+  }
+  async enhanceExtensions(schemas) {
+    return schemas;
+  }
+  async enhanceValueSets(schemas) {
+    return schemas;
+  }
+  async enhanceCodeSystems(schemas) {
+    return schemas;
+  }
+}
+
+// src/typeschema/parser.ts
+import { readFile as readFile7 } from "node:fs/promises";
+
+class TypeSchemaParser {
+  options;
+  constructor(options = {}) {
+    this.options = {
+      format: "auto",
+      validate: true,
+      strict: false,
+      ...options
+    };
+  }
+  async parseFromFile(filePath) {
+    const content = await readFile7(filePath, "utf-8");
+    const format = this.options.format === "auto" ? this.detectFormat(content, filePath) : this.options.format;
+    return this.parseFromString(content, format);
+  }
+  async parseFromString(content, format) {
+    const actualFormat = format || this.detectFormat(content);
+    let schemas;
+    if (actualFormat === "ndjson") {
+      schemas = this.parseNDJSON(content);
+    } else {
+      schemas = this.parseJSON(content);
+    }
+    if (this.options.validate) {
+      this.validateSchemas(schemas);
+    }
+    return schemas;
+  }
+  async parseFromFiles(filePaths) {
+    const allSchemas = [];
+    for (const filePath of filePaths) {
+      const schemas = await this.parseFromFile(filePath);
+      allSchemas.push(...schemas);
+    }
+    return allSchemas;
+  }
+  parseSchema(schemaData) {
+    if (!schemaData.identifier) {
+      throw new Error("TypeSchema must have an identifier");
+    }
+    if (!this.isValidIdentifier(schemaData.identifier)) {
+      throw new Error("TypeSchema identifier is invalid");
+    }
+    return schemaData;
+  }
+  findByIdentifier(schemas, identifier) {
+    return schemas.filter((schema) => this.matchesIdentifier(schema.identifier, identifier));
+  }
+  findByUrl(schemas, url) {
+    return schemas.find((schema) => schema.identifier.url === url);
+  }
+  findByKind(schemas, kind) {
+    return schemas.filter((schema) => schema.identifier.kind === kind);
+  }
+  findByPackage(schemas, packageName) {
+    return schemas.filter((schema) => schema.identifier.package === packageName);
+  }
+  getDependencies(schema) {
+    const dependencies = [];
+    if ("base" in schema && schema.base) {
+      dependencies.push(schema.base);
+    }
+    if ("dependencies" in schema && schema.dependencies) {
+      dependencies.push(...schema.dependencies);
+    }
+    if ("fields" in schema && schema.fields) {
+      for (const field of Object.values(schema.fields)) {
+        if ("type" in field && field.type) {
+          dependencies.push(field.type);
+        }
+        if ("binding" in field && field.binding) {
+          dependencies.push(field.binding);
+        }
+        if ("reference" in field && field.reference) {
+          dependencies.push(...field.reference);
+        }
+      }
+    }
+    if ("nested" in schema && schema.nested) {
+      for (const nested of schema.nested) {
+        dependencies.push(nested.identifier);
+        dependencies.push(nested.base);
+        for (const field of Object.values(nested.fields)) {
+          if ("type" in field && field.type) {
+            dependencies.push(field.type);
+          }
+          if ("binding" in field && field.binding) {
+            dependencies.push(field.binding);
+          }
+          if ("reference" in field && field.reference) {
+            dependencies.push(...field.reference);
+          }
+        }
+      }
+    }
+    if ("valueset" in schema) {
+      const bindingSchema = schema;
+      dependencies.push(bindingSchema.valueset);
+      if (bindingSchema.type) {
+        dependencies.push(bindingSchema.type);
+      }
+    }
+    return this.deduplicateDependencies(dependencies);
+  }
+  resolveDependencies(schemas, targetSchema) {
+    const dependencies = this.getDependencies(targetSchema);
+    const resolved = [];
+    for (const dep of dependencies) {
+      const depSchema = this.findByUrl(schemas, dep.url);
+      if (depSchema) {
+        resolved.push(depSchema);
+      }
+    }
+    return resolved;
+  }
+  detectFormat(content, filename) {
+    if (filename) {
+      if (filename.endsWith(".ndjson"))
+        return "ndjson";
+      if (filename.endsWith(".json"))
+        return "json";
+    }
+    const trimmed = content.trim();
+    if (trimmed.includes(`
+`)) {
+      const lines = trimmed.split(`
+`).filter((line) => line.trim());
+      if (lines.length > 1) {
+        try {
+          if (lines[0]) {
+            JSON.parse(lines[0]);
+          }
+          return "ndjson";
+        } catch {}
+      }
+    }
+    return "json";
+  }
+  parseNDJSON(content) {
+    const schemas = [];
+    const lines = content.split(`
+`).filter((line) => line.trim());
+    for (const line of lines) {
+      try {
+        const parsed = JSON.parse(line);
+        schemas.push(this.parseSchema(parsed));
+      } catch (error) {
+        if (this.options.strict) {
+          throw new Error(`Failed to parse NDJSON line: ${error}`);
+        }
+      }
+    }
+    return schemas;
+  }
+  parseJSON(content) {
+    try {
+      const parsed = JSON.parse(content);
+      if (Array.isArray(parsed)) {
+        return parsed.map((item) => this.parseSchema(item));
+      } else {
+        return [this.parseSchema(parsed)];
+      }
+    } catch (error) {
+      throw new Error(`Failed to parse JSON: ${error}`);
+    }
+  }
+  validateSchemas(schemas) {
+    for (const schema of schemas) {
+      if (!schema.identifier) {
+        throw new Error("Schema missing identifier");
+      }
+      if (!this.isValidIdentifier(schema.identifier)) {
+        throw new Error(`Invalid identifier in schema: ${JSON.stringify(schema.identifier)}`);
+      }
+    }
+  }
+  isValidIdentifier(identifier) {
+    return typeof identifier === "object" && identifier !== null && typeof identifier.kind === "string" && typeof identifier.package === "string" && typeof identifier.version === "string" && typeof identifier.name === "string" && typeof identifier.url === "string";
+  }
+  matchesIdentifier(identifier, criteria) {
+    return (!criteria.kind || identifier.kind === criteria.kind) && (!criteria.package || identifier.package === criteria.package) && (!criteria.version || identifier.version === criteria.version) && (!criteria.name || identifier.name === criteria.name) && (!criteria.url || identifier.url === criteria.url);
+  }
+  deduplicateDependencies(deps) {
+    const seen = new Set;
+    const unique = [];
+    for (const dep of deps) {
+      if (!seen.has(dep.url)) {
+        seen.add(dep.url);
+        unique.push(dep);
+      }
+    }
+    return unique.sort((a, b) => a.name.localeCompare(b.name));
+  }
+}
+// src/typeschema/utils.ts
+var isPolymorphicInstanceField = (field) => {
+  return "choiceOf" in field;
+};
+var isRegularField = (field) => {
+  return !("choices" in field);
+};
+var isTypeSchemaForResourceComplexTypeLogical = (schema) => {
+  return schema.identifier.kind === "resource" || schema.identifier.kind === "complex-type" || schema.identifier.kind === "logical";
+};
+// src/api/generators/typescript.ts
+import { mkdir as mkdir2, writeFile as writeFile4 } from "node:fs/promises";
+import { dirname, join as join10 } from "node:path";
+
+// src/utils.ts
+function toPascalCase(input) {
+  const parts = input.replace(/[^A-Za-z0-9]+/g, " ").split(" ").map((p) => p.trim()).filter(Boolean);
+  if (parts.length === 0)
+    return "";
+  return parts.map((p) => p.charAt(0).toUpperCase() + p.slice(1)).join("");
+}
+
+// src/api/generators/typescript.ts
+var PRIMITIVE_TYPE_MAP = {
+  string: "string",
+  code: "string",
+  uri: "string",
+  url: "string",
+  canonical: "string",
+  oid: "string",
+  uuid: "string",
+  id: "string",
+  markdown: "string",
+  xhtml: "string",
+  base64Binary: "string",
+  integer: "number",
+  unsignedInt: "number",
+  positiveInt: "number",
+  decimal: "number",
+  boolean: "boolean",
+  date: "string",
+  dateTime: "string",
+  instant: "string",
+  time: "string"
+};
+
+class TypeScriptAPIGenerator {
+  options;
+  imports = new Map;
+  exports = new Set;
+  resourceTypes = new Set;
+  currentSchemaName;
+  constructor(options) {
+    this.options = {
+      moduleFormat: "esm",
+      generateIndex: true,
+      includeDocuments: true,
+      namingConvention: "PascalCase",
+      includeExtensions: false,
+      includeProfiles: false,
+      ...options
+    };
+  }
+  async transformSchema(schema) {
+    this.currentSchemaName = this.formatTypeName(schema.identifier.name);
+    if (schema.identifier.kind === "value-set" || schema.identifier.kind === "binding" || schema.identifier.kind === "primitive-type" || schema.identifier.kind === "profile") {
+      return;
+    }
+    this.imports.clear();
+    this.exports.clear();
+    this.currentSchemaName = this.formatTypeName(schema.identifier.name);
+    const content = this.generateTypeScriptForSchema(schema);
+    const imports = new Map(this.imports);
+    const filename = this.getFilename(schema.identifier);
+    const exports = Array.from(this.exports.keys());
+    return {
+      content,
+      imports,
+      exports,
+      filename
+    };
+  }
+  generateTypeScriptForSchema(schema) {
+    const lines = [];
+    const interfaceName = this.formatTypeName(schema.identifier.name);
+    let overridedName;
+    if (interfaceName === "Reference") {
+      overridedName = `Reference<T extends ResourceTypes = ResourceTypes>`;
+    }
+    this.exports.add(interfaceName);
+    const baseInterface = this.getBaseInterface(schema);
+    if (baseInterface && !baseInterface.isPrimitive) {
+      this.imports.set(baseInterface.value, baseInterface.value);
+      lines.push(`export interface ${overridedName ?? interfaceName} extends ${baseInterface.value} {`);
+    } else {
+      lines.push(`export interface ${overridedName ?? interfaceName} {`);
+    }
+    if (schema.identifier.kind === "resource" && interfaceName !== "DomainResource" && interfaceName !== "Resource") {
+      this.resourceTypes.add(interfaceName);
+      lines.push(`	resourceType: '${interfaceName}';`);
+    }
+    if (isTypeSchemaForResourceComplexTypeLogical(schema)) {
+      if (schema.fields) {
+        for (const [fieldName, field] of Object.entries(schema.fields)) {
+          const fieldLine = this.generateField(fieldName, field, {
+            isNested: "type" in field && field.type.kind === "nested",
+            baseName: interfaceName
+          });
+          if (fieldLine) {
+            lines.push(`	${fieldLine}`);
+          }
+        }
+      }
+      lines.push("}");
+      if (schema.nested) {
+        for (const nested of schema.nested) {
+          lines.push("");
+          lines.push(this.generateNested(this.currentSchemaName ?? "", nested));
+        }
+      }
+    } else {
+      lines.push("}");
+    }
+    return lines.join(`
+`);
+  }
+  generateNested(baseName, nested) {
+    const lines = [];
+    const interfaceName = this.formatTypeName(nested.identifier.name);
+    this.exports.add(interfaceName);
+    if (nested.base) {
+      const baseInterface = this.getType(nested.base);
+      if (baseInterface.isPrimitive) {
+        lines.push(`export interface ${baseName}${interfaceName}{`);
+      } else {
+        this.imports.set(baseInterface.value, baseInterface.value);
+        lines.push(`export interface ${baseName}${interfaceName} extends ${baseInterface.value} {`);
+      }
+    } else {
+      lines.push(`export interface ${baseName}${interfaceName}{`);
+    }
+    if (nested.fields) {
+      for (const [fieldName, field] of Object.entries(nested.fields)) {
+        const fieldLine = this.generateField(fieldName, field);
+        if (fieldLine) {
+          lines.push(`	${fieldLine}`);
+        }
+      }
+    }
+    lines.push("}");
+    return lines.join(`
+`);
+  }
+  generateField(fieldName, field, nestedOpts) {
+    if (isPolymorphicInstanceField(field)) {
+      return this.generatePolymorphicInstance(fieldName, field, nestedOpts);
+    } else if (isRegularField(field)) {
+      return this.generateRegularField(fieldName, field, nestedOpts);
+    }
+    return "";
+  }
+  generatePolymorphicInstance(fieldName, field, nestedOpts) {
+    let typeString = "any";
+    if (field.reference) {
+      typeString = this.buildReferenceType(field.reference);
+    } else if (field.type) {
+      const subType = this.getType(field.type);
+      if (!subType.isPrimitive && !nestedOpts?.isNested) {
+        this.imports.set(subType.value, subType.value);
+      }
+      typeString = subType.value;
+    }
+    const optional = !field.required ? "?" : "";
+    const array = field.array ? "[]" : "";
+    return `${fieldName}${optional}: ${nestedOpts?.isNested && nestedOpts.baseName ? nestedOpts.baseName : ""}${typeString}${array};`;
+  }
+  generateRegularField(fieldName, field, nestedOpts) {
+    let typeString = "any";
+    if (field.enum) {
+      if (field.enum.length > 15) {
+        typeString = "string";
+      } else {
+        typeString = `${field.enum.map((e) => `'${e}'`).join(" | ")}`;
+      }
+    } else if (field.reference) {
+      typeString = this.buildReferenceType(field.reference);
+    } else if (field.type) {
+      const subType = this.getType(field.type);
+      if (!subType.isPrimitive && !nestedOpts?.isNested) {
+        this.imports.set(subType.value, subType.value);
+      }
+      typeString = subType.value;
+    }
+    if (nestedOpts?.baseName === "Reference" && fieldName === "type") {
+      typeString = "T";
+      this.imports.set("ResourceTypes", "utility");
+    }
+    const optional = !field.required ? "?" : "";
+    const array = field.array ? "[]" : "";
+    return `${fieldName}${optional}: ${nestedOpts?.isNested && nestedOpts.baseName ? nestedOpts.baseName : ""}${typeString}${array};`;
+  }
+  buildReferenceType(refers) {
+    this.imports.set("Reference", "Reference");
+    if (refers.length === 0) {
+      return "Reference";
+    }
+    if (refers.length === 1 && refers[0]?.name === "Resource") {
+      return "Reference";
+    }
+    return `Reference<${refers.map((r) => `'${r.name}'`).join(" | ")}>`;
+  }
+  async transformSchemas(schemas) {
+    const results = [];
+    for (const schema of schemas) {
+      const result = await this.transformSchema(schema);
+      if (result) {
+        results.push(result);
+      }
+    }
+    return results;
+  }
+  async generate(schemas) {
+    const filteredSchemas = this.filterSchemas(schemas);
+    const results = await this.transformSchemas(filteredSchemas);
+    const generatedFiles = [];
+    await mkdir2(this.options.outputDir, { recursive: true });
+    if (this.options.includeProfiles) {
+      await mkdir2(join10(this.options.outputDir, "profiles"), {
+        recursive: true
+      });
+    }
+    if (this.options.includeExtensions) {
+      await mkdir2(join10(this.options.outputDir, "extensions"), {
+        recursive: true
+      });
+    }
+    results.push({
+      filename: "utility.ts",
+      content: `export type ResourceTypes = ${Array.from(this.resourceTypes.keys().map((key) => `'${key}'`)).join(" | ")};
+
+`,
+      imports: new Map,
+      exports: ["ResourceTypes"]
+    });
+    for (const result of results) {
+      const filePath = join10(this.options.outputDir, result.filename);
+      await this.ensureDirectoryExists(filePath);
+      await writeFile4(filePath, `${this.generateImportStatements(result.imports)}
+
+${result.content}`, "utf-8");
+      generatedFiles.push({
+        path: filePath,
+        filename: result.filename,
+        content: result.content,
+        exports: result.exports
+      });
+    }
+    if (this.options.generateIndex) {
+      const indexFile = await this.generateIndexFile(results);
+      const indexPath = join10(this.options.outputDir, "index.ts");
+      await writeFile4(indexPath, indexFile.content, "utf-8");
+      generatedFiles.push({
+        path: indexPath,
+        filename: "index.ts",
+        content: indexFile.content,
+        exports: indexFile.exports
+      });
+      await this.generateSubfolderIndexFiles(results, generatedFiles);
+    }
+    return generatedFiles;
+  }
+  generateImportStatements(imports) {
+    const lines = [];
+    for (const [item, pkg] of imports.entries()) {
+      lines.push(`import type { ${item} } from './${pkg}';`);
+    }
+    return lines.join(`
+`);
+  }
+  async build(schemas) {
+    const filteredSchemas = this.filterSchemas(schemas);
+    const results = await this.transformSchemas(filteredSchemas);
+    const generatedFiles = [];
+    for (const result of results) {
+      generatedFiles.push({
+        path: join10(this.options.outputDir, result.filename),
+        filename: result.filename,
+        content: result.content,
+        exports: result.exports
+      });
+    }
+    if (this.options.generateIndex) {
+      const indexFile = await this.generateIndexFile(results);
+      generatedFiles.push({
+        path: join10(this.options.outputDir, "index.ts"),
+        filename: "index.ts",
+        content: indexFile.content,
+        exports: indexFile.exports
+      });
+    }
+    return generatedFiles;
+  }
+  setOutputDir(directory) {
+    this.options.outputDir = directory;
+  }
+  setOptions(options) {
+    this.options = { ...this.options, ...options };
+  }
+  getOptions() {
+    return { ...this.options };
+  }
+  async generateIndexFile(results) {
+    const lines = [];
+    const exports = [];
+    lines.push("/**");
+    lines.push(" * Generated TypeScript Type Definitions");
+    lines.push(" * ");
+    lines.push(" * Auto-generated from TypeSchema documents using atomic-codegen.");
+    lines.push(" * ");
+    lines.push(" * @packageDocumentation");
+    lines.push(" */");
+    lines.push("");
+    const primitiveTypes = [];
+    const complexTypes = [];
+    const resources = [];
+    const profiles = [];
+    const valueSets = [];
+    for (const result of results) {
+      for (const exportName of result.exports) {
+        if (result.filename.includes("primitive")) {
+          primitiveTypes.push(exportName);
+        } else if (result.filename.includes("complex")) {
+          complexTypes.push(exportName);
+        } else if (result.filename.includes("resource")) {
+          resources.push(exportName);
+        } else if (result.filename.includes("profile")) {
+          profiles.push(exportName);
+        } else if (result.filename.includes("valueset")) {
+          valueSets.push(exportName);
+        } else {
+          complexTypes.push(exportName);
+        }
+      }
+      const baseName = result.filename.replace(".ts", "");
+      if (baseName.startsWith("valueset") || baseName.startsWith("extension") || baseName.startsWith("profile")) {
+        continue;
+      }
+      if (result.exports.length > 0) {
+        if (result.exports.length === 1) {
+          lines.push(`export type { ${result.exports[0]} } from './${baseName}';`);
+        } else {
+          lines.push(`export type {`);
+          for (let i = 0;i < result.exports.length; i++) {
+            const exportName = result.exports[i];
+            const isLast = i === result.exports.length - 1;
+            lines.push(`  ${exportName}${isLast ? "" : ","}`);
+          }
+          lines.push(`} from './${baseName}';`);
+        }
+        exports.push(...result.exports);
+      }
+    }
+    lines.push("");
+    if (resources.length > 0) {
+      lines.push("// Resource type utilities");
+      lines.push("");
+      lines.push("export const ResourceTypeMap = {");
+      for (const resource of resources.sort()) {
+        lines.push(`  ${resource}: true,`);
+      }
+      lines.push("} as const;");
+      lines.push("");
+      lines.push("export type ResourceType = keyof typeof ResourceTypeMap;");
+      lines.push("");
+      lines.push("export type AnyResource =");
+      for (let i = 0;i < resources.length; i++) {
+        const resource = resources[i];
+        const isLast = i === resources.length - 1;
+        lines.push(`  ${i === 0 ? "" : "| "}${resource}${isLast ? ";" : ""}`);
+      }
+      lines.push("");
+      lines.push("/**");
+      lines.push(" * Type guard to check if an object is a FHIR resource");
+      lines.push(" */");
+      lines.push("export function isFHIRResource(obj: unknown): obj is AnyResource {");
+      lines.push('  return obj && typeof obj === "object" && "resourceType" in obj && (obj.resourceType as string) in ResourceTypeMap;');
+      lines.push("}");
+      lines.push("");
+    }
+    lines.push("// Namespace exports for organized access");
+    lines.push("");
+    lines.push("// Value sets namespace - contains all FHIR ValueSet types and bindings");
+    lines.push('export * as ValueSets from "./valuesets";');
+    lines.push("");
+    if (this.options.includeExtensions) {
+      lines.push("// Extensions namespace - contains all FHIR Extension types");
+      lines.push('export * as Extensions from "./extensions";');
+      lines.push("");
+    }
+    if (profiles.length > 0) {
+      lines.push("// Profiles namespace - contains all FHIR Profile types");
+      lines.push('export * as Profiles from "./profiles";');
+      lines.push("");
+    }
+    const content = lines.join(`
+`);
+    return { content, exports };
+  }
+  async ensureDirectoryExists(filePath) {
+    const dir = dirname(filePath);
+    await mkdir2(dir, { recursive: true });
+  }
+  filterSchemas(schemas) {
+    if (this.options.includeExtensions) {
+      return schemas;
+    }
+    return schemas;
+  }
+  async generateSubfolderIndexFiles(results, generatedFiles) {
+    const subfolders = [];
+    if (this.options.includeExtensions) {
+      subfolders.push("extensions");
+    }
+    for (const subfolder of subfolders) {
+      const subfolderResults = results.filter((r) => r.filename.startsWith(`${subfolder}/`));
+      const indexContent = this.generateSubfolderIndex(subfolderResults, subfolder);
+      const indexPath = join10(this.options.outputDir, subfolder, "index.ts");
+      await writeFile4(indexPath, indexContent, "utf-8");
+      generatedFiles.push({
+        path: indexPath,
+        filename: `${subfolder}/index.ts`,
+        content: indexContent,
+        exports: subfolderResults.flatMap((r) => r.exports)
+      });
+    }
+  }
+  generateSubfolderIndex(results, subfolder) {
+    const lines = [];
+    lines.push("/**");
+    lines.push(` * ${subfolder.charAt(0).toUpperCase() + subfolder.slice(1)} Index`);
+    lines.push(" * ");
+    lines.push(" * Auto-generated exports for all types in this subfolder.");
+    lines.push(" */");
+    lines.push("");
+    if (results.length === 0) {
+      lines.push("// No types in this category");
+      lines.push("export {};");
+      return lines.join(`
+`);
+    }
+    for (const result of results) {
+      const baseName = result.filename.replace(`${subfolder}/`, "").replace(".ts", "");
+      if (result.exports.length > 0) {
+        if (result.exports.length === 1) {
+          lines.push(`export type { ${result.exports[0]} } from './${baseName}';`);
+        } else {
+          lines.push(`export type {`);
+          for (let i = 0;i < result.exports.length; i++) {
+            const exportName = result.exports[i];
+            const isLast = i === result.exports.length - 1;
+            lines.push(`  ${exportName}${isLast ? "" : ","}`);
+          }
+          lines.push(`} from './${baseName}';`);
+        }
+      }
+    }
+    return lines.join(`
+`);
+  }
+  formatTypeName(name) {
+    if (this.options.namingConvention === "PascalCase") {
+      return toPascalCase(name);
+    }
+    return name;
+  }
+  getType(identifier) {
+    const primitiveType = PRIMITIVE_TYPE_MAP[identifier.name];
+    if (primitiveType) {
+      return { isPrimitive: true, value: primitiveType };
+    }
+    return { isPrimitive: false, value: this.formatTypeName(identifier.name) };
+  }
+  getBaseInterface(schema) {
+    if (isTypeSchemaForResourceComplexTypeLogical(schema) && schema.base) {
+      return this.getType(schema.base);
+    }
+    return null;
+  }
+  getFilename(identifier) {
+    const name = toPascalCase(identifier.name);
+    return `${name}.ts`;
+  }
+}
+
+// src/api/builder.ts
+class APIBuilder {
+  schemas = [];
+  options;
+  generators = new Map;
+  progressCallback;
+  cache;
+  pendingOperations = [];
+  typeSchemaGenerator;
+  logger;
+  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
+    };
+    this.typeSchemaConfig = options.typeSchemaConfig;
+    this.logger = new Logger({
+      component: "APIBuilder",
+      level: this.options.verbose ? 0 : 1
+    });
+    if (this.options.cache) {
+      this.cache = new TypeSchemaCache(this.typeSchemaConfig);
+    }
+  }
+  fromPackage(packageName, version) {
+    this.logger.info(`Configuring generation from FHIR package`, { packageName, version: version || "latest" }, "fromPackage");
+    const operation = this.loadFromPackage(packageName, version);
+    this.pendingOperations.push(operation);
+    return this;
+  }
+  fromFiles(...filePaths) {
+    this.logger.info(`Configuring generation from TypeSchema files`, { count: filePaths.length, files: filePaths.slice(0, 5) }, "fromFiles");
+    const operation = this.loadFromFiles(filePaths);
+    this.pendingOperations.push(operation);
+    return this;
+  }
+  fromSchemas(schemas) {
+    this.logger.info(`Adding TypeSchemas to generation`, { count: schemas.length }, "fromSchemas");
+    this.schemas = [...this.schemas, ...schemas];
+    return this;
+  }
+  typescript(options = {}) {
+    const typesOutputDir = `${this.options.outputDir}/types`;
+    const generator = new TypeScriptAPIGenerator({
+      outputDir: typesOutputDir,
+      moduleFormat: options.moduleFormat || "esm",
+      generateIndex: options.generateIndex ?? true,
+      includeDocuments: options.includeDocuments ?? true,
+      namingConvention: options.namingConvention || "PascalCase",
+      includeExtensions: options.includeExtensions ?? false,
+      includeProfiles: options.includeProfiles ?? false
+    });
+    this.generators.set("typescript", generator);
+    this.logger.info("Configured TypeScript generator", {
+      outputDir: typesOutputDir,
+      moduleFormat: options.moduleFormat || "esm",
+      generateValidators: options.generateValidators ?? true,
+      generateGuards: options.generateGuards ?? true,
+      generateBuilders: options.generateBuilders ?? false
+    }, "typescript");
+    return this;
+  }
+  onProgress(callback) {
+    this.progressCallback = callback;
+    return this;
+  }
+  outputTo(directory) {
+    this.logger.info(`Setting output directory`, { directory, generatorCount: this.generators.size }, "outputTo");
+    this.options.outputDir = directory;
+    for (const generator of this.generators.values()) {
+      if (generator.setOutputDir) {
+        generator.setOutputDir(directory);
+      }
+    }
+    return this;
+  }
+  verbose(enabled = true) {
+    this.options.verbose = enabled;
+    return this;
+  }
+  validate(enabled = true) {
+    this.options.validate = enabled;
+    return this;
+  }
+  async generate() {
+    const startTime = performance.now();
+    const result = {
+      success: false,
+      outputDir: this.options.outputDir,
+      filesGenerated: [],
+      errors: [],
+      warnings: [],
+      duration: 0
+    };
+    await this.logger.info("Starting code generation", {
+      outputDir: this.options.outputDir,
+      pendingOperations: this.pendingOperations.length,
+      generatorTypes: Array.from(this.generators.keys()),
+      validate: this.options.validate,
+      cache: this.options.cache
+    }, "generate");
+    try {
+      this.reportProgress("Loading", 0, 4, "Loading TypeSchema data...");
+      await this.resolveSchemas();
+      await this.logger.info("Schemas resolved", { schemasCount: this.schemas.length }, "resolveSchemas");
+      this.reportProgress("Validating", 1, 4, "Validating TypeSchema documents...");
+      if (this.options.validate) {
+        await this.logger.info("Starting schema validation", {}, "validate");
+        await this.validateSchemas(result);
+        await this.logger.info("Schema validation completed", { warnings: result.warnings.length }, "validate");
+      }
+      this.reportProgress("Generating", 2, 4, "Generating code...");
+      await this.logger.info("Starting code generation", { generatorCount: this.generators.size }, "executeGenerators");
+      await this.executeGenerators(result);
+      this.reportProgress("Complete", 4, 4, "Generation completed successfully");
+      result.success = result.errors.length === 0;
+      await this.logger.info("Code generation completed", {
+        success: result.success,
+        filesGenerated: result.filesGenerated.length,
+        errors: result.errors.length,
+        warnings: result.warnings.length,
+        duration: `${Math.round(result.duration)}ms`
+      }, "generate");
+    } catch (error) {
+      await this.logger.error("Code generation failed", error instanceof Error ? error : new Error(String(error)), {
+        outputDir: this.options.outputDir,
+        schemasCount: this.schemas.length
+      });
+      result.errors.push(error instanceof Error ? error.message : String(error));
+      result.success = false;
+    } finally {
+      result.duration = performance.now() - startTime;
+    }
+    return result;
+  }
+  async build() {
+    await this.resolveSchemas();
+    const results = {};
+    for (const [type, generator] of this.generators.entries()) {
+      if (generator.build) {
+        results[type] = await generator.build(this.schemas);
+      }
+    }
+    return results;
+  }
+  reset() {
+    this.schemas = [];
+    this.generators.clear();
+    this.progressCallback = undefined;
+    return this;
+  }
+  getSchemas() {
+    return [...this.schemas];
+  }
+  getGenerators() {
+    return Array.from(this.generators.keys());
+  }
+  async loadFromPackage(packageName, version) {
+    const generator = new TypeSchemaGenerator({
+      verbose: this.options.verbose
+    }, 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({
+        verbose: this.options.verbose
+      }, this.typeSchemaConfig);
+    }
+    const parser = new TypeSchemaParser({
+      format: "auto",
+      validate: this.options.validate
+    });
+    const schemas = await parser.parseFromFiles(filePaths);
+    this.schemas = [...this.schemas, ...schemas];
+    if (this.cache) {
+      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;
+    for (const [type, generator] of this.generators.entries()) {
+      this.reportProgress("Generating", 2 + current / generatorCount, 4, `Generating ${type}...`);
+      try {
+        const files = await generator.generate(this.schemas);
+        result.filesGenerated.push(...files.map((f) => f.path || f.filename));
+      } 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) {
+      console.log(`[${phase}] ${message}`);
+    }
+  }
+}
+function createAPI(options) {
+  return new APIBuilder(options);
+}
+async function generateTypesFromPackage(packageName, outputDir, options = {}) {
+  return createAPI({
+    outputDir,
+    verbose: options.verbose,
+    validate: options.validate
+  }).fromPackage(packageName, options.version).typescript().generate();
+}
+async function generateTypesFromFiles(inputFiles, outputDir, options = {}) {
+  return createAPI({
+    outputDir,
+    verbose: options.verbose,
+    validate: options.validate
+  }).fromFiles(...inputFiles).typescript().generate();
+}
+// src/config.ts
+import { existsSync as existsSync2 } from "node:fs";
+import { readFile as readFile8 } from "node:fs/promises";
+import { resolve } from "node:path";
+var DEFAULT_CONFIG = {
+  outputDir: "./generated",
+  verbose: false,
+  overwrite: true,
+  validate: true,
+  cache: true,
+  typescript: {
+    moduleFormat: "esm",
+    generateIndex: true,
+    includeDocuments: false,
+    namingConvention: "PascalCase",
+    strictMode: true,
+    generateValidators: true,
+    generateGuards: true,
+    includeProfiles: true,
+    includeExtensions: false,
+    includeValueSets: true,
+    includeCodeSystems: false,
+    includeOperations: false,
+    fhirVersion: "R4",
+    resourceTypes: [],
+    maxDepth: 10,
+    generateBuilders: false,
+    builderOptions: {
+      includeValidation: true,
+      includeFactoryMethods: true,
+      includeInterfaces: true,
+      generateNestedBuilders: true,
+      includeHelperMethods: true,
+      supportPartialBuild: true,
+      includeJSDoc: true,
+      generateFactories: true,
+      includeTypeGuards: true,
+      handleChoiceTypes: true,
+      generateArrayHelpers: true
+    },
+    validatorOptions: {
+      includeCardinality: true,
+      includeTypes: true,
+      includeConstraints: true,
+      includeInvariants: false,
+      validateRequired: true,
+      allowAdditional: false,
+      strictValidation: false,
+      collectMetrics: false,
+      generateAssertions: true,
+      generatePartialValidators: true,
+      optimizePerformance: true,
+      includeJSDoc: true,
+      generateCompositeValidators: true
+    },
+    guardOptions: {
+      includeRuntimeValidation: true,
+      includeErrorMessages: true,
+      treeShakeable: true,
+      targetTSVersion: "5.0",
+      strictGuards: false,
+      includeNullChecks: true,
+      verbose: false
+    }
+  },
+  typeSchema: {
+    enablePersistence: true,
+    cacheDir: ".typeschema-cache",
+    maxAge: 24 * 60 * 60 * 1000,
+    validateCached: true,
+    forceRegenerate: false,
+    shareCache: true,
+    cacheKeyPrefix: ""
+  },
+  packages: [],
+  files: [],
+  $schema: "https://atomic-ehr.github.io/codegen/config-schema.json"
+};
+var CONFIG_FILE_NAMES = [
+  "atomic-codegen.config.ts",
+  "atomic-codegen.config.js",
+  "atomic-codegen.config.json",
+  ".atomic-codegenrc",
+  "atomic-codegen.json",
+  ".atomic-codegen.json",
+  "codegen.config.json",
+  "codegen.json"
+];
+
+class ConfigValidator {
+  validate(config) {
+    const result = {
+      valid: true,
+      errors: [],
+      warnings: []
+    };
+    if (!config || typeof config !== "object") {
+      result.valid = false;
+      result.errors.push({
+        path: "root",
+        message: "Configuration must be an object",
+        value: config
+      });
+      return result;
+    }
+    const cfg = config;
+    if (cfg.outputDir !== undefined && typeof cfg.outputDir !== "string") {
+      result.errors.push({
+        path: "outputDir",
+        message: "outputDir must be a string",
+        value: cfg.outputDir
+      });
+    }
+    const booleanFields = ["verbose", "overwrite", "validate", "cache"];
+    for (const field of booleanFields) {
+      if (cfg[field] !== undefined && typeof cfg[field] !== "boolean") {
+        result.errors.push({
+          path: field,
+          message: `${field} must be a boolean`,
+          value: cfg[field]
+        });
+      }
+    }
+    if (cfg.typescript !== undefined) {
+      const tsErrors = this.validateTypeScriptConfig(cfg.typescript);
+      result.errors.push(...tsErrors);
+    }
+    if (cfg.packages !== undefined) {
+      if (!Array.isArray(cfg.packages)) {
+        result.errors.push({
+          path: "packages",
+          message: "packages must be an array",
+          value: cfg.packages
+        });
+      } else {
+        cfg.packages.forEach((pkg, index) => {
+          if (typeof pkg !== "string") {
+            result.errors.push({
+              path: `packages[${index}]`,
+              message: "package name must be a string",
+              value: pkg
+            });
+          }
+        });
+      }
+    }
+    if (cfg.files !== undefined) {
+      if (!Array.isArray(cfg.files)) {
+        result.errors.push({
+          path: "files",
+          message: "files must be an array",
+          value: cfg.files
+        });
+      } else {
+        cfg.files.forEach((file, index) => {
+          if (typeof file !== "string") {
+            result.errors.push({
+              path: `files[${index}]`,
+              message: "file path must be a string",
+              value: file
+            });
+          }
+        });
+      }
+    }
+    result.valid = result.errors.length === 0;
+    if (result.valid) {
+      result.config = cfg;
+    }
+    return result;
+  }
+  validateTypeScriptConfig(config) {
+    const errors = [];
+    if (typeof config !== "object" || config === null) {
+      errors.push({
+        path: "typescript",
+        message: "typescript config must be an object",
+        value: config
+      });
+      return errors;
+    }
+    const cfg = config;
+    if (cfg.moduleFormat !== undefined) {
+      if (!["esm", "cjs"].includes(cfg.moduleFormat)) {
+        errors.push({
+          path: "typescript.moduleFormat",
+          message: 'moduleFormat must be "esm" or "cjs"',
+          value: cfg.moduleFormat
+        });
+      }
+    }
+    if (cfg.namingConvention !== undefined) {
+      if (!["PascalCase", "camelCase"].includes(cfg.namingConvention)) {
+        errors.push({
+          path: "typescript.namingConvention",
+          message: 'namingConvention must be "PascalCase" or "camelCase"',
+          value: cfg.namingConvention
+        });
+      }
+    }
+    const booleanFields = [
+      "generateIndex",
+      "includeDocuments",
+      "strictMode",
+      "generateValidators",
+      "generateGuards",
+      "includeProfiles",
+      "includeExtensions"
+    ];
+    for (const field of booleanFields) {
+      if (cfg[field] !== undefined && typeof cfg[field] !== "boolean") {
+        errors.push({
+          path: `typescript.${field}`,
+          message: `${field} must be a boolean`,
+          value: cfg[field]
+        });
+      }
+    }
+    if (cfg.validatorOptions !== undefined) {
+      const validatorErrors = this.validateValidatorOptions(cfg.validatorOptions);
+      errors.push(...validatorErrors);
+    }
+    if (cfg.guardOptions !== undefined) {
+      const guardErrors = this.validateGuardOptions(cfg.guardOptions);
+      errors.push(...guardErrors);
+    }
+    return errors;
+  }
+  validateValidatorOptions(config) {
+    const errors = [];
+    if (typeof config !== "object" || config === null) {
+      errors.push({
+        path: "typescript.validatorOptions",
+        message: "validatorOptions must be an object",
+        value: config
+      });
+      return errors;
+    }
+    const cfg = config;
+    const booleanFields = [
+      "includeCardinality",
+      "includeTypes",
+      "includeConstraints",
+      "includeInvariants",
+      "validateRequired",
+      "allowAdditional",
+      "strictValidation",
+      "collectMetrics",
+      "generateAssertions",
+      "generatePartialValidators",
+      "optimizePerformance",
+      "includeJSDoc",
+      "generateCompositeValidators"
+    ];
+    for (const field of booleanFields) {
+      if (cfg[field] !== undefined && typeof cfg[field] !== "boolean") {
+        errors.push({
+          path: `typescript.validatorOptions.${field}`,
+          message: `${field} must be a boolean`,
+          value: cfg[field]
+        });
+      }
+    }
+    return errors;
+  }
+  validateGuardOptions(config) {
+    const errors = [];
+    if (typeof config !== "object" || config === null) {
+      errors.push({
+        path: "typescript.guardOptions",
+        message: "guardOptions must be an object",
+        value: config
+      });
+      return errors;
+    }
+    const cfg = config;
+    if (cfg.targetTSVersion !== undefined) {
+      if (!["3.8", "4.0", "4.5", "5.0"].includes(cfg.targetTSVersion)) {
+        errors.push({
+          path: "typescript.guardOptions.targetTSVersion",
+          message: 'targetTSVersion must be one of: "3.8", "4.0", "4.5", "5.0"',
+          value: cfg.targetTSVersion
+        });
+      }
+    }
+    const booleanFields = [
+      "includeRuntimeValidation",
+      "includeErrorMessages",
+      "treeShakeable",
+      "strictGuards",
+      "includeNullChecks",
+      "verbose"
+    ];
+    for (const field of booleanFields) {
+      if (cfg[field] !== undefined && typeof cfg[field] !== "boolean") {
+        errors.push({
+          path: `typescript.guardOptions.${field}`,
+          message: `${field} must be a boolean`,
+          value: cfg[field]
+        });
+      }
+    }
+    return errors;
+  }
+}
+
+class ConfigLoader {
+  validator = new ConfigValidator;
+  async autoload(workingDir = process.cwd()) {
+    const configPath = await this.findConfigFile(workingDir);
+    if (configPath) {
+      return this.loadFromFile(configPath);
+    }
+    return { ...DEFAULT_CONFIG };
+  }
+  async loadFromFile(filePath) {
+    try {
+      let config;
+      if (filePath.endsWith(".ts") || filePath.endsWith(".js")) {
+        const absolutePath = resolve(filePath);
+        const importResult = await import(absolutePath);
+        config = importResult.default || importResult;
+      } else {
+        const content = await readFile8(filePath, "utf-8");
+        config = JSON.parse(content);
+      }
+      const validation = this.validator.validate(config);
+      if (!validation.valid) {
+        const errorMessages = validation.errors.map((e) => `${e.path}: ${e.message}`).join(`
+`);
+        throw new Error(`Configuration validation failed:
+${errorMessages}`);
+      }
+      return this.mergeWithDefaults(validation.config);
+    } catch (error) {
+      if (error instanceof Error) {
+        throw new Error(`Failed to load config from ${filePath}: ${error.message}`);
+      }
+      throw error;
+    }
+  }
+  async findConfigFile(startDir) {
+    for (const fileName of CONFIG_FILE_NAMES) {
+      const configPath = resolve(startDir, fileName);
+      if (existsSync2(configPath)) {
+        return configPath;
+      }
+    }
+    return null;
+  }
+  mergeWithDefaults(userConfig) {
+    return {
+      ...DEFAULT_CONFIG,
+      ...userConfig,
+      typescript: {
+        ...DEFAULT_CONFIG.typescript,
+        ...userConfig.typescript
+      }
+    };
+  }
+}
+var configLoader = new ConfigLoader;
+async function loadConfig(workingDir) {
+  return configLoader.autoload(workingDir);
+}
+function isConfig(obj) {
+  const validator = new ConfigValidator;
+  const result = validator.validate(obj);
+  return result.valid;
+}
+export {
+  loadConfig,
+  isConfig,
+  generateTypesFromPackage,
+  generateTypesFromFiles,
+  createAPI,
+  configLoader,
+  TypeScriptAPIGenerator,
+  TypeSchemaParser,
+  TypeSchemaGenerator,
+  TypeSchemaCache,
+  DEFAULT_CONFIG,
+  ConfigValidator,
+  ConfigLoader,
+  CONFIG_FILE_NAMES,
+  APIBuilder
+};