import { loadFromDirectory } from "fhir-definition";

const registry = loadFromDirectory("./definitions");

// Query resources
const patientSD = registry.getStructureDefinition(
  "http://hl7.org/fhir/StructureDefinition/Patient",
);
const genderVS = registry.getValueSet(
  "http://hl7.org/fhir/ValueSet/administrative-gender",
);
const patientSPs = registry.getSearchParameters("Patient");

import { loadDefinitionPackages } from "fhir-definition";

// Directory structure:
// definitions/
//   hl7.fhir.r4.core/
//     package.json
//     package/
//       StructureDefinition-Patient.json
//   hl7.fhir.us.core/
//     package.json (depends on r4.core)
//     package/
//       StructureDefinition-us-core-patient.json

const { registry, result } = loadDefinitionPackages("./definitions");

console.log(result.loadedPackages); // [r4.core, us.core] (dependency order)
console.log(registry.getStatistics()); // { structureDefinitionCount: 4, ... }

import {
  loadFromDirectory,
  StructureDefinitionResolver,
  CodeSystemResolver,
} from "fhir-definition";

const registry = loadFromDirectory("./definitions");
const sdResolver = new StructureDefinitionResolver(registry);
const csResolver = new CodeSystemResolver(registry);

// Resolve with version
const patient = sdResolver.resolveVersioned(
  "http://hl7.org/fhir/StructureDefinition/Patient|4.0.1",
);

// Lookup code in CodeSystem
const conceptInfo = csResolver.lookupCode(
  "http://terminology.hl7.org/CodeSystem/observation-category",
  "vital-signs",
);
console.log(conceptInfo); // { code: 'vital-signs', display: 'Vital Signs', system: '...' }

import { loadDefinitionPackages } from "fhir-definition";
import { FhirRuntime } from "fhir-runtime"; // hypothetical

const { registry } = loadDefinitionPackages("./definitions");

// registry satisfies DefinitionProvider interface (structural typing)
const runtime = new FhirRuntime({ definitions: registry });

// Runtime can now query definitions for validation
runtime.validate(
  patientResource,
  "http://hl7.org/fhir/StructureDefinition/Patient",
);

interface DefinitionRegistry {
  // Write
  register(resource: FhirDefinitionResource): void;
  registerPackage(pkg: LoadedPackage): void;

  // StructureDefinition
  getStructureDefinition(url: string): StructureDefinition | undefined;
  getStructureDefinitionByVersion(
    url: string,
    version: string,
  ): StructureDefinition | undefined;
  hasStructureDefinition(url: string): boolean;
  listStructureDefinitions(): string[];

  // ValueSet
  getValueSet(url: string): ValueSet | undefined;
  hasValueSet(url: string): boolean;
  listValueSets(): string[];

  // CodeSystem
  getCodeSystem(url: string): CodeSystem | undefined;
  hasCodeSystem(url: string): boolean;
  listCodeSystems(): string[];

  // SearchParameter
  getSearchParameters(resourceType: string): SearchParameter[];
  getSearchParameter(
    resourceType: string,
    name: string,
  ): SearchParameter | undefined;
  getSearchParameterByUrl(url: string): SearchParameter | undefined;

  // Metadata
  getLoadedPackages(): LoadedPackage[];
  getStatistics(): RegistryStatistics;
}

// StructureDefinitionResolver
resolve(url: string): StructureDefinition | undefined;
resolveVersioned(url: string, version?: string): StructureDefinition | undefined; // supports url|version
list(): string[];

// ValueSetResolver
resolve(url: string): ValueSet | undefined;
list(): string[];

// CodeSystemResolver
resolve(url: string): CodeSystem | undefined;
lookupCode(system: string, code: string): ConceptInfo | undefined; // recursive concept tree search
list(): string[];

// SearchParameterResolver
resolveByResourceType(resourceType: string): SearchParameter[];
resolveByName(resourceType: string, name: string): SearchParameter | undefined;
resolveByUrl(url: string): SearchParameter | undefined;
getAllResourceTypes(): string[];
listAll(): SearchParameter[]; // deduplicated

// Scan packages
const scanner = new PackageScanner();
const scanResult = scanner.scan("./definitions", {
  recursive: true,
  maxDepth: 3,
});

// Resolve dependencies (topological sort)
const resolver = new DependencyResolver();
const { sortedPackages, errors } = resolver.resolve(scanResult.packages);

// Load single package
const loader = new PackageLoader();
const loadResult = loader.loadPackage(pkg, {
  resourceTypes: ["StructureDefinition"],
});

// Full pipeline
const manager = new PackageManager();
const { registry, result } = manager.loadPackages("./definitions");