babelfhir-ts 1.0.16 → 1.0.18

package/README.md

@@ -4,30 +4,23 @@
 
 ## Why BabelFHIR-TS?
 
-**The FHIR Challenge**: Implementation Guides define strict profiles (e.g., US Core, German basisprofil) that constrain base FHIR resources with must-support elements, custom extensions, value set bindings, and cardinality rules. Existing TypeScript libraries can't capture these requirements when you need profile-specific types.
+**The FHIR Challenge**: Implementation Guides define strict profiles that constrain base FHIR resources with required or must-support elements, custom extensions, value set bindings, and cardinality rules. Existing TypeScript libraries can't capture these requirements when you need profile-specific types, leading to an overhead when using TypeScript to build apps that interact with FHIR servers.
 
-**The BabelFHIR-TS Solution**: Automatically generates TypeScript interfaces and validation logic directly from StructureDefinition JSON. Your IDE autocompletes must-support fields, flags missing extensions at compile-time, and validates FHIRPath invariants at runtime.
+**The BabelFHIR-TS Solution**: Automatically generates TypeScript interfaces and validation logic directly from StructureDefinition JSON. Your IDE autocompletes required fields, flags missing extensions at compile-time, and validates FHIRPath invariants at runtime.
 
 ### What you get
 
-- **Strongly typed interfaces** that merge profile constraints with base FHIR types (built on `@types/fhir`)
+- **Strongly typed interfaces** that merge profile constraints with base FHIR types (types come from `@types/fhir`)
+- **Compiled output by default** — packages ship JavaScript (`.js`) plus TypeScript declarations (`.d.ts`)
 - **Runtime validation** using FHIRPath expressions from the profile—no external validator required for basic checks
 - **Type-safe extension handling** with proper slicing and nested extension support
 - **Random data builders** for testing and development (when class generation is enabled)
 - **Zero manual mapping**—consume any FHIR package or Implementation Guide directly from registries
+- **Fast and lightweight**—minimal runtime deps; only `fhirpath` is required for validators
+- **Install any FHIR profile as a node module**—use `babelfhir-ts install` to add Implementation Guides directly to your project
 
 Use it to build FHIR-compliant APIs, validate incoming resources against profiles, or generate type-safe client SDKs from Implementation Guides.
 
-## Key features
-
-- 🎯 **Profile-first design** – generate interfaces that understand your IG's must-support elements, slices, and extensions
-- ⚙️ **CLI-first workflow** – install globally or run with `npx`; works against package archives, entire directories, or single `.json` profiles
-- ✅ **Built-in validation** – every generated class includes an async `validate()` function that executes profile constraints through FHIRPath *(high-level checks only; see details below)*
-- 🔌 **Extension-aware** – properly types extension slices, nested extensions, and sidecar `_field` elements for primitive extensions
-- 📦 **Package-friendly** – re-embeds generated code back into `.tgz` archives or expands into a target folder for direct consumption
-- 🌐 **Registry integration** – download and process packages directly from Simplifier, HL7, or custom FHIR registries
-- ♻️ **Caching + cleanup** – opt into `--no-cache` to remove temporary `.cache` directories after generation
-
 ## Installation
 
 Install globally (recommended when using the CLI frequently):
@@ -79,24 +72,59 @@ const patient = USCorePatientClass.random();
 const { errors, warnings } = await patient.validate();
 ```
 
+## Using the generated code in your project
+
+Generated profile packages installed via `babelfhir-ts install` are published as **compiled JavaScript with TypeScript declarations**:
+
+- JavaScript for runtime: `index.js`, `*.js`
+- Type declarations for IDE/TS: `index.d.ts`, `*.d.ts`
+- Dependencies:
+  - `@types/fhir` is included as a dependency of the generated package (no extra setup in your app)
+  - `fhirpath` is a peer dependency (required only if you use the generated validators/classes)
+
+Install `fhirpath` in your app if you plan to call `.validate()` or use the generated classes:
+
+```bash
+npm install fhirpath
+```
+
+Import and use:
+
+```ts
+// TypeScript or JavaScript
+import { AdmissionAppointment, AdmissionAppointmentClass } from "pink.admission-generated";
+
+// Types are available automatically via .d.ts
+const appt: AdmissionAppointment = {
+  resourceType: "Appointment",
+  status: "booked",
+  start: "2025-10-23T14:00:00Z",
+};
+
+// Optional helper class + validation
+const instance = AdmissionAppointmentClass.random();
+const result = await new AdmissionAppointmentClass(appt).validate();
+console.log(result.errors, result.warnings);
+```
+
 ## CLI reference
 
 ```
 babelfhir-ts [options] [<input> [output]]
 ```
 
-| Argument / option | Description |
-| ----------------- | ----------- |
-| `<input>` | Directory of FHIR packages/StructureDefinitions, single package (`.tgz`/`.zip`), or single StructureDefinition `.json`. Defaults to `./input` when omitted. |
-| `<output>` | Destination directory or archive. Defaults to `./output` when omitted. |
-| `install` | Downloads, processes, and installs a package as a project dependency. |
-| `--package <pkg@version>` | Fetch a package from a registry and process it without manual download. |
-| `--registry <url>` | Custom registry base URL (default: `https://packages.simplifier.net`). |
-| `--log <level>` | Control logging output: `none` (default), `console`, or `file`. |
-| `--no-cache` | Remove the `.cache` directory once generation completes. |
-| `--no-classes` | Skip emitting helper classes (interfaces & validators only). |
-| `-h, --help` | Print usage help. |
-| `-v, --version` | Print the BabelFHIR-TS version. |
+| Argument / option           | Description                                                                                                                                                         |
+| --------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `<input>`                 | Directory of FHIR packages/StructureDefinitions, single package (`.tgz`/`.zip`), or single StructureDefinition `.json`. Defaults to `./input` when omitted. |
+| `<output>`                | Destination directory or archive. Defaults to `./output` when omitted.                                                                                            |
+| `install`                 | Downloads, processes, and installs a package as a project dependency.                                                                                               |
+| `--package <pkg@version>` | Fetch a package from a registry and process it without manual download.                                                                                             |
+| `--registry <url>`        | Custom registry base URL (default:`https://packages.simplifier.net`).                                                                                             |
+| `--log <level>`           | Control logging output:`none` (default), `console`, or `file`.                                                                                                |
+| `--no-cache`              | Remove the `.cache` directory once generation completes.                                                                                                          |
+| `--no-classes`            | Skip emitting helper classes (interfaces & validators only).                                                                                                        |
+| `-h, --help`              | Print usage help.                                                                                                                                                   |
+| `-v, --version`           | Print the BabelFHIR-TS version.                                                                                                                                     |
 
 ### Supported inputs
 
@@ -115,21 +143,113 @@ For each StructureDefinition the generator produces:
   - `validate()` that evaluates FHIR invariant expressions via `fhirpath`
 - optional validation parity artefacts when you run the test suite (`npm test validatorParity`)
 
-The validator relies on `fhirpath.evaluate(...)` to enforce profile invariants (including min cardinalities, slices, and custom expressions) without requiring a full FHIR server. It intentionally performs **high-level** checks only: terminology expansion, reference resolution, and other server-backed logic are out of scope, so keep a downstream validator (e.g., the HL7 Java validator CLI) in your QA pipeline for full conformance.
+The validator relies on `fhirpath.evaluate(...)` to enforce profile invariants (including min cardinalities, slices, and custom expressions) without requiring a full FHIR server. It intentionally performs **high-level** checks only: terminology expansion, reference resolution, and other server-backed logic are out of scope, so keep a downstream validator (e.g. the HL7 Java validator CLI) in your QA pipeline for full conformance.
+
+### Example: Generated US Core Encounter Profile
+
+Given the US Core Encounter profile, BabelFHIR-TS generates TypeScript interfaces that capture all must-support elements and profile extensions:
+
+```typescript
+import { Encounter, Meta, Extension, Identifier, Coding, CodeableConcept, 
+         Reference, EncounterParticipant, Period, EncounterHospitalization, 
+         EncounterLocation } from "fhir/r4";
+
+// Extension interface with type-safe URL
+export interface UsCoreInterpreterNeeded extends Extension { 
+  url: 'http://hl7.org/fhir/us/core/StructureDefinition/us-core-interpreter-needed' 
+}
+
+// Profile interface extending base Encounter with must-support constraints
+export interface USCoreEncounterProfile extends Encounter {
+  /** Must Support */
+  meta?: Meta;
+  /** Must Support */
+  identifier?: Identifier[];
+  /** Must Support */
+  class: Coding;
+  /** Must Support */
+  type: CodeableConcept[];
+  /** Must Support */
+  subject: Reference;
+  /** Must Support */
+  participant?: EncounterParticipant[];
+  /** Must Support */
+  period?: Period;
+  /** Must Support */
+  reasonCode?: CodeableConcept[];
+  /** Must Support */
+  reasonReference?: Reference[];
+  /** Must Support */
+  hospitalization?: EncounterHospitalization;
+  /** Must Support */
+  location?: EncounterLocation[];
+  /** Must Support */
+  serviceProvider?: Reference;
+
+  // Typed extension slicing
+  extension?: (Extension | UsCoreInterpreterNeeded)[];
+}
+
+// Generated validator function
+export async function validateUSCoreEncounterProfile(
+  resource: USCoreEncounterProfile
+): Promise<{ errors: string[], warnings: string[] }>;
+
+```
 
 ## Scripts for contributors
 
-| Script | Purpose |
-| ------ | ------- |
-| `npm run generate` | Execute the CLI against the local `input/` folder and refresh `output/`. |
-| `npm run generate:check` | End-to-end check: generate, type-check, and lint the emitted output. |
-| `npm test` | Type-check and run all Vitest suites (coverage enabled). |
-| `npm run download-validator` | Fetch the official HL7 validation jar used for parity testing. |
+| Script                         | Purpose                                                                      |
+| ------------------------------ | ---------------------------------------------------------------------------- |
+| `npm run generate`           | Execute the CLI against the local `input/` folder and refresh `output/`. |
+| `npm run generate:check`     | End-to-end check: generate, type-check, and lint the emitted output.         |
+| `npm test`                   | Type-check and run all Vitest suites (coverage enabled).                     |
+| `npm run download-validator` | Fetch the official HL7 validation jar used for parity testing.               |
 
 ## Caching notes
 
 The generator caches downloaded StructureDefinitions and packages inside `.cache/`. When you need a clean run, pass `--no-cache` or manually remove the folder. Temporary downloads land in `.temp-*` directories and are cleaned up automatically.
 
+## Limitations
+
+BabelFHIR-TS is a code generation tool that parses FHIR StructureDefinitions and produces TypeScript interfaces and validators. While it handles many common FHIR profiling patterns, there are important limitations to be aware of:
+
+### Profile Mapping Accuracy
+
+- **Not guaranteed for all IGs**: The generator uses heuristics to interpret StructureDefinition constraints, slicing rules, and extensions. Complex or unusual profiling patterns may not map correctly to TypeScript.
+- **Test before production**: Always validate the generated code against your specific Implementation Guide's examples and test cases. We recommend running the official FHIR validator alongside BabelFHIR-TS in your QA pipeline.
+- **Edge cases**: Rare profiling constructs (deeply nested slicing, conditional constraints, complex discriminators) may generate suboptimal or incomplete types.
+
+### Validation Scope
+
+- **High-level checks only**: The generated `validate()` functions execute FHIRPath expressions from profile invariants but do **not** perform:
+  - Terminology expansion or ValueSet validation
+  - Reference resolution (checking that referenced resources exist)
+  - Full cardinality enforcement for complex slicing scenarios
+  - Server-side business logic or workflow rules
+- **Use the official validator**: For production conformance testing, use the [HL7 FHIR Validator](https://github.com/hapifhir/org.hl7.fhir.core) alongside BabelFHIR-TS.
+
+### TypeScript Limitations
+
+- **Runtime type checking is limited**: TypeScript types are erased at compile time. The generated interfaces provide compile-time safety but cannot enforce constraints at runtime without the validator functions.
+- **Extension slicing**: While the generator creates typed extension interfaces, TypeScript cannot enforce that extension arrays contain exactly the required slices at compile time (this is validated at runtime).
+- **Choice types**: FHIR's `[x]` choice types (e.g., `value[x]`) are represented as union types in TypeScript, which may require runtime type narrowing.
+
+### FHIR Version Support
+
+- **R4 only**: The current version targets FHIR R4. Support for R5, DSTU2, or STU3 is not yet available.
+- **Dependencies**: Generated code depends on `@types/fhir` (R4 definitions) and `fhirpath` (R4 compatible).
+
+### Reporting Issues
+
+If you encounter an Implementation Guide that doesn't generate correctly, please [open an issue](https://github.com/quotentiroler/BabelFHIR-ts/issues) with:
+- The package name and version
+- The specific StructureDefinition URL
+- Expected vs. actual generated output
+- Any validation errors or type mismatches
+
+We continuously improve the generator based on real-world IG usage, and your feedback helps make BabelFHIR-TS more robust.
+
 ## License
 
 ISC © Maximilian Nussbaumer

package/bin/babelfhir-ts.js

@@ -9,24 +9,16 @@ import fs from 'fs';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 
-// Use tsx to run the compiled JavaScript (tsx handles ES module resolution better)
-const tsxBin = process.platform === 'win32' ? 'tsx.cmd' : 'tsx';
-const tsxPath = join(__dirname, '..', 'node_modules', '.bin', tsxBin);
+// Use node directly to run the compiled JavaScript
 const mainJsPath = join(__dirname, '..', 'out', 'main.js');
 
-// Check if tsx exists
-if (!fs.existsSync(tsxPath)) {
-  console.error('tsx not found. Please install dependencies with: npm install');
-  process.exit(1);
-}
-
 // Check if the compiled file exists
 if (!fs.existsSync(mainJsPath)) {
   console.error('Compiled main.js not found. Please ensure the package was built correctly.');
   process.exit(1);
 }
 
-const child = spawn(tsxPath, [mainJsPath, ...process.argv.slice(2)], {
+const child = spawn('node', [mainJsPath, ...process.argv.slice(2)], {
   stdio: 'inherit',
   cwd: process.cwd(),  // Use the current working directory where the command was invoked
   shell: process.platform === 'win32'

package/out/generator/classGenerator.js

@@ -427,9 +427,9 @@ export function generateClass(className, interfaceName, baseResource, requiredFi
     }
     const helperImportList = Array.from(helperImports).join(', ');
     return `
-import { validate${interfaceName}, ${interfaceName} } from "./${interfaceName}";
+import { validate${interfaceName}, ${interfaceName} } from "./${interfaceName}.js";
 // Only import helpers actually referenced below (dynamic based on required fields)
-import { ${helperImportList} } from "./RandomSupport";
+import { ${helperImportList} } from "./RandomSupport.js";
 
 // Helper emitted only when meta.profile enforcement is applicable (resource profiles)
 ${enableMetaProfile ? `type WithMeta = { meta?: { profile?: string[] } };

package/out/generator/index.js

@@ -1,15 +1,16 @@
 import path from 'path';
 import fs from 'fs';
-import { generateClass } from './classGenerator';
-import { generateInterfaces } from './interfaceGenerator';
-import { extractPackage, readStructureDefinitionsFromDir, createPackageFromDir, readValueSetCodesFromDir, readValueSetsFromDir } from './packageParser';
-import { fetchStructureDefinitions, parseStructureDefinition, fetchStructureDefinition, registerLocalStructureDefinitions, buildFhirChildTypeMap } from './sdParser';
-import { writeInterfaceAndValidatorToFile, mergeFields, alignFields, ensureDirectoryExists, writeToFile, getBaseResource, downloadFile, sanitizeIdentifier, toPascalCase } from './utils';
-import { generateValidateProfileFunction } from './validatorGenerator';
-import { loadExamplesFromPackage, generateTestFile } from './testGenerator';
+import { generateClass } from './classGenerator.js';
+import { generateInterfaces } from './interfaceGenerator.js';
+import { extractPackage, readStructureDefinitionsFromDir, createPackageFromDir, readValueSetCodesFromDir, readValueSetsFromDir } from './packageParser.js';
+import { fetchStructureDefinitions, parseStructureDefinition, fetchStructureDefinition, registerLocalStructureDefinitions, buildFhirChildTypeMap } from './sdParser.js';
+import { writeInterfaceAndValidatorToFile, mergeFields, alignFields, ensureDirectoryExists, writeToFile, getBaseResource, downloadFile, sanitizeIdentifier, toPascalCase } from './utils.js';
+import { generateValidateProfileFunction } from './validatorGenerator.js';
+import { loadExamplesFromPackage, generateTestFile } from './testGenerator.js';
 import { generateValueSetTypeScript, generateValueSetRegistry } from './valueSetGenerator.js';
-import { logger } from '../logger';
-import fhirInterfaceNames from './fhirInterfaces.json';
+import { logger } from '../logger.js';
+import fhirInterfaceNames from './fhirInterfaces.json' with { type: 'json' };
+import { spawn } from 'child_process';
 /** Ensure RandomSupport.ts exists in a generation output directory */
 function ensureRandomSupportFile(dir) {
     const filePath = path.join(dir, 'RandomSupport.ts');
@@ -54,6 +55,118 @@ export function skeletonQuantity(): Quantity { return { value: randomInt(1,100),
         fs.writeFileSync(filePath, content, 'utf-8');
     }
 }
+/** Compile TypeScript files to JavaScript with declaration files */
+async function compileTypeScriptToJS(dir) {
+    return new Promise((resolve, reject) => {
+        const tscCmd = process.platform === 'win32' ? 'tsc.cmd' : 'tsc';
+        // Create a temporary tsconfig.json for compilation
+        const tsconfig = {
+            compilerOptions: {
+                target: 'ES2020',
+                module: 'ES2020',
+                moduleResolution: 'node',
+                declaration: true,
+                outDir: dir,
+                rootDir: dir,
+                skipLibCheck: true,
+                esModuleInterop: true,
+                allowSyntheticDefaultImports: true,
+                strict: false,
+                resolveJsonModule: true,
+                types: ['node']
+            },
+            include: [`${dir}/**/*.ts`],
+            exclude: ['node_modules']
+        };
+        const tsconfigPath = path.join(dir, 'tsconfig.temp.json');
+        fs.writeFileSync(tsconfigPath, JSON.stringify(tsconfig, null, 2));
+        const child = spawn(tscCmd, ['-p', tsconfigPath], {
+            stdio: 'inherit',
+            shell: true
+        });
+        child.on('exit', (code) => {
+            // Clean up temp tsconfig
+            try {
+                fs.unlinkSync(tsconfigPath);
+            }
+            catch { /* ignore */ }
+            if (code === 0) {
+                // Remove .ts files after successful compilation
+                const files = fs.readdirSync(dir, { recursive: true, withFileTypes: true });
+                for (const file of files) {
+                    if (file.isFile() && file.name.endsWith('.ts') && !file.name.endsWith('.d.ts')) {
+                        const fullPath = path.join(file.path || dir, file.name);
+                        fs.unlinkSync(fullPath);
+                    }
+                }
+                resolve();
+            }
+            else {
+                reject(new Error(`TypeScript compilation failed with exit code ${code}`));
+            }
+        });
+        child.on('error', (err) => {
+            try {
+                fs.unlinkSync(tsconfigPath);
+            }
+            catch { /* ignore */ }
+            reject(new Error(`Failed to run tsc: ${err.message}`));
+        });
+    });
+}
+/** Generate index.ts that exports all generated interfaces and classes */
+async function generateIndexFile(dir) {
+    const files = fs.readdirSync(dir, { withFileTypes: true });
+    const exports = [];
+    const exportedNames = new Set();
+    // First pass: collect all files and their exports
+    const fileExports = new Map();
+    for (const file of files) {
+        if (file.isFile() && file.name.endsWith('.ts') && file.name !== 'index.ts' && file.name !== 'RandomSupport.ts') {
+            const filePath = path.join(dir, file.name);
+            const content = fs.readFileSync(filePath, 'utf-8');
+            const names = new Set();
+            // Extract export names (interfaces, classes, functions, types)
+            const exportMatches = content.matchAll(/export\s+(?:interface|class|type|const|function)\s+(\w+)/g);
+            for (const match of exportMatches) {
+                names.add(match[1]);
+            }
+            fileExports.set(file.name, names);
+        }
+    }
+    // Second pass: only export from files that have unique exports or are primary files
+    for (const file of files) {
+        if (file.isFile() && file.name.endsWith('.ts') && file.name !== 'index.ts' && file.name !== 'RandomSupport.ts') {
+            const baseName = file.name.replace('.ts', '');
+            const fileNames = fileExports.get(file.name) || new Set();
+            // Check if this file's exports would conflict with already exported names
+            let hasConflict = false;
+            for (const name of fileNames) {
+                if (exportedNames.has(name)) {
+                    hasConflict = true;
+                    break;
+                }
+            }
+            // Only export if no conflicts, or if it's a Class file (which are primary)
+            if (!hasConflict || file.name.endsWith('Class.ts')) {
+                exports.push(`export * from './${baseName}.js';`);
+                // Mark all names from this file as exported
+                for (const name of fileNames) {
+                    exportedNames.add(name);
+                }
+            }
+        }
+    }
+    // Also export from valuesets subfolder if it exists
+    const valueSetsDir = path.join(dir, 'valuesets');
+    if (fs.existsSync(valueSetsDir)) {
+        exports.push(`export * from './valuesets/index.js';`);
+    }
+    // Sort exports alphabetically for consistency
+    exports.sort();
+    const indexContent = `// Auto-generated index file - exports all generated FHIR profiles\n${exports.join('\n')}\n`;
+    fs.writeFileSync(path.join(dir, 'index.ts'), indexContent, 'utf-8');
+}
 // Reusable processor for a single StructureDefinition
 async function processStructureDefinition(sd, ctx) {
     const { outputDir, fhirSourceHint, valueSetCodesMap, valueSets, examplesMap, existingStructureDefinitions, profileIdToName, flags, fhirChildTypeMap } = ctx;
@@ -332,15 +445,42 @@ export async function generateIntoPackage(packageArchivePath, outArchivePath, fl
             version: packageVersion,
             description: `Generated TypeScript interfaces for ${packageName}`,
             type: 'module',
-            main: 'index.ts',
-            types: 'index.ts',
+            main: 'index.js',
+            types: 'index.d.ts',
             scripts: {},
             keywords: ['fhir', 'typescript', 'generated'],
-            license: 'MIT'
+            license: 'MIT',
+            // fhirpath is required at runtime by validators; keep as peer so host decides version
+            peerDependencies: {
+                'fhirpath': '^4.0.0'
+            },
+            // Type definitions for FHIR are needed for the .d.ts files
+            dependencies: {
+                '@types/fhir': '^0.0.41'
+            }
         };
         const generatedPackageJsonPath = path.join(outputDir, 'package.json');
         fs.writeFileSync(generatedPackageJsonPath, JSON.stringify(generatedPackageJson, null, 2));
         console.log(`Created package.json in generated folder: ${packageName}-generated@${packageVersion}`);
+        // Create a tsconfig.json for better IDE support with bundler moduleResolution
+        const generatedTsConfig = {
+            compilerOptions: {
+                moduleResolution: 'bundler',
+                module: 'ES2020',
+                target: 'ES2020',
+                strict: false,
+                skipLibCheck: true,
+                esModuleInterop: true
+            }
+        };
+        const generatedTsConfigPath = path.join(outputDir, 'tsconfig.json');
+        fs.writeFileSync(generatedTsConfigPath, JSON.stringify(generatedTsConfig, null, 2));
+        // Generate index.ts that exports all interfaces
+        console.log('Generating index.ts exports...');
+        await generateIndexFile(outputDir);
+        // Compile TypeScript to JavaScript
+        console.log('Compiling TypeScript to JavaScript...');
+        await compileTypeScriptToJS(outputDir);
         const finalArchive = outArchivePath || deriveOutputArchiveName(packageArchivePath);
         await createPackageFromDir(extractedRoot, finalArchive);
         return finalArchive;

package/out/generator/interfaceGenerator.js

@@ -1,7 +1,7 @@
-import fhirInterfaceNames from "./fhirInterfaces.json";
-import { capitalize, sanitizeIdentifier, toPascalCase } from './utils';
+import fhirInterfaceNames from "./fhirInterfaces.json" with { type: 'json' };
+import { capitalize, sanitizeIdentifier, toPascalCase } from './utils.js';
 import { generateCodeUnionType, getUniformSystem } from './vsParser.js';
-import { logger } from '../logger';
+import { logger } from '../logger.js';
 export function generateInterfaces(interfaceName, newFields, baseResource, baseFields = [], valueSets, resourceType, existingProfiles, fhirChildTypeMap) {
     const debug = (...args) => { if (process.env.DEBUG_FHIR_GEN === 'true')
         console.log('[gen:interfaces]', ...args); };

package/out/generator/temp/1761563744855-kptdikzwryj/generated/AdmissionAppointment.ts

@@ -0,0 +1,94 @@
+import { Appointment, Extension } from "fhir/r4";
+
+export interface AdmissionCheckInNoCode extends Extension { url: 'http://fhir.pink-protocol.io/StructureDefinition/AdmissionCheckInNoCode' }
+
+export interface AdmissionCheckIn extends Extension { url: 'http://fhir.pink-protocol.io/StructureDefinition/AdmissionCheckIn' }
+
+export interface AdmissionFormUrl extends Extension { url: 'http://fhir.pink-protocol.io/StructureDefinition/AdmissionFormUrl' }
+
+export interface AdmissionFormUuid extends Extension { url: 'http://fhir.pink-protocol.io/StructureDefinition/AdmissionFormUuid' }
+
+export interface AdmissionAppointment extends Appointment {
+    start: string;
+
+    extension?: (Extension | AdmissionFormUuid | AdmissionFormUrl | AdmissionCheckIn | AdmissionCheckInNoCode)[];
+}
+
+
+import fhirpath from "fhirpath";
+
+export async function validateAdmissionAppointment(resource: AdmissionAppointment): Promise<{ errors: string[], warnings: string[] }> {
+  const errors: string[] = [];
+  const warnings: string[] = [];
+  
+    const result0 = await Promise.resolve(fhirpath.evaluate(resource, "start.exists() = end.exists()", { resource }));
+    if (!result0.every(Boolean)) {
+      errors.push("Constraint violation: Either start and end are specified, or neither");
+    }
+
+    const result1 = await Promise.resolve(fhirpath.evaluate(resource, "(start.exists() and end.exists()) or (status in ('proposed' | 'cancelled' | 'waitlist'))", { resource }));
+    if (!result1.every(Boolean)) {
+      errors.push("Constraint violation: Only proposed or cancelled appointments can be missing start/end dates");
+    }
+
+    const result2 = await Promise.resolve(fhirpath.evaluate(resource, "Appointment.cancelationReason.exists() implies (Appointment.status='no-show' or Appointment.status='cancelled')", { resource }));
+    if (!result2.every(Boolean)) {
+      errors.push("Constraint violation: Cancelation reason is only used for appointments that have been cancelled, or no-show");
+    }
+
+    const result3 = await Promise.resolve(fhirpath.evaluate(resource, "contained.contained.empty()", { resource }));
+    if (!result3.every(Boolean)) {
+      errors.push("Constraint violation: If the resource is contained in another resource, it SHALL NOT contain nested Resources");
+    }
+
+    const result4 = await Promise.resolve(fhirpath.evaluate(resource, "contained.where((('#'+id in (%resource.descendants().reference | %resource.descendants().as(canonical) | %resource.descendants().as(uri) | %resource.descendants().as(url))) or descendants().where(reference = '#').exists() or descendants().where(as(canonical) = '#').exists() or descendants().where(as(canonical) = '#').exists()).not()).trace('unmatched', id).empty()", { resource }));
+    if (!result4.every(Boolean)) {
+      errors.push("Constraint violation: If the resource is contained in another resource, it SHALL be referred to from elsewhere in the resource or SHALL refer to the containing resource");
+    }
+
+    const result5 = await Promise.resolve(fhirpath.evaluate(resource, "contained.meta.versionId.empty() and contained.meta.lastUpdated.empty()", { resource }));
+    if (!result5.every(Boolean)) {
+      errors.push("Constraint violation: If a resource is contained in another resource, it SHALL NOT have a meta.versionId or a meta.lastUpdated");
+    }
+
+    const result6 = await Promise.resolve(fhirpath.evaluate(resource, "contained.meta.security.empty()", { resource }));
+    if (!result6.every(Boolean)) {
+      errors.push("Constraint violation: If a resource is contained in another resource, it SHALL NOT have a security label");
+    }
+
+    const result7 = await Promise.resolve(fhirpath.evaluate(resource, "text.`div`.exists()", { resource }));
+    if (!result7.every(Boolean)) {
+      warnings.push("Constraint violation: A resource should have narrative for robust management");
+    }
+
+    const result8 = await Promise.resolve(fhirpath.evaluate(resource, "hasValue() or (children().count() > id.count())", { resource }));
+    if (!result8.every(Boolean)) {
+      errors.push("Constraint violation: All FHIR elements must have a @value or children");
+    }
+
+    const result9 = await Promise.resolve(fhirpath.evaluate(resource, "type.exists() or actor.exists()", { resource }));
+    if (!result9.every(Boolean)) {
+      errors.push("Constraint violation: Either the type or actor on the participant SHALL be specified");
+    }
+
+    const result10 = await Promise.resolve(fhirpath.evaluate(resource, "status.exists()", { resource }));
+    if (!result10.every(Boolean)) {
+      errors.push("Constraint violation: status must be present");
+    }
+
+    const result11 = await Promise.resolve(fhirpath.evaluate(resource, "start.exists()", { resource }));
+    if (!result11.every(Boolean)) {
+      errors.push("Constraint violation: start must be present");
+    }
+
+    const result12 = await Promise.resolve(fhirpath.evaluate(resource, "participant.exists()", { resource }));
+    if (!result12.every(Boolean)) {
+      errors.push("Constraint violation: participant must be present");
+    }
+
+    const result13 = await Promise.resolve(fhirpath.evaluate(resource, "participant.status.exists()", { resource }));
+    if (!result13.every(Boolean)) {
+      errors.push("Constraint violation: participant.status must be present");
+    }
+  return { errors, warnings };
+}