fhir-runtime 0.2.0

package/dist/lib/profile/slicing-handler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"slicing-handler.d.ts","sourceRoot":"","sources":["../../../src/profile/slicing-handler.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH,OAAO,KAAK,EACV,iBAAiB,EACjB,wBAAwB,EACxB,qBAAqB,EACtB,MAAM,mBAAmB,CAAC;AAC3B,OAAO,KAAK,EAAE,kBAAkB,EAAE,aAAa,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAEpF,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAuBxD;;;;;;;GAOG;AACH,wBAAgB,oBAAoB,IAAI,wBAAwB,CAW/D;AAMD;;;;;;;;;GASG;AACH,wBAAgB,gBAAgB,CAC9B,QAAQ,EAAE,SAAS,iBAAiB,EAAE,EACtC,gBAAgB,EAAE,MAAM,GACvB,iBAAiB,EAAE,CAsBrB;AAMD;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,4BAA4B,CAC1C,WAAW,EAAE,wBAAwB,EACrC,WAAW,EAAE,wBAAwB,EACrC,MAAM,EAAE,aAAa,EAAE,EACvB,IAAI,EAAE,MAAM,GACX,OAAO,CAoET;AAMD;;;;;;;;;;;;GAYG;AACH,wBAAgB,mBAAmB,CACjC,WAAW,EAAE,SAAS,kBAAkB,EAAE,EAC1C,QAAQ,EAAE,MAAM,EAChB,SAAS,EAAE,SAAS,qBAAqB,EAAE,GAAG,SAAS,GACtD,OAAO,CAwBT;AAMD;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,gBAAgB,CAC9B,OAAO,EAAE,YAAY,EACrB,MAAM,EAAE,iBAAiB,EAAE,EAC3B,WAAW,EAAE,iBAAiB,EAC9B,SAAS,EAAE,cAAc,EACzB,WAAW,EAAE,kBAAkB,EAAE,EACjC,YAAY,EAAE,SAAS,kBAAkB,EAAE,EAC3C,SAAS,EAAE,MAAM,EACjB,OAAO,EAAE,MAAM,EACf,cAAc,EAAE,MAAM,EACtB,cAAc,EAAE,MAAM,EACtB,KAAK,EAAE,MAAM,GACZ,IAAI,CAkEN;AAMD;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,qBAAqB,CACnC,OAAO,EAAE,YAAY,EACrB,MAAM,EAAE,iBAAiB,EAAE,EAC3B,WAAW,EAAE,iBAAiB,EAC9B,SAAS,EAAE,cAAc,EACzB,WAAW,EAAE,kBAAkB,EAAE,EACjC,YAAY,EAAE,SAAS,kBAAkB,EAAE,EAC3C,SAAS,EAAE,MAAM,EACjB,OAAO,EAAE,MAAM,EACf,cAAc,EAAE,MAAM,EACtB,cAAc,EAAE,MAAM,EACtB,KAAK,EAAE,MAAM,GACZ,IAAI,CA8HN"}

package/dist/lib/profile/snapshot-generator.d.ts

@@ -0,0 +1,73 @@
+/**
+ * fhir-profile — Snapshot Generator (Orchestrator)
+ *
+ * Implements the top-level snapshot generation workflow, corresponding to
+ * HAPI FHIR R4's `ProfileUtilities.generateSnapshot()`.
+ *
+ * This is the **orchestrator** that coordinates:
+ * 1. Input validation
+ * 2. Circular dependency detection (generation stack)
+ * 3. Base SD loading (recursive snapshot generation if needed)
+ * 4. Datatype cache population
+ * 5. Merge loop delegation to {@link processPaths}
+ * 6. Post-processing (unconsumed diff, element IDs)
+ * 7. Result caching
+ *
+ * @module fhir-profile
+ */
+import type { StructureDefinition } from '../model/index.js';
+import type { FhirContext } from '../context/types.js';
+import type { SnapshotGeneratorOptions, SnapshotResult } from './types.js';
+/**
+ * Snapshot Generator — top-level orchestrator for snapshot generation.
+ *
+ * Corresponds to HAPI's `ProfileUtilities.generateSnapshot()`.
+ *
+ * @example
+ * ```typescript
+ * const generator = new SnapshotGenerator(fhirContext, { throwOnError: false });
+ * const result = await generator.generate(myProfile);
+ * if (result.success) {
+ *   console.log('Snapshot generated with', result.structureDefinition.snapshot?.element.length, 'elements');
+ * }
+ * ```
+ */
+export declare class SnapshotGenerator {
+    private readonly context;
+    private readonly options;
+    /** URLs currently being generated — for circular dependency detection. */
+    private readonly generationStack;
+    constructor(context: FhirContext, options?: SnapshotGeneratorOptions);
+    /**
+     * Generate a snapshot for a StructureDefinition.
+     *
+     * @param sd - StructureDefinition with a differential to expand.
+     * @returns SnapshotResult with the populated snapshot and any issues.
+     * @throws {SnapshotCircularDependencyError} if circular reference detected
+     * @throws {BaseNotFoundError} if base SD cannot be loaded
+     * @throws {UnconsumedDifferentialError} if throwOnError and unconsumed diffs
+     */
+    generate(sd: StructureDefinition): Promise<SnapshotResult>;
+    /**
+     * Validate input StructureDefinition.
+     * Returns true if there's a fatal validation error.
+     */
+    private validateInput;
+    /**
+     * Load the base StructureDefinition.
+     */
+    private loadBase;
+    /**
+     * Populate the datatype cache with snapshots of types referenced by
+     * the differential's child paths.
+     *
+     * Scans both base elements and diff elements for type codes, then
+     * pre-loads their StructureDefinitions into the merge context cache.
+     */
+    private populateDatatypeCache;
+    /**
+     * Build a SnapshotResult from the current state.
+     */
+    private buildResult;
+}
+//# sourceMappingURL=snapshot-generator.d.ts.map

package/dist/lib/profile/snapshot-generator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"snapshot-generator.d.ts","sourceRoot":"","sources":["../../../src/profile/snapshot-generator.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,OAAO,KAAK,EAAqB,mBAAmB,EAAE,MAAM,mBAAmB,CAAC;AAChF,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAC;AACvD,OAAO,KAAK,EAAE,wBAAwB,EAAE,cAAc,EAAiB,MAAM,YAAY,CAAC;AAc1F;;;;;;;;;;;;;GAaG;AACH,qBAAa,iBAAiB;IAC5B,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAc;IACtC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAA2B;IAEnD,0EAA0E;IAC1E,OAAO,CAAC,QAAQ,CAAC,eAAe,CAA0B;gBAE9C,OAAO,EAAE,WAAW,EAAE,OAAO,GAAE,wBAA6B;IASxE;;;;;;;;OAQG;IACG,QAAQ,CAAC,EAAE,EAAE,mBAAmB,GAAG,OAAO,CAAC,cAAc,CAAC;IAmJhE;;;OAGG;IACH,OAAO,CAAC,aAAa;IAgCrB;;OAEG;YACW,QAAQ;IA0BtB;;;;;;OAMG;YACW,qBAAqB;IA+CnC;;OAEG;IACH,OAAO,CAAC,WAAW;CAQpB"}

package/dist/lib/profile/types.d.ts

@@ -0,0 +1,220 @@
+/**
+ * fhir-profile — Public Interfaces & Types
+ *
+ * Defines the core abstractions for the FHIR profile module:
+ * - {@link SnapshotGeneratorOptions} — generation configuration
+ * - {@link SnapshotResult} — generation output
+ * - {@link SnapshotIssue} — issue reporting
+ * - {@link DiffElementTracker} — internal differential consumption tracking
+ * - {@link TraversalScope} — cursor-based scope for base-driven traversal
+ *
+ * This module implements the snapshot generation algorithm conceptually
+ * equivalent to HAPI FHIR's `ProfileUtilities.generateSnapshot()`.
+ *
+ * @module fhir-profile
+ */
+import type { CanonicalProfile, ElementDefinition, StructureDefinition } from '../model/index.js';
+/**
+ * Configuration options for snapshot generation.
+ *
+ * @example
+ * ```typescript
+ * const options: SnapshotGeneratorOptions = {
+ *   throwOnError: false,
+ *   maxRecursionDepth: 50,
+ *   generateCanonical: true,
+ * };
+ * ```
+ */
+export interface SnapshotGeneratorOptions {
+    /**
+     * Whether to throw on the first error or collect all errors.
+     *
+     * When `true`, the generator throws immediately on the first error
+     * (matching HAPI's "exception mode"). When `false` (default), errors
+     * are collected in {@link SnapshotResult.issues} and generation
+     * continues as far as possible.
+     *
+     * @default false
+     */
+    readonly throwOnError?: boolean;
+    /**
+     * Maximum recursion depth for nested snapshot generation.
+     *
+     * Snapshot generation can recursively trigger generation of other
+     * profiles (e.g., when a base profile lacks a snapshot, or when
+     * expanding into datatype definitions). This limit prevents runaway
+     * recursion in pathological or circular profiles.
+     *
+     * @default 50
+     */
+    readonly maxRecursionDepth?: number;
+    /**
+     * Whether to generate a {@link CanonicalProfile} alongside the snapshot.
+     *
+     * When `true`, the result includes a `canonical` field containing
+     * the MedXAI internal semantic model derived from the generated snapshot.
+     *
+     * @default false
+     */
+    readonly generateCanonical?: boolean;
+}
+/**
+ * Result of snapshot generation.
+ *
+ * Contains the StructureDefinition with its populated snapshot, any issues
+ * encountered during generation, and optionally a {@link CanonicalProfile}.
+ *
+ * @example
+ * ```typescript
+ * const result = await generator.generate(sd);
+ * if (result.success) {
+ *   console.log(`Generated ${result.structureDefinition.snapshot?.element.length} elements`);
+ * } else {
+ *   console.error('Errors:', result.issues.filter(i => i.severity === 'error'));
+ * }
+ * ```
+ */
+export interface SnapshotResult {
+    /** The StructureDefinition with populated snapshot. */
+    readonly structureDefinition: StructureDefinition;
+    /**
+     * Optional {@link CanonicalProfile} if
+     * {@link SnapshotGeneratorOptions.generateCanonical} was `true`.
+     */
+    readonly canonical?: CanonicalProfile;
+    /** Issues encountered during generation (warnings + errors). */
+    readonly issues: readonly SnapshotIssue[];
+    /**
+     * Whether generation completed successfully.
+     *
+     * `true` when no error-severity issues were recorded.
+     * Warnings and informational issues do not affect this flag.
+     */
+    readonly success: boolean;
+}
+/**
+ * An issue encountered during snapshot generation.
+ *
+ * Mirrors the concept of HAPI's `ValidationMessage` but scoped to
+ * snapshot generation. Issues are collected during generation and
+ * returned in {@link SnapshotResult.issues}.
+ *
+ * @example
+ * ```typescript
+ * const issue: SnapshotIssue = {
+ *   severity: 'error',
+ *   code: 'CARDINALITY_VIOLATION',
+ *   message: 'Derived min (0) is less than base min (1)',
+ *   path: 'Patient.identifier',
+ * };
+ * ```
+ */
+export interface SnapshotIssue {
+    /** Severity level of the issue. */
+    readonly severity: 'error' | 'warning' | 'information';
+    /** Machine-readable issue code. */
+    readonly code: SnapshotIssueCode;
+    /** Human-readable description of the issue. */
+    readonly message: string;
+    /** Element path where the issue occurred (e.g., `'Patient.identifier'`). */
+    readonly path?: string;
+    /** Additional details for debugging. */
+    readonly details?: string;
+}
+/**
+ * Machine-readable issue codes for snapshot generation.
+ *
+ * Each code corresponds to a specific category of problem that can
+ * occur during the snapshot generation process.
+ */
+export type SnapshotIssueCode = 
+/** Circular dependency detected in profile chain. */
+'CIRCULAR_DEPENDENCY'
+/** Base StructureDefinition could not be loaded. */
+ | 'BASE_NOT_FOUND'
+/** Base StructureDefinition exists but has no snapshot. */
+ | 'BASE_MISSING_SNAPSHOT'
+/** Differential element was not consumed during generation. */
+ | 'DIFFERENTIAL_NOT_CONSUMED'
+/** Cardinality constraint violation (min/max tightening rules). */
+ | 'CARDINALITY_VIOLATION'
+/** Type constraint is incompatible with base types. */
+ | 'TYPE_INCOMPATIBLE'
+/** Binding constraint violation (e.g., relaxing REQUIRED binding). */
+ | 'BINDING_VIOLATION'
+/** Slicing-related error (compatibility, closed slicing, etc.). */
+ | 'SLICING_ERROR'
+/** Differential path not found in base snapshot. */
+ | 'PATH_NOT_FOUND'
+/** Generic invalid constraint (catch-all for other violations). */
+ | 'INVALID_CONSTRAINT'
+/** Internal error in the generator (should not happen). */
+ | 'INTERNAL_ERROR';
+/**
+ * Tracks a differential element during snapshot generation.
+ *
+ * Implements the HAPI marker pattern where each differential element
+ * is tagged with `userData(GENERATED_IN_SNAPSHOT)` after being consumed
+ * by the merge algorithm. At the end of generation, any tracker with
+ * `consumed === false` indicates an unmatched differential element.
+ *
+ * @internal Used by {@link ElementMerger} and {@link SnapshotGenerator}.
+ */
+export interface DiffElementTracker {
+    /** The original differential ElementDefinition. */
+    readonly element: ElementDefinition;
+    /**
+     * Whether this element has been consumed (matched and merged)
+     * during snapshot generation.
+     *
+     * Set to `true` by the merge algorithm when the element is
+     * successfully applied to the snapshot. Checked post-generation
+     * to detect unmatched differential elements.
+     */
+    consumed: boolean;
+}
+/**
+ * Cursor-based scope for base-driven traversal.
+ *
+ * Used by the element merger (`processPaths` equivalent) to define
+ * the current working range within a list of ElementDefinitions.
+ * Both `start` and `end` are inclusive indices.
+ *
+ * This mirrors HAPI's `baseCursor/baseLimit` and `diffCursor/diffLimit`
+ * parameter pairs in `processPaths()`.
+ *
+ * @example
+ * ```typescript
+ * // Scope covering elements[2] through elements[5]
+ * const scope: TraversalScope = {
+ *   elements: baseSnapshot.element,
+ *   start: 2,
+ *   end: 5,
+ * };
+ * ```
+ *
+ * @internal Used by {@link ElementMerger}.
+ */
+export interface TraversalScope {
+    /** The element list being traversed. */
+    readonly elements: readonly ElementDefinition[];
+    /** Start index (inclusive). */
+    readonly start: number;
+    /** End index (inclusive). */
+    readonly end: number;
+}
+/**
+ * Create a {@link SnapshotIssue} with the given parameters.
+ *
+ * Convenience factory to reduce boilerplate when recording issues.
+ */
+export declare function createSnapshotIssue(severity: SnapshotIssue['severity'], code: SnapshotIssueCode, message: string, path?: string, details?: string): SnapshotIssue;
+/**
+ * Create a {@link DiffElementTracker} for a differential element.
+ *
+ * @param element - The differential ElementDefinition to track.
+ * @returns A tracker with `consumed` set to `false`.
+ */
+export declare function createDiffTracker(element: ElementDefinition): DiffElementTracker;
+//# sourceMappingURL=types.d.ts.map

package/dist/lib/profile/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/profile/types.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,KAAK,EACV,gBAAgB,EAChB,iBAAiB,EACjB,mBAAmB,EACpB,MAAM,mBAAmB,CAAC;AAM3B;;;;;;;;;;;GAWG;AACH,MAAM,WAAW,wBAAwB;IACvC;;;;;;;;;OASG;IACH,QAAQ,CAAC,YAAY,CAAC,EAAE,OAAO,CAAC;IAEhC;;;;;;;;;OASG;IACH,QAAQ,CAAC,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAEpC;;;;;;;OAOG;IACH,QAAQ,CAAC,iBAAiB,CAAC,EAAE,OAAO,CAAC;CACtC;AAMD;;;;;;;;;;;;;;;GAeG;AACH,MAAM,WAAW,cAAc;IAC7B,uDAAuD;IACvD,QAAQ,CAAC,mBAAmB,EAAE,mBAAmB,CAAC;IAElD;;;OAGG;IACH,QAAQ,CAAC,SAAS,CAAC,EAAE,gBAAgB,CAAC;IAEtC,gEAAgE;IAChE,QAAQ,CAAC,MAAM,EAAE,SAAS,aAAa,EAAE,CAAC;IAE1C;;;;;OAKG;IACH,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;CAC3B;AAMD;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,WAAW,aAAa;IAC5B,mCAAmC;IACnC,QAAQ,CAAC,QAAQ,EAAE,OAAO,GAAG,SAAS,GAAG,aAAa,CAAC;IAEvD,mCAAmC;IACnC,QAAQ,CAAC,IAAI,EAAE,iBAAiB,CAAC;IAEjC,+CAA+C;IAC/C,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IAEzB,4EAA4E;IAC5E,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IAEvB,wCAAwC;IACxC,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;CAC3B;AAMD;;;;;GAKG;AACH,MAAM,MAAM,iBAAiB;AAC3B,qDAAqD;AACnD,qBAAqB;AACvB,oDAAoD;GAClD,gBAAgB;AAClB,2DAA2D;GACzD,uBAAuB;AACzB,+DAA+D;GAC7D,2BAA2B;AAC7B,mEAAmE;GACjE,uBAAuB;AACzB,uDAAuD;GACrD,mBAAmB;AACrB,sEAAsE;GACpE,mBAAmB;AACrB,mEAAmE;GACjE,eAAe;AACjB,oDAAoD;GAClD,gBAAgB;AAClB,mEAAmE;GACjE,oBAAoB;AACtB,2DAA2D;GACzD,gBAAgB,CAAC;AAMrB;;;;;;;;;GASG;AACH,MAAM,WAAW,kBAAkB;IACjC,mDAAmD;IACnD,QAAQ,CAAC,OAAO,EAAE,iBAAiB,CAAC;IAEpC;;;;;;;OAOG;IACH,QAAQ,EAAE,OAAO,CAAC;CACnB;AAMD;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,MAAM,WAAW,cAAc;IAC7B,wCAAwC;IACxC,QAAQ,CAAC,QAAQ,EAAE,SAAS,iBAAiB,EAAE,CAAC;IAEhD,+BAA+B;IAC/B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IAEvB,6BAA6B;IAC7B,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;CACtB;AAMD;;;;GAIG;AACH,wBAAgB,mBAAmB,CACjC,QAAQ,EAAE,aAAa,CAAC,UAAU,CAAC,EACnC,IAAI,EAAE,iBAAiB,EACvB,OAAO,EAAE,MAAM,EACf,IAAI,CAAC,EAAE,MAAM,EACb,OAAO,CAAC,EAAE,MAAM,GACf,aAAa,CASf;AAED;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,iBAAiB,GAAG,kBAAkB,CAEhF"}

package/dist/lib/validator/errors.d.ts

@@ -0,0 +1,83 @@
+/**
+ * fhir-validator — Error Types
+ *
+ * Structured error hierarchy for the FHIR validator module.
+ * All errors extend {@link ValidatorError} so consumers can catch
+ * validator-related failures with a single `catch` clause.
+ *
+ * Error hierarchy:
+ * ```
+ * ValidatorError (base)
+ * ├── ProfileNotFoundError
+ * └── ValidationFailedError
+ * ```
+ *
+ * @module fhir-validator
+ */
+import type { ValidationIssue } from './types.js';
+/**
+ * Base error class for all fhir-validator failures.
+ *
+ * Provides a stable `name` property and preserves the original `cause`
+ * when wrapping lower-level errors.
+ *
+ * @example
+ * ```typescript
+ * try {
+ *   await validator.validate(resource);
+ * } catch (err) {
+ *   if (err instanceof ValidatorError) {
+ *     // Handle any validator-related error
+ *   }
+ * }
+ * ```
+ */
+export declare class ValidatorError extends Error {
+    readonly name: string;
+    constructor(message: string, options?: ErrorOptions);
+}
+/**
+ * Thrown when the profile required for validation cannot be found or loaded.
+ *
+ * This occurs when:
+ * - The specified `profileUrl` does not exist in the FhirContext
+ * - The profile exists but has no snapshot
+ * - No profile URL is specified and none can be inferred from the resource
+ *
+ * @example
+ * ```typescript
+ * throw new ProfileNotFoundError(
+ *   'http://example.org/StructureDefinition/UnknownProfile',
+ * );
+ * ```
+ */
+export declare class ProfileNotFoundError extends ValidatorError {
+    readonly name = "ProfileNotFoundError";
+    /** The canonical URL of the profile that could not be found. */
+    readonly profileUrl: string;
+    constructor(profileUrl: string, cause?: Error);
+}
+/**
+ * Thrown when validation fails and {@link ValidationOptions.failFast} is enabled.
+ *
+ * Contains the issues accumulated up to the point of failure. This allows
+ * callers to inspect the first error(s) that triggered the failure.
+ *
+ * @example
+ * ```typescript
+ * try {
+ *   await validator.validate(resource, { failFast: true });
+ * } catch (err) {
+ *   if (err instanceof ValidationFailedError) {
+ *     console.error('First error:', err.issues[0].message);
+ *   }
+ * }
+ * ```
+ */
+export declare class ValidationFailedError extends ValidatorError {
+    readonly name = "ValidationFailedError";
+    /** The validation issues accumulated before failure. */
+    readonly issues: readonly ValidationIssue[];
+    constructor(message: string, issues: readonly ValidationIssue[], cause?: Error);
+}
+//# sourceMappingURL=errors.d.ts.map

package/dist/lib/validator/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../../src/validator/errors.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAMlD;;;;;;;;;;;;;;;;GAgBG;AACH,qBAAa,cAAe,SAAQ,KAAK;IACvC,SAAkB,IAAI,EAAE,MAAM,CAAoB;gBAEtC,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,YAAY;CAKpD;AAMD;;;;;;;;;;;;;;GAcG;AACH,qBAAa,oBAAqB,SAAQ,cAAc;IACtD,SAAkB,IAAI,0BAA0B;IAEhD,gEAAgE;IAChE,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;gBAEhB,UAAU,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,KAAK;CAO9C;AAMD;;;;;;;;;;;;;;;;GAgBG;AACH,qBAAa,qBAAsB,SAAQ,cAAc;IACvD,SAAkB,IAAI,2BAA2B;IAEjD,wDAAwD;IACxD,QAAQ,CAAC,MAAM,EAAE,SAAS,eAAe,EAAE,CAAC;gBAEhC,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,SAAS,eAAe,EAAE,EAAE,KAAK,CAAC,EAAE,KAAK;CAO/E"}

package/dist/lib/validator/index.d.ts

@@ -0,0 +1,23 @@
+/**
+ * fhir-validator — Barrel Exports
+ *
+ * Re-exports all public types, interfaces, error classes, and helper
+ * functions from the FHIR validator module.
+ *
+ * Public surface:
+ * - Types: ValidationOptions, ValidationResult, ValidationIssue, etc.
+ * - Errors: ValidatorError hierarchy
+ * - Helpers: createValidationIssue, hasValidationErrors, etc.
+ *
+ * @module fhir-validator
+ */
+export type { ValidationOptions, ValidationResult, ValidationIssue, ValidationIssueCode, ValidationContext, } from './types.js';
+export { createValidationIssue, createValidationContext, resolveValidationOptions, hasValidationErrors, filterIssuesBySeverity, filterIssuesByCode, } from './types.js';
+export { extractValues, pathExists, findChoiceTypeField, normalizeChoicePath, extractChoiceTypeSuffix, } from './path-extractor.js';
+export { validateCardinality, validateRequired, validateType, validateChoiceType, inferFhirType, deepEqual, validateFixed, matchesPattern, validatePattern, extractReferenceType, validateReference, } from './validation-rules.js';
+export { validateSlicing, findMatchingSlice, matchesDiscriminator, isSliceOrderValid, extractValueAtPath, getSliceDiscriminatorValue, getSliceTypes, } from './slicing-validator.js';
+export { StructureValidator } from './structure-validator.js';
+export type { InvariantValidationOptions } from './invariant-validator.js';
+export { validateInvariants, validateSingleInvariant, validateAllInvariants, } from './invariant-validator.js';
+export { ValidatorError, ProfileNotFoundError, ValidationFailedError, } from './errors.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/lib/validator/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/validator/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAGH,YAAY,EACV,iBAAiB,EACjB,gBAAgB,EAChB,eAAe,EACf,mBAAmB,EACnB,iBAAiB,GAClB,MAAM,YAAY,CAAC;AAGpB,OAAO,EACL,qBAAqB,EACrB,uBAAuB,EACvB,wBAAwB,EACxB,mBAAmB,EACnB,sBAAsB,EACtB,kBAAkB,GACnB,MAAM,YAAY,CAAC;AAGpB,OAAO,EACL,aAAa,EACb,UAAU,EACV,mBAAmB,EACnB,mBAAmB,EACnB,uBAAuB,GACxB,MAAM,qBAAqB,CAAC;AAG7B,OAAO,EACL,mBAAmB,EACnB,gBAAgB,EAChB,YAAY,EACZ,kBAAkB,EAClB,aAAa,EACb,SAAS,EACT,aAAa,EACb,cAAc,EACd,eAAe,EACf,oBAAoB,EACpB,iBAAiB,GAClB,MAAM,uBAAuB,CAAC;AAG/B,OAAO,EACL,eAAe,EACf,iBAAiB,EACjB,oBAAoB,EACpB,iBAAiB,EACjB,kBAAkB,EAClB,0BAA0B,EAC1B,aAAa,GACd,MAAM,wBAAwB,CAAC;AAGhC,OAAO,EAAE,kBAAkB,EAAE,MAAM,0BAA0B,CAAC;AAG9D,YAAY,EAAE,0BAA0B,EAAE,MAAM,0BAA0B,CAAC;AAC3E,OAAO,EACL,kBAAkB,EAClB,uBAAuB,EACvB,qBAAqB,GACtB,MAAM,0BAA0B,CAAC;AAGlC,OAAO,EACL,cAAc,EACd,oBAAoB,EACpB,qBAAqB,GACtB,MAAM,aAAa,CAAC"}

package/dist/lib/validator/invariant-validator.d.ts

@@ -0,0 +1,62 @@
+/**
+ * FHIRPath Invariant Validator
+ *
+ * Evaluates FHIRPath constraint expressions from StructureDefinition
+ * elements and reports violations as ValidationIssues.
+ *
+ * @module validator
+ */
+import type { Invariant, CanonicalElement } from '../model/canonical-profile.js';
+import type { ValidationIssue } from './types.js';
+/**
+ * Options for invariant validation.
+ */
+export interface InvariantValidationOptions {
+    /** Skip all invariant evaluation. */
+    skipInvariants?: boolean;
+    /** Skip invariants from inherited profiles (only evaluate local constraints). */
+    skipInheritedInvariants?: boolean;
+    /** Profile URL of the current profile (used to filter inherited constraints). */
+    currentProfileUrl?: string;
+}
+/**
+ * Validate FHIRPath invariants (constraint.expression) on a single element value.
+ *
+ * For each constraint on the element that has an expression, the expression
+ * is evaluated against the value. If it evaluates to `false`, a validation
+ * issue is recorded.
+ *
+ * @param element - The canonical element with constraints.
+ * @param value - The value at the element path (raw JS value).
+ * @param resource - The root resource being validated (for %resource context).
+ * @param issues - Mutable array to push validation issues into.
+ * @param options - Validation options.
+ */
+export declare function validateInvariants(element: CanonicalElement, value: unknown, resource: unknown, issues: ValidationIssue[], options?: InvariantValidationOptions): void;
+/**
+ * Validate a single FHIRPath invariant constraint.
+ *
+ * @param constraint - The invariant to validate.
+ * @param path - The element path for error reporting.
+ * @param value - The value to validate.
+ * @param resource - The root resource.
+ * @param issues - Mutable array to push issues into.
+ * @param options - Validation options.
+ */
+export declare function validateSingleInvariant(constraint: Invariant, path: string, value: unknown, resource: unknown, issues: ValidationIssue[], options?: InvariantValidationOptions): void;
+/**
+ * Validate all invariants for multiple element-value pairs.
+ *
+ * Convenience function for batch validation of all constraints
+ * across a resource's elements.
+ *
+ * @param elements - Array of [element, values] pairs.
+ * @param resource - The root resource.
+ * @param options - Validation options.
+ * @returns Array of validation issues.
+ */
+export declare function validateAllInvariants(elements: Array<{
+    element: CanonicalElement;
+    values: unknown[];
+}>, resource: unknown, options?: InvariantValidationOptions): ValidationIssue[];
+//# sourceMappingURL=invariant-validator.d.ts.map

package/dist/lib/validator/invariant-validator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"invariant-validator.d.ts","sourceRoot":"","sources":["../../../src/validator/invariant-validator.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,gBAAgB,EAAE,MAAM,+BAA+B,CAAC;AACjF,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAUlD;;GAEG;AACH,MAAM,WAAW,0BAA0B;IACzC,qCAAqC;IACrC,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,iFAAiF;IACjF,uBAAuB,CAAC,EAAE,OAAO,CAAC;IAClC,iFAAiF;IACjF,iBAAiB,CAAC,EAAE,MAAM,CAAC;CAC5B;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,kBAAkB,CAChC,OAAO,EAAE,gBAAgB,EACzB,KAAK,EAAE,OAAO,EACd,QAAQ,EAAE,OAAO,EACjB,MAAM,EAAE,eAAe,EAAE,EACzB,OAAO,GAAE,0BAA+B,GACvC,IAAI,CAYN;AAED;;;;;;;;;GASG;AACH,wBAAgB,uBAAuB,CACrC,UAAU,EAAE,SAAS,EACrB,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,OAAO,EACd,QAAQ,EAAE,OAAO,EACjB,MAAM,EAAE,eAAe,EAAE,EACzB,OAAO,GAAE,0BAA+B,GACvC,IAAI,CAyDN;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,qBAAqB,CACnC,QAAQ,EAAE,KAAK,CAAC;IAAE,OAAO,EAAE,gBAAgB,CAAC;IAAC,MAAM,EAAE,OAAO,EAAE,CAAA;CAAE,CAAC,EACjE,QAAQ,EAAE,OAAO,EACjB,OAAO,GAAE,0BAA+B,GACvC,eAAe,EAAE,CAcnB"}

package/dist/lib/validator/path-extractor.d.ts

@@ -0,0 +1,123 @@
+/**
+ * fhir-validator — Path Extractor
+ *
+ * Extracts values from FHIR resource instances using element paths.
+ * Handles nested objects, arrays, and choice type (`[x]`) paths.
+ *
+ * This is the core utility that bridges CanonicalProfile element paths
+ * (e.g., `Patient.name.family`) to actual values in a resource JSON object.
+ *
+ * @module fhir-validator
+ */
+/**
+ * Extract values from a resource instance using an element path.
+ *
+ * Navigates the resource object following the dot-separated path segments.
+ * Arrays are automatically expanded — if an intermediate node is an array,
+ * extraction continues into each element.
+ *
+ * @param resource - The resource object to extract from.
+ * @param path - Element path (e.g., `'Patient.name.family'`).
+ * @returns Array of extracted values (empty if path not found).
+ *
+ * @example
+ * ```typescript
+ * const patient = {
+ *   resourceType: 'Patient',
+ *   name: [
+ *     { family: 'Smith', given: ['John', 'James'] },
+ *     { family: 'Doe' },
+ *   ],
+ * };
+ *
+ * extractValues(patient, 'Patient.name')
+ * // → [{ family: 'Smith', given: ['John', 'James'] }, { family: 'Doe' }]
+ *
+ * extractValues(patient, 'Patient.name.family')
+ * // → ['Smith', 'Doe']
+ *
+ * extractValues(patient, 'Patient.name.given')
+ * // → ['John', 'James']
+ * ```
+ */
+export declare function extractValues(resource: Record<string, unknown>, path: string): unknown[];
+/**
+ * Check if a path exists in the resource (even if value is null/undefined).
+ *
+ * Unlike `extractValues`, this checks for property existence rather than
+ * value presence. A property set to `null` or `undefined` still "exists".
+ *
+ * @param resource - The resource object to check.
+ * @param path - Element path (e.g., `'Patient.name'`).
+ * @returns `true` if the path exists in the resource.
+ *
+ * @example
+ * ```typescript
+ * pathExists({ resourceType: 'Patient', name: [] }, 'Patient.name')
+ * // → true
+ *
+ * pathExists({ resourceType: 'Patient' }, 'Patient.name')
+ * // → false
+ * ```
+ */
+export declare function pathExists(resource: Record<string, unknown>, path: string): boolean;
+/**
+ * Find the concrete choice type property name in an object.
+ *
+ * Given a choice base name (e.g., `'value'`), searches the object for
+ * a property like `valueString`, `valueQuantity`, etc.
+ *
+ * @param obj - The object to search.
+ * @param baseName - The choice type base name (without `[x]`).
+ * @returns The concrete property name, or `undefined` if not found.
+ *
+ * @example
+ * ```typescript
+ * findChoiceTypeField({ valueQuantity: { value: 120 } }, 'value')
+ * // → 'valueQuantity'
+ *
+ * findChoiceTypeField({ code: '12345' }, 'value')
+ * // → undefined
+ * ```
+ */
+export declare function findChoiceTypeField(obj: Record<string, unknown>, baseName: string): string | undefined;
+/**
+ * Normalize a choice type path to a concrete path.
+ *
+ * Replaces the `[x]` suffix with the actual type suffix found in the object.
+ *
+ * @param basePath - The choice type path (e.g., `'Observation.value[x]'`).
+ * @param concreteField - The concrete field name (e.g., `'valueQuantity'`).
+ * @returns The normalized path (e.g., `'Observation.valueQuantity'`).
+ *
+ * @example
+ * ```typescript
+ * normalizeChoicePath('Observation.value[x]', 'valueQuantity')
+ * // → 'Observation.valueQuantity'
+ *
+ * normalizeChoicePath('Extension.value[x]', 'valueString')
+ * // → 'Extension.valueString'
+ * ```
+ */
+export declare function normalizeChoicePath(basePath: string, concreteField: string): string;
+/**
+ * Extract the type suffix from a concrete choice type property name.
+ *
+ * @param concreteField - The concrete field name (e.g., `'valueQuantity'`).
+ * @param baseName - The choice type base name (e.g., `'value'`).
+ * @returns The type suffix (e.g., `'Quantity'`), or `undefined` if not a match.
+ *
+ * @example
+ * ```typescript
+ * extractChoiceTypeSuffix('valueQuantity', 'value')
+ * // → 'Quantity'
+ *
+ * extractChoiceTypeSuffix('valueString', 'value')
+ * // → 'String'
+ *
+ * extractChoiceTypeSuffix('code', 'value')
+ * // → undefined
+ * ```
+ */
+export declare function extractChoiceTypeSuffix(concreteField: string, baseName: string): string | undefined;
+//# sourceMappingURL=path-extractor.d.ts.map

package/dist/lib/validator/path-extractor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"path-extractor.d.ts","sourceRoot":"","sources":["../../../src/validator/path-extractor.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAwEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,wBAAgB,aAAa,CAC3B,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACjC,IAAI,EAAE,MAAM,GACX,OAAO,EAAE,CAwBX;AAmHD;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,UAAU,CACxB,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACjC,IAAI,EAAE,MAAM,GACX,OAAO,CAaT;AAsED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,mBAAmB,CACjC,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC5B,QAAQ,EAAE,MAAM,GACf,MAAM,GAAG,SAAS,CAsBpB;AAMD;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,mBAAmB,CACjC,QAAQ,EAAE,MAAM,EAChB,aAAa,EAAE,MAAM,GACpB,MAAM,CAYR;AAMD;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,uBAAuB,CACrC,aAAa,EAAE,MAAM,EACrB,QAAQ,EAAE,MAAM,GACf,MAAM,GAAG,SAAS,CAepB"}