@medplum/core 2.0.18 → 2.0.20

package/dist/cjs/index.cjs

@@ -1098,6 +1098,18 @@
         }
         return Math.round(a * Math.pow(10, precision));
     }
+    /**
+     * Finds the first resource in the input array that matches the specified code and system.
+     * @param resources - The array of resources to search.
+     * @param code - The code to search for.
+     * @param system - The system to search for.
+     * @returns The first resource in the input array that matches the specified code and system, or undefined if no such resource is found.
+     */
+    function findResourceByCode(resources, code, system) {
+        return resources.find((r) => typeof code === 'string'
+            ? getCodeBySystem(r.code || {}, system) === code
+            : getCodeBySystem(r.code || {}, system) === getCodeBySystem(code, system));
+    }
 
     /**
      * Returns a cryptographically secure random string.
@@ -6404,7 +6416,8 @@
     const globalSchema = baseSchema;
 
     // PKCE auth based on:
-    const MEDPLUM_VERSION = "2.0.18-e7b9bd9c" ;
+    // https://aws.amazon.com/blogs/security/how-to-add-authentication-single-page-web-application-with-amazon-cognito-oauth2-implementation/
+    const MEDPLUM_VERSION = "2.0.20-effeb76c" ;
     const DEFAULT_BASE_URL = 'https://api.medplum.com/';
     const DEFAULT_RESOURCE_CACHE_SIZE = 1000;
     const DEFAULT_CACHE_TIME = 60000; // 60 seconds
@@ -6575,6 +6588,13 @@
             url = url.toString();
             this.requestCache?.delete(url);
         }
+        /**
+         * Invalidates all cached values and flushes the cache.
+         * @category Caching
+         */
+        invalidateAll() {
+            this.requestCache?.clear();
+        }
         /**
          * Invalidates all cached search results or cached requests for the given resourceType.
          * @category Caching
@@ -7906,6 +7926,26 @@
             const response = await this.fetch(url.toString(), options);
             return response.blob();
         }
+        /**
+         * Upload media to the server and create a Media instance for the uploaded content.
+         * @param contents The contents of the media file, as a string, Uint8Array, File, or Blob.
+         * @param contentType The media type of the content
+         * @param filename The name of the file to be uploaded, or undefined if not applicable
+         * @param additionalFields  Additional fields for Media
+         * @returns Promise that resolves to the created Media
+         */
+        async uploadMedia(contents, contentType, filename, additionalFields) {
+            const binary = await this.createBinary(contents, filename, contentType);
+            return this.createResource({
+                ...additionalFields,
+                resourceType: 'Media',
+                content: {
+                    contentType: contentType,
+                    url: 'Binary/' + binary.id,
+                    title: filename,
+                },
+            });
+        }
         //
         // Private helpers
         //
@@ -7981,7 +8021,10 @@
                 return undefined;
             }
             if (response.status === 404) {
-                throw new OperationOutcomeError(normalizeOperationOutcome(notFound));
+                const contentType = response.headers.get('content-type');
+                if (!contentType?.includes('application/fhir+json')) {
+                    throw new OperationOutcomeError(notFound);
+                }
             }
             let obj = undefined;
             try {
@@ -11394,157 +11437,572 @@
         return new StructureMapParser(parser).parse();
     }
 
-    const MAPPING_LANGUAGE_OPERATORS = [...FHIRPATH_OPERATORS, 'eq', 'ne', 'co'];
-    function tokenize(str) {
-        return new Tokenizer(str, FHIRPATH_KEYWORDS, MAPPING_LANGUAGE_OPERATORS, {
-            dateTimeLiterals: true,
-            symbolRegex: /[^\s\])]/,
-        }).tokenize();
-    }
-
-    // See: https://hl7.org/fhir/search_filter.html
+    const DEFAULT_SEARCH_COUNT = 20;
     /**
-     * The FhirFilterComparison class represents a comparison expression.
+     * Search operators.
+     * These operators represent "modifiers" and "prefixes" in FHIR search.
+     * See: https://www.hl7.org/fhir/search.html
      */
-    class FhirFilterComparison {
-        constructor(path, operator, value) {
-            this.path = path;
-            this.operator = operator;
-            this.value = value;
-        }
-    }
+    exports.Operator = void 0;
+    (function (Operator) {
+        Operator["EQUALS"] = "eq";
+        Operator["NOT_EQUALS"] = "ne";
+        // Numbers
+        Operator["GREATER_THAN"] = "gt";
+        Operator["LESS_THAN"] = "lt";
+        Operator["GREATER_THAN_OR_EQUALS"] = "ge";
+        Operator["LESS_THAN_OR_EQUALS"] = "le";
+        // Dates
+        Operator["STARTS_AFTER"] = "sa";
+        Operator["ENDS_BEFORE"] = "eb";
+        Operator["APPROXIMATELY"] = "ap";
+        // String
+        Operator["CONTAINS"] = "contains";
+        Operator["EXACT"] = "exact";
+        // Token
+        Operator["TEXT"] = "text";
+        Operator["NOT"] = "not";
+        Operator["ABOVE"] = "above";
+        Operator["BELOW"] = "below";
+        Operator["IN"] = "in";
+        Operator["NOT_IN"] = "not-in";
+        Operator["OF_TYPE"] = "of-type";
+        // All
+        Operator["MISSING"] = "missing";
+        // Reference
+        Operator["IDENTIFIER"] = "identifier";
+        // _include and _revinclude
+        Operator["ITERATE"] = "iterate";
+    })(exports.Operator || (exports.Operator = {}));
     /**
-     * The FhirFilterNegation class represents a negation expression.
-     * It contains a single child expression.
+     * Parameter names may specify a modifier as a suffix.
+     * The modifiers are separated from the parameter name by a colon.
+     * See: https://www.hl7.org/fhir/search.html#modifiers
      */
-    class FhirFilterNegation {
-        constructor(child) {
-            this.child = child;
-        }
-    }
+    const MODIFIER_OPERATORS = {
+        contains: exports.Operator.CONTAINS,
+        exact: exports.Operator.EXACT,
+        above: exports.Operator.ABOVE,
+        below: exports.Operator.BELOW,
+        text: exports.Operator.TEXT,
+        not: exports.Operator.NOT,
+        in: exports.Operator.IN,
+        'not-in': exports.Operator.NOT_IN,
+        'of-type': exports.Operator.OF_TYPE,
+        missing: exports.Operator.MISSING,
+        identifier: exports.Operator.IDENTIFIER,
+        iterate: exports.Operator.ITERATE,
+    };
     /**
-     * The FhirFilterConnective class represents a connective expression.
-     * It contains a list of child expressions.
+     * For the ordered parameter types of number, date, and quantity,
+     * a prefix to the parameter value may be used to control the nature
+     * of the matching.
+     * See: https://www.hl7.org/fhir/search.html#prefix
      */
-    class FhirFilterConnective {
-        constructor(keyword, left, right) {
-            this.keyword = keyword;
-            this.left = left;
-            this.right = right;
-        }
-    }
-
-    class FilterParameterParser {
-        constructor(parser) {
-            this.parser = parser;
-        }
-        parse() {
-            let result;
-            if (this.parser.peek()?.value === '(') {
-                this.parser.consume('(');
-                result = this.parse();
-                this.parser.consume(')');
-            }
-            else if (this.parser.peek()?.value === 'not') {
-                this.parser.consume('Symbol', 'not');
-                this.parser.consume('(');
-                result = new FhirFilterNegation(this.parse());
-                this.parser.consume(')');
+    const PREFIX_OPERATORS = {
+        eq: exports.Operator.EQUALS,
+        ne: exports.Operator.NOT_EQUALS,
+        lt: exports.Operator.LESS_THAN,
+        le: exports.Operator.LESS_THAN_OR_EQUALS,
+        gt: exports.Operator.GREATER_THAN,
+        ge: exports.Operator.GREATER_THAN_OR_EQUALS,
+        sa: exports.Operator.STARTS_AFTER,
+        eb: exports.Operator.ENDS_BEFORE,
+        ap: exports.Operator.APPROXIMATELY,
+    };
+    /**
+     * Parses a search URL into a search request.
+     * @param resourceType The FHIR resource type.
+     * @param query The collection of query string parameters.
+     * @returns A parsed SearchRequest.
+     */
+    function parseSearchRequest(resourceType, query) {
+        const queryArray = [];
+        for (const [key, value] of Object.entries(query)) {
+            if (Array.isArray(value)) {
+                for (let i = 0; i < value.length; i++) {
+                    queryArray.push([key, value[i]]);
+                }
             }
             else {
-                result = new FhirFilterComparison(this.parser.consume('Symbol').value, this.parser.consume('Symbol').value, this.parser.consume().value);
-            }
-            const next = this.parser.peek()?.value;
-            if (next === 'and' || next === 'or') {
-                this.parser.consume('Symbol', next);
-                return new FhirFilterConnective(next, result, this.parse());
+                queryArray.push([key, value || '']);
             }
-            return result;
         }
+        return parseSearchImpl(resourceType, queryArray);
     }
-    const fhirPathParserBuilder = initFhirPathParserBuilder();
     /**
-     * Parses a FHIR _filter parameter expression into an AST.
-     * @param input The FHIR _filter parameter expression.
-     * @returns The AST representing the filters.
+     * Parses a search URL into a search request.
+     * @param url The search URL.
+     * @returns A parsed SearchRequest.
      */
-    function parseFilterParameter(input) {
-        const parser = fhirPathParserBuilder.construct(tokenize(input));
-        parser.removeComments();
-        return new FilterParameterParser(parser).parse();
+    function parseSearchUrl(url) {
+        const resourceType = url.pathname.split('/').filter(Boolean).pop();
+        return parseSearchImpl(resourceType, url.searchParams.entries());
     }
-
     /**
-     * The Hl7Context class represents the parsing context for an HL7 message.
-     *
-     * MSH-1:
-     * https://hl7-definition.caristix.com/v2/HL7v2.6/Fields/MSH.1
-     *
-     * MSH-2:
-     * https://hl7-definition.caristix.com/v2/HL7v2.6/Fields/MSH.2
-     *
-     * See this tutorial on MSH, and why it's a bad idea to use anything other than the default values:
-     * https://www.hl7soup.com/HL7TutorialMSH.html
+     * Parses a URL string into a SearchRequest.
+     * @param url The URL to parse.
+     * @returns Parsed search definition.
      */
-    class Hl7Context {
-        constructor(segmentSeparator = '\r', fieldSeparator = '|', componentSeparator = '^', repetitionSeparator = '~', escapeCharacter = '\\', subcomponentSeparator = '&') {
-            this.segmentSeparator = segmentSeparator;
-            this.fieldSeparator = fieldSeparator;
-            this.componentSeparator = componentSeparator;
-            this.repetitionSeparator = repetitionSeparator;
-            this.escapeCharacter = escapeCharacter;
-            this.subcomponentSeparator = subcomponentSeparator;
-        }
-        /**
-         * Returns the MSH-2 field value based on the configured separators.
-         * @returns The HL7 MSH-2 field value.
-         */
-        getMsh2() {
-            return (this.fieldSeparator +
-                this.componentSeparator +
-                this.repetitionSeparator +
-                this.escapeCharacter +
-                this.subcomponentSeparator);
-        }
+    function parseSearchDefinition(url) {
+        return parseSearchUrl(new URL(url, 'https://example.com/'));
     }
-    /**
-     * The Hl7Message class represents one HL7 message.
-     * A message is a collection of segments.
-     */
-    class Hl7Message {
-        /**
-         * Creates a new HL7 message.
-         * @param segments The HL7 segments.
-         * @param context Optional HL7 parsing context.
-         */
-        constructor(segments, context = new Hl7Context()) {
-            this.context = context;
-            this.segments = segments;
+    function parseSearchImpl(resourceType, query) {
+        const searchRequest = {
+            resourceType,
+        };
+        for (const [key, value] of query) {
+            parseKeyValue(searchRequest, key, value);
         }
-        /**
-         * Returns an HL7 segment by index or by name.
-         * @param index The HL7 segment index or name.
-         * @returns The HL7 segment if found; otherwise, undefined.
-         */
-        get(index) {
-            if (typeof index === 'number') {
-                return this.segments[index];
-            }
-            return this.segments.find((s) => s.name === index);
+        return searchRequest;
+    }
+    function parseKeyValue(searchRequest, key, value) {
+        let code;
+        let modifier;
+        const colonIndex = key.indexOf(':');
+        if (colonIndex >= 0) {
+            code = key.substring(0, colonIndex);
+            modifier = key.substring(colonIndex + 1);
         }
-        /**
-         * Returns all HL7 segments of a given name.
-         * @param name The HL7 segment name.
-         * @returns An array of HL7 segments with the specified name.
-         */
-        getAll(name) {
-            return this.segments.filter((s) => s.name === name);
+        else {
+            code = key;
+            modifier = '';
         }
-        /**
-         * Returns the HL7 message as a string.
-         * @returns The HL7 message as a string.
-         */
-        toString() {
+        switch (code) {
+            case '_sort':
+                parseSortRule(searchRequest, value);
+                break;
+            case '_count':
+                searchRequest.count = parseInt(value);
+                break;
+            case '_offset':
+                searchRequest.offset = parseInt(value);
+                break;
+            case '_total':
+                searchRequest.total = value;
+                break;
+            case '_summary':
+                searchRequest.total = 'estimate';
+                searchRequest.count = 0;
+                break;
+            case '_include': {
+                const target = parseIncludeTarget(value);
+                if (modifier === 'iterate') {
+                    target.modifier = exports.Operator.ITERATE;
+                }
+                if (searchRequest.include) {
+                    searchRequest.include.push(target);
+                }
+                else {
+                    searchRequest.include = [target];
+                }
+                break;
+            }
+            case '_revinclude': {
+                const target = parseIncludeTarget(value);
+                if (modifier === 'iterate') {
+                    target.modifier = exports.Operator.ITERATE;
+                }
+                if (searchRequest.revInclude) {
+                    searchRequest.revInclude.push(target);
+                }
+                else {
+                    searchRequest.revInclude = [target];
+                }
+                break;
+            }
+            case '_fields':
+                searchRequest.fields = value.split(',');
+                break;
+            default: {
+                const param = globalSchema.types[searchRequest.resourceType]?.searchParams?.[code];
+                if (param) {
+                    parseParameter(searchRequest, param, modifier, value);
+                }
+                else {
+                    parseUnknownParameter(searchRequest, code, modifier, value);
+                }
+            }
+        }
+    }
+    function parseSortRule(searchRequest, value) {
+        for (const field of value.split(',')) {
+            let code;
+            let descending = false;
+            if (field.startsWith('-')) {
+                code = field.substring(1);
+                descending = true;
+            }
+            else {
+                code = field;
+            }
+            if (!searchRequest.sortRules) {
+                searchRequest.sortRules = [];
+            }
+            searchRequest.sortRules.push({ code, descending });
+        }
+    }
+    function parseParameter(searchRequest, searchParam, modifier, value) {
+        if (modifier === 'missing') {
+            addFilter(searchRequest, {
+                code: searchParam.code,
+                operator: exports.Operator.MISSING,
+                value,
+            });
+            return;
+        }
+        switch (searchParam.type) {
+            case 'number':
+            case 'date':
+                parsePrefixType(searchRequest, searchParam, value);
+                break;
+            case 'reference':
+            case 'string':
+            case 'token':
+            case 'uri':
+                parseModifierType(searchRequest, searchParam, modifier, value);
+                break;
+            case 'quantity':
+                parseQuantity(searchRequest, searchParam, value);
+                break;
+        }
+    }
+    function parsePrefixType(searchRequest, param, input) {
+        const { operator, value } = parsePrefix(input);
+        addFilter(searchRequest, {
+            code: param.code,
+            operator,
+            value,
+        });
+    }
+    function parseModifierType(searchRequest, param, modifier, value) {
+        addFilter(searchRequest, {
+            code: param.code,
+            operator: parseModifier(modifier),
+            value,
+        });
+    }
+    function parseQuantity(searchRequest, param, input) {
+        const [prefixNumber, unitSystem, unitCode] = input.split('|');
+        const { operator, value } = parsePrefix(prefixNumber);
+        addFilter(searchRequest, {
+            code: param.code,
+            operator,
+            value,
+            unitSystem,
+            unitCode,
+        });
+    }
+    function parseUnknownParameter(searchRequest, code, modifier, value) {
+        let operator = exports.Operator.EQUALS;
+        if (modifier) {
+            operator = modifier;
+        }
+        else if (value.length >= 2) {
+            const prefix = value.substring(0, 2);
+            if (prefix in PREFIX_OPERATORS) {
+                if (value.length === 2 || value.at(2)?.match(/\d/)) {
+                    operator = prefix;
+                    value = value.substring(prefix.length);
+                }
+            }
+        }
+        addFilter(searchRequest, {
+            code,
+            operator,
+            value,
+        });
+    }
+    function parsePrefix(input) {
+        const prefix = input.substring(0, 2);
+        const prefixOperator = PREFIX_OPERATORS[prefix];
+        if (prefixOperator) {
+            return { operator: prefixOperator, value: input.substring(2) };
+        }
+        return { operator: exports.Operator.EQUALS, value: input };
+    }
+    function parseModifier(modifier) {
+        return MODIFIER_OPERATORS[modifier] || exports.Operator.EQUALS;
+    }
+    function parseIncludeTarget(input) {
+        const parts = input.split(':');
+        parts.forEach((p) => {
+            if (p === '*') {
+                throw new OperationOutcomeError(badRequest(`'*' is not supported as a value for search inclusion parameters`));
+            }
+        });
+        if (parts.length === 1) {
+            // Full wildcard, not currently supported
+            throw new OperationOutcomeError(badRequest(`Invalid include value '${input}': must be of the form ResourceType:search-parameter`));
+        }
+        else if (parts.length === 2) {
+            return {
+                resourceType: parts[0],
+                searchParam: parts[1],
+            };
+        }
+        else if (parts.length === 3) {
+            return {
+                resourceType: parts[0],
+                searchParam: parts[1],
+                targetType: parts[2],
+            };
+        }
+        else {
+            throw new OperationOutcomeError(badRequest(`Invalid include value '${input}'`));
+        }
+    }
+    function addFilter(searchRequest, filter) {
+        if (searchRequest.filters) {
+            searchRequest.filters.push(filter);
+        }
+        else {
+            searchRequest.filters = [filter];
+        }
+    }
+    /**
+     * Formats a search definition object into a query string.
+     * Note: The return value does not include the resource type.
+     * @param {!SearchRequest} definition The search definition.
+     * @returns Formatted URL.
+     */
+    function formatSearchQuery(definition) {
+        const params = [];
+        if (definition.fields) {
+            params.push('_fields=' + definition.fields.join(','));
+        }
+        if (definition.filters) {
+            definition.filters.forEach((filter) => params.push(formatFilter(filter)));
+        }
+        if (definition.sortRules && definition.sortRules.length > 0) {
+            params.push(formatSortRules(definition.sortRules));
+        }
+        if (definition.offset !== undefined) {
+            params.push('_offset=' + definition.offset);
+        }
+        if (definition.count !== undefined) {
+            params.push('_count=' + definition.count);
+        }
+        if (definition.total !== undefined) {
+            params.push('_total=' + definition.total);
+        }
+        if (params.length === 0) {
+            return '';
+        }
+        params.sort();
+        return '?' + params.join('&');
+    }
+    function formatFilter(filter) {
+        const modifier = filter.operator in MODIFIER_OPERATORS ? ':' + filter.operator : '';
+        const prefix = filter.operator !== exports.Operator.EQUALS && filter.operator in PREFIX_OPERATORS ? filter.operator : '';
+        return `${filter.code}${modifier}=${prefix}${encodeURIComponent(filter.value)}`;
+    }
+    function formatSortRules(sortRules) {
+        return '_sort=' + sortRules.map((sr) => (sr.descending ? '-' + sr.code : sr.code)).join(',');
+    }
+
+    const MAPPING_LANGUAGE_OPERATORS = [...FHIRPATH_OPERATORS, 'eq', 'ne', 'co'];
+    function tokenize(str) {
+        return new Tokenizer(str, FHIRPATH_KEYWORDS, MAPPING_LANGUAGE_OPERATORS, {
+            dateTimeLiterals: true,
+            symbolRegex: /[^\s\])]/,
+        }).tokenize();
+    }
+
+    // See: https://hl7.org/fhir/search_filter.html
+    /**
+     * The FhirFilterComparison class represents a comparison expression.
+     */
+    class FhirFilterComparison {
+        constructor(path, operator, value) {
+            this.path = path;
+            this.operator = operator;
+            this.value = value;
+        }
+    }
+    /**
+     * The FhirFilterNegation class represents a negation expression.
+     * It contains a single child expression.
+     */
+    class FhirFilterNegation {
+        constructor(child) {
+            this.child = child;
+        }
+    }
+    /**
+     * The FhirFilterConnective class represents a connective expression.
+     * It contains a list of child expressions.
+     */
+    class FhirFilterConnective {
+        constructor(keyword, left, right) {
+            this.keyword = keyword;
+            this.left = left;
+            this.right = right;
+        }
+    }
+
+    /**
+     * The operatorMap maps FHIR _filter operators to Medplum search operators.
+     * See _filter operators: https://www.hl7.org/fhir/search_filter.html#ops
+     */
+    const operatorMap = {
+        // eq - an item in the set has an equal value
+        eq: exports.Operator.EQUALS,
+        // ne - An item in the set has an unequal value
+        ne: exports.Operator.NOT_EQUALS,
+        // co - An item in the set contains this value
+        co: exports.Operator.CONTAINS,
+        // sw - An item in the set starts with this value
+        sw: undefined,
+        // ew - An item in the set ends with this value
+        ew: undefined,
+        // gt / lt / ge / le - A value in the set is (greater than, less than, greater or equal, less or equal) the given value
+        gt: exports.Operator.GREATER_THAN,
+        lt: exports.Operator.LESS_THAN,
+        ge: exports.Operator.GREATER_THAN_OR_EQUALS,
+        le: exports.Operator.LESS_THAN_OR_EQUALS,
+        // ap - A value in the set is approximately the same as this value.
+        // Note that the recommended value for the approximation is 10% of the stated value (or for a date, 10% of the gap between now and the date), but systems may choose other values where appropriate
+        ap: exports.Operator.APPROXIMATELY,
+        // sa - The value starts after the specified value
+        sa: exports.Operator.STARTS_AFTER,
+        // eb - The value ends before the specified value
+        eb: exports.Operator.ENDS_BEFORE,
+        // pr - The set is empty or not (value is false or true)
+        pr: exports.Operator.MISSING,
+        // po - True if a (implied) date period in the set overlaps with the implied period in the value
+        po: undefined,
+        // ss - True if the value subsumes a concept in the set
+        ss: undefined,
+        // sb - True if the value is subsumed by a concept in the set
+        sb: undefined,
+        // in - True if one of the concepts is in the nominated value set by URI, either a relative, literal or logical vs
+        in: exports.Operator.IN,
+        // ni - True if none of the concepts are in the nominated value set by URI, either a relative, literal or logical vs
+        ni: exports.Operator.NOT_IN,
+        // re - True if one of the references in set points to the given URL
+        re: undefined,
+        // identifier - True if the identifier is in the identifier set (Medplum extension)
+        identifier: exports.Operator.IDENTIFIER,
+    };
+    function getOperator(value) {
+        const operator = operatorMap[value];
+        if (!operator) {
+            throw new OperationOutcomeError(badRequest('Invalid operator: ' + value));
+        }
+        return operator;
+    }
+    class FilterParameterParser {
+        constructor(parser) {
+            this.parser = parser;
+        }
+        parse() {
+            let result;
+            if (this.parser.peek()?.value === '(') {
+                this.parser.consume('(');
+                result = this.parse();
+                this.parser.consume(')');
+            }
+            else if (this.parser.peek()?.value === 'not') {
+                this.parser.consume('Symbol', 'not');
+                this.parser.consume('(');
+                result = new FhirFilterNegation(this.parse());
+                this.parser.consume(')');
+            }
+            else {
+                result = new FhirFilterComparison(this.parser.consume('Symbol').value, getOperator(this.parser.consume('Symbol').value), this.parser.consume().value);
+            }
+            const next = this.parser.peek()?.value;
+            if (next === 'and' || next === 'or') {
+                this.parser.consume('Symbol', next);
+                return new FhirFilterConnective(next, result, this.parse());
+            }
+            return result;
+        }
+    }
+    const fhirPathParserBuilder = initFhirPathParserBuilder();
+    /**
+     * Parses a FHIR _filter parameter expression into an AST.
+     * @param input The FHIR _filter parameter expression.
+     * @returns The AST representing the filters.
+     */
+    function parseFilterParameter(input) {
+        const parser = fhirPathParserBuilder.construct(tokenize(input));
+        parser.removeComments();
+        return new FilterParameterParser(parser).parse();
+    }
+
+    /**
+     * The Hl7Context class represents the parsing context for an HL7 message.
+     *
+     * MSH-1:
+     * https://hl7-definition.caristix.com/v2/HL7v2.6/Fields/MSH.1
+     *
+     * MSH-2:
+     * https://hl7-definition.caristix.com/v2/HL7v2.6/Fields/MSH.2
+     *
+     * See this tutorial on MSH, and why it's a bad idea to use anything other than the default values:
+     * https://www.hl7soup.com/HL7TutorialMSH.html
+     */
+    class Hl7Context {
+        constructor(segmentSeparator = '\r', fieldSeparator = '|', componentSeparator = '^', repetitionSeparator = '~', escapeCharacter = '\\', subcomponentSeparator = '&') {
+            this.segmentSeparator = segmentSeparator;
+            this.fieldSeparator = fieldSeparator;
+            this.componentSeparator = componentSeparator;
+            this.repetitionSeparator = repetitionSeparator;
+            this.escapeCharacter = escapeCharacter;
+            this.subcomponentSeparator = subcomponentSeparator;
+        }
+        /**
+         * Returns the MSH-2 field value based on the configured separators.
+         * @returns The HL7 MSH-2 field value.
+         */
+        getMsh2() {
+            return (this.fieldSeparator +
+                this.componentSeparator +
+                this.repetitionSeparator +
+                this.escapeCharacter +
+                this.subcomponentSeparator);
+        }
+    }
+    /**
+     * The Hl7Message class represents one HL7 message.
+     * A message is a collection of segments.
+     */
+    class Hl7Message {
+        /**
+         * Creates a new HL7 message.
+         * @param segments The HL7 segments.
+         * @param context Optional HL7 parsing context.
+         */
+        constructor(segments, context = new Hl7Context()) {
+            this.context = context;
+            this.segments = segments;
+        }
+        /**
+         * Returns an HL7 segment by index or by name.
+         * @param index The HL7 segment index or name.
+         * @returns The HL7 segment if found; otherwise, undefined.
+         */
+        get(index) {
+            if (typeof index === 'number') {
+                return this.segments[index];
+            }
+            return this.segments.find((s) => s.name === index);
+        }
+        /**
+         * Returns all HL7 segments of a given name.
+         * @param name The HL7 segment name.
+         * @returns An array of HL7 segments with the specified name.
+         */
+        getAll(name) {
+            return this.segments.filter((s) => s.name === name);
+        }
+        /**
+         * Returns the HL7 message as a string.
+         * @returns The HL7 message as a string.
+         */
+        toString() {
             return this.segments.map((s) => s.toString()).join(this.context.segmentSeparator);
         }
         /**
@@ -11689,6 +12147,28 @@
             return new Hl7Field(text.split(context.repetitionSeparator).map((r) => r.split(context.componentSeparator)), context);
         }
     }
+    /**
+     * Returns a formatted string representing the date in ISO-8601 format.
+     * @param hl7Date Date string.
+     * @param options Optional configuration Object
+     * @returns
+     */
+    function parseHl7Date(hl7Date, options) {
+        if (!hl7Date) {
+            return undefined;
+        }
+        options = { ...{ seconds: true, tzOffset: 'Z' }, ...options };
+        const year = Number.parseInt(hl7Date.substring(0, 4));
+        const month = Number.parseInt(hl7Date.substring(4, 6));
+        const date = Number.parseInt(hl7Date.substring(6, 8));
+        const hours = Number.parseInt(hl7Date.substring(8, 10));
+        const minutes = Number.parseInt(hl7Date.substring(10, 12));
+        const seconds = options.seconds ? Number.parseInt(hl7Date.substring(12, 14)) : 0;
+        return `${pad2(year)}-${pad2(month)}-${pad2(date)}T${pad2(hours)}:${pad2(minutes)}:${pad2(seconds)}.000${options.tzOffset}`;
+    }
+    function pad2(n) {
+        return n.toString().padStart(2, '0');
+    }
 
     /*
      * This file provides schema validation utilities for FHIR JSON objects.
@@ -12112,6 +12592,7 @@
         SearchParameterType["QUANTITY"] = "QUANTITY";
         SearchParameterType["TEXT"] = "TEXT";
         SearchParameterType["REFERENCE"] = "REFERENCE";
+        SearchParameterType["CANONICAL"] = "CANONICAL";
         SearchParameterType["DATE"] = "DATE";
         SearchParameterType["DATETIME"] = "DATETIME";
         SearchParameterType["PERIOD"] = "PERIOD";
@@ -12154,474 +12635,114 @@
             // In the future, explore returning multiple column definitions
             return { columnName, type: exports.SearchParameterType.TEXT };
         }
-        const defaultType = getSearchParameterType(searchParam);
-        let baseType = resourceType;
-        let elementDefinition = undefined;
-        let propertyType = undefined;
-        let array = false;
-        for (let i = 1; i < expression.length; i++) {
-            const propertyName = expression[i];
-            elementDefinition = getElementDefinition(baseType, propertyName);
-            if (!elementDefinition) {
-                throw new Error(`Element definition not found for ${resourceType} ${searchParam.code}`);
-            }
-            if (elementDefinition.max === '*') {
-                array = true;
-            }
-            propertyType = elementDefinition.type?.[0].code;
-            if (!propertyType) {
-                // This happens when one of parent properties uses contentReference
-                // In the future, explore following the reference
-                return { columnName, type: defaultType, array };
-            }
-            if (i < expression.length - 1) {
-                if (isBackboneElement(propertyType)) {
-                    baseType = buildTypeName(elementDefinition.path?.split('.'));
-                }
-                else {
-                    baseType = propertyType;
-                }
-            }
-        }
-        const type = getSearchParameterType(searchParam, propertyType);
-        const result = { columnName, type, elementDefinition, array };
-        setSearchParamterDetails(resourceType, code, result);
-        return result;
-    }
-    function isBackboneElement(propertyType) {
-        return propertyType === 'Element' || propertyType === 'BackboneElement';
-    }
-    /**
-     * Converts a hyphen-delimited code to camelCase string.
-     * @param code The search parameter code.
-     * @returns The SQL column name.
-     */
-    function convertCodeToColumnName(code) {
-        return code.split('-').reduce((result, word, index) => result + (index ? capitalize(word) : word), '');
-    }
-    function getSearchParameterType(searchParam, propertyType) {
-        let type = exports.SearchParameterType.TEXT;
-        switch (searchParam.type) {
-            case 'date':
-                if (propertyType === exports.PropertyType.dateTime || propertyType === exports.PropertyType.instant) {
-                    type = exports.SearchParameterType.DATETIME;
-                }
-                else {
-                    type = exports.SearchParameterType.DATE;
-                }
-                break;
-            case 'number':
-                type = exports.SearchParameterType.NUMBER;
-                break;
-            case 'quantity':
-                type = exports.SearchParameterType.QUANTITY;
-                break;
-            case 'reference':
-                type = exports.SearchParameterType.REFERENCE;
-                break;
-            case 'token':
-                if (propertyType === 'boolean') {
-                    type = exports.SearchParameterType.BOOLEAN;
-                }
-                break;
-        }
-        return type;
-    }
-    function getExpressionForResourceType(resourceType, expression) {
-        const expressions = expression.split(' | ');
-        for (const e of expressions) {
-            if (isIgnoredExpression(e)) {
-                continue;
-            }
-            const simplified = simplifyExpression(e);
-            if (simplified.startsWith(resourceType + '.')) {
-                return simplified;
-            }
-        }
-        return undefined;
-    }
-    function isIgnoredExpression(input) {
-        return input.includes(' as Period') || input.includes(' as SampledDate');
-    }
-    function simplifyExpression(input) {
-        let result = input.trim();
-        if (result.startsWith('(') && result.endsWith(')')) {
-            result = result.substring(1, result.length - 1);
-        }
-        if (result.includes('[0]')) {
-            result = result.replaceAll('[0]', '');
-        }
-        const stopStrings = [' != ', ' as ', '.as(', '.exists(', '.resolve(', '.where('];
-        for (const stopString of stopStrings) {
-            if (result.includes(stopString)) {
-                result = result.substring(0, result.indexOf(stopString));
-            }
-        }
-        return result;
-    }
-
-    const DEFAULT_SEARCH_COUNT = 20;
-    /**
-     * Search operators.
-     * These operators represent "modifiers" and "prefixes" in FHIR search.
-     * See: https://www.hl7.org/fhir/search.html
-     */
-    exports.Operator = void 0;
-    (function (Operator) {
-        Operator["EQUALS"] = "eq";
-        Operator["NOT_EQUALS"] = "ne";
-        // Numbers
-        Operator["GREATER_THAN"] = "gt";
-        Operator["LESS_THAN"] = "lt";
-        Operator["GREATER_THAN_OR_EQUALS"] = "ge";
-        Operator["LESS_THAN_OR_EQUALS"] = "le";
-        // Dates
-        Operator["STARTS_AFTER"] = "sa";
-        Operator["ENDS_BEFORE"] = "eb";
-        Operator["APPROXIMATELY"] = "ap";
-        // String
-        Operator["CONTAINS"] = "contains";
-        Operator["EXACT"] = "exact";
-        // Token
-        Operator["TEXT"] = "text";
-        Operator["NOT"] = "not";
-        Operator["ABOVE"] = "above";
-        Operator["BELOW"] = "below";
-        Operator["IN"] = "in";
-        Operator["NOT_IN"] = "not-in";
-        Operator["OF_TYPE"] = "of-type";
-        // All
-        Operator["MISSING"] = "missing";
-        // Reference
-        Operator["IDENTIFIER"] = "identifier";
-        // _include and _revinclude
-        Operator["ITERATE"] = "iterate";
-    })(exports.Operator || (exports.Operator = {}));
-    /**
-     * Parameter names may specify a modifier as a suffix.
-     * The modifiers are separated from the parameter name by a colon.
-     * See: https://www.hl7.org/fhir/search.html#modifiers
-     */
-    const MODIFIER_OPERATORS = {
-        contains: exports.Operator.CONTAINS,
-        exact: exports.Operator.EXACT,
-        above: exports.Operator.ABOVE,
-        below: exports.Operator.BELOW,
-        text: exports.Operator.TEXT,
-        not: exports.Operator.NOT,
-        in: exports.Operator.IN,
-        'not-in': exports.Operator.NOT_IN,
-        'of-type': exports.Operator.OF_TYPE,
-        missing: exports.Operator.MISSING,
-        identifier: exports.Operator.IDENTIFIER,
-        iterate: exports.Operator.ITERATE,
-    };
-    /**
-     * For the ordered parameter types of number, date, and quantity,
-     * a prefix to the parameter value may be used to control the nature
-     * of the matching.
-     * See: https://www.hl7.org/fhir/search.html#prefix
-     */
-    const PREFIX_OPERATORS = {
-        eq: exports.Operator.EQUALS,
-        ne: exports.Operator.NOT_EQUALS,
-        lt: exports.Operator.LESS_THAN,
-        le: exports.Operator.LESS_THAN_OR_EQUALS,
-        gt: exports.Operator.GREATER_THAN,
-        ge: exports.Operator.GREATER_THAN_OR_EQUALS,
-        sa: exports.Operator.STARTS_AFTER,
-        eb: exports.Operator.ENDS_BEFORE,
-        ap: exports.Operator.APPROXIMATELY,
-    };
-    /**
-     * Parses a search URL into a search request.
-     * @param resourceType The FHIR resource type.
-     * @param query The collection of query string parameters.
-     * @returns A parsed SearchRequest.
-     */
-    function parseSearchRequest(resourceType, query) {
-        const queryArray = [];
-        for (const [key, value] of Object.entries(query)) {
-            if (Array.isArray(value)) {
-                for (let i = 0; i < value.length; i++) {
-                    queryArray.push([key, value[i]]);
-                }
-            }
-            else {
-                queryArray.push([key, value || '']);
-            }
-        }
-        return parseSearchImpl(resourceType, queryArray);
-    }
-    /**
-     * Parses a search URL into a search request.
-     * @param url The search URL.
-     * @returns A parsed SearchRequest.
-     */
-    function parseSearchUrl(url) {
-        const resourceType = url.pathname.split('/').filter(Boolean).pop();
-        return parseSearchImpl(resourceType, url.searchParams.entries());
-    }
-    /**
-     * Parses a URL string into a SearchRequest.
-     * @param url The URL to parse.
-     * @returns Parsed search definition.
-     */
-    function parseSearchDefinition(url) {
-        return parseSearchUrl(new URL(url, 'https://example.com/'));
-    }
-    function parseSearchImpl(resourceType, query) {
-        const searchRequest = {
-            resourceType,
-        };
-        for (const [key, value] of query) {
-            parseKeyValue(searchRequest, key, value);
-        }
-        return searchRequest;
-    }
-    function parseKeyValue(searchRequest, key, value) {
-        let code;
-        let modifier;
-        const colonIndex = key.indexOf(':');
-        if (colonIndex >= 0) {
-            code = key.substring(0, colonIndex);
-            modifier = key.substring(colonIndex + 1);
-        }
-        else {
-            code = key;
-            modifier = '';
-        }
-        switch (code) {
-            case '_sort':
-                parseSortRule(searchRequest, value);
-                break;
-            case '_count':
-                searchRequest.count = parseInt(value);
-                break;
-            case '_offset':
-                searchRequest.offset = parseInt(value);
-                break;
-            case '_total':
-                searchRequest.total = value;
-                break;
-            case '_summary':
-                searchRequest.total = 'estimate';
-                searchRequest.count = 0;
-                break;
-            case '_include': {
-                const target = parseIncludeTarget(value);
-                if (modifier === 'iterate') {
-                    target.modifier = exports.Operator.ITERATE;
-                }
-                if (searchRequest.include) {
-                    searchRequest.include.push(target);
-                }
-                else {
-                    searchRequest.include = [target];
-                }
-                break;
+        let baseType = resourceType;
+        let elementDefinition = undefined;
+        let propertyType = undefined;
+        let array = false;
+        for (let i = 1; i < expression.length; i++) {
+            let propertyName = expression[i];
+            let hasArrayIndex = false;
+            const arrayIndexMatch = /\[\d+\]$/.exec(propertyName);
+            if (arrayIndexMatch) {
+                propertyName = propertyName.substring(0, propertyName.length - arrayIndexMatch[0].length);
+                hasArrayIndex = true;
             }
-            case '_revinclude': {
-                const target = parseIncludeTarget(value);
-                if (modifier === 'iterate') {
-                    target.modifier = exports.Operator.ITERATE;
-                }
-                if (searchRequest.revInclude) {
-                    searchRequest.revInclude.push(target);
-                }
-                else {
-                    searchRequest.revInclude = [target];
-                }
-                break;
+            elementDefinition = getElementDefinition(baseType, propertyName);
+            if (!elementDefinition) {
+                throw new Error(`Element definition not found for ${resourceType} ${searchParam.code}`);
             }
-            case '_fields':
-                searchRequest.fields = value.split(',');
-                break;
-            default: {
-                const param = globalSchema.types[searchRequest.resourceType]?.searchParams?.[code];
-                if (param) {
-                    parseParameter(searchRequest, param, modifier, value);
+            if (elementDefinition.max !== '0' && elementDefinition.max !== '1' && !hasArrayIndex) {
+                array = true;
+            }
+            // "code" is only missing when using "contentReference"
+            // "contentReference" is handled above in "getElementDefinition"
+            propertyType = elementDefinition.type?.[0].code;
+            if (i < expression.length - 1) {
+                if (isBackboneElement(propertyType)) {
+                    baseType = buildTypeName(elementDefinition.path?.split('.'));
                 }
                 else {
-                    parseUnknownParameter(searchRequest, code, modifier, value);
+                    baseType = propertyType;
                 }
             }
         }
+        const type = getSearchParameterType(searchParam, propertyType);
+        const result = { columnName, type, elementDefinition, array };
+        setSearchParamterDetails(resourceType, code, result);
+        return result;
     }
-    function parseSortRule(searchRequest, value) {
-        for (const field of value.split(',')) {
-            let code;
-            let descending = false;
-            if (field.startsWith('-')) {
-                code = field.substring(1);
-                descending = true;
-            }
-            else {
-                code = field;
-            }
-            if (!searchRequest.sortRules) {
-                searchRequest.sortRules = [];
-            }
-            searchRequest.sortRules.push({ code, descending });
-        }
+    function isBackboneElement(propertyType) {
+        return propertyType === 'Element' || propertyType === 'BackboneElement';
     }
-    function parseParameter(searchRequest, searchParam, modifier, value) {
-        if (modifier === 'missing') {
-            addFilter(searchRequest, {
-                code: searchParam.code,
-                operator: exports.Operator.MISSING,
-                value,
-            });
-            return;
-        }
+    /**
+     * Converts a hyphen-delimited code to camelCase string.
+     * @param code The search parameter code.
+     * @returns The SQL column name.
+     */
+    function convertCodeToColumnName(code) {
+        return code.split('-').reduce((result, word, index) => result + (index ? capitalize(word) : word), '');
+    }
+    function getSearchParameterType(searchParam, propertyType) {
+        let type = exports.SearchParameterType.TEXT;
         switch (searchParam.type) {
-            case 'number':
             case 'date':
-                parsePrefixType(searchRequest, searchParam, value);
+                if (propertyType === exports.PropertyType.date) {
+                    type = exports.SearchParameterType.DATE;
+                }
+                else {
+                    type = exports.SearchParameterType.DATETIME;
+                }
                 break;
-            case 'reference':
-            case 'string':
-            case 'token':
-            case 'uri':
-                parseModifierType(searchRequest, searchParam, modifier, value);
+            case 'number':
+                type = exports.SearchParameterType.NUMBER;
                 break;
             case 'quantity':
-                parseQuantity(searchRequest, searchParam, value);
+                type = exports.SearchParameterType.QUANTITY;
                 break;
-        }
-    }
-    function parsePrefixType(searchRequest, param, input) {
-        const { operator, value } = parsePrefix(input);
-        addFilter(searchRequest, {
-            code: param.code,
-            operator,
-            value,
-        });
-    }
-    function parseModifierType(searchRequest, param, modifier, value) {
-        addFilter(searchRequest, {
-            code: param.code,
-            operator: parseModifier(modifier),
-            value,
-        });
-    }
-    function parseQuantity(searchRequest, param, input) {
-        const [prefixNumber, unitSystem, unitCode] = input.split('|');
-        const { operator, value } = parsePrefix(prefixNumber);
-        addFilter(searchRequest, {
-            code: param.code,
-            operator,
-            value,
-            unitSystem,
-            unitCode,
-        });
-    }
-    function parseUnknownParameter(searchRequest, code, modifier, value) {
-        let operator = exports.Operator.EQUALS;
-        if (modifier) {
-            operator = modifier;
-        }
-        else if (value.length >= 2) {
-            const prefix = value.substring(0, 2);
-            if (prefix in PREFIX_OPERATORS) {
-                if (value.length === 2 || value.at(2)?.match(/\d/)) {
-                    operator = prefix;
-                    value = value.substring(prefix.length);
+            case 'reference':
+                if (propertyType === exports.PropertyType.canonical) {
+                    type = exports.SearchParameterType.CANONICAL;
                 }
-            }
-        }
-        addFilter(searchRequest, {
-            code,
-            operator,
-            value,
-        });
-    }
-    function parsePrefix(input) {
-        const prefix = input.substring(0, 2);
-        const prefixOperator = PREFIX_OPERATORS[prefix];
-        if (prefixOperator) {
-            return { operator: prefixOperator, value: input.substring(2) };
+                else {
+                    type = exports.SearchParameterType.REFERENCE;
+                }
+                break;
+            case 'token':
+                if (propertyType === 'boolean') {
+                    type = exports.SearchParameterType.BOOLEAN;
+                }
+                break;
         }
-        return { operator: exports.Operator.EQUALS, value: input };
-    }
-    function parseModifier(modifier) {
-        return MODIFIER_OPERATORS[modifier] || exports.Operator.EQUALS;
+        return type;
     }
-    function parseIncludeTarget(input) {
-        const parts = input.split(':');
-        parts.forEach((p) => {
-            if (p === '*') {
-                throw new OperationOutcomeError(badRequest(`'*' is not supported as a value for search inclusion parameters`));
+    function getExpressionForResourceType(resourceType, expression) {
+        const expressions = expression.split(' | ');
+        for (const e of expressions) {
+            if (isIgnoredExpression(e)) {
+                continue;
+            }
+            const simplified = simplifyExpression(e);
+            if (simplified.startsWith(resourceType + '.')) {
+                return simplified;
             }
-        });
-        if (parts.length === 1) {
-            // Full wildcard, not currently supported
-            throw new OperationOutcomeError(badRequest(`Invalid include value '${input}': must be of the form ResourceType:search-parameter`));
-        }
-        else if (parts.length === 2) {
-            return {
-                resourceType: parts[0],
-                searchParam: parts[1],
-            };
-        }
-        else if (parts.length === 3) {
-            return {
-                resourceType: parts[0],
-                searchParam: parts[1],
-                targetType: parts[2],
-            };
-        }
-        else {
-            throw new OperationOutcomeError(badRequest(`Invalid include value '${input}'`));
         }
+        return undefined;
     }
-    function addFilter(searchRequest, filter) {
-        if (searchRequest.filters) {
-            searchRequest.filters.push(filter);
-        }
-        else {
-            searchRequest.filters = [filter];
-        }
+    function isIgnoredExpression(input) {
+        return input.includes(' as Period') || input.includes(' as SampledDate');
     }
-    /**
-     * Formats a search definition object into a query string.
-     * Note: The return value does not include the resource type.
-     * @param {!SearchRequest} definition The search definition.
-     * @returns Formatted URL.
-     */
-    function formatSearchQuery(definition) {
-        const params = [];
-        if (definition.fields) {
-            params.push('_fields=' + definition.fields.join(','));
-        }
-        if (definition.filters) {
-            definition.filters.forEach((filter) => params.push(formatFilter(filter)));
-        }
-        if (definition.sortRules && definition.sortRules.length > 0) {
-            params.push(formatSortRules(definition.sortRules));
-        }
-        if (definition.offset !== undefined) {
-            params.push('_offset=' + definition.offset);
-        }
-        if (definition.count !== undefined) {
-            params.push('_count=' + definition.count);
-        }
-        if (definition.total !== undefined) {
-            params.push('_total=' + definition.total);
+    function simplifyExpression(input) {
+        let result = input.trim();
+        if (result.startsWith('(') && result.endsWith(')')) {
+            result = result.substring(1, result.length - 1);
         }
-        if (params.length === 0) {
-            return '';
+        const stopStrings = [' != ', ' as ', '.as(', '.exists(', '.resolve(', '.where('];
+        for (const stopString of stopStrings) {
+            if (result.includes(stopString)) {
+                result = result.substring(0, result.indexOf(stopString));
+            }
         }
-        params.sort();
-        return '?' + params.join('&');
-    }
-    function formatFilter(filter) {
-        const modifier = filter.operator in MODIFIER_OPERATORS ? ':' + filter.operator : '';
-        const prefix = filter.operator !== exports.Operator.EQUALS && filter.operator in PREFIX_OPERATORS ? filter.operator : '';
-        return `${filter.code}${modifier}=${prefix}${encodeURIComponent(filter.value)}`;
-    }
-    function formatSortRules(sortRules) {
-        return '_sort=' + sortRules.map((sr) => (sr.descending ? '-' + sr.code : sr.code)).join(',');
+        return result;
     }
 
     /**
@@ -12779,6 +12900,29 @@
         return operator === exports.Operator.NOT_EQUALS || operator === exports.Operator.NOT;
     }
 
+    /**
+     * Reads data from a Readable stream and returns a Promise that resolves with a Buffer containing all the data.
+     * @param stream - The Readable stream to read from.
+     * @returns A Promise that resolves with a Buffer containing all the data from the Readable stream.
+     */
+    function streamToBuffer(stream) {
+        const chunks = [];
+        return new Promise((resolve, reject) => {
+            stream.on('data', (chunk) => chunks.push(Buffer.from(chunk)));
+            stream.on('error', (err) => {
+                console.error(err.message);
+                stream.destroy();
+                reject(err);
+            });
+            stream.on('end', () => {
+                resolve(Buffer.concat(chunks));
+            });
+            stream.on('close', () => {
+                stream.destroy();
+            });
+        });
+    }
+
     exports.AndAtom = AndAtom;
     exports.ArithemticOperatorAtom = ArithemticOperatorAtom;
     exports.AsAtom = AsAtom;
@@ -12852,6 +12996,7 @@
     exports.fhirPathNot = fhirPathNot;
     exports.findObservationInterval = findObservationInterval;
     exports.findObservationReferenceRange = findObservationReferenceRange;
+    exports.findResourceByCode = findResourceByCode;
     exports.forbidden = forbidden;
     exports.formatAddress = formatAddress;
     exports.formatCodeableConcept = formatCodeableConcept;
@@ -12922,6 +13067,7 @@
     exports.operationOutcomeToString = operationOutcomeToString;
     exports.parseFhirPath = parseFhirPath;
     exports.parseFilterParameter = parseFilterParameter;
+    exports.parseHl7Date = parseHl7Date;
     exports.parseJWTPayload = parseJWTPayload;
     exports.parseMappingLanguage = parseMappingLanguage;
     exports.parseSearchDefinition = parseSearchDefinition;
@@ -12936,6 +13082,7 @@
     exports.removeDuplicates = removeDuplicates;
     exports.resolveId = resolveId;
     exports.setCodeBySystem = setCodeBySystem;
+    exports.streamToBuffer = streamToBuffer;
     exports.stringify = stringify;
     exports.toJsBoolean = toJsBoolean;
     exports.toTypedValue = toTypedValue;