fhir-runtime 0.2.0

package/dist/lib/fhirpath/parse.d.ts

@@ -0,0 +1,101 @@
+/**
+ * FHIRPath Parser
+ *
+ * Builds a Pratt parser configured with FHIRPath-specific parselets,
+ * and provides the public API for parsing and evaluating FHIRPath expressions.
+ *
+ * @module fhirpath
+ */
+import type { TypedValue } from './types.js';
+import { ParserBuilder } from './lexer/parse.js';
+import { FhirPathAtom } from './atoms.js';
+/**
+ * FHIRPath operator precedence levels.
+ * Lower number = tighter binding.
+ * @see https://hl7.org/fhirpath/#operator-precedence
+ */
+export declare const OperatorPrecedence: {
+    readonly FunctionCall: 0;
+    readonly Dot: 1;
+    readonly Indexer: 2;
+    readonly UnaryAdd: 3;
+    readonly UnarySubtract: 3;
+    readonly Multiply: 4;
+    readonly Divide: 4;
+    readonly IntegerDivide: 4;
+    readonly Modulo: 4;
+    readonly Add: 5;
+    readonly Subtract: 5;
+    readonly Ampersand: 5;
+    readonly Is: 6;
+    readonly As: 6;
+    readonly Union: 7;
+    readonly GreaterThan: 8;
+    readonly GreaterThanOrEquals: 8;
+    readonly LessThan: 8;
+    readonly LessThanOrEquals: 8;
+    readonly Equals: 9;
+    readonly Equivalent: 9;
+    readonly NotEquals: 9;
+    readonly NotEquivalent: 9;
+    readonly In: 10;
+    readonly Contains: 10;
+    readonly And: 11;
+    readonly Xor: 12;
+    readonly Or: 12;
+    readonly Implies: 13;
+};
+/**
+ * Initialize the FHIRPath parser builder with all prefix and infix parselets.
+ */
+export declare function initFhirPathParserBuilder(): ParserBuilder;
+/**
+ * Parse a FHIRPath expression string into an AST.
+ * Results are cached in the global expression cache for reuse.
+ *
+ * @param input - The FHIRPath expression string.
+ * @returns The parsed AST as a {@link FhirPathAtom}.
+ */
+export declare function parseFhirPath(input: string): FhirPathAtom;
+/**
+ * Evaluate a FHIRPath expression against a resource or other object.
+ * Accepts raw values (auto-wrapped in TypedValue) or pre-wrapped TypedValue arrays.
+ *
+ * @param expression - The FHIRPath expression string or pre-parsed AST.
+ * @param input - The resource or object to evaluate against.
+ * @returns Array of result values (unwrapped from TypedValue).
+ */
+export declare function evalFhirPath(expression: string | FhirPathAtom, input: unknown): unknown[];
+/**
+ * Evaluate a FHIRPath expression against typed input values.
+ *
+ * @param expression - The FHIRPath expression string or pre-parsed AST.
+ * @param input - Array of TypedValue inputs.
+ * @param variables - Optional variable bindings.
+ * @returns Array of TypedValue results.
+ */
+export declare function evalFhirPathTyped(expression: string | FhirPathAtom, input: TypedValue[], variables?: Record<string, TypedValue>): TypedValue[];
+/**
+ * Evaluate a FHIRPath expression and return a boolean result.
+ *
+ * Useful for invariant validation where the expression must evaluate to `true`.
+ * Uses FHIRPath boolean semantics: empty → false, single truthy → true.
+ *
+ * @param expression - FHIRPath expression string or pre-parsed AST.
+ * @param input - The resource or typed values to evaluate against.
+ * @param variables - Optional variable bindings.
+ * @returns Boolean result of the expression.
+ */
+export declare function evalFhirPathBoolean(expression: string | FhirPathAtom, input: unknown, variables?: Record<string, TypedValue>): boolean;
+/**
+ * Evaluate a FHIRPath expression and return the first result as a string.
+ *
+ * Useful for extracting display values, identifiers, etc.
+ *
+ * @param expression - FHIRPath expression string or pre-parsed AST.
+ * @param input - The resource or typed values to evaluate against.
+ * @param variables - Optional variable bindings.
+ * @returns The first result value as a string, or `undefined` if empty.
+ */
+export declare function evalFhirPathString(expression: string | FhirPathAtom, input: unknown, variables?: Record<string, TypedValue>): string | undefined;
+//# sourceMappingURL=parse.d.ts.map

package/dist/lib/fhirpath/parse.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse.d.ts","sourceRoot":"","sources":["../../../src/fhirpath/parse.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAIH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAE7C,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAEjD,OAAO,EAUL,YAAY,EAeb,MAAM,YAAY,CAAC;AAcpB;;;;GAIG;AACH,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA8BrB,CAAC;AAmEX;;GAEG;AACH,wBAAgB,yBAAyB,IAAI,aAAa,CAyFzD;AASD;;;;;;GAMG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,MAAM,GAAG,YAAY,CAYzD;AAED;;;;;;;GAOG;AACH,wBAAgB,YAAY,CAAC,UAAU,EAAE,MAAM,GAAG,YAAY,EAAE,KAAK,EAAE,OAAO,GAAG,OAAO,EAAE,CASzF;AAED;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,CAC/B,UAAU,EAAE,MAAM,GAAG,YAAY,EACjC,KAAK,EAAE,UAAU,EAAE,EACnB,SAAS,GAAE,MAAM,CAAC,MAAM,EAAE,UAAU,CAAM,GACzC,UAAU,EAAE,CAMd;AAMD;;;;;;;;;;GAUG;AACH,wBAAgB,mBAAmB,CACjC,UAAU,EAAE,MAAM,GAAG,YAAY,EACjC,KAAK,EAAE,OAAO,EACd,SAAS,GAAE,MAAM,CAAC,MAAM,EAAE,UAAU,CAAM,GACzC,OAAO,CAUT;AAED;;;;;;;;;GASG;AACH,wBAAgB,kBAAkB,CAChC,UAAU,EAAE,MAAM,GAAG,YAAY,EACjC,KAAK,EAAE,OAAO,EACd,SAAS,GAAE,MAAM,CAAC,MAAM,EAAE,UAAU,CAAM,GACzC,MAAM,GAAG,SAAS,CAOpB"}

package/dist/lib/fhirpath/tokenize.d.ts

@@ -0,0 +1,20 @@
+/**
+ * FHIRPath-specific tokenizer.
+ *
+ * Thin wrapper around the generic {@link Tokenizer} that provides
+ * FHIRPath keywords and operators.
+ *
+ * @module fhirpath
+ */
+import type { Token } from './lexer/tokenize.js';
+/** FHIRPath keywords that are treated as their own token type. */
+export declare const FHIRPATH_KEYWORDS: string[];
+/** FHIRPath multi-character operators. */
+export declare const FHIRPATH_OPERATORS: string[];
+/**
+ * Tokenize a FHIRPath expression string into a token array.
+ * @param str - The FHIRPath expression.
+ * @returns Array of tokens.
+ */
+export declare function tokenize(str: string): Token[];
+//# sourceMappingURL=tokenize.d.ts.map

package/dist/lib/fhirpath/tokenize.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tokenize.d.ts","sourceRoot":"","sources":["../../../src/fhirpath/tokenize.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,qBAAqB,CAAC;AAGjD,kEAAkE;AAClE,eAAO,MAAM,iBAAiB,UAAoB,CAAC;AAEnD,0CAA0C;AAC1C,eAAO,MAAM,kBAAkB,UAAuC,CAAC;AAEvE;;;;GAIG;AACH,wBAAgB,QAAQ,CAAC,GAAG,EAAE,MAAM,GAAG,KAAK,EAAE,CAE7C"}

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

@@ -0,0 +1,111 @@
+/**
+ * FHIRPath Core Types
+ *
+ * Defines the fundamental types used throughout the FHIRPath engine:
+ * - {@link TypedValue} — A value paired with its FHIR type
+ * - {@link PropertyType} — Enum of all FHIR property types
+ * - {@link Atom} — AST node interface for parsed expressions
+ * - {@link AtomContext} — Evaluation context with variable scoping
+ *
+ * @module fhirpath
+ */
+/**
+ * Enum of FHIR property type identifiers used in {@link TypedValue}.
+ * Covers all FHIR R4 primitive types and commonly used complex types.
+ */
+export declare const PropertyType: {
+    readonly boolean: "boolean";
+    readonly integer: "integer";
+    readonly decimal: "decimal";
+    readonly string: "string";
+    readonly uri: "uri";
+    readonly url: "url";
+    readonly canonical: "canonical";
+    readonly base64Binary: "base64Binary";
+    readonly instant: "instant";
+    readonly date: "date";
+    readonly dateTime: "dateTime";
+    readonly time: "time";
+    readonly code: "code";
+    readonly oid: "oid";
+    readonly id: "id";
+    readonly markdown: "markdown";
+    readonly unsignedInt: "unsignedInt";
+    readonly positiveInt: "positiveInt";
+    readonly uuid: "uuid";
+    readonly xhtml: "xhtml";
+    readonly BackboneElement: "BackboneElement";
+    readonly CodeableConcept: "CodeableConcept";
+    readonly Coding: "Coding";
+    readonly Quantity: "Quantity";
+    readonly Reference: "Reference";
+    readonly Period: "Period";
+    readonly Identifier: "Identifier";
+    readonly HumanName: "HumanName";
+    readonly Address: "Address";
+    readonly ContactPoint: "ContactPoint";
+    readonly Attachment: "Attachment";
+    readonly Extension: "Extension";
+};
+export type PropertyType = (typeof PropertyType)[keyof typeof PropertyType];
+/**
+ * A value paired with its FHIR type identifier.
+ * This is the fundamental unit of data flowing through the FHIRPath engine.
+ *
+ * @example
+ * ```ts
+ * const tv: TypedValue = { type: PropertyType.string, value: 'hello' };
+ * ```
+ */
+export interface TypedValue {
+    readonly type: string;
+    readonly value: unknown;
+}
+/**
+ * Evaluation context for FHIRPath expressions.
+ * Supports nested scoping via the `parent` chain, used by functions
+ * like `where()` and `select()` that introduce `$this`.
+ */
+export interface AtomContext {
+    readonly parent?: AtomContext;
+    readonly variables: Record<string, TypedValue>;
+}
+/**
+ * Interface for all AST nodes in the FHIRPath expression tree.
+ * Each node can evaluate itself given a context and input collection.
+ */
+export interface Atom {
+    /**
+     * Evaluate this atom against the given input collection.
+     * @param context - The evaluation context (variables, parent scope).
+     * @param input - The input collection of typed values.
+     * @returns The result collection.
+     */
+    eval(context: AtomContext, input: TypedValue[]): TypedValue[];
+    /** Returns a string representation of this atom (for debugging). */
+    toString(): string;
+}
+/**
+ * Base class for prefix (unary) operator atoms.
+ * Examples: unary `-`, unary `+`
+ */
+export declare abstract class PrefixOperatorAtom implements Atom {
+    readonly operator: string;
+    readonly child: Atom;
+    constructor(operator: string, child: Atom);
+    abstract eval(context: AtomContext, input: TypedValue[]): TypedValue[];
+    toString(): string;
+}
+/**
+ * Base class for infix (binary) operator atoms.
+ * Examples: `+`, `-`, `=`, `and`, `or`
+ */
+export declare abstract class InfixOperatorAtom implements Atom {
+    readonly operator: string;
+    readonly left: Atom;
+    readonly right: Atom;
+    constructor(operator: string, left: Atom, right: Atom);
+    abstract eval(context: AtomContext, input: TypedValue[]): TypedValue[];
+    toString(): string;
+}
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/fhirpath/types.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAMH;;;GAGG;AACH,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoCf,CAAC;AAEX,MAAM,MAAM,YAAY,GAAG,CAAC,OAAO,YAAY,CAAC,CAAC,MAAM,OAAO,YAAY,CAAC,CAAC;AAM5E;;;;;;;;GAQG;AACH,MAAM,WAAW,UAAU;IACzB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC;CACzB;AAMD;;;;GAIG;AACH,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,MAAM,CAAC,EAAE,WAAW,CAAC;IAC9B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC;CAChD;AAMD;;;GAGG;AACH,MAAM,WAAW,IAAI;IACnB;;;;;OAKG;IACH,IAAI,CAAC,OAAO,EAAE,WAAW,EAAE,KAAK,EAAE,UAAU,EAAE,GAAG,UAAU,EAAE,CAAC;IAE9D,oEAAoE;IACpE,QAAQ,IAAI,MAAM,CAAC;CACpB;AAMD;;;GAGG;AACH,8BAAsB,kBAAmB,YAAW,IAAI;IACtD,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,KAAK,EAAE,IAAI,CAAC;gBAET,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,IAAI;IAKzC,QAAQ,CAAC,IAAI,CAAC,OAAO,EAAE,WAAW,EAAE,KAAK,EAAE,UAAU,EAAE,GAAG,UAAU,EAAE;IAEtE,QAAQ,IAAI,MAAM;CAGnB;AAED;;;GAGG;AACH,8BAAsB,iBAAkB,YAAW,IAAI;IACrD,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,IAAI,EAAE,IAAI,CAAC;IACpB,QAAQ,CAAC,KAAK,EAAE,IAAI,CAAC;gBAET,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI;IAMrD,QAAQ,CAAC,IAAI,CAAC,OAAO,EAAE,WAAW,EAAE,KAAK,EAAE,UAAU,EAAE,GAAG,UAAU,EAAE;IAEtE,QAAQ,IAAI,MAAM;CAGnB"}

package/dist/lib/fhirpath/utils.d.ts

@@ -0,0 +1,81 @@
+/**
+ * FHIRPath utility functions.
+ *
+ * Provides type conversion, equality/equivalence comparison,
+ * and helper functions used by atoms and the function library.
+ *
+ * @module fhirpath
+ */
+import type { Quantity } from '../model/primitives.js';
+import type { TypedValue } from './types.js';
+/**
+ * Returns a single-element array with a typed boolean value.
+ */
+export declare function booleanToTypedValue(value: boolean): [TypedValue];
+/**
+ * Returns a "best guess" TypedValue for a given unknown value.
+ */
+export declare function toTypedValue(value: unknown): TypedValue;
+/**
+ * Converts a TypedValue collection to a JavaScript boolean.
+ * Empty collection → false; otherwise truthy check on first element.
+ */
+export declare function toJsBoolean(obj: TypedValue[]): boolean;
+/**
+ * Returns the single element from a collection, or undefined if empty.
+ * Throws if the collection has more than one element.
+ */
+export declare function singleton(collection: TypedValue[], type?: string): TypedValue | undefined;
+/**
+ * Extract a typed property value from a TypedValue without schema.
+ * Handles simple paths and choice-type paths (value[x]).
+ */
+export declare function getTypedPropertyValue(input: TypedValue, path: string): TypedValue[] | TypedValue | undefined;
+/**
+ * FHIRPath equality comparison for two TypedValue elements.
+ * Returns `[{type:'boolean', value:true/false}]` or `[]` for incomparable.
+ */
+export declare function fhirPathEquals(x: TypedValue, y: TypedValue): TypedValue[];
+/**
+ * FHIRPath array equality: both arrays must have same length and pairwise equal elements.
+ * Returns `[]` if either side is empty.
+ */
+export declare function fhirPathArrayEquals(x: TypedValue[], y: TypedValue[]): TypedValue[];
+/**
+ * FHIRPath array not-equals.
+ */
+export declare function fhirPathArrayNotEquals(x: TypedValue[], y: TypedValue[]): TypedValue[];
+/**
+ * FHIRPath equivalence comparison for two TypedValue elements.
+ * More lenient than equality (case-insensitive strings, rounded decimals, etc.).
+ */
+export declare function fhirPathEquivalent(x: TypedValue, y: TypedValue): TypedValue[];
+/**
+ * FHIRPath array equivalence: sorted pairwise equivalence.
+ */
+export declare function fhirPathArrayEquivalent(x: TypedValue[], y: TypedValue[]): TypedValue[];
+/**
+ * Negate a FHIRPath boolean result.
+ */
+export declare function fhirPathNot(input: TypedValue[]): TypedValue[];
+/**
+ * Remove duplicates using FHIRPath equality rules.
+ */
+export declare function removeDuplicates(arr: TypedValue[]): TypedValue[];
+/**
+ * Determines if a typed value matches the desired FHIRPath type name.
+ */
+export declare function fhirPathIs(typedValue: TypedValue, desiredType: string): boolean;
+/**
+ * Heuristic check for Quantity objects.
+ */
+export declare function isQuantity(input: unknown): input is Quantity;
+/**
+ * Heuristic check for FHIR Resource objects.
+ */
+export declare function isResource(input: unknown): boolean;
+/**
+ * Check if a value is a FHIR Resource with a specific resourceType.
+ */
+export declare function isResourceType(input: unknown, resourceType: string): boolean;
+//# sourceMappingURL=utils.d.ts.map

package/dist/lib/fhirpath/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../src/fhirpath/utils.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,wBAAwB,CAAC;AACvD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAO7C;;GAEG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,OAAO,GAAG,CAAC,UAAU,CAAC,CAEhE;AAED;;GAEG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,OAAO,GAAG,UAAU,CAkBvD;AAMD;;;GAGG;AACH,wBAAgB,WAAW,CAAC,GAAG,EAAE,UAAU,EAAE,GAAG,OAAO,CAEtD;AAMD;;;GAGG;AACH,wBAAgB,SAAS,CAAC,UAAU,EAAE,UAAU,EAAE,EAAE,IAAI,CAAC,EAAE,MAAM,GAAG,UAAU,GAAG,SAAS,CAQzF;AAMD;;;GAGG;AACH,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,UAAU,EAAE,IAAI,EAAE,MAAM,GAAG,UAAU,EAAE,GAAG,UAAU,GAAG,SAAS,CA+B5G;AAMD;;;GAGG;AACH,wBAAgB,cAAc,CAAC,CAAC,EAAE,UAAU,EAAE,CAAC,EAAE,UAAU,GAAG,UAAU,EAAE,CAazE;AAED;;;GAGG;AACH,wBAAgB,mBAAmB,CAAC,CAAC,EAAE,UAAU,EAAE,EAAE,CAAC,EAAE,UAAU,EAAE,GAAG,UAAU,EAAE,CAQlF;AAED;;GAEG;AACH,wBAAgB,sBAAsB,CAAC,CAAC,EAAE,UAAU,EAAE,EAAE,CAAC,EAAE,UAAU,EAAE,GAAG,UAAU,EAAE,CAQrF;AAMD;;;GAGG;AACH,wBAAgB,kBAAkB,CAAC,CAAC,EAAE,UAAU,EAAE,CAAC,EAAE,UAAU,GAAG,UAAU,EAAE,CAiB7E;AAED;;GAEG;AACH,wBAAgB,uBAAuB,CAAC,CAAC,EAAE,UAAU,EAAE,EAAE,CAAC,EAAE,UAAU,EAAE,GAAG,UAAU,EAAE,CAUtF;AAMD;;GAEG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,UAAU,EAAE,GAAG,UAAU,EAAE,CAE7D;AAED;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,UAAU,EAAE,GAAG,UAAU,EAAE,CAehE;AAMD;;GAEG;AACH,wBAAgB,UAAU,CAAC,UAAU,EAAE,UAAU,EAAE,WAAW,EAAE,MAAM,GAAG,OAAO,CAkC/E;AAMD;;GAEG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,QAAQ,CAE5D;AAED;;GAEG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAElD;AAED;;GAEG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,OAAO,EAAE,YAAY,EAAE,MAAM,GAAG,OAAO,CAE5E"}

package/dist/lib/index.d.ts

@@ -0,0 +1,24 @@
+/**
+ * `@medxai/fhir-core` — Public API (Frozen at v0.1.0)
+ *
+ * Re-exports all public types and functions from the six core modules:
+ *   model → parser → context → profile → validator (+ fhirpath internal)
+ *
+ * This file defines the frozen public API surface for @medxai/fhir-core v0.1.
+ * Any symbol exported here is subject to the v0.1 compatibility contract.
+ * See: docs/specs/engine-capability-contract-v0.1.md
+ *      docs/api/fhir-core-api-v0.1.md
+ *
+ * @packageDocumentation
+ */
+export type { ParseSeverity, ParseErrorCode, ParseIssue, ParseResult, ChoiceValue, ChoiceTypeField, } from './parser/index.js';
+export { parseFhirJson, parseFhirObject, parseStructureDefinition, parseElementDefinition, serializeToFhirJson, serializeToFhirObject, parseSuccess, parseFailure, createIssue, hasErrors, } from './parser/index.js';
+export type { FhirBoolean, FhirInteger, FhirString, FhirDecimal, FhirUri, FhirUrl, FhirCanonical, FhirBase64Binary, FhirInstant, FhirDate, FhirDateTime, FhirTime, FhirCode, FhirOid, FhirId, FhirMarkdown, FhirUnsignedInt, FhirPositiveInt, FhirUuid, FhirXhtml, PublicationStatus, StructureDefinitionKind, TypeDerivationRule, ExtensionContextType, FhirVersionCode, PropertyRepresentation, SlicingRules, DiscriminatorType, AggregationMode, ReferenceVersionRules, ConstraintSeverity, BindingStrength, NarrativeStatus, Element, Extension, Coding, CodeableConcept, Identifier, Period, Reference, ContactDetail, ContactPoint, UsageContext, Quantity, Narrative, Meta, Resource, DomainResource, BackboneElement, ElementDefinition, ElementDefinitionSlicing, SlicingDiscriminator, ElementDefinitionBase, ElementDefinitionType, ElementDefinitionConstraint, ElementDefinitionBinding, ElementDefinitionExample, ElementDefinitionMapping, StructureDefinition, StructureDefinitionMapping, StructureDefinitionContext, StructureDefinitionSnapshot, StructureDefinitionDifferential, CanonicalProfile, CanonicalElement, TypeConstraint, BindingConstraint, Invariant, SlicingDefinition, SlicingDiscriminatorDef, } from './model/index.js';
+export type { FhirContext, FhirContextOptions, StructureDefinitionLoader, LoaderOptions, ContextStatistics, BundleLoadOptions, BundleLoadResult, BundleLoadError, } from './context/index.js';
+export { FhirContextImpl, createEmptyStatistics, MemoryLoader, FileSystemLoader, CompositeLoader, ContextError, ResourceNotFoundError, CircularDependencyError, LoaderError, InvalidStructureDefinitionError, loadBundleFromObject, loadBundleFromFile, loadBundlesFromFiles, BASE_RESOURCES, PRIMITIVE_TYPES, COMPLEX_TYPES, CORE_RESOURCES, ALL_CORE_DEFINITIONS, loadAllCoreDefinitions, loadCoreDefinition, loadCoreDefinitionSync, getCoreDefinitionsDir, extractInnerTypes, buildTypeName, isBackboneElementType, } from './context/index.js';
+export type { SnapshotGeneratorOptions, SnapshotResult, SnapshotIssue, SnapshotIssueCode, DiffElementTracker, TraversalScope, MergeContext, } from './profile/index.js';
+export { SnapshotGenerator, buildCanonicalProfile, buildCanonicalElement, buildTypeConstraints, buildBindingConstraint, buildInvariants, buildSlicingDefinition, ProfileError, SnapshotCircularDependencyError, BaseNotFoundError, ConstraintViolationError, UnconsumedDifferentialError, createSnapshotIssue, createDiffTracker, pathMatches, isDirectChild, isDescendant, pathDepth, parentPath, tailSegment, isChoiceTypePath, matchesChoiceType, extractChoiceTypeName, hasSliceName, extractSliceName, findBaseIndex, sortDifferential, validateElementOrder, ensureElementIds, mergeConstraints, setBaseTraceability, mergeCardinality, mergeTypes, mergeBinding, mergeConstraintList, isLargerMax, createMergeContext, processPaths, mergeSnapshot, makeExtensionSlicing, getSliceSiblings, validateSlicingCompatibility, diffsConstrainTypes, handleNewSlicing, handleExistingSlicing, } from './profile/index.js';
+export type { ValidationOptions, ValidationResult, ValidationIssue, ValidationIssueCode, } from './validator/index.js';
+export { StructureValidator, createValidationIssue, resolveValidationOptions, hasValidationErrors, extractValues, ProfileNotFoundError, ValidationFailedError, } from './validator/index.js';
+export { evalFhirPath, evalFhirPathBoolean, evalFhirPathTyped, evalFhirPathString, } from './fhirpath/index.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"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"}