@medplum/core 0.9.32 → 0.9.35

package/dist/cjs/index.js

@@ -129,7 +129,7 @@
     }
     function formatHumanName(name, options) {
         const builder = [];
-        if (name.prefix && ((options === null || options === void 0 ? void 0 : options.all) || (options === null || options === void 0 ? void 0 : options.prefix))) {
+        if (name.prefix && (options === null || options === void 0 ? void 0 : options.prefix) !== false) {
             builder.push(...name.prefix);
         }
         if (name.given) {
@@ -138,7 +138,7 @@
         if (name.family) {
             builder.push(name.family);
         }
-        if (name.suffix && ((options === null || options === void 0 ? void 0 : options.all) || (options === null || options === void 0 ? void 0 : options.suffix))) {
+        if (name.suffix && (options === null || options === void 0 ? void 0 : options.suffix) !== false) {
             builder.push(...name.suffix);
         }
         if (name.use && ((options === null || options === void 0 ? void 0 : options.all) || (options === null || options === void 0 ? void 0 : options.use))) {
@@ -692,7 +692,7 @@
         return word.charAt(0).toUpperCase() + word.substring(1);
     }
     function isLowerCase(c) {
-        return c === c.toLowerCase();
+        return c === c.toLowerCase() && c !== c.toUpperCase();
     }
     /**
      * Tries to find a code string for a given system within a given codeable concept.
@@ -6070,19 +6070,13 @@
     function createSchema() {
         return { types: {} };
     }
-    function createTypeSchema(typeName, description) {
+    function createTypeSchema(typeName, structureDefinition, elementDefinition) {
         return {
+            structureDefinition,
+            elementDefinition,
             display: typeName,
-            description,
+            description: elementDefinition.definition,
             properties: {},
-            searchParams: {
-                _lastUpdated: {
-                    base: [typeName],
-                    code: '_lastUpdated',
-                    type: 'date',
-                    expression: typeName + '.meta.lastUpdated',
-                },
-            },
         };
     }
     /**
@@ -6093,33 +6087,27 @@
         for (const entry of bundle.entry) {
             const resource = entry.resource;
             if (resource.resourceType === 'StructureDefinition') {
-                indexStructureDefinition(globalSchema, resource);
+                indexStructureDefinition(resource);
             }
         }
     }
     /**
      * Indexes a StructureDefinition for fast lookup.
      * See comments on IndexedStructureDefinition for more details.
-     * @param schema The output IndexedStructureDefinition.
      * @param structureDefinition The original StructureDefinition.
      */
-    function indexStructureDefinition(schema, structureDefinition) {
+    function indexStructureDefinition(structureDefinition) {
         var _a;
         const typeName = structureDefinition.name;
         if (!typeName) {
             return;
         }
-        if (!(typeName in schema.types)) {
-            schema.types[typeName] = createTypeSchema(typeName, structureDefinition.description);
-        }
         const elements = (_a = structureDefinition.snapshot) === null || _a === void 0 ? void 0 : _a.element;
         if (elements) {
-            // Filter out any elements missing path or type
-            const filtered = elements.filter((e) => e.path !== typeName && e.path);
             // First pass, build types
-            filtered.forEach((element) => indexType(schema, element));
+            elements.forEach((element) => indexType(structureDefinition, element));
             // Second pass, build properties
-            filtered.forEach((element) => indexProperty(schema, element));
+            elements.forEach((element) => indexProperty(element));
         }
     }
     /**
@@ -6129,33 +6117,31 @@
      * @param schema The output IndexedStructureDefinition.
      * @param element The input ElementDefinition.
      */
-    function indexType(schema, element) {
+    function indexType(structureDefinition, elementDefinition) {
         var _a, _b;
-        const path = element.path;
-        const typeCode = (_b = (_a = element.type) === null || _a === void 0 ? void 0 : _a[0]) === null || _b === void 0 ? void 0 : _b.code;
-        if (typeCode !== 'Element' && typeCode !== 'BackboneElement') {
+        const path = elementDefinition.path;
+        const typeCode = (_b = (_a = elementDefinition.type) === null || _a === void 0 ? void 0 : _a[0]) === null || _b === void 0 ? void 0 : _b.code;
+        if (typeCode !== undefined && typeCode !== 'Element' && typeCode !== 'BackboneElement') {
             return;
         }
         const parts = path.split('.');
         const typeName = buildTypeName(parts);
-        if (!(typeName in schema.types)) {
-            schema.types[typeName] = createTypeSchema(typeName, element.definition);
-            schema.types[typeName].parentType = buildTypeName(parts.slice(0, parts.length - 1));
-        }
+        globalSchema.types[typeName] = createTypeSchema(typeName, structureDefinition, elementDefinition);
+        globalSchema.types[typeName].parentType = buildTypeName(parts.slice(0, parts.length - 1));
     }
     /**
      * Indexes PropertySchema from an ElementDefinition.
      * @param schema The output IndexedStructureDefinition.
      * @param element The input ElementDefinition.
      */
-    function indexProperty(schema, element) {
+    function indexProperty(element) {
         const path = element.path;
         const parts = path.split('.');
         if (parts.length === 1) {
             return;
         }
         const typeName = buildTypeName(parts.slice(0, parts.length - 1));
-        const typeSchema = schema.types[typeName];
+        const typeSchema = globalSchema.types[typeName];
         if (!typeSchema) {
             return;
         }
@@ -6168,22 +6154,38 @@
      * @param schema The output IndexedStructureDefinition.
      * @param searchParam The SearchParameter resource.
      */
-    function indexSearchParameter(schema, searchParam) {
+    function indexSearchParameter(searchParam) {
         if (!searchParam.base) {
             return;
         }
         for (const resourceType of searchParam.base) {
-            const typeSchema = schema.types[resourceType];
+            const typeSchema = globalSchema.types[resourceType];
             if (!typeSchema) {
                 continue;
             }
             if (!typeSchema.searchParams) {
-                typeSchema.searchParams = {};
+                typeSchema.searchParams = {
+                    _id: {
+                        base: [resourceType],
+                        code: '_id',
+                        type: 'token',
+                        expression: resourceType + '.id',
+                    },
+                    _lastUpdated: {
+                        base: [resourceType],
+                        code: '_lastUpdated',
+                        type: 'date',
+                        expression: resourceType + '.meta.lastUpdated',
+                    },
+                };
             }
             typeSchema.searchParams[searchParam.code] = searchParam;
         }
     }
     function buildTypeName(components) {
+        if (components.length === 1) {
+            return components[0];
+        }
         return components.map(capitalize).join('');
     }
     function getPropertyDisplayName(path) {
@@ -6208,6 +6210,33 @@
             .replace('_', ' ')
             .replace(/\s+/g, ' ');
     }
+    /**
+     * Returns an element definition by type and property name.
+     * Handles content references.
+     * @param typeName The type name.
+     * @param propertyName The property name.
+     * @returns The element definition if found.
+     */
+    function getElementDefinition(typeName, propertyName) {
+        var _a;
+        const typeSchema = globalSchema.types[typeName];
+        if (!typeSchema) {
+            return undefined;
+        }
+        const property = (_a = typeSchema.properties[propertyName]) !== null && _a !== void 0 ? _a : typeSchema.properties[propertyName + '[x]'];
+        if (!property) {
+            return undefined;
+        }
+        if (property.contentReference) {
+            // Content references start with a "#"
+            // Remove the "#" character
+            const contentReference = property.contentReference.substring(1).split('.');
+            const referencePropertyName = contentReference.pop();
+            const referenceTypeName = buildTypeName(contentReference);
+            return getElementDefinition(referenceTypeName, referencePropertyName);
+        }
+        return property;
+    }
     /**
      * Global schema singleton.
      */
@@ -6523,8 +6552,10 @@
         startLogin(loginRequest) {
             var _a, _b;
             return __awaiter(this, void 0, void 0, function* () {
-                yield __classPrivateFieldGet(this, _MedplumClient_instances, "m", _MedplumClient_startPkce).call(this);
-                return this.post('auth/login', Object.assign(Object.assign({}, loginRequest), { clientId: (_a = loginRequest.clientId) !== null && _a !== void 0 ? _a : __classPrivateFieldGet(this, _MedplumClient_clientId, "f"), scope: (_b = loginRequest.scope) !== null && _b !== void 0 ? _b : DEFAULT_SCOPE, codeChallengeMethod: 'S256', codeChallenge: __classPrivateFieldGet(this, _MedplumClient_storage, "f").getString('codeChallenge') }));
+                if (!loginRequest.codeChallenge || !loginRequest.codeChallengeMethod) {
+                    yield __classPrivateFieldGet(this, _MedplumClient_instances, "m", _MedplumClient_startPkce).call(this);
+                }
+                return this.post('auth/login', Object.assign(Object.assign({}, loginRequest), { clientId: (_a = loginRequest.clientId) !== null && _a !== void 0 ? _a : __classPrivateFieldGet(this, _MedplumClient_clientId, "f"), scope: (_b = loginRequest.scope) !== null && _b !== void 0 ? _b : DEFAULT_SCOPE, codeChallengeMethod: loginRequest.codeChallengeMethod || 'S256', codeChallenge: loginRequest.codeChallenge || __classPrivateFieldGet(this, _MedplumClient_storage, "f").getString('codeChallenge') }));
             });
         }
         /**
@@ -6538,8 +6569,10 @@
         startGoogleLogin(loginRequest) {
             var _a, _b;
             return __awaiter(this, void 0, void 0, function* () {
-                yield __classPrivateFieldGet(this, _MedplumClient_instances, "m", _MedplumClient_startPkce).call(this);
-                return this.post('auth/google', Object.assign(Object.assign({}, loginRequest), { clientId: (_a = loginRequest.clientId) !== null && _a !== void 0 ? _a : __classPrivateFieldGet(this, _MedplumClient_clientId, "f"), scope: (_b = loginRequest.scope) !== null && _b !== void 0 ? _b : DEFAULT_SCOPE }));
+                if (!loginRequest.codeChallenge || !loginRequest.codeChallengeMethod) {
+                    yield __classPrivateFieldGet(this, _MedplumClient_instances, "m", _MedplumClient_startPkce).call(this);
+                }
+                return this.post('auth/google', Object.assign(Object.assign({}, loginRequest), { clientId: (_a = loginRequest.clientId) !== null && _a !== void 0 ? _a : __classPrivateFieldGet(this, _MedplumClient_clientId, "f"), scope: (_b = loginRequest.scope) !== null && _b !== void 0 ? _b : DEFAULT_SCOPE, codeChallengeMethod: loginRequest.codeChallengeMethod || 'S256', codeChallenge: loginRequest.codeChallenge || __classPrivateFieldGet(this, _MedplumClient_storage, "f").getString('codeChallenge') }));
             });
         }
         /**
@@ -6616,7 +6649,7 @@
          * ```json
          * {
          *    "resourceType": "Bundle",
-         *    "type": "searchest",
+         *    "type": "searchset",
          *    "total": 1,
          *    "entry": [
          *       {
@@ -6766,7 +6799,7 @@
          *
          * See the FHIR "read" operation for full details: https://www.hl7.org/fhir/http.html#read
          *
-         * @category Caching
+         * @category Read
          * @param resourceType The FHIR resource type.
          * @param id The resource ID.
          * @returns The resource if available; undefined otherwise.
@@ -6859,10 +6892,10 @@
     }`.replace(/\s+/g, ' ');
                 const response = (yield this.graphql(query));
                 for (const structureDefinition of response.data.StructureDefinitionList) {
-                    indexStructureDefinition(globalSchema, structureDefinition);
+                    indexStructureDefinition(structureDefinition);
                 }
                 for (const searchParameter of response.data.SearchParameterList) {
-                    indexSearchParameter(globalSchema, searchParameter);
+                    indexSearchParameter(searchParameter);
                 }
                 return globalSchema;
             });
@@ -7321,6 +7354,20 @@
         graphql(query, operationName, variables, options) {
             return this.post(this.fhirUrl('$graphql'), { query, operationName, variables }, JSON_CONTENT_TYPE, options);
         }
+        /**
+         *
+         * Executes the $graph operation on this resource to fetch a Bundle of resources linked to the target resource
+         * according to a graph definition
+      
+         * @category Read
+         * @param resourceType The FHIR resource type.
+         * @param id The resource ID.
+         * @param graphName `name` parameter of the GraphDefinition
+         * @returns A Bundle
+         */
+        readResourceGraph(resourceType, id, graphName) {
+            return this.get(`${this.fhirUrl(resourceType, id)}/$graph?graph=${graphName}`);
+        }
         /**
          * @category Authentication
          * @returns The Login State
@@ -7516,6 +7563,7 @@
             options.headers = {};
         }
         const headers = options.headers;
+        headers['X-Medplum'] = 'extended';
         if (!headers['Content-Type']) {
             headers['Content-Type'] = FHIR_CONTENT_TYPE;
         }
@@ -7661,6 +7709,28 @@
         return url.endsWith('/') ? url : url + '/';
     }
 
+    function parseDateString(str) {
+        if (str.startsWith('T')) {
+            // If a time string,
+            // then normalize to full length.
+            return str + 'T00:00:00.000Z'.substring(str.length);
+        }
+        if (str.length <= 10) {
+            // If a local date (i.e., "2021-01-01"),
+            // then return as-is.
+            return str;
+        }
+        try {
+            // Try to normalize to UTC
+            return new Date(str).toISOString();
+        }
+        catch (e) {
+            // Fallback to original input
+            // This happens on unsupported time formats such as "2021-01-01T12"
+            return str;
+        }
+    }
+
     /**
      * Returns a single element array with a typed boolean value.
      * @param value The primitive boolean value.
@@ -7724,9 +7794,9 @@
         if (!(input === null || input === void 0 ? void 0 : input.value)) {
             return undefined;
         }
-        const typeSchema = globalSchema.types[input.type];
-        if (typeSchema) {
-            const typedResult = getTypedPropertyValueWithSchema(input, path, typeSchema);
+        const elementDefinition = getElementDefinition(input.type, path);
+        if (elementDefinition) {
+            const typedResult = getTypedPropertyValueWithSchema(input, path, elementDefinition);
             if (typedResult) {
                 return typedResult;
             }
@@ -7737,24 +7807,18 @@
      * Returns the value of the property and the property type using a type schema.
      * @param input The base context (FHIR resource or backbone element).
      * @param path The property path.
-     * @param typeSchema The input type schema.
+     * @param property The property element definition.
      * @returns The value of the property and the property type.
      */
-    function getTypedPropertyValueWithSchema(input, path, typeSchema) {
+    function getTypedPropertyValueWithSchema(input, path, property) {
         var _a;
-        const property = (_a = typeSchema.properties[path]) !== null && _a !== void 0 ? _a : typeSchema.properties[path + '[x]'];
-        if (!property) {
-            return undefined;
-        }
         const types = property.type;
         if (!types || types.length === 0) {
             return undefined;
         }
-        let propertyName = undefined;
         let resultValue = undefined;
         let resultType = 'undefined';
         if (types.length === 1) {
-            propertyName = path;
             resultValue = input.value[path];
             resultType = types[0].code;
         }
@@ -7762,7 +7826,6 @@
             for (const type of types) {
                 const path2 = path.replace('[x]', '') + capitalize(type.code);
                 if (path2 in input.value) {
-                    propertyName = path2;
                     resultValue = input.value[path2];
                     resultType = type.code;
                     break;
@@ -7772,15 +7835,21 @@
         if (isEmpty(resultValue)) {
             return undefined;
         }
-        if (resultType === 'BackboneElement') {
-            resultType = buildTypeName([input.type, propertyName]);
+        if (resultType === 'Element' || resultType === 'BackboneElement') {
+            resultType = buildTypeName((_a = property.path) === null || _a === void 0 ? void 0 : _a.split('.'));
         }
         if (Array.isArray(resultValue)) {
-            return resultValue.map((element) => ({ value: element, type: resultType }));
+            return resultValue.map((element) => toTypedValueWithType(element, resultType));
         }
         else {
-            return { value: resultValue, type: resultType };
+            return toTypedValueWithType(resultValue, resultType);
+        }
+    }
+    function toTypedValueWithType(value, type) {
+        if (type === 'Resource' && typeof value === 'object' && 'resourceType' in value) {
+            type = value.resourceType;
         }
+        return { type, value };
     }
     /**
      * Returns the value of the property and the property type using a type schema.
@@ -8005,7 +8074,6 @@
     }
     /**
      * Resource equality.
-     * Ignores meta.versionId and meta.lastUpdated.
      * See: https://dmitripavlutin.com/how-to-compare-objects-in-javascript/#4-deep-equality
      * @param object1 The first object.
      * @param object2 The second object.
@@ -8033,466 +8101,121 @@
         }
         return true;
     }
-    function isObject(object) {
-        return object !== null && typeof object === 'object';
+    function isObject(obj) {
+        return obj !== null && typeof obj === 'object';
     }
 
-    var _SymbolAtom_instances, _SymbolAtom_evalValue;
-    class FhirPathAtom {
-        constructor(original, child) {
-            this.original = original;
-            this.child = child;
-        }
-        eval(context) {
-            try {
-                if (context.length > 0) {
-                    return context.map((e) => this.child.eval([e])).flat();
-                }
-                else {
-                    return this.child.eval([]);
-                }
+    /**
+     * Temporary placholder for unimplemented methods.
+     */
+    const stub = () => [];
+    const functions = {
+        /*
+         * 5.1 Existence
+         * See: https://hl7.org/fhirpath/#existence
+         */
+        /**
+         * Returns true if the input collection is empty ({ }) and false otherwise.
+         *
+         * See: https://hl7.org/fhirpath/#empty-boolean
+         *
+         * @param input The input collection.
+         * @returns True if the input collection is empty ({ }) and false otherwise.
+         */
+        empty: (input) => {
+            return booleanToTypedValue(input.length === 0);
+        },
+        /**
+         * Returns true if the collection has unknown elements, and false otherwise.
+         * This is the opposite of empty(), and as such is a shorthand for empty().not().
+         * If the input collection is empty ({ }), the result is false.
+         *
+         * The function can also take an optional criteria to be applied to the collection
+         * prior to the determination of the exists. In this case, the function is shorthand
+         * for where(criteria).exists().
+         *
+         * See: https://hl7.org/fhirpath/#existscriteria-expression-boolean
+         *
+         * @param input
+         * @param criteria
+         * @returns True if the collection has unknown elements, and false otherwise.
+         */
+        exists: (input, criteria) => {
+            if (criteria) {
+                return booleanToTypedValue(input.filter((e) => toJsBoolean(criteria.eval([e]))).length > 0);
             }
-            catch (error) {
-                throw new Error(`FhirPathError on "${this.original}": ${error}`);
+            else {
+                return booleanToTypedValue(input.length > 0);
             }
-        }
-    }
-    class LiteralAtom {
-        constructor(value) {
-            this.value = value;
-        }
-        eval() {
-            return [this.value];
-        }
-    }
-    class SymbolAtom {
-        constructor(name) {
-            this.name = name;
-            _SymbolAtom_instances.add(this);
-        }
-        eval(context) {
-            if (this.name === '$this') {
-                return context;
+        },
+        /**
+         * Returns true if for every element in the input collection, criteria evaluates to true.
+         * Otherwise, the result is false.
+         *
+         * If the input collection is empty ({ }), the result is true.
+         *
+         * See: https://hl7.org/fhirpath/#allcriteria-expression-boolean
+         *
+         * @param input The input collection.
+         * @param criteria The evaluation criteria.
+         * @returns True if for every element in the input collection, criteria evaluates to true.
+         */
+        all: (input, criteria) => {
+            return booleanToTypedValue(input.every((e) => toJsBoolean(criteria.eval([e]))));
+        },
+        /**
+         * Takes a collection of Boolean values and returns true if all the items are true.
+         * If unknown items are false, the result is false.
+         * If the input is empty ({ }), the result is true.
+         *
+         * See: https://hl7.org/fhirpath/#alltrue-boolean
+         *
+         * @param input The input collection.
+         * @param criteria The evaluation criteria.
+         * @returns True if all the items are true.
+         */
+        allTrue: (input) => {
+            for (const value of input) {
+                if (!value.value) {
+                    return booleanToTypedValue(false);
+                }
             }
-            return context
-                .map((e) => __classPrivateFieldGet(this, _SymbolAtom_instances, "m", _SymbolAtom_evalValue).call(this, e))
-                .flat()
-                .filter((e) => (e === null || e === void 0 ? void 0 : e.value) !== undefined);
-        }
-    }
-    _SymbolAtom_instances = new WeakSet(), _SymbolAtom_evalValue = function _SymbolAtom_evalValue(typedValue) {
-        const input = typedValue.value;
-        if (!input || typeof input !== 'object') {
-            return undefined;
-        }
-        if ('resourceType' in input && input.resourceType === this.name) {
-            return typedValue;
-        }
-        return getTypedPropertyValue(typedValue, this.name);
-    };
-    class EmptySetAtom {
-        eval() {
-            return [];
-        }
-    }
-    class UnaryOperatorAtom {
-        constructor(child, impl) {
-            this.child = child;
-            this.impl = impl;
-        }
-        eval(context) {
-            return this.impl(this.child.eval(context));
-        }
-    }
-    class AsAtom {
-        constructor(left, right) {
-            this.left = left;
-            this.right = right;
-        }
-        eval(context) {
-            return this.left.eval(context);
-        }
-    }
-    class ArithemticOperatorAtom {
-        constructor(left, right, impl) {
-            this.left = left;
-            this.right = right;
-            this.impl = impl;
-        }
-        eval(context) {
-            const leftEvalResult = this.left.eval(context);
-            if (leftEvalResult.length !== 1) {
-                return [];
+            return booleanToTypedValue(true);
+        },
+        /**
+         * Takes a collection of Boolean values and returns true if unknown of the items are true.
+         * If all the items are false, or if the input is empty ({ }), the result is false.
+         *
+         * See: https://hl7.org/fhirpath/#anytrue-boolean
+         *
+         * @param input The input collection.
+         * @param criteria The evaluation criteria.
+         * @returns True if unknown of the items are true.
+         */
+        anyTrue: (input) => {
+            for (const value of input) {
+                if (value.value) {
+                    return booleanToTypedValue(true);
+                }
             }
-            const rightEvalResult = this.right.eval(context);
-            if (rightEvalResult.length !== 1) {
-                return [];
-            }
-            const leftValue = leftEvalResult[0].value;
-            const rightValue = rightEvalResult[0].value;
-            const leftNumber = isQuantity(leftValue) ? leftValue.value : leftValue;
-            const rightNumber = isQuantity(rightValue) ? rightValue.value : rightValue;
-            const result = this.impl(leftNumber, rightNumber);
-            if (typeof result === 'boolean') {
-                return booleanToTypedValue(result);
-            }
-            else if (isQuantity(leftValue)) {
-                return [{ type: exports.PropertyType.Quantity, value: Object.assign(Object.assign({}, leftValue), { value: result }) }];
-            }
-            else {
-                return [toTypedValue(result)];
-            }
-        }
-    }
-    class ConcatAtom {
-        constructor(left, right) {
-            this.left = left;
-            this.right = right;
-        }
-        eval(context) {
-            const leftValue = this.left.eval(context);
-            const rightValue = this.right.eval(context);
-            const result = [...leftValue, ...rightValue];
-            if (result.length > 0 && result.every((e) => typeof e.value === 'string')) {
-                return [{ type: exports.PropertyType.string, value: result.map((e) => e.value).join('') }];
-            }
-            return result;
-        }
-    }
-    class ContainsAtom {
-        constructor(left, right) {
-            this.left = left;
-            this.right = right;
-        }
-        eval(context) {
-            const leftValue = this.left.eval(context);
-            const rightValue = this.right.eval(context);
-            return booleanToTypedValue(leftValue.some((e) => e.value === rightValue[0].value));
-        }
-    }
-    class InAtom {
-        constructor(left, right) {
-            this.left = left;
-            this.right = right;
-        }
-        eval(context) {
-            const leftValue = this.left.eval(context);
-            const rightValue = this.right.eval(context);
-            return booleanToTypedValue(rightValue.some((e) => e.value === leftValue[0].value));
-        }
-    }
-    class DotAtom {
-        constructor(left, right) {
-            this.left = left;
-            this.right = right;
-        }
-        eval(context) {
-            return this.right.eval(this.left.eval(context));
-        }
-    }
-    class UnionAtom {
-        constructor(left, right) {
-            this.left = left;
-            this.right = right;
-        }
-        eval(context) {
-            const leftResult = this.left.eval(context);
-            const rightResult = this.right.eval(context);
-            return removeDuplicates([...leftResult, ...rightResult]);
-        }
-    }
-    class EqualsAtom {
-        constructor(left, right) {
-            this.left = left;
-            this.right = right;
-        }
-        eval(context) {
-            const leftValue = this.left.eval(context);
-            const rightValue = this.right.eval(context);
-            return fhirPathArrayEquals(leftValue, rightValue);
-        }
-    }
-    class NotEqualsAtom {
-        constructor(left, right) {
-            this.left = left;
-            this.right = right;
-        }
-        eval(context) {
-            const leftValue = this.left.eval(context);
-            const rightValue = this.right.eval(context);
-            return fhirPathNot(fhirPathArrayEquals(leftValue, rightValue));
-        }
-    }
-    class EquivalentAtom {
-        constructor(left, right) {
-            this.left = left;
-            this.right = right;
-        }
-        eval(context) {
-            const leftValue = this.left.eval(context);
-            const rightValue = this.right.eval(context);
-            return fhirPathArrayEquivalent(leftValue, rightValue);
-        }
-    }
-    class NotEquivalentAtom {
-        constructor(left, right) {
-            this.left = left;
-            this.right = right;
-        }
-        eval(context) {
-            const leftValue = this.left.eval(context);
-            const rightValue = this.right.eval(context);
-            return fhirPathNot(fhirPathArrayEquivalent(leftValue, rightValue));
-        }
-    }
-    class IsAtom {
-        constructor(left, right) {
-            this.left = left;
-            this.right = right;
-        }
-        eval(context) {
-            const leftValue = this.left.eval(context);
-            if (leftValue.length !== 1) {
-                return [];
-            }
-            const typeName = this.right.name;
-            return booleanToTypedValue(fhirPathIs(leftValue[0], typeName));
-        }
-    }
-    /**
-     * 6.5.1. and
-     * Returns true if both operands evaluate to true,
-     * false if either operand evaluates to false,
-     * and the empty collection otherwise.
-     */
-    class AndAtom {
-        constructor(left, right) {
-            this.left = left;
-            this.right = right;
-        }
-        eval(context) {
-            var _a, _b, _c, _d;
-            const leftValue = this.left.eval(context);
-            const rightValue = this.right.eval(context);
-            if (((_a = leftValue[0]) === null || _a === void 0 ? void 0 : _a.value) === true && ((_b = rightValue[0]) === null || _b === void 0 ? void 0 : _b.value) === true) {
-                return booleanToTypedValue(true);
-            }
-            if (((_c = leftValue[0]) === null || _c === void 0 ? void 0 : _c.value) === false || ((_d = rightValue[0]) === null || _d === void 0 ? void 0 : _d.value) === false) {
-                return booleanToTypedValue(false);
-            }
-            return [];
-        }
-    }
-    class OrAtom {
-        constructor(left, right) {
-            this.left = left;
-            this.right = right;
-        }
-        eval(context) {
-            const leftValue = this.left.eval(context);
-            if (toJsBoolean(leftValue)) {
-                return leftValue;
-            }
-            const rightValue = this.right.eval(context);
-            if (toJsBoolean(rightValue)) {
-                return rightValue;
-            }
-            return [];
-        }
-    }
-    /**
-     * 6.5.4. xor
-     * Returns true if exactly one of the operands evaluates to true,
-     * false if either both operands evaluate to true or both operands evaluate to false,
-     * and the empty collection otherwise.
-     */
-    class XorAtom {
-        constructor(left, right) {
-            this.left = left;
-            this.right = right;
-        }
-        eval(context) {
-            const leftResult = this.left.eval(context);
-            const rightResult = this.right.eval(context);
-            if (leftResult.length === 0 && rightResult.length === 0) {
-                return [];
-            }
-            const leftValue = leftResult.length === 0 ? null : leftResult[0].value;
-            const rightValue = rightResult.length === 0 ? null : rightResult[0].value;
-            if ((leftValue === true && rightValue !== true) || (leftValue !== true && rightValue === true)) {
-                return booleanToTypedValue(true);
-            }
-            if ((leftValue === true && rightValue === true) || (leftValue === false && rightValue === false)) {
-                return booleanToTypedValue(false);
-            }
-            return [];
-        }
-    }
-    class FunctionAtom {
-        constructor(name, args, impl) {
-            this.name = name;
-            this.args = args;
-            this.impl = impl;
-        }
-        eval(context) {
-            return this.impl(context, ...this.args);
-        }
-    }
-    class IndexerAtom {
-        constructor(left, expr) {
-            this.left = left;
-            this.expr = expr;
-        }
-        eval(context) {
-            const evalResult = this.expr.eval(context);
-            if (evalResult.length !== 1) {
-                return [];
-            }
-            const index = evalResult[0].value;
-            if (typeof index !== 'number') {
-                throw new Error(`Invalid indexer expression: should return integer}`);
-            }
-            const leftResult = this.left.eval(context);
-            if (!(index in leftResult)) {
-                return [];
-            }
-            return [leftResult[index]];
-        }
-    }
-
-    function parseDateString(str) {
-        if (str.startsWith('T')) {
-            // If a time string,
-            // then normalize to full length.
-            return str + 'T00:00:00.000Z'.substring(str.length);
-        }
-        if (str.length <= 10) {
-            // If a local date (i.e., "2021-01-01"),
-            // then return as-is.
-            return str;
-        }
-        try {
-            // Try to normalize to UTC
-            return new Date(str).toISOString();
-        }
-        catch (e) {
-            // Fallback to original input
-            // This happens on unsupported time formats such as "2021-01-01T12"
-            return str;
-        }
-    }
-
-    /**
-     * Temporary placholder for unimplemented methods.
-     */
-    const stub = () => [];
-    const functions = {
-        /*
-         * 5.1 Existence
-         * See: https://hl7.org/fhirpath/#existence
-         */
-        /**
-         * Returns true if the input collection is empty ({ }) and false otherwise.
-         *
-         * See: https://hl7.org/fhirpath/#empty-boolean
-         *
-         * @param input The input collection.
-         * @returns True if the input collection is empty ({ }) and false otherwise.
-         */
-        empty: (input) => {
-            return booleanToTypedValue(input.length === 0);
-        },
-        /**
-         * Returns true if the collection has unknown elements, and false otherwise.
-         * This is the opposite of empty(), and as such is a shorthand for empty().not().
-         * If the input collection is empty ({ }), the result is false.
-         *
-         * The function can also take an optional criteria to be applied to the collection
-         * prior to the determination of the exists. In this case, the function is shorthand
-         * for where(criteria).exists().
-         *
-         * See: https://hl7.org/fhirpath/#existscriteria-expression-boolean
-         *
-         * @param input
-         * @param criteria
-         * @returns True if the collection has unknown elements, and false otherwise.
-         */
-        exists: (input, criteria) => {
-            if (criteria) {
-                return booleanToTypedValue(input.filter((e) => toJsBoolean(criteria.eval([e]))).length > 0);
-            }
-            else {
-                return booleanToTypedValue(input.length > 0);
-            }
-        },
-        /**
-         * Returns true if for every element in the input collection, criteria evaluates to true.
-         * Otherwise, the result is false.
-         *
-         * If the input collection is empty ({ }), the result is true.
-         *
-         * See: https://hl7.org/fhirpath/#allcriteria-expression-boolean
-         *
-         * @param input The input collection.
-         * @param criteria The evaluation criteria.
-         * @returns True if for every element in the input collection, criteria evaluates to true.
-         */
-        all: (input, criteria) => {
-            return booleanToTypedValue(input.every((e) => toJsBoolean(criteria.eval([e]))));
-        },
-        /**
-         * Takes a collection of Boolean values and returns true if all the items are true.
-         * If unknown items are false, the result is false.
-         * If the input is empty ({ }), the result is true.
-         *
-         * See: https://hl7.org/fhirpath/#alltrue-boolean
-         *
-         * @param input The input collection.
-         * @param criteria The evaluation criteria.
-         * @returns True if all the items are true.
-         */
-        allTrue: (input) => {
-            for (const value of input) {
-                if (!value.value) {
-                    return booleanToTypedValue(false);
-                }
-            }
-            return booleanToTypedValue(true);
-        },
-        /**
-         * Takes a collection of Boolean values and returns true if unknown of the items are true.
-         * If all the items are false, or if the input is empty ({ }), the result is false.
-         *
-         * See: https://hl7.org/fhirpath/#anytrue-boolean
-         *
-         * @param input The input collection.
-         * @param criteria The evaluation criteria.
-         * @returns True if unknown of the items are true.
-         */
-        anyTrue: (input) => {
-            for (const value of input) {
-                if (value.value) {
-                    return booleanToTypedValue(true);
-                }
-            }
-            return booleanToTypedValue(false);
-        },
-        /**
-         * Takes a collection of Boolean values and returns true if all the items are false.
-         * If unknown items are true, the result is false.
-         * If the input is empty ({ }), the result is true.
-         *
-         * See: https://hl7.org/fhirpath/#allfalse-boolean
-         *
-         * @param input The input collection.
-         * @param criteria The evaluation criteria.
-         * @returns True if all the items are false.
-         */
-        allFalse: (input) => {
-            for (const value of input) {
-                if (value.value) {
-                    return booleanToTypedValue(false);
-                }
+            return booleanToTypedValue(false);
+        },
+        /**
+         * Takes a collection of Boolean values and returns true if all the items are false.
+         * If unknown items are true, the result is false.
+         * If the input is empty ({ }), the result is true.
+         *
+         * See: https://hl7.org/fhirpath/#allfalse-boolean
+         *
+         * @param input The input collection.
+         * @param criteria The evaluation criteria.
+         * @returns True if all the items are false.
+         */
+        allFalse: (input) => {
+            for (const value of input) {
+                if (value.value) {
+                    return booleanToTypedValue(false);
+                }
             }
             return booleanToTypedValue(true);
         },
@@ -8641,7 +8364,9 @@
          *
          * See: http://hl7.org/fhirpath/#oftypetype-type-specifier-collection
          */
-        ofType: stub,
+        ofType: (input, criteria) => {
+            return input.filter((e) => e.type === criteria.name);
+        },
         /*
          * 5.3 Subsetting
          */
@@ -9686,195 +9411,518 @@
             if (startDate.length === 0) {
                 throw new Error('Invalid start date');
             }
-            const endDate = functions.toDateTime(endAtom.eval(input));
-            if (endDate.length === 0) {
-                throw new Error('Invalid end date');
+            const endDate = functions.toDateTime(endAtom.eval(input));
+            if (endDate.length === 0) {
+                throw new Error('Invalid end date');
+            }
+            const unit = (_a = unitsAtom.eval(input)[0]) === null || _a === void 0 ? void 0 : _a.value;
+            if (unit !== 'years' && unit !== 'months' && unit !== 'days') {
+                throw new Error('Invalid units');
+            }
+            const age = calculateAge(startDate[0].value, endDate[0].value);
+            return [{ type: exports.PropertyType.Quantity, value: { value: age[unit], unit } }];
+        },
+        /*
+         * 6.3 Types
+         */
+        /**
+         * The is() function is supported for backwards compatibility with previous
+         * implementations of FHIRPath. Just as with the is keyword, the type argument
+         * is an identifier that must resolve to the name of a type in a model.
+         *
+         * For implementations with compile-time typing, this requires special-case
+         * handling when processing the argument to treat it as a type specifier rather
+         * than an identifier expression:
+         *
+         * @param input
+         * @param typeAtom
+         * @returns
+         */
+        is: (input, typeAtom) => {
+            let typeName = '';
+            if (typeAtom instanceof SymbolAtom) {
+                typeName = typeAtom.name;
+            }
+            else if (typeAtom instanceof DotAtom) {
+                typeName = typeAtom.left.name + '.' + typeAtom.right.name;
+            }
+            if (!typeName) {
+                return [];
+            }
+            return input.map((value) => ({ type: exports.PropertyType.boolean, value: fhirPathIs(value, typeName) }));
+        },
+        /*
+         * 6.5 Boolean logic
+         */
+        /**
+         * 6.5.3. not() : Boolean
+         *
+         * Returns true if the input collection evaluates to false, and false if it evaluates to true. Otherwise, the result is empty ({ }):
+         *
+         * @param input
+         * @returns
+         */
+        not: (input) => {
+            return functions.toBoolean(input).map((value) => ({ type: exports.PropertyType.boolean, value: !value.value }));
+        },
+        /*
+         * Additional functions
+         * See: https://hl7.org/fhir/fhirpath.html#functions
+         */
+        /**
+         * For each item in the collection, if it is a string that is a uri (or canonical or url), locate the target of the reference, and add it to the resulting collection. If the item does not resolve to a resource, the item is ignored and nothing is added to the output collection.
+         * The items in the collection may also represent a Reference, in which case the Reference.reference is resolved.
+         * @param input The input collection.
+         * @returns
+         */
+        resolve: (input) => {
+            return input
+                .map((e) => {
+                const value = e.value;
+                let refStr;
+                if (typeof value === 'string') {
+                    refStr = value;
+                }
+                else if (typeof value === 'object') {
+                    const ref = value;
+                    if (ref.resource) {
+                        return toTypedValue(ref.resource);
+                    }
+                    refStr = ref.reference;
+                }
+                if (!refStr) {
+                    return { type: exports.PropertyType.BackboneElement, value: null };
+                }
+                const [resourceType, id] = refStr.split('/');
+                return { type: exports.PropertyType.BackboneElement, value: { resourceType, id } };
+            })
+                .filter((e) => !!e.value);
+        },
+        /**
+         * The as operator can be used to treat a value as a specific type.
+         * @param input The input value.
+         * @returns The value as the specific type.
+         */
+        as: (input) => {
+            return input;
+        },
+        /*
+         * 12. Formal Specifications
+         */
+        /**
+         * Returns the type of the input.
+         *
+         * 12.2. Model Information
+         *
+         * The model information returned by the reflection function type() is specified as an
+         * XML Schema document (xsd) and included in this specification at the following link:
+         * https://hl7.org/fhirpath/modelinfo.xsd
+         *
+         * See: https://hl7.org/fhirpath/#model-information
+         *
+         * @param input The input collection.
+         * @returns
+         */
+        type: (input) => {
+            return input.map(({ value }) => {
+                if (typeof value === 'boolean') {
+                    return { type: exports.PropertyType.BackboneElement, value: { namespace: 'System', name: 'Boolean' } };
+                }
+                if (typeof value === 'number') {
+                    return { type: exports.PropertyType.BackboneElement, value: { namespace: 'System', name: 'Integer' } };
+                }
+                if (value && typeof value === 'object' && 'resourceType' in value) {
+                    return {
+                        type: exports.PropertyType.BackboneElement,
+                        value: { namespace: 'FHIR', name: value.resourceType },
+                    };
+                }
+                return { type: exports.PropertyType.BackboneElement, value: null };
+            });
+        },
+        conformsTo: (input, systemAtom) => {
+            const system = systemAtom.eval(input)[0].value;
+            if (!system.startsWith('http://hl7.org/fhir/StructureDefinition/')) {
+                throw new Error('Expected a StructureDefinition URL');
+            }
+            const expectedResourceType = system.replace('http://hl7.org/fhir/StructureDefinition/', '');
+            return input.map((value) => {
+                var _a;
+                return ({
+                    type: exports.PropertyType.boolean,
+                    value: ((_a = value.value) === null || _a === void 0 ? void 0 : _a.resourceType) === expectedResourceType,
+                });
+            });
+        },
+    };
+    /*
+     * Helper utilities
+     */
+    function applyStringFunc(func, input, ...argsAtoms) {
+        if (input.length === 0) {
+            return [];
+        }
+        const [{ value }] = validateInput(input, 1);
+        if (typeof value !== 'string') {
+            throw new Error('String function cannot be called with non-string');
+        }
+        const result = func(value, ...argsAtoms.map((atom) => { var _a, _b; return atom && ((_b = (_a = atom.eval(input)) === null || _a === void 0 ? void 0 : _a[0]) === null || _b === void 0 ? void 0 : _b.value); }));
+        if (result === undefined) {
+            return [];
+        }
+        if (Array.isArray(result)) {
+            return result.map(toTypedValue);
+        }
+        return [toTypedValue(result)];
+    }
+    function applyMathFunc(func, input, ...argsAtoms) {
+        if (input.length === 0) {
+            return [];
+        }
+        const [{ value }] = validateInput(input, 1);
+        const quantity = isQuantity(value);
+        const numberInput = quantity ? value.value : value;
+        if (typeof numberInput !== 'number') {
+            throw new Error('Math function cannot be called with non-number');
+        }
+        const result = func(numberInput, ...argsAtoms.map((atom) => { var _a, _b; return (_b = (_a = atom.eval(input)) === null || _a === void 0 ? void 0 : _a[0]) === null || _b === void 0 ? void 0 : _b.value; }));
+        const type = quantity ? exports.PropertyType.Quantity : input[0].type;
+        const returnValue = quantity ? Object.assign(Object.assign({}, value), { value: result }) : result;
+        return [{ type, value: returnValue }];
+    }
+    function validateInput(input, count) {
+        if (input.length !== count) {
+            throw new Error(`Expected ${count} arguments`);
+        }
+        for (const element of input) {
+            if (element === null || element === undefined) {
+                throw new Error('Expected non-null argument');
+            }
+        }
+        return input;
+    }
+
+    var _SymbolAtom_instances, _SymbolAtom_evalValue;
+    class FhirPathAtom {
+        constructor(original, child) {
+            this.original = original;
+            this.child = child;
+        }
+        eval(context) {
+            try {
+                if (context.length > 0) {
+                    return context.map((e) => this.child.eval([e])).flat();
+                }
+                else {
+                    return this.child.eval([]);
+                }
             }
-            const unit = (_a = unitsAtom.eval(input)[0]) === null || _a === void 0 ? void 0 : _a.value;
-            if (unit !== 'years' && unit !== 'months' && unit !== 'days') {
-                throw new Error('Invalid units');
+            catch (error) {
+                throw new Error(`FhirPathError on "${this.original}": ${error}`);
             }
-            const age = calculateAge(startDate[0].value, endDate[0].value);
-            return [{ type: exports.PropertyType.Quantity, value: { value: age[unit], unit } }];
-        },
-        /*
-         * 6.3 Types
-         */
-        /**
-         * The is() function is supported for backwards compatibility with previous
-         * implementations of FHIRPath. Just as with the is keyword, the type argument
-         * is an identifier that must resolve to the name of a type in a model.
-         *
-         * For implementations with compile-time typing, this requires special-case
-         * handling when processing the argument to treat it as a type specifier rather
-         * than an identifier expression:
-         *
-         * @param input
-         * @param typeAtom
-         * @returns
-         */
-        is: (input, typeAtom) => {
-            let typeName = '';
-            if (typeAtom instanceof SymbolAtom) {
-                typeName = typeAtom.name;
+        }
+    }
+    class LiteralAtom {
+        constructor(value) {
+            this.value = value;
+        }
+        eval() {
+            return [this.value];
+        }
+    }
+    class SymbolAtom {
+        constructor(name) {
+            this.name = name;
+            _SymbolAtom_instances.add(this);
+        }
+        eval(context) {
+            if (this.name === '$this') {
+                return context;
             }
-            else if (typeAtom instanceof DotAtom) {
-                typeName = typeAtom.left.name + '.' + typeAtom.right.name;
+            return context
+                .map((e) => __classPrivateFieldGet(this, _SymbolAtom_instances, "m", _SymbolAtom_evalValue).call(this, e))
+                .flat()
+                .filter((e) => (e === null || e === void 0 ? void 0 : e.value) !== undefined);
+        }
+    }
+    _SymbolAtom_instances = new WeakSet(), _SymbolAtom_evalValue = function _SymbolAtom_evalValue(typedValue) {
+        const input = typedValue.value;
+        if (!input || typeof input !== 'object') {
+            return undefined;
+        }
+        if ('resourceType' in input && input.resourceType === this.name) {
+            return typedValue;
+        }
+        return getTypedPropertyValue(typedValue, this.name);
+    };
+    class EmptySetAtom {
+        eval() {
+            return [];
+        }
+    }
+    class UnaryOperatorAtom {
+        constructor(child, impl) {
+            this.child = child;
+            this.impl = impl;
+        }
+        eval(context) {
+            return this.impl(this.child.eval(context));
+        }
+    }
+    class AsAtom {
+        constructor(left, right) {
+            this.left = left;
+            this.right = right;
+        }
+        eval(context) {
+            return functions.ofType(this.left.eval(context), this.right);
+        }
+    }
+    class ArithemticOperatorAtom {
+        constructor(left, right, impl) {
+            this.left = left;
+            this.right = right;
+            this.impl = impl;
+        }
+        eval(context) {
+            const leftEvalResult = this.left.eval(context);
+            if (leftEvalResult.length !== 1) {
+                return [];
             }
-            if (!typeName) {
+            const rightEvalResult = this.right.eval(context);
+            if (rightEvalResult.length !== 1) {
+                return [];
+            }
+            const leftValue = leftEvalResult[0].value;
+            const rightValue = rightEvalResult[0].value;
+            const leftNumber = isQuantity(leftValue) ? leftValue.value : leftValue;
+            const rightNumber = isQuantity(rightValue) ? rightValue.value : rightValue;
+            const result = this.impl(leftNumber, rightNumber);
+            if (typeof result === 'boolean') {
+                return booleanToTypedValue(result);
+            }
+            else if (isQuantity(leftValue)) {
+                return [{ type: exports.PropertyType.Quantity, value: Object.assign(Object.assign({}, leftValue), { value: result }) }];
+            }
+            else {
+                return [toTypedValue(result)];
+            }
+        }
+    }
+    class ConcatAtom {
+        constructor(left, right) {
+            this.left = left;
+            this.right = right;
+        }
+        eval(context) {
+            const leftValue = this.left.eval(context);
+            const rightValue = this.right.eval(context);
+            const result = [...leftValue, ...rightValue];
+            if (result.length > 0 && result.every((e) => typeof e.value === 'string')) {
+                return [{ type: exports.PropertyType.string, value: result.map((e) => e.value).join('') }];
+            }
+            return result;
+        }
+    }
+    class ContainsAtom {
+        constructor(left, right) {
+            this.left = left;
+            this.right = right;
+        }
+        eval(context) {
+            const leftValue = this.left.eval(context);
+            const rightValue = this.right.eval(context);
+            return booleanToTypedValue(leftValue.some((e) => e.value === rightValue[0].value));
+        }
+    }
+    class InAtom {
+        constructor(left, right) {
+            this.left = left;
+            this.right = right;
+        }
+        eval(context) {
+            const leftValue = this.left.eval(context);
+            const rightValue = this.right.eval(context);
+            return booleanToTypedValue(rightValue.some((e) => e.value === leftValue[0].value));
+        }
+    }
+    class DotAtom {
+        constructor(left, right) {
+            this.left = left;
+            this.right = right;
+        }
+        eval(context) {
+            return this.right.eval(this.left.eval(context));
+        }
+    }
+    class UnionAtom {
+        constructor(left, right) {
+            this.left = left;
+            this.right = right;
+        }
+        eval(context) {
+            const leftResult = this.left.eval(context);
+            const rightResult = this.right.eval(context);
+            return removeDuplicates([...leftResult, ...rightResult]);
+        }
+    }
+    class EqualsAtom {
+        constructor(left, right) {
+            this.left = left;
+            this.right = right;
+        }
+        eval(context) {
+            const leftValue = this.left.eval(context);
+            const rightValue = this.right.eval(context);
+            return fhirPathArrayEquals(leftValue, rightValue);
+        }
+    }
+    class NotEqualsAtom {
+        constructor(left, right) {
+            this.left = left;
+            this.right = right;
+        }
+        eval(context) {
+            const leftValue = this.left.eval(context);
+            const rightValue = this.right.eval(context);
+            return fhirPathNot(fhirPathArrayEquals(leftValue, rightValue));
+        }
+    }
+    class EquivalentAtom {
+        constructor(left, right) {
+            this.left = left;
+            this.right = right;
+        }
+        eval(context) {
+            const leftValue = this.left.eval(context);
+            const rightValue = this.right.eval(context);
+            return fhirPathArrayEquivalent(leftValue, rightValue);
+        }
+    }
+    class NotEquivalentAtom {
+        constructor(left, right) {
+            this.left = left;
+            this.right = right;
+        }
+        eval(context) {
+            const leftValue = this.left.eval(context);
+            const rightValue = this.right.eval(context);
+            return fhirPathNot(fhirPathArrayEquivalent(leftValue, rightValue));
+        }
+    }
+    class IsAtom {
+        constructor(left, right) {
+            this.left = left;
+            this.right = right;
+        }
+        eval(context) {
+            const leftValue = this.left.eval(context);
+            if (leftValue.length !== 1) {
                 return [];
             }
-            return input.map((value) => ({ type: exports.PropertyType.boolean, value: fhirPathIs(value, typeName) }));
-        },
-        /*
-         * 6.5 Boolean logic
-         */
-        /**
-         * 6.5.3. not() : Boolean
-         *
-         * Returns true if the input collection evaluates to false, and false if it evaluates to true. Otherwise, the result is empty ({ }):
-         *
-         * @param input
-         * @returns
-         */
-        not: (input) => {
-            return functions.toBoolean(input).map((value) => ({ type: exports.PropertyType.boolean, value: !value.value }));
-        },
-        /*
-         * Additional functions
-         * See: https://hl7.org/fhir/fhirpath.html#functions
-         */
-        /**
-         * For each item in the collection, if it is a string that is a uri (or canonical or url), locate the target of the reference, and add it to the resulting collection. If the item does not resolve to a resource, the item is ignored and nothing is added to the output collection.
-         * The items in the collection may also represent a Reference, in which case the Reference.reference is resolved.
-         * @param input The input collection.
-         * @returns
-         */
-        resolve: (input) => {
-            return input
-                .map((e) => {
-                const value = e.value;
-                let refStr;
-                if (typeof value === 'string') {
-                    refStr = value;
-                }
-                else if (typeof value === 'object') {
-                    const ref = value;
-                    if (ref.resource) {
-                        return toTypedValue(ref.resource);
-                    }
-                    refStr = ref.reference;
-                }
-                if (!refStr) {
-                    return { type: exports.PropertyType.BackboneElement, value: null };
-                }
-                const [resourceType, id] = refStr.split('/');
-                return { type: exports.PropertyType.BackboneElement, value: { resourceType, id } };
-            })
-                .filter((e) => !!e.value);
-        },
-        /**
-         * The as operator can be used to treat a value as a specific type.
-         * @param input The input value.
-         * @returns The value as the specific type.
-         */
-        as: (input) => {
-            return input;
-        },
-        /*
-         * 12. Formal Specifications
-         */
-        /**
-         * Returns the type of the input.
-         *
-         * 12.2. Model Information
-         *
-         * The model information returned by the reflection function type() is specified as an
-         * XML Schema document (xsd) and included in this specification at the following link:
-         * https://hl7.org/fhirpath/modelinfo.xsd
-         *
-         * See: https://hl7.org/fhirpath/#model-information
-         *
-         * @param input The input collection.
-         * @returns
-         */
-        type: (input) => {
-            return input.map(({ value }) => {
-                if (typeof value === 'boolean') {
-                    return { type: exports.PropertyType.BackboneElement, value: { namespace: 'System', name: 'Boolean' } };
-                }
-                if (typeof value === 'number') {
-                    return { type: exports.PropertyType.BackboneElement, value: { namespace: 'System', name: 'Integer' } };
-                }
-                if (value && typeof value === 'object' && 'resourceType' in value) {
-                    return {
-                        type: exports.PropertyType.BackboneElement,
-                        value: { namespace: 'FHIR', name: value.resourceType },
-                    };
-                }
-                return { type: exports.PropertyType.BackboneElement, value: null };
-            });
-        },
-        conformsTo: (input, systemAtom) => {
-            const system = systemAtom.eval(input)[0].value;
-            if (!system.startsWith('http://hl7.org/fhir/StructureDefinition/')) {
-                throw new Error('Expected a StructureDefinition URL');
-            }
-            const expectedResourceType = system.replace('http://hl7.org/fhir/StructureDefinition/', '');
-            return input.map((value) => {
-                var _a;
-                return ({
-                    type: exports.PropertyType.boolean,
-                    value: ((_a = value.value) === null || _a === void 0 ? void 0 : _a.resourceType) === expectedResourceType,
-                });
-            });
-        },
-    };
-    /*
-     * Helper utilities
+            const typeName = this.right.name;
+            return booleanToTypedValue(fhirPathIs(leftValue[0], typeName));
+        }
+    }
+    /**
+     * 6.5.1. and
+     * Returns true if both operands evaluate to true,
+     * false if either operand evaluates to false,
+     * and the empty collection otherwise.
      */
-    function applyStringFunc(func, input, ...argsAtoms) {
-        if (input.length === 0) {
+    class AndAtom {
+        constructor(left, right) {
+            this.left = left;
+            this.right = right;
+        }
+        eval(context) {
+            var _a, _b, _c, _d;
+            const leftValue = this.left.eval(context);
+            const rightValue = this.right.eval(context);
+            if (((_a = leftValue[0]) === null || _a === void 0 ? void 0 : _a.value) === true && ((_b = rightValue[0]) === null || _b === void 0 ? void 0 : _b.value) === true) {
+                return booleanToTypedValue(true);
+            }
+            if (((_c = leftValue[0]) === null || _c === void 0 ? void 0 : _c.value) === false || ((_d = rightValue[0]) === null || _d === void 0 ? void 0 : _d.value) === false) {
+                return booleanToTypedValue(false);
+            }
             return [];
         }
-        const [{ value }] = validateInput(input, 1);
-        if (typeof value !== 'string') {
-            throw new Error('String function cannot be called with non-string');
+    }
+    class OrAtom {
+        constructor(left, right) {
+            this.left = left;
+            this.right = right;
         }
-        const result = func(value, ...argsAtoms.map((atom) => { var _a, _b; return atom && ((_b = (_a = atom.eval(input)) === null || _a === void 0 ? void 0 : _a[0]) === null || _b === void 0 ? void 0 : _b.value); }));
-        if (result === undefined) {
+        eval(context) {
+            const leftValue = this.left.eval(context);
+            if (toJsBoolean(leftValue)) {
+                return leftValue;
+            }
+            const rightValue = this.right.eval(context);
+            if (toJsBoolean(rightValue)) {
+                return rightValue;
+            }
             return [];
         }
-        if (Array.isArray(result)) {
-            return result.map(toTypedValue);
-        }
-        return [toTypedValue(result)];
     }
-    function applyMathFunc(func, input, ...argsAtoms) {
-        if (input.length === 0) {
+    /**
+     * 6.5.4. xor
+     * Returns true if exactly one of the operands evaluates to true,
+     * false if either both operands evaluate to true or both operands evaluate to false,
+     * and the empty collection otherwise.
+     */
+    class XorAtom {
+        constructor(left, right) {
+            this.left = left;
+            this.right = right;
+        }
+        eval(context) {
+            const leftResult = this.left.eval(context);
+            const rightResult = this.right.eval(context);
+            if (leftResult.length === 0 && rightResult.length === 0) {
+                return [];
+            }
+            const leftValue = leftResult.length === 0 ? null : leftResult[0].value;
+            const rightValue = rightResult.length === 0 ? null : rightResult[0].value;
+            if ((leftValue === true && rightValue !== true) || (leftValue !== true && rightValue === true)) {
+                return booleanToTypedValue(true);
+            }
+            if ((leftValue === true && rightValue === true) || (leftValue === false && rightValue === false)) {
+                return booleanToTypedValue(false);
+            }
             return [];
         }
-        const [{ value }] = validateInput(input, 1);
-        const quantity = isQuantity(value);
-        const numberInput = quantity ? value.value : value;
-        if (typeof numberInput !== 'number') {
-            throw new Error('Math function cannot be called with non-number');
+    }
+    class FunctionAtom {
+        constructor(name, args, impl) {
+            this.name = name;
+            this.args = args;
+            this.impl = impl;
+        }
+        eval(context) {
+            return this.impl(context, ...this.args);
         }
-        const result = func(numberInput, ...argsAtoms.map((atom) => { var _a, _b; return (_b = (_a = atom.eval(input)) === null || _a === void 0 ? void 0 : _a[0]) === null || _b === void 0 ? void 0 : _b.value; }));
-        const type = quantity ? exports.PropertyType.Quantity : input[0].type;
-        const returnValue = quantity ? Object.assign(Object.assign({}, value), { value: result }) : result;
-        return [{ type, value: returnValue }];
     }
-    function validateInput(input, count) {
-        if (input.length !== count) {
-            throw new Error(`Expected ${count} arguments`);
+    class IndexerAtom {
+        constructor(left, expr) {
+            this.left = left;
+            this.expr = expr;
         }
-        for (const element of input) {
-            if (element === null || element === undefined) {
-                throw new Error('Expected non-null argument');
+        eval(context) {
+            const evalResult = this.expr.eval(context);
+            if (evalResult.length !== 1) {
+                return [];
+            }
+            const index = evalResult[0].value;
+            if (typeof index !== 'number') {
+                throw new Error(`Invalid indexer expression: should return integer}`);
+            }
+            const leftResult = this.left.eval(context);
+            if (!(index in leftResult)) {
+                return [];
             }
+            return [leftResult[index]];
         }
-        return input;
     }
 
     var _Tokenizer_instances, _Tokenizer_str, _Tokenizer_pos, _Tokenizer_peekToken, _Tokenizer_consumeToken, _Tokenizer_consumeWhitespace, _Tokenizer_consumeMultiLineComment, _Tokenizer_consumeSingleLineComment, _Tokenizer_consumeString, _Tokenizer_consumeBacktickSymbol, _Tokenizer_consumeDateTime, _Tokenizer_consumeNumber, _Tokenizer_consumeSymbol, _Tokenizer_consumeOperator, _Tokenizer_consumeWhile, _Tokenizer_curr, _Tokenizer_prev, _Tokenizer_peek;
@@ -10427,7 +10475,7 @@
         issue: [
             {
                 severity: 'information',
-                code: 'information',
+                code: 'informational',
                 details: {
                     text: 'All OK',
                 },
@@ -10440,7 +10488,7 @@
         issue: [
             {
                 severity: 'information',
-                code: 'information',
+                code: 'informational',
                 details: {
                     text: 'Created',
                 },
@@ -10453,7 +10501,7 @@
         issue: [
             {
                 severity: 'information',
-                code: 'information',
+                code: 'informational',
                 details: {
                     text: 'Not Modified',
                 },
@@ -10844,17 +10892,32 @@
      *   2) The "token" type includes enums and booleans.
      *   3) Arrays/multiple values are not reflected at all.
      *
-     * @param structureDefinitions Collection of StructureDefinition resources indexed by name.
      * @param resourceType The root resource type.
      * @param searchParam The search parameter.
      * @returns The search parameter type details.
      */
-    function getSearchParameterDetails(structureDefinitions, resourceType, searchParam) {
+    function getSearchParameterDetails(resourceType, searchParam) {
+        var _a, _b;
+        let result = (_b = (_a = globalSchema.types[resourceType]) === null || _a === void 0 ? void 0 : _a.searchParamsDetails) === null || _b === void 0 ? void 0 : _b[searchParam.code];
+        if (!result) {
+            result = buildSearchParamterDetails(resourceType, searchParam);
+        }
+        return result;
+    }
+    function setSearchParamterDetails(resourceType, code, details) {
+        const typeSchema = globalSchema.types[resourceType];
+        if (!typeSchema.searchParamsDetails) {
+            typeSchema.searchParamsDetails = {};
+        }
+        typeSchema.searchParamsDetails[code] = details;
+    }
+    function buildSearchParamterDetails(resourceType, searchParam) {
         var _a, _b, _c, _d, _e, _f, _g;
         if (searchParam.code === '_lastUpdated') {
             return { columnName: 'lastUpdated', type: exports.SearchParameterType.DATETIME };
         }
-        const columnName = convertCodeToColumnName(searchParam.code);
+        const code = searchParam.code;
+        const columnName = convertCodeToColumnName(code);
         const expression = (_a = getExpressionForResourceType(resourceType, searchParam.expression)) === null || _a === void 0 ? void 0 : _a.split('.');
         if (!expression) {
             // This happens on compound types
@@ -10869,7 +10932,7 @@
         for (let i = 1; i < expression.length; i++) {
             const propertyName = expression[i];
             elementDefinition =
-                (_d = (_c = (_b = structureDefinitions.types[baseType]) === null || _b === void 0 ? void 0 : _b.properties) === null || _c === void 0 ? void 0 : _c[propertyName]) !== null && _d !== void 0 ? _d : (_f = (_e = structureDefinitions.types[baseType]) === null || _e === void 0 ? void 0 : _e.properties) === null || _f === void 0 ? void 0 : _f[propertyName + '[x]'];
+                (_d = (_c = (_b = globalSchema.types[baseType]) === null || _b === void 0 ? void 0 : _b.properties) === null || _c === void 0 ? void 0 : _c[propertyName]) !== null && _d !== void 0 ? _d : (_f = (_e = globalSchema.types[baseType]) === null || _e === void 0 ? void 0 : _e.properties) === null || _f === void 0 ? void 0 : _f[propertyName + '[x]'];
             if (!elementDefinition) {
                 throw new Error(`Element definition not found for ${resourceType} ${searchParam.code}`);
             }
@@ -10892,7 +10955,9 @@
             }
         }
         const type = getSearchParameterType(searchParam, propertyType);
-        return { columnName, type, elementDefinition, array };
+        const result = { columnName, type, elementDefinition, array };
+        setSearchParamterDetails(resourceType, code, result);
+        return result;
     }
     /**
      * Converts a hyphen-delimited code to camelCase string.
@@ -11008,7 +11073,6 @@
     exports.capitalize = capitalize;
     exports.createReference = createReference;
     exports.createSchema = createSchema;
-    exports.createTypeSchema = createTypeSchema;
     exports.created = created;
     exports.deepClone = deepClone;
     exports.deepEquals = deepEquals$1;
@@ -11036,6 +11100,7 @@
     exports.getCodeBySystem = getCodeBySystem;
     exports.getDateProperty = getDateProperty;
     exports.getDisplayString = getDisplayString;
+    exports.getElementDefinition = getElementDefinition;
     exports.getExpressionForResourceType = getExpressionForResourceType;
     exports.getExtensionValue = getExtensionValue;
     exports.getIdentifier = getIdentifier;