babelfhir-ts 1.0.17 → 1.0.18

package/README.md

@@ -10,13 +10,14 @@
 
 ### 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**—pure TypeScript code generation with no runtime dependencies except `fhirpath` for validation
-- **Install any FHIR profile as a node module**—use `babelfhir-ts install` to add Implementation Guides directly to your TypeScript project
+- **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.
 
@@ -71,6 +72,41 @@ 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
 
 ```

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 };
+}

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

@@ -0,0 +1,194 @@
+
+import { validateAdmissionAppointment, AdmissionAppointment } from "./AdmissionAppointment.js";
+// Only import helpers actually referenced below (dynamic based on required fields)
+import { randomId, setRandomSeed } from "./RandomSupport.js";
+
+// Helper emitted only when meta.profile enforcement is applicable (resource profiles)
+
+
+// Internal helper (emitted per class file) to clone without resorting to 'any'.
+function safeClone<T>(value: T): T {
+  // Use native structuredClone if present; otherwise fallback to JSON round-trip.
+  // We intentionally avoid casting through any to satisfy no-explicit-any lint rule.
+  const g: unknown = globalThis as unknown;
+  // Narrow globalThis to an object potentially containing structuredClone.
+  if (typeof (g as { structuredClone?: unknown }).structuredClone === 'function') {
+    return (g as { structuredClone: <U>(arg: U) => U }).structuredClone(value);
+  }
+  return JSON.parse(JSON.stringify(value)) as T; // best-effort deep clone
+}
+
+export class AdmissionAppointmentClass {
+  constructor(private resource: AdmissionAppointment) {
+    
+  }
+  /** Validate current resource instance. */
+  async validate(): Promise<{ errors: string[], warnings: string[] }> {
+    return validateAdmissionAppointment(this.resource);
+  }
+
+  getResource(): AdmissionAppointment {
+    return this.resource;
+  }
+
+  setResource(resource: AdmissionAppointment): void {
+    this.resource = resource;
+    
+  }
+
+  /**
+   * Returns a plain JSON clone of the underlying resource ONLY if the last validation succeeded with zero errors.
+   * Call validate() first; otherwise this method throws to prevent accidental use of invalid / unchecked data.
+   */
+  async toJSON(): Promise<AdmissionAppointment> {
+    return safeClone(this.resource);
+  }
+
+  /**
+   * Create an empty instance for parity testing: for true FHIR resources, includes only resourceType; for datatypes, returns an empty object.
+   * Note: meta.profile (when applicable) will be ensured by the constructor when wrapping this resource.
+   */
+  static empty(overrides: Partial<AdmissionAppointment> = {}): AdmissionAppointment {
+    // For Resource profiles, include only resourceType. For Extension profiles, include url so the instance is minimally meaningful.
+    const base: Record<string, unknown> = {
+      
+      
+    };
+    return { ...(base as unknown as AdmissionAppointment), ...overrides };
+  }
+
+  /**
+   * Create a minimal randomized instance of AdmissionAppointment.
+   * Populates id, resourceType (if applicable) and primitive required (min>0) top-level fields with placeholders.
+   */
+  static random(overrides: Partial<AdmissionAppointment> = {}, opts?: { seed?: number }): AdmissionAppointment {
+    if (opts?.seed !== undefined) {
+      // Direct call (no dynamic require) to ensure deterministic seeding works under ESM.
+      setRandomSeed(opts.seed);
+    }
+  // Start with a Partial to avoid unsafe casting errors; we'll assert at the end.
+  const base: Record<string, unknown> = {  id: randomId(),  };
+  // Always include meta.profile with this profile's canonical URL if available & only for resource profiles
+  // (no profileUrl provided or profile targets a datatype – meta.profile not applicable)
+    // Opportunistic enrichment: add some common fields if absent and the interface suggests a matching resource type name.
+    try {
+      const maybe: Record<string, unknown> = base as unknown as Record<string, unknown>;
+      const baseRes = 'Appointment';
+      // Identifier-like profile: ensure system & value
+      if (/Identifier/i.test(baseRes)) {
+        if (!('system' in maybe)) maybe.system = 'urn:ietf:rfc:3986';
+        if (!('value' in maybe)) maybe.value = 'urn:uuid:' + randomId();
+        if (!('type' in maybe)) maybe.type = { text: 'Primary Identifier' };
+      }
+      // Patient / Practitioner names
+      if (/Patient|Practitioner/i.test(baseRes)) {
+        if (!('identifier' in maybe)) maybe.identifier = [{ system: 'urn:ietf:rfc:3986', value: 'urn:uuid:' + randomId() }];
+        if (!('name' in maybe)) maybe.name = [{ family: randomId(), given: [randomId()] }];
+        if (!('gender' in maybe)) maybe.gender = 'unknown';
+        if (!('birthDate' in maybe)) maybe.birthDate = new Date(Date.now() - 10*365*24*60*60*1000).toISOString().substring(0,10);
+        if (!('address' in maybe)) maybe.address = [{ city: 'Example City', postalCode: '12345', country: 'DE' }];
+      }
+      if (/Condition/i.test(baseRes)) {
+        if (!('code' in maybe)) maybe.code = { coding: [{ system: 'http://snomed.info/sct', code: '64572001', display: 'Condition' }], text: 'Example condition' };
+        if (!('clinicalStatus' in maybe)) maybe.clinicalStatus = { coding: [{ system: 'http://terminology.hl7.org/CodeSystem/condition-clinical', code: 'active' }] };
+        if (!('verificationStatus' in maybe)) maybe.verificationStatus = { coding: [{ system: 'http://terminology.hl7.org/CodeSystem/condition-ver-status', code: 'confirmed' }] };
+        if (!('subject' in maybe)) maybe.subject = { reference: 'Patient/' + randomId() };
+        if (!('category' in maybe)) maybe.category = [{ coding: [{ system: 'http://terminology.hl7.org/CodeSystem/condition-category', code: 'encounter-diagnosis' }] }];
+      }
+      if (/Procedure/i.test(baseRes)) {
+        if (!('code' in maybe)) maybe.code = { coding: [{ system: 'http://snomed.info/sct', code: '71388002', display: 'Procedure' }], text: 'Example procedure' };
+        if (!('status' in maybe)) maybe.status = 'completed';
+        if (!('subject' in maybe)) maybe.subject = { reference: 'Patient/' + randomId() };
+        if (!('performedDateTime' in maybe)) maybe.performedDateTime = new Date().toISOString();
+        if (!('category' in maybe)) maybe.category = { coding: [{ system: 'http://snomed.info/sct', code: '387713003' }] };
+      }
+      if (/Encounter/i.test(baseRes)) {
+        if (!('status' in maybe)) maybe.status = 'finished';
+        if (!('class' in maybe)) maybe.class = { system: 'http://terminology.hl7.org/CodeSystem/v3-ActCode', code: 'IMP', display: 'inpatient encounter' };
+        if (!('subject' in maybe)) maybe.subject = { reference: 'Patient/' + randomId() };
+        if (!('period' in maybe)) maybe.period = { start: new Date(Date.now() - 7*24*60*60*1000).toISOString(), end: new Date().toISOString() };
+        if (!('type' in maybe)) maybe.type = [{ coding: [{ system: 'http://terminology.hl7.org/CodeSystem/v3-ActCode', code: 'IMP' }] }];
+        if (!('serviceProvider' in maybe)) maybe.serviceProvider = { reference: 'Organization/' + randomId() };
+      }
+      if (/Account/i.test(baseRes)) {
+        if (!('status' in maybe)) maybe.status = 'active';
+        if (!('type' in maybe)) maybe.type = { coding: [{ system: 'http://terminology.hl7.org/CodeSystem/v3-ActCode', code: 'PBILLACCT' }] };
+        if (!('identifier' in maybe)) maybe.identifier = [{ system: 'urn:ietf:rfc:3986', value: 'urn:uuid:' + randomId() }];
+        if (!('subject' in maybe)) maybe.subject = [{ reference: 'Patient/' + randomId() }];
+      }
+      if (/Bundle/i.test(baseRes)) {
+        if (!('type' in maybe)) maybe.type = 'document';
+        if (!('timestamp' in maybe)) maybe.timestamp = new Date().toISOString();
+        if (!('identifier' in maybe)) maybe.identifier = { system: 'urn:ietf:rfc:3986', value: 'urn:uuid:' + randomId() };
+        if (!('entry' in maybe)) maybe.entry = [{ fullUrl: 'urn:uuid:' + randomId(), resource: { resourceType: 'Composition', id: randomId(), status: 'final', type: { coding: [{ system: 'http://loinc.org', code: '60591-5' }] }, subject: { reference: 'Patient/' + randomId() }, date: new Date().toISOString(), author: [{ reference: 'Practitioner/' + randomId() }], title: 'Example Document', section: [] } }];
+      }
+      if (/Composition/i.test(baseRes)) {
+        if (!('status' in maybe)) maybe.status = 'final';
+        if (!('type' in maybe)) maybe.type = { coding: [{ system: 'http://loinc.org', code: '60591-5', display: 'Patient summary Document' }] };
+        if (!('subject' in maybe)) maybe.subject = { reference: 'Patient/' + randomId() };
+        if (!('date' in maybe)) maybe.date = new Date().toISOString();
+        if (!('author' in maybe)) maybe.author = [{ reference: 'Practitioner/' + randomId() }];
+        if (!('title' in maybe)) maybe.title = 'Patient Summary';
+        if (!('section' in maybe)) maybe.section = [];
+      }
+      if (/ValueSet/i.test(baseRes)) {
+        if (!('status' in maybe)) maybe.status = 'active';
+        if (!('url' in maybe)) maybe.url = 'urn:uuid:' + randomId();
+        if (!('name' in maybe)) maybe.name = 'ExampleValueSet';
+        if (!('version' in maybe)) maybe.version = '1.0.0';
+        if (!('compose' in maybe)) maybe.compose = { include: [{ system: 'http://loinc.org', concept: [{ code: '1234-5', display: 'Example LOINC' }] }] };
+      }
+      if (/CodeSystem/i.test(baseRes)) {
+        if (!('status' in maybe)) maybe.status = 'active';
+        if (!('content' in maybe)) maybe.content = 'complete';
+        if (!('url' in maybe)) maybe.url = 'urn:uuid:' + randomId();
+        if (!('name' in maybe)) maybe.name = 'ExampleCodeSystem';
+        if (!('version' in maybe)) maybe.version = '1.0.0';
+        if (!('concept' in maybe)) maybe.concept = [{ code: 'example', display: 'Example Code' }];
+      }
+      if (/RelatedPerson/i.test(baseRes)) {
+        if (!('patient' in maybe)) maybe.patient = { reference: 'Patient/' + randomId() };
+        if (!('identifier' in maybe)) maybe.identifier = [{ system: 'urn:ietf:rfc:3986', value: 'urn:uuid:' + randomId() }];
+        if (!('name' in maybe)) maybe.name = [{ family: randomId(), given: [randomId()] }];
+        if (!('relationship' in maybe)) maybe.relationship = [{ coding: [{ system: 'http://terminology.hl7.org/CodeSystem/v3-RoleCode', code: 'FTH', display: 'father' }] }];
+        if (!('address' in maybe)) maybe.address = [{ city: 'Example City', postalCode: '12345', country: 'DE' }];
+      }
+      if (/DocumentReference/i.test(baseRes)) {
+        if (!('status' in maybe)) maybe.status = 'current';
+        if (!('type' in maybe)) maybe.type = { coding: [{ system: 'http://loinc.org', code: '34133-9' }] };
+        if (!('category' in maybe)) maybe.category = [{ coding: [{ system: 'http://hl7.org/fhir/us/core/CodeSystem/us-core-documentreference-category', code: 'clinical-note' }] }];
+        if (!('subject' in maybe)) maybe.subject = { reference: 'Patient/' + randomId() };
+        if (!('content' in maybe)) maybe.content = [{ attachment: { contentType: 'application/pdf', data: 'ZXhhbXBsZQ==' } }]; // 'example'
+      }
+      if (/Binary/i.test(baseRes)) {
+        if (!('contentType' in maybe)) maybe.contentType = 'application/pdf';
+        if (!('data' in maybe)) maybe.data = 'SGVsbG8gV29ybGQ='; // "Hello World" in base64
+      }
+      if (/Coverage/i.test(baseRes)) {
+        if (!('status' in maybe)) maybe.status = 'active';
+        if (!('type' in maybe)) maybe.type = { coding: [{ system: 'http://terminology.hl7.org/CodeSystem/v3-ActCode', code: 'EHCPOL', display: 'extended healthcare' }] };
+        if (!('subscriberId' in maybe)) maybe.subscriberId = randomId();
+        if (!('beneficiary' in maybe)) maybe.beneficiary = { reference: 'Patient/' + randomId() };
+        if (!('payor' in maybe)) maybe.payor = [{ reference: 'Organization/' + randomId() }];
+      }
+      // Generic narrative for DomainResource derivatives
+      if (/DomainResource|Patient|Account|Bundle|Composition|Binary|CodeSystem|Condition|Encounter|Practitioner|Procedure|ValueSet|RelatedPerson|DocumentReference|Coverage/.test(baseRes)) {
+        if (!('text' in maybe)) maybe.text = { status: 'generated', div: '<div xmlns="http://www.w3.org/1999/xhtml">Generated</div>' };
+      }
+      // Extension value fallback: if profile base is Extension ensure a value[x]
+      if (/Extension/.test(baseRes)) {
+        const hasValue = Object.keys(maybe).some(k => k.startsWith('value'));
+        if (!hasValue) maybe['valueString'] = 'value';
+        // For Extension profiles, set url to the profile's canonical URL if available
+        if (!('url' in maybe)) maybe.url = 'http://fhir.pink-protocol.io/StructureDefinition/AdmissionAppointment';
+      }
+    } catch { /* enrichment is best-effort */ }
+  // Cast through unknown to acknowledge dynamic enrichment
+  return { ...(base as unknown as AdmissionAppointment), ...overrides };
+  }
+
+  /** Convenience: returns a class instance wrapping a randomized resource. */
+  static randomClass(overrides: Partial<AdmissionAppointment> = {}, opts?: { seed?: number }): AdmissionAppointmentClass {
+    return new AdmissionAppointmentClass(this.random(overrides, opts));
+  }
+}

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

@@ -0,0 +1,29 @@
+import { Extension } from "fhir/r4";
+
+export interface AdmissionCheckIn extends Extension {
+    url: "http://fhir.pink-protocol.io/StructureDefinition/AdmissionCheckIn";
+}
+
+
+import fhirpath from "fhirpath";
+
+export async function validateAdmissionCheckIn(resource: AdmissionCheckIn): Promise<{ errors: string[], warnings: string[] }> {
+  const errors: string[] = [];
+  const warnings: string[] = [];
+  
+    const result0 = await Promise.resolve(fhirpath.evaluate(resource, "hasValue() or (children().count() > id.count())", { resource }));
+    if (!result0.every(Boolean)) {
+      errors.push("Constraint violation: All FHIR elements must have a @value or children");
+    }
+
+    const result1 = await Promise.resolve(fhirpath.evaluate(resource, "url.exists()", { resource }));
+    if (!result1.every(Boolean)) {
+      errors.push("Constraint violation: url must be present");
+    }
+
+    const result2 = await Promise.resolve(fhirpath.evaluate(resource, "value.exists()", { resource }));
+    if (!result2.every(Boolean)) {
+      errors.push("Constraint violation: value must be present");
+    }
+  return { errors, warnings };
+}