@medplum/core 2.0.4 → 2.0.6

package/dist/cjs/index.cjs

@@ -1301,6 +1301,20 @@
             ],
         };
     }
+    function validationError(details) {
+        return {
+            resourceType: 'OperationOutcome',
+            issue: [
+                {
+                    severity: 'error',
+                    code: 'structure',
+                    details: {
+                        text: details,
+                    },
+                },
+            ],
+        };
+    }
     function isOperationOutcome(value) {
         return typeof value === 'object' && value !== null && value.resourceType === 'OperationOutcome';
     }
@@ -1353,10 +1367,25 @@
         }
     }
     class OperationOutcomeError extends Error {
-        constructor(outcome) {
+        constructor(outcome, cause) {
             super(outcome?.issue?.[0].details?.text);
             this.outcome = outcome;
+            this.cause = cause;
+        }
+    }
+    /**
+     * Normalizes an error object into an OperationOutcome.
+     * @param error The error value which could be a string, Error, OperationOutcome, or other unknown type.
+     * @returns The normalized OperationOutcome.
+     */
+    function normalizeOperationOutcome(error) {
+        if (error instanceof OperationOutcomeError) {
+            return error.outcome;
         }
+        if (isOperationOutcome(error)) {
+            return error;
+        }
+        return badRequest(normalizeErrorString(error));
     }
     /**
      * Normalizes an error object into a displayable error string.
@@ -6051,7 +6080,7 @@
             // First pass, build types
             elements.forEach((element) => indexType(structureDefinition, element));
             // Second pass, build properties
-            elements.forEach((element) => indexProperty(element));
+            elements.forEach((element) => indexProperty(structureDefinition, element));
         }
     }
     /**
@@ -6069,6 +6098,9 @@
             return;
         }
         const parts = path.split('.');
+        // Force the first part to be the type name
+        // This is necessary for "SimpleQuantity" and "MoneyQuantity"
+        parts[0] = structureDefinition.name;
         const typeName = buildTypeName(parts);
         let typeSchema = globalSchema.types[typeName];
         if (!typeSchema) {
@@ -6086,12 +6118,15 @@
      * @param element The input ElementDefinition.
      * @see {@link IndexedStructureDefinition} for more details on indexed StructureDefinitions.
      */
-    function indexProperty(element) {
+    function indexProperty(structureDefinition, element) {
         const path = element.path;
         const parts = path.split('.');
         if (parts.length === 1) {
             return;
         }
+        // Force the first part to be the type name
+        // This is necessary for "SimpleQuantity" and "MoneyQuantity"
+        parts[0] = structureDefinition.name;
         const typeName = buildTypeName(parts.slice(0, parts.length - 1));
         const typeSchema = globalSchema.types[typeName];
         if (!typeSchema) {
@@ -6195,12 +6230,16 @@
         return components.map(capitalize).join('');
     }
     /**
-     * Returns true if the type schema is a DomainResource.
+     * Returns true if the type schema is a non-abstract FHIR resource.
      * @param typeSchema The type schema to check.
-     * @returns True if the type schema is a DomainResource.
+     * @returns True if the type schema is a non-abstract FHIR resource.
      */
-    function isResourceType(typeSchema) {
-        return typeSchema.structureDefinition?.baseDefinition === 'http://hl7.org/fhir/StructureDefinition/DomainResource';
+    function isResourceTypeSchema(typeSchema) {
+        const structureDefinition = typeSchema.structureDefinition;
+        return (structureDefinition &&
+            structureDefinition.name === typeSchema.elementDefinition?.path &&
+            structureDefinition.kind === 'resource' &&
+            !structureDefinition.abstract);
     }
     /**
      * Returns an array of all resource types.
@@ -6210,7 +6249,7 @@
     function getResourceTypes() {
         const result = [];
         for (const [resourceType, typeSchema] of Object.entries(globalSchema.types)) {
-            if (isResourceType(typeSchema)) {
+            if (isResourceTypeSchema(typeSchema)) {
                 result.push(resourceType);
             }
         }
@@ -6289,6 +6328,22 @@
         }
         return property;
     }
+    /**
+     * Typeguard to validate that an object is a FHIR resource
+     * @param value The object to check
+     * @returns True if the input is of type 'object' and contains property 'resourceType'
+     */
+    function isResource(value) {
+        return !!(value && typeof value === 'object' && 'resourceType' in value);
+    }
+    /**
+     * Typeguard to validate that an object is a FHIR resource
+     * @param value The object to check
+     * @returns True if the input is of type 'object' and contains property 'reference'
+     */
+    function isReference(value) {
+        return !!(value && typeof value === 'object' && 'reference' in value);
+    }
     /**
      * Global schema singleton.
      */
@@ -6297,7 +6352,7 @@
     // PKCE auth based on:
     // https://aws.amazon.com/blogs/security/how-to-add-authentication-single-page-web-application-with-amazon-cognito-oauth2-implementation/
     var _MedplumClient_instances, _MedplumClient_fetch, _MedplumClient_createPdf, _MedplumClient_storage, _MedplumClient_requestCache, _MedplumClient_cacheTime, _MedplumClient_baseUrl, _MedplumClient_fhirBaseUrl, _MedplumClient_authorizeUrl, _MedplumClient_tokenUrl, _MedplumClient_logoutUrl, _MedplumClient_onUnauthenticated, _MedplumClient_autoBatchTime, _MedplumClient_autoBatchQueue, _MedplumClient_clientId, _MedplumClient_clientSecret, _MedplumClient_autoBatchTimerId, _MedplumClient_accessToken, _MedplumClient_refreshToken, _MedplumClient_refreshPromise, _MedplumClient_profilePromise, _MedplumClient_profile, _MedplumClient_config, _MedplumClient_addLogin, _MedplumClient_refreshProfile, _MedplumClient_getCacheEntry, _MedplumClient_setCacheEntry, _MedplumClient_cacheResource, _MedplumClient_deleteCacheEntry, _MedplumClient_request, _MedplumClient_fetchWithRetry, _MedplumClient_executeAutoBatch, _MedplumClient_addFetchOptionsDefaults, _MedplumClient_setRequestContentType, _MedplumClient_setRequestBody, _MedplumClient_handleUnauthenticated, _MedplumClient_requestAuthorization, _MedplumClient_refresh, _MedplumClient_fetchTokens, _MedplumClient_verifyTokens, _MedplumClient_setupStorageListener;
-    const MEDPLUM_VERSION = "2.0.4-c4747b4e";
+    const MEDPLUM_VERSION = "2.0.6-c4b403f5";
     const DEFAULT_BASE_URL = 'https://api.medplum.com/';
     const DEFAULT_RESOURCE_CACHE_SIZE = 1000;
     const DEFAULT_CACHE_TIME = 60000; // 60 seconds
@@ -6754,13 +6809,14 @@
          * Builds a FHIR search URL from a search query or structured query object.
          * @category HTTP
          * @category Search
-         * @param query The FHIR search query or structured query object.
+         * @param resourceType The FHIR resource type.
+         * @param query The FHIR search query or structured query object. Can be any valid input to the URLSearchParams() constructor.
          * @returns The well-formed FHIR URL.
          */
         fhirSearchUrl(resourceType, query) {
             const url = this.fhirUrl(resourceType);
             if (query) {
-                url.search = query.toString();
+                url.search = new URLSearchParams(query).toString();
             }
             return url;
         }
@@ -6808,7 +6864,7 @@
          *
          * @category Search
          * @param resourceType The FHIR resource type.
-         * @param query The search query as either a string or a structured search object.
+         * @param query Optional FHIR search query or structured query object. Can be any valid input to the URLSearchParams() constructor.
          * @param options Optional fetch options.
          * @returns Promise to the search result bundle.
          */
@@ -6849,7 +6905,7 @@
          *
          * @category Search
          * @param resourceType The FHIR resource type.
-         * @param query The search query as either a string or a structured search object.
+         * @param query Optional FHIR search query or structured query object. Can be any valid input to the URLSearchParams() constructor.
          * @param options Optional fetch options.
          * @returns Promise to the search result bundle.
          */
@@ -6884,7 +6940,7 @@
          *
          * @category Search
          * @param resourceType The FHIR resource type.
-         * @param query The search query as either a string or a structured search object.
+         * @param query Optional FHIR search query or structured query object. Can be any valid input to the URLSearchParams() constructor.
          * @param options Optional fetch options.
          * @returns Promise to the search result bundle.
          */
@@ -7812,7 +7868,7 @@
             throw err;
         }
         if (response.status >= 400) {
-            throw obj;
+            throw new OperationOutcomeError(normalizeOperationOutcome(obj));
         }
         return obj;
     }, _MedplumClient_fetchWithRetry = async function _MedplumClient_fetchWithRetry(url, options) {
@@ -7863,7 +7919,7 @@
             const entry = entries[i];
             const responseEntry = response.entry?.[i];
             if (responseEntry?.response?.outcome && !isOk(responseEntry.response.outcome)) {
-                entry.reject(responseEntry.response.outcome);
+                entry.reject(new OperationOutcomeError(responseEntry.response.outcome));
             }
             else {
                 entry.resolve(responseEntry?.resource);
@@ -8007,14 +8063,6 @@
             // Silently ignore if this environment does not support storage events
         }
     };
-    /**
-     * Returns the current window if available.
-     * All access to the current window should use this to support SSR such as Next.js.
-     * @returns The current window or undefined if not available.
-     */
-    function getWindow() {
-        return typeof window === 'undefined' ? undefined : window;
-    }
     /**
      * Returns the default fetch method.
      * The default fetch is currently only available in browser environments.
@@ -8022,19 +8070,20 @@
      * @returns The default fetch function for the current environment.
      */
     function getDefaultFetch() {
-        const window = getWindow();
-        if (!window) {
+        if (!globalThis.fetch) {
             throw new Error('Fetch not available in this environment');
         }
-        return window.fetch.bind(window);
+        return globalThis.fetch.bind(globalThis);
     }
     /**
      * Returns the base URL for the current page.
      * @category HTTP
      */
     function getWindowOrigin() {
-        const window = getWindow();
-        return window ? window.location.protocol + '//' + window.location.host + '/' : '';
+        if (typeof window === 'undefined') {
+            return '';
+        }
+        return window.location.protocol + '//' + window.location.host + '/';
     }
     function ensureTrailingSlash(url) {
         if (!url) {
@@ -8169,7 +8218,7 @@
     }
     _Parser_tokens = new WeakMap(), _Parser_prefixParselets = new WeakMap(), _Parser_infixParselets = new WeakMap();
 
-    var _Tokenizer_instances, _Tokenizer_str, _Tokenizer_keywords, _Tokenizer_operators, _Tokenizer_result, _Tokenizer_pos, _Tokenizer_markStack, _Tokenizer_prevToken, _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, _Tokenizer_mark, _Tokenizer_reset, _Tokenizer_advance, _Tokenizer_buildToken;
+    var _Tokenizer_instances, _Tokenizer_str, _Tokenizer_keywords, _Tokenizer_operators, _Tokenizer_dateTimeLiterals, _Tokenizer_symbolRegex, _Tokenizer_result, _Tokenizer_pos, _Tokenizer_markStack, _Tokenizer_prevToken, _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, _Tokenizer_mark, _Tokenizer_reset, _Tokenizer_advance, _Tokenizer_buildToken;
     const STANDARD_UNITS = [
         'year',
         'years',
@@ -8189,17 +8238,21 @@
         'milliseconds',
     ];
     class Tokenizer {
-        constructor(str, keywords, operators) {
+        constructor(str, keywords, operators, options) {
             _Tokenizer_instances.add(this);
             _Tokenizer_str.set(this, void 0);
             _Tokenizer_keywords.set(this, void 0);
             _Tokenizer_operators.set(this, void 0);
+            _Tokenizer_dateTimeLiterals.set(this, void 0);
+            _Tokenizer_symbolRegex.set(this, void 0);
             _Tokenizer_result.set(this, []);
             _Tokenizer_pos.set(this, { index: 0, line: 1, column: 0 });
             _Tokenizer_markStack.set(this, []);
             __classPrivateFieldSet(this, _Tokenizer_str, str, "f");
             __classPrivateFieldSet(this, _Tokenizer_keywords, keywords, "f");
             __classPrivateFieldSet(this, _Tokenizer_operators, operators, "f");
+            __classPrivateFieldSet(this, _Tokenizer_dateTimeLiterals, !!options?.dateTimeLiterals, "f");
+            __classPrivateFieldSet(this, _Tokenizer_symbolRegex, options?.symbolRegex ?? /[$\w]/, "f");
         }
         tokenize() {
             while (__classPrivateFieldGet(this, _Tokenizer_pos, "f").index < __classPrivateFieldGet(this, _Tokenizer_str, "f").length) {
@@ -8211,7 +8264,7 @@
             return __classPrivateFieldGet(this, _Tokenizer_result, "f");
         }
     }
-    _Tokenizer_str = new WeakMap(), _Tokenizer_keywords = new WeakMap(), _Tokenizer_operators = new WeakMap(), _Tokenizer_result = new WeakMap(), _Tokenizer_pos = new WeakMap(), _Tokenizer_markStack = new WeakMap(), _Tokenizer_instances = new WeakSet(), _Tokenizer_prevToken = function _Tokenizer_prevToken() {
+    _Tokenizer_str = new WeakMap(), _Tokenizer_keywords = new WeakMap(), _Tokenizer_operators = new WeakMap(), _Tokenizer_dateTimeLiterals = new WeakMap(), _Tokenizer_symbolRegex = new WeakMap(), _Tokenizer_result = new WeakMap(), _Tokenizer_pos = new WeakMap(), _Tokenizer_markStack = new WeakMap(), _Tokenizer_instances = new WeakSet(), _Tokenizer_prevToken = function _Tokenizer_prevToken() {
         return __classPrivateFieldGet(this, _Tokenizer_result, "f").slice(-1)[0];
     }, _Tokenizer_peekToken = function _Tokenizer_peekToken() {
         __classPrivateFieldGet(this, _Tokenizer_instances, "m", _Tokenizer_mark).call(this);
@@ -8299,6 +8352,11 @@
             __classPrivateFieldGet(this, _Tokenizer_instances, "m", _Tokenizer_advance).call(this);
             __classPrivateFieldGet(this, _Tokenizer_instances, "m", _Tokenizer_consumeWhile).call(this, () => __classPrivateFieldGet(this, _Tokenizer_instances, "m", _Tokenizer_curr).call(this).match(/\d/));
         }
+        if (__classPrivateFieldGet(this, _Tokenizer_instances, "m", _Tokenizer_curr).call(this) === '-' && __classPrivateFieldGet(this, _Tokenizer_dateTimeLiterals, "f")) {
+            // Rewind to one character before the start, and then treat as dateTime literal.
+            __classPrivateFieldGet(this, _Tokenizer_pos, "f").index = start - 1;
+            return __classPrivateFieldGet(this, _Tokenizer_instances, "m", _Tokenizer_consumeDateTime).call(this);
+        }
         if (__classPrivateFieldGet(this, _Tokenizer_instances, "m", _Tokenizer_curr).call(this) === ' ') {
             if (isUnitToken(__classPrivateFieldGet(this, _Tokenizer_instances, "m", _Tokenizer_peekToken).call(this))) {
                 id = 'Quantity';
@@ -8307,7 +8365,7 @@
         }
         return __classPrivateFieldGet(this, _Tokenizer_instances, "m", _Tokenizer_buildToken).call(this, id, __classPrivateFieldGet(this, _Tokenizer_str, "f").substring(start, __classPrivateFieldGet(this, _Tokenizer_pos, "f").index));
     }, _Tokenizer_consumeSymbol = function _Tokenizer_consumeSymbol() {
-        const value = __classPrivateFieldGet(this, _Tokenizer_instances, "m", _Tokenizer_consumeWhile).call(this, () => __classPrivateFieldGet(this, _Tokenizer_instances, "m", _Tokenizer_curr).call(this).match(/[$\w]/));
+        const value = __classPrivateFieldGet(this, _Tokenizer_instances, "m", _Tokenizer_consumeWhile).call(this, () => __classPrivateFieldGet(this, _Tokenizer_instances, "m", _Tokenizer_curr).call(this).match(__classPrivateFieldGet(this, _Tokenizer_symbolRegex, "f")));
         if (__classPrivateFieldGet(this, _Tokenizer_instances, "m", _Tokenizer_prevToken).call(this)?.value !== '.' && __classPrivateFieldGet(this, _Tokenizer_keywords, "f").includes(value)) {
             return __classPrivateFieldGet(this, _Tokenizer_instances, "m", _Tokenizer_buildToken).call(this, value, value);
         }
@@ -8431,7 +8489,7 @@
         else if (isQuantity(value)) {
             return { type: exports.PropertyType.Quantity, value };
         }
-        else if (typeof value === 'object' && 'resourceType' in value) {
+        else if (isResource(value)) {
             return { type: value.resourceType, value };
         }
         else {
@@ -8513,7 +8571,7 @@
         }
     }
     function toTypedValueWithType(value, type) {
-        if (type === 'Resource' && typeof value === 'object' && 'resourceType' in value) {
+        if (type === 'Resource' && isResource(value)) {
             type = value.resourceType;
         }
         return { type, value };
@@ -8540,7 +8598,7 @@
             // Examples:
             // value + valueString = ok, because "string" is valid
             // value + valueDecimal = ok, because "decimal" is valid
-            // id + identifiier = not ok, because "entifier" is not a valid type
+            // id + identifier = not ok, because "entifier" is not a valid type
             // resource + resourceType = not ok, because "type" is not a valid type
             for (const propertyType in exports.PropertyType) {
                 const propertyName = path + capitalize(propertyType);
@@ -10195,7 +10253,7 @@
                 if (typeof value === 'number') {
                     return { type: exports.PropertyType.BackboneElement, value: { namespace: 'System', name: 'Integer' } };
                 }
-                if (value && typeof value === 'object' && 'resourceType' in value) {
+                if (isResource(value)) {
                     return {
                         type: exports.PropertyType.BackboneElement,
                         value: { namespace: 'FHIR', name: value.resourceType },
@@ -10324,7 +10382,7 @@
         if (!input || typeof input !== 'object') {
             return undefined;
         }
-        if ('resourceType' in input && input.resourceType === this.name) {
+        if (isResource(input) && input.resourceType === this.name) {
             return typedValue;
         }
         return getTypedPropertyValue(typedValue, this.name);
@@ -10603,7 +10661,7 @@
 
     const FHIRPATH_KEYWORDS = ['true', 'false'];
     const FHIRPATH_OPERATORS = ['!=', '!~', '<=', '>=', '{}', '->'];
-    function tokenize(str) {
+    function tokenize$2(str) {
         return new Tokenizer(str, FHIRPATH_KEYWORDS, FHIRPATH_OPERATORS).tokenize();
     }
 
@@ -10700,7 +10758,7 @@
             .infixLeft('or', 6 /* OperatorPrecedence.Is */, (left, _, right) => new OrAtom(left, right))
             .infixLeft('xor', 6 /* OperatorPrecedence.Is */, (left, _, right) => new XorAtom(left, right));
     }
-    const fhirPathParserBuilder = initFhirPathParserBuilder();
+    const fhirPathParserBuilder$2 = initFhirPathParserBuilder();
     /**
      * Parses a FHIRPath expression into an AST.
      * The result can be used to evaluate the expression against a resource or other object.
@@ -10710,7 +10768,7 @@
      * @returns The AST representing the expression.
      */
     function parseFhirPath(input) {
-        return new FhirPathAtom(input, fhirPathParserBuilder.construct(tokenize(input)).consumeAndParse());
+        return new FhirPathAtom(input, fhirPathParserBuilder$2.construct(tokenize$2(input)).consumeAndParse());
     }
     /**
      * Evaluates a FHIRPath expression against a resource or other object.
@@ -10740,6 +10798,397 @@
         return parseFhirPath(expression).eval(input);
     }
 
+    const MAPPING_LANGUAGE_OPERATORS$1 = [...FHIRPATH_OPERATORS, '->', '<<', '>>'];
+    function tokenize$1(str) {
+        return new Tokenizer(str, FHIRPATH_KEYWORDS, MAPPING_LANGUAGE_OPERATORS$1).tokenize();
+    }
+
+    var _StructureMapParser_instances, _StructureMapParser_parseUses, _StructureMapParser_parseImport, _StructureMapParser_parseGroup, _StructureMapParser_parseParameters, _StructureMapParser_parseParameter, _StructureMapParser_parseRules, _StructureMapParser_parseRule, _StructureMapParser_parseRuleSources, _StructureMapParser_parseRuleSource, _StructureMapParser_parseRuleTargets, _StructureMapParser_parseRuleTarget, _StructureMapParser_parseRuleTargetTransform, _StructureMapParser_parseRuleTargetSymbol, _StructureMapParser_parseRuleTargetFunction, _StructureMapParser_parseRuleTargetLiteral, _StructureMapParser_parseRuleContext, _StructureMapParser_parseRuleDependents, _StructureMapParser_parseConceptMap;
+    class StructureMapParser {
+        constructor(parser) {
+            this.parser = parser;
+            _StructureMapParser_instances.add(this);
+            this.structureMap = { resourceType: 'StructureMap' };
+        }
+        parse() {
+            // 'map' url '=' identifier
+            // map "http://hl7.org/fhir/StructureMap/tutorial" = tutorial
+            this.parser.consume('Symbol', 'map');
+            this.structureMap.url = this.parser.consume('String').value;
+            this.parser.consume('=');
+            this.structureMap.name = this.parser.consume().value;
+            while (this.parser.hasMore()) {
+                const next = this.parser.peek()?.value;
+                switch (next) {
+                    case 'uses':
+                        __classPrivateFieldGet(this, _StructureMapParser_instances, "m", _StructureMapParser_parseUses).call(this);
+                        break;
+                    case 'imports':
+                        __classPrivateFieldGet(this, _StructureMapParser_instances, "m", _StructureMapParser_parseImport).call(this);
+                        break;
+                    case 'group':
+                        __classPrivateFieldGet(this, _StructureMapParser_instances, "m", _StructureMapParser_parseGroup).call(this);
+                        break;
+                    case 'conceptmap':
+                        __classPrivateFieldGet(this, _StructureMapParser_instances, "m", _StructureMapParser_parseConceptMap).call(this);
+                        break;
+                    default:
+                        throw new Error(`Unexpected token: ${next}`);
+                }
+            }
+            return this.structureMap;
+        }
+    }
+    _StructureMapParser_instances = new WeakSet(), _StructureMapParser_parseUses = function _StructureMapParser_parseUses() {
+        // 'uses' url structureAlias? 'as' modelMode
+        // uses "http://hl7.org/fhir/StructureDefinition/tutorial-left" as source
+        this.parser.consume('Symbol', 'uses');
+        const result = {};
+        result.url = this.parser.consume('String').value;
+        if (this.parser.peek()?.value === 'alias') {
+            this.parser.consume('Symbol', 'alias');
+            result.alias = this.parser.consume('Symbol').value;
+        }
+        this.parser.consume('Symbol', 'as');
+        result.mode = this.parser.consume().value;
+        if (!this.structureMap.structure) {
+            this.structureMap.structure = [];
+        }
+        this.structureMap.structure.push(result);
+    }, _StructureMapParser_parseImport = function _StructureMapParser_parseImport() {
+        this.parser.consume('Symbol', 'imports');
+        if (!this.structureMap.import) {
+            this.structureMap.import = [];
+        }
+        this.structureMap.import.push(this.parser.consume('String').value);
+    }, _StructureMapParser_parseGroup = function _StructureMapParser_parseGroup() {
+        // 'group' identifier parameters extends? typeMode? rules
+        // group tutorial(source src : TLeft, target tgt : TRight) {
+        const result = {};
+        this.parser.consume('Symbol', 'group');
+        result.name = this.parser.consume('Symbol').value;
+        result.input = __classPrivateFieldGet(this, _StructureMapParser_instances, "m", _StructureMapParser_parseParameters).call(this);
+        if (this.parser.peek()?.value === 'extends') {
+            this.parser.consume('Symbol', 'extends');
+            result.extends = this.parser.consume('Symbol').value;
+        }
+        if (this.parser.peek()?.value === '<<') {
+            this.parser.consume('<<');
+            result.typeMode = this.parser.consume().value;
+            if (this.parser.peek()?.value === '+') {
+                this.parser.consume('+');
+                result.typeMode = 'type-and-types';
+            }
+            this.parser.consume('>>');
+        }
+        else {
+            result.typeMode = 'none';
+        }
+        result.rule = __classPrivateFieldGet(this, _StructureMapParser_instances, "m", _StructureMapParser_parseRules).call(this);
+        if (!this.structureMap.group) {
+            this.structureMap.group = [];
+        }
+        this.structureMap.group.push(result);
+    }, _StructureMapParser_parseParameters = function _StructureMapParser_parseParameters() {
+        const parameters = [];
+        this.parser.consume('(');
+        while (this.parser.hasMore() && this.parser.peek()?.value !== ')') {
+            parameters.push(__classPrivateFieldGet(this, _StructureMapParser_instances, "m", _StructureMapParser_parseParameter).call(this));
+            if (this.parser.peek()?.value === ',') {
+                this.parser.consume(',');
+            }
+        }
+        this.parser.consume(')');
+        return parameters;
+    }, _StructureMapParser_parseParameter = function _StructureMapParser_parseParameter() {
+        // inputMode identifier type?
+        // ':' identifier
+        // source src : TLeft
+        const result = {};
+        result.mode = this.parser.consume().value;
+        result.name = this.parser.consume('Symbol').value;
+        if (this.parser.peek()?.value === ':') {
+            this.parser.consume(':');
+            result.type = this.parser.consume('Symbol').value;
+        }
+        return result;
+    }, _StructureMapParser_parseRules = function _StructureMapParser_parseRules() {
+        const rules = [];
+        this.parser.consume('{');
+        while (this.parser.hasMore() && this.parser.peek()?.value !== '}') {
+            rules.push(__classPrivateFieldGet(this, _StructureMapParser_instances, "m", _StructureMapParser_parseRule).call(this));
+        }
+        this.parser.consume('}');
+        return rules;
+    }, _StructureMapParser_parseRule = function _StructureMapParser_parseRule() {
+        const result = {
+            source: __classPrivateFieldGet(this, _StructureMapParser_instances, "m", _StructureMapParser_parseRuleSources).call(this),
+        };
+        if (this.parser.peek()?.value === '->') {
+            this.parser.consume('->');
+            result.target = __classPrivateFieldGet(this, _StructureMapParser_instances, "m", _StructureMapParser_parseRuleTargets).call(this);
+        }
+        if (this.parser.peek()?.value === 'then') {
+            this.parser.consume('Symbol', 'then');
+            if (this.parser.peek()?.id === '{') {
+                result.rule = __classPrivateFieldGet(this, _StructureMapParser_instances, "m", _StructureMapParser_parseRules).call(this);
+            }
+            else {
+                result.dependent = __classPrivateFieldGet(this, _StructureMapParser_instances, "m", _StructureMapParser_parseRuleDependents).call(this);
+            }
+        }
+        if (this.parser.peek()?.id === 'String') {
+            result.name = this.parser.consume().value;
+        }
+        else {
+            result.name = result.source?.[0]?.element;
+        }
+        this.parser.consume(';');
+        return result;
+    }, _StructureMapParser_parseRuleSources = function _StructureMapParser_parseRuleSources() {
+        const sources = [__classPrivateFieldGet(this, _StructureMapParser_instances, "m", _StructureMapParser_parseRuleSource).call(this)];
+        while (this.parser.hasMore() && this.parser.peek()?.value === ',') {
+            this.parser.consume(',');
+            sources.push(__classPrivateFieldGet(this, _StructureMapParser_instances, "m", _StructureMapParser_parseRuleSource).call(this));
+        }
+        return sources;
+    }, _StructureMapParser_parseRuleSource = function _StructureMapParser_parseRuleSource() {
+        const result = {};
+        const context = __classPrivateFieldGet(this, _StructureMapParser_instances, "m", _StructureMapParser_parseRuleContext).call(this);
+        if (context.includes('.')) {
+            const parts = context.split('.');
+            result.context = parts[0];
+            result.element = parts[1];
+        }
+        else {
+            result.context = context;
+        }
+        if (this.parser.hasMore() && this.parser.peek()?.value === ':') {
+            this.parser.consume(':');
+            result.type = this.parser.consume().value;
+        }
+        if (this.parser.hasMore() && this.parser.peek()?.value === 'default') {
+            this.parser.consume('default');
+            this.parser.consumeAndParse();
+        }
+        if (this.parser.peek()?.value === 'first' ||
+            this.parser.peek()?.value === 'not_first' ||
+            this.parser.peek()?.value === 'last' ||
+            this.parser.peek()?.value === 'not_last' ||
+            this.parser.peek()?.value === 'only_one') {
+            result.listMode = this.parser.consume().value;
+        }
+        if (this.parser.peek()?.value === 'as') {
+            this.parser.consume('Symbol', 'as');
+            result.variable = this.parser.consume().value;
+        }
+        if (this.parser.peek()?.value === 'where') {
+            this.parser.consume('Symbol', 'where');
+            const whereFhirPath = this.parser.consumeAndParse(100 /* OperatorPrecedence.Arrow */);
+            result.condition = whereFhirPath.toString();
+        }
+        if (this.parser.peek()?.value === 'check') {
+            this.parser.consume('Symbol', 'check');
+            const checkFhirPath = this.parser.consumeAndParse(100 /* OperatorPrecedence.Arrow */);
+            result.check = checkFhirPath.toString();
+        }
+        return result;
+    }, _StructureMapParser_parseRuleTargets = function _StructureMapParser_parseRuleTargets() {
+        const targets = [__classPrivateFieldGet(this, _StructureMapParser_instances, "m", _StructureMapParser_parseRuleTarget).call(this)];
+        while (this.parser.hasMore() && this.parser.peek()?.value === ',') {
+            this.parser.consume(',');
+            targets.push(__classPrivateFieldGet(this, _StructureMapParser_instances, "m", _StructureMapParser_parseRuleTarget).call(this));
+        }
+        return targets;
+    }, _StructureMapParser_parseRuleTarget = function _StructureMapParser_parseRuleTarget() {
+        const result = {};
+        const context = __classPrivateFieldGet(this, _StructureMapParser_instances, "m", _StructureMapParser_parseRuleContext).call(this);
+        if (context.includes('.')) {
+            const parts = context.split('.');
+            result.contextType = 'variable';
+            result.context = parts[0];
+            result.element = parts[1];
+        }
+        else {
+            result.context = context;
+        }
+        if (this.parser.peek()?.value === '=') {
+            this.parser.consume('=');
+            __classPrivateFieldGet(this, _StructureMapParser_instances, "m", _StructureMapParser_parseRuleTargetTransform).call(this, result);
+        }
+        if (this.parser.peek()?.value === 'as') {
+            this.parser.consume('Symbol', 'as');
+            result.variable = this.parser.consume().value;
+        }
+        if (this.parser.peek()?.value === 'first' ||
+            this.parser.peek()?.value === 'share' ||
+            this.parser.peek()?.value === 'last' ||
+            this.parser.peek()?.value === 'collate') {
+            result.listMode = [this.parser.consume().value];
+        }
+        return result;
+    }, _StructureMapParser_parseRuleTargetTransform = function _StructureMapParser_parseRuleTargetTransform(result) {
+        result.transform = 'copy';
+        const transformFhirPath = this.parser.consumeAndParse(6 /* OperatorPrecedence.As */);
+        if (transformFhirPath instanceof SymbolAtom) {
+            __classPrivateFieldGet(this, _StructureMapParser_instances, "m", _StructureMapParser_parseRuleTargetSymbol).call(this, result, transformFhirPath);
+        }
+        else if (transformFhirPath instanceof FunctionAtom) {
+            __classPrivateFieldGet(this, _StructureMapParser_instances, "m", _StructureMapParser_parseRuleTargetFunction).call(this, result, transformFhirPath);
+        }
+        else if (transformFhirPath instanceof LiteralAtom) {
+            __classPrivateFieldGet(this, _StructureMapParser_instances, "m", _StructureMapParser_parseRuleTargetLiteral).call(this, result, transformFhirPath);
+        }
+        else {
+            throw new Error(`Unexpected FHIRPath: ${transformFhirPath}`);
+        }
+    }, _StructureMapParser_parseRuleTargetSymbol = function _StructureMapParser_parseRuleTargetSymbol(result, literalAtom) {
+        result.parameter = [{ valueId: literalAtom.name }];
+    }, _StructureMapParser_parseRuleTargetFunction = function _StructureMapParser_parseRuleTargetFunction(result, functionAtom) {
+        const functionName = functionAtom.name;
+        switch (functionName) {
+            case 'create':
+                result.parameter = [
+                    {
+                        valueString: (functionAtom.args?.[0]).value.value,
+                    },
+                ];
+                break;
+            case 'translate':
+                result.parameter = [{}];
+                break;
+            default:
+                throw new Error('Unknown target function: ' + functionName);
+        }
+    }, _StructureMapParser_parseRuleTargetLiteral = function _StructureMapParser_parseRuleTargetLiteral(result, literalAtom) {
+        switch (literalAtom.value.type) {
+            case 'boolean':
+                result.parameter = [{ valueBoolean: literalAtom.value.value }];
+                break;
+            case 'decimal':
+                result.parameter = [{ valueDecimal: literalAtom.value.value }];
+                break;
+            case 'string':
+                result.parameter = [{ valueString: literalAtom.value.value }];
+                break;
+            default:
+                throw new Error('Unknown target literal type: ' + literalAtom.value.type);
+        }
+    }, _StructureMapParser_parseRuleContext = function _StructureMapParser_parseRuleContext() {
+        let identifier = this.parser.consume().value;
+        while (this.parser.peek()?.value === '.') {
+            this.parser.consume('.');
+            identifier += '.' + this.parser.consume().value;
+        }
+        return identifier;
+    }, _StructureMapParser_parseRuleDependents = function _StructureMapParser_parseRuleDependents() {
+        const atom = this.parser.consumeAndParse(100 /* OperatorPrecedence.Arrow */);
+        return [
+            {
+                name: atom.name,
+                variable: atom.args.map((arg) => arg.name),
+            },
+        ];
+    }, _StructureMapParser_parseConceptMap = function _StructureMapParser_parseConceptMap() {
+        while (this.parser.peek()?.value !== '}') {
+            this.parser.consume();
+        }
+        this.parser.consume('}');
+    };
+    const fhirPathParserBuilder$1 = initFhirPathParserBuilder()
+        .registerInfix('->', { precedence: 100 /* OperatorPrecedence.Arrow */ })
+        .registerInfix(';', { precedence: 200 /* OperatorPrecedence.Semicolon */ });
+    /**
+     * Parses a FHIR Mapping Language document into an AST.
+     * @param input The FHIR Mapping Language document to parse.
+     * @returns The AST representing the document.
+     */
+    function parseMappingLanguage(input) {
+        const parser = fhirPathParserBuilder$1.construct(tokenize$1(input));
+        parser.removeComments();
+        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
+    /**
+     * 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;
+        }
+    }
+
+    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, 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.
      *
@@ -10956,6 +11405,391 @@
         }
     }
 
+    var _FhirSchemaValidator_instances, _FhirSchemaValidator_issues, _FhirSchemaValidator_root, _FhirSchemaValidator_validateObject, _FhirSchemaValidator_checkProperties, _FhirSchemaValidator_checkProperty, _FhirSchemaValidator_checkPropertyValue, _FhirSchemaValidator_validatePrimitiveType, _FhirSchemaValidator_validateString, _FhirSchemaValidator_validateNumber, _FhirSchemaValidator_checkAdditionalProperties, _FhirSchemaValidator_checkAdditionalProperty, _FhirSchemaValidator_checkPrimitiveElement, _FhirSchemaValidator_createIssue;
+    /*
+     * This file provides schema validation utilities for FHIR JSON objects.
+     *
+     * See: [JSON Representation of Resources](https://hl7.org/fhir/json.html)
+     * See: [FHIR Data Types](https://www.hl7.org/fhir/datatypes.html)
+     */
+    const fhirTypeToJsType = {
+        base64Binary: 'string',
+        boolean: 'boolean',
+        canonical: 'string',
+        code: 'string',
+        date: 'string',
+        dateTime: 'string',
+        decimal: 'number',
+        id: 'string',
+        instant: 'string',
+        integer: 'number',
+        markdown: 'string',
+        oid: 'string',
+        positiveInt: 'number',
+        string: 'string',
+        time: 'string',
+        unsignedInt: 'number',
+        uri: 'string',
+        url: 'string',
+        uuid: 'string',
+        xhtml: 'string',
+        'http://hl7.org/fhirpath/System.String': 'string',
+    };
+    const baseResourceProperties = new Set([
+        // Resource
+        'resourceType',
+        'id',
+        'meta',
+        'implicitRules',
+        'language',
+        // DomainResource
+        'text',
+        'contained',
+        'extension',
+        'modifierExtension',
+    ]);
+    /**
+     * Returns true if the given string is a valid FHIR resource type.
+     *
+     * ```ts
+     * isResourceType('Patient'); // true
+     * isResourceType('XYZ'); // false
+     * ```
+     *
+     * Note that this depends on globalSchema, which is populated by the StructureDefinition loader.
+     *
+     * In a server context, you can load all schema definitions:
+     *
+     * ```ts
+     * import { indexStructureDefinitionBundle } from '@medplum/core';
+     * import { readJson } from '@medplum/definitions';
+     * import { Bundle } from '@medplum/fhirtypes';
+     *
+     * indexStructureDefinitionBundle(readJson('fhir/r4/profiles-resources.json') as Bundle);
+     * ```
+     *
+     * In a client context, you can load the schema definitions using MedplumClient:
+     *
+     * ```ts
+     * import { MedplumClient } from '@medplum/core';
+     *
+     * const medplum = new MedplumClient();
+     * await medplum.requestSchema('Patient');
+     * ```
+     *
+     * @param resourceType The candidate resource type string.
+     * @returns True if the resource type is a valid FHIR resource type.
+     */
+    function isResourceType(resourceType) {
+        const typeSchema = globalSchema.types[resourceType];
+        return (typeSchema &&
+            typeSchema.structureDefinition.id === resourceType &&
+            typeSchema.structureDefinition.kind === 'resource');
+    }
+    /**
+     * Validates that the given string is a valid FHIR resource type.
+     * On success, silently returns void.
+     * On failure, throws an OperationOutcomeError.
+     *
+     * ```ts
+     * validateResourceType('Patient'); // nothing
+     * validateResourceType('XYZ'); // throws OperationOutcomeError
+     * ```
+     *
+     * Note that this depends on globalSchema, which is populated by the StructureDefinition loader.
+     *
+     * In a server context, you can load all schema definitions:
+     *
+     * ```ts
+     * import { indexStructureDefinitionBundle } from '@medplum/core';
+     * import { readJson } from '@medplum/definitions';
+     * import { Bundle } from '@medplum/fhirtypes';
+     *
+     * indexStructureDefinitionBundle(readJson('fhir/r4/profiles-resources.json') as Bundle);
+     * ```
+     *
+     * In a client context, you can load the schema definitions using MedplumClient:
+     *
+     * ```ts
+     * import { MedplumClient } from '@medplum/core';
+     *
+     * const medplum = new MedplumClient();
+     * await medplum.requestSchema('Patient');
+     * ```
+     *
+     * @param resourceType The candidate resource type string.
+     * @returns True if the resource type is a valid FHIR resource type.
+     */
+    function validateResourceType(resourceType) {
+        if (!resourceType) {
+            throw new OperationOutcomeError(validationError('Resource type is null'));
+        }
+        if (!isResourceType(resourceType)) {
+            throw new OperationOutcomeError(validationError('Unknown resource type'));
+        }
+    }
+    /**
+     * Validates a candidate FHIR resource object.
+     * On success, silently returns void.
+     * On failure, throws an OperationOutcomeError with issues for each violation.
+     *
+     * ```ts
+     * validateResource({ resourceType: 'Patient' }); // nothing
+     * validateResource({ resourceType: 'XYZ' }); // throws OperationOutcomeError
+     * ```
+     *
+     * Note that this depends on globalSchema, which is populated by the StructureDefinition loader.
+     *
+     * In a server context, you can load all schema definitions:
+     *
+     * ```ts
+     * import { indexStructureDefinitionBundle } from '@medplum/core';
+     * import { readJson } from '@medplum/definitions';
+     * import { Bundle } from '@medplum/fhirtypes';
+     *
+     * indexStructureDefinitionBundle(readJson('fhir/r4/profiles-resources.json') as Bundle);
+     * ```
+     *
+     * In a client context, you can load the schema definitions using MedplumClient:
+     *
+     * ```ts
+     * import { MedplumClient } from '@medplum/core';
+     *
+     * const medplum = new MedplumClient();
+     * await medplum.requestSchema('Patient');
+     * ```
+     *
+     * @param resourceType The candidate resource type string.
+     * @returns True if the resource type is a valid FHIR resource type.
+     */
+    function validateResource(resource) {
+        new FhirSchemaValidator(resource).validate();
+    }
+    class FhirSchemaValidator {
+        constructor(root) {
+            _FhirSchemaValidator_instances.add(this);
+            _FhirSchemaValidator_issues.set(this, void 0);
+            _FhirSchemaValidator_root.set(this, void 0);
+            __classPrivateFieldSet(this, _FhirSchemaValidator_issues, [], "f");
+            __classPrivateFieldSet(this, _FhirSchemaValidator_root, root, "f");
+        }
+        validate() {
+            const resource = __classPrivateFieldGet(this, _FhirSchemaValidator_root, "f");
+            if (!resource) {
+                throw new OperationOutcomeError(validationError('Resource is null'));
+            }
+            const resourceType = resource.resourceType;
+            if (!resourceType) {
+                throw new OperationOutcomeError(validationError('Missing resource type'));
+            }
+            // Check for "null" once for the entire object hierarchy
+            checkForNull(resource, '', __classPrivateFieldGet(this, _FhirSchemaValidator_issues, "f"));
+            __classPrivateFieldGet(this, _FhirSchemaValidator_instances, "m", _FhirSchemaValidator_validateObject).call(this, toTypedValue(resource), resourceType);
+            if (__classPrivateFieldGet(this, _FhirSchemaValidator_issues, "f").length > 0) {
+                throw new OperationOutcomeError({
+                    resourceType: 'OperationOutcome',
+                    issue: __classPrivateFieldGet(this, _FhirSchemaValidator_issues, "f"),
+                });
+            }
+        }
+    }
+    _FhirSchemaValidator_issues = new WeakMap(), _FhirSchemaValidator_root = new WeakMap(), _FhirSchemaValidator_instances = new WeakSet(), _FhirSchemaValidator_validateObject = function _FhirSchemaValidator_validateObject(typedValue, path) {
+        const definition = globalSchema.types[typedValue.type];
+        if (!definition) {
+            throw new OperationOutcomeError(validationError('Unknown type: ' + typedValue.type));
+        }
+        const propertyDefinitions = definition.properties;
+        __classPrivateFieldGet(this, _FhirSchemaValidator_instances, "m", _FhirSchemaValidator_checkProperties).call(this, path, propertyDefinitions, typedValue);
+        __classPrivateFieldGet(this, _FhirSchemaValidator_instances, "m", _FhirSchemaValidator_checkAdditionalProperties).call(this, path, typedValue, propertyDefinitions);
+    }, _FhirSchemaValidator_checkProperties = function _FhirSchemaValidator_checkProperties(path, propertyDefinitions, typedValue) {
+        for (const [key, elementDefinition] of Object.entries(propertyDefinitions)) {
+            __classPrivateFieldGet(this, _FhirSchemaValidator_instances, "m", _FhirSchemaValidator_checkProperty).call(this, path + '.' + key, elementDefinition, typedValue);
+        }
+    }, _FhirSchemaValidator_checkProperty = function _FhirSchemaValidator_checkProperty(path, elementDefinition, typedValue) {
+        const propertyName = path.split('.').pop();
+        const value = getTypedPropertyValue(typedValue, propertyName);
+        if (isEmpty(value)) {
+            if (elementDefinition.min !== undefined && elementDefinition.min > 0) {
+                __classPrivateFieldGet(this, _FhirSchemaValidator_issues, "f").push(createStructureIssue(path, 'Missing required property'));
+            }
+            return;
+        }
+        if (elementDefinition.max === '*') {
+            if (!Array.isArray(value)) {
+                __classPrivateFieldGet(this, _FhirSchemaValidator_issues, "f").push(createStructureIssue(path, 'Expected array for property'));
+                return;
+            }
+            for (const item of value) {
+                __classPrivateFieldGet(this, _FhirSchemaValidator_instances, "m", _FhirSchemaValidator_checkPropertyValue).call(this, path, elementDefinition, item);
+            }
+        }
+        else {
+            __classPrivateFieldGet(this, _FhirSchemaValidator_instances, "m", _FhirSchemaValidator_checkPropertyValue).call(this, path, elementDefinition, value);
+        }
+    }, _FhirSchemaValidator_checkPropertyValue = function _FhirSchemaValidator_checkPropertyValue(path, elementDefinition, typedValue) {
+        if (typedValue.value === null) {
+            // Null handled separately
+            return;
+        }
+        if (isLowerCase(typedValue.type.charAt(0))) {
+            __classPrivateFieldGet(this, _FhirSchemaValidator_instances, "m", _FhirSchemaValidator_validatePrimitiveType).call(this, elementDefinition, typedValue);
+        }
+        else {
+            __classPrivateFieldGet(this, _FhirSchemaValidator_instances, "m", _FhirSchemaValidator_validateObject).call(this, typedValue, path);
+        }
+    }, _FhirSchemaValidator_validatePrimitiveType = function _FhirSchemaValidator_validatePrimitiveType(elementDefinition, typedValue) {
+        const { type, value } = typedValue;
+        if (value === null) {
+            // Null handled separately, so this code should never be reached
+            // Leaving this check in place for now, in case we change the null handling
+            return;
+        }
+        // First, make sure the value is the correct JS type
+        const expectedType = fhirTypeToJsType[typedValue.type];
+        if (typeof value !== expectedType) {
+            __classPrivateFieldGet(this, _FhirSchemaValidator_instances, "m", _FhirSchemaValidator_createIssue).call(this, elementDefinition, 'Invalid type for ' + type);
+            return;
+        }
+        // Then, perform additional checks for specialty types
+        if (expectedType === 'string') {
+            __classPrivateFieldGet(this, _FhirSchemaValidator_instances, "m", _FhirSchemaValidator_validateString).call(this, elementDefinition, type, value);
+        }
+        else if (expectedType === 'number') {
+            __classPrivateFieldGet(this, _FhirSchemaValidator_instances, "m", _FhirSchemaValidator_validateNumber).call(this, elementDefinition, type, value);
+        }
+    }, _FhirSchemaValidator_validateString = function _FhirSchemaValidator_validateString(elementDefinition, type, value) {
+        if (!value.trim()) {
+            __classPrivateFieldGet(this, _FhirSchemaValidator_instances, "m", _FhirSchemaValidator_createIssue).call(this, elementDefinition, 'Invalid empty string');
+            return;
+        }
+        // Try to get the regex
+        const valueDefinition = globalSchema.types[type]?.properties?.['value'];
+        if (valueDefinition?.type) {
+            const regex = getExtensionValue(valueDefinition.type[0], 'http://hl7.org/fhir/StructureDefinition/regex');
+            if (regex) {
+                if (!value.match(new RegExp(regex))) {
+                    __classPrivateFieldGet(this, _FhirSchemaValidator_instances, "m", _FhirSchemaValidator_createIssue).call(this, elementDefinition, 'Invalid ' + type + ' format');
+                }
+            }
+        }
+    }, _FhirSchemaValidator_validateNumber = function _FhirSchemaValidator_validateNumber(elementDefinition, type, value) {
+        if (isNaN(value) || !isFinite(value)) {
+            __classPrivateFieldGet(this, _FhirSchemaValidator_instances, "m", _FhirSchemaValidator_createIssue).call(this, elementDefinition, 'Invalid ' + type + ' value');
+            return;
+        }
+        if (isIntegerType(type) && !Number.isInteger(value)) {
+            __classPrivateFieldGet(this, _FhirSchemaValidator_instances, "m", _FhirSchemaValidator_createIssue).call(this, elementDefinition, 'Number is not an integer');
+        }
+        if (type === exports.PropertyType.positiveInt && value <= 0) {
+            __classPrivateFieldGet(this, _FhirSchemaValidator_instances, "m", _FhirSchemaValidator_createIssue).call(this, elementDefinition, 'Number is less than or equal to zero');
+        }
+        if (type === exports.PropertyType.unsignedInt && value < 0) {
+            __classPrivateFieldGet(this, _FhirSchemaValidator_instances, "m", _FhirSchemaValidator_createIssue).call(this, elementDefinition, 'Number is negative');
+        }
+    }, _FhirSchemaValidator_checkAdditionalProperties = function _FhirSchemaValidator_checkAdditionalProperties(path, typedValue, propertyDefinitions) {
+        const object = typedValue.value;
+        for (const key of Object.keys(object)) {
+            __classPrivateFieldGet(this, _FhirSchemaValidator_instances, "m", _FhirSchemaValidator_checkAdditionalProperty).call(this, path, key, typedValue, propertyDefinitions);
+        }
+    }, _FhirSchemaValidator_checkAdditionalProperty = function _FhirSchemaValidator_checkAdditionalProperty(path, key, typedValue, propertyDefinitions) {
+        if (!baseResourceProperties.has(key) &&
+            !(key in propertyDefinitions) &&
+            !isChoiceOfType(key, typedValue, propertyDefinitions) &&
+            !__classPrivateFieldGet(this, _FhirSchemaValidator_instances, "m", _FhirSchemaValidator_checkPrimitiveElement).call(this, path, key, typedValue)) {
+            const expression = `${path}.${key}`;
+            __classPrivateFieldGet(this, _FhirSchemaValidator_issues, "f").push(createStructureIssue(expression, `Invalid additional property "${expression}"`));
+        }
+    }, _FhirSchemaValidator_checkPrimitiveElement = function _FhirSchemaValidator_checkPrimitiveElement(path, key, typedValue) {
+        // Primitive element starts with underscore
+        if (!key.startsWith('_')) {
+            return false;
+        }
+        // Validate the non-underscore property exists
+        const primitiveKey = key.slice(1);
+        if (!(primitiveKey in typedValue.value)) {
+            return false;
+        }
+        // Then validate the element
+        __classPrivateFieldGet(this, _FhirSchemaValidator_instances, "m", _FhirSchemaValidator_validateObject).call(this, { type: 'Element', value: typedValue.value[key] }, path);
+        return true;
+    }, _FhirSchemaValidator_createIssue = function _FhirSchemaValidator_createIssue(elementDefinition, message) {
+        __classPrivateFieldGet(this, _FhirSchemaValidator_issues, "f").push(createStructureIssue(elementDefinition.path, message));
+    };
+    function isIntegerType(propertyType) {
+        return (propertyType === exports.PropertyType.integer ||
+            propertyType === exports.PropertyType.positiveInt ||
+            propertyType === exports.PropertyType.unsignedInt);
+    }
+    function isChoiceOfType(key, typedValue, propertyDefinitions) {
+        for (const propertyName of Object.keys(propertyDefinitions)) {
+            if (!propertyName.endsWith('[x]')) {
+                continue;
+            }
+            const basePropertyName = propertyName.replace('[x]', '');
+            if (!key.startsWith(basePropertyName)) {
+                continue;
+            }
+            let typedPropertyValue = getTypedPropertyValue(typedValue, propertyName);
+            if (!typedPropertyValue) {
+                continue;
+            }
+            if (Array.isArray(typedPropertyValue)) {
+                // At present, there are no choice types that are arrays in the FHIR spec
+                // Leaving this here to make TypeScript happy, and in case that changes
+                typedPropertyValue = typedPropertyValue[0];
+            }
+            if (typedPropertyValue && key === basePropertyName + capitalize(typedPropertyValue.type)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    /**
+     * Recursively checks for null values in an object.
+     *
+     * Note that "null" is a special value in JSON that is not allowed in FHIR.
+     *
+     * @param value Input value of any type.
+     * @param path Path string to the value for OperationOutcome.
+     * @param issues Output list of issues.
+     */
+    function checkForNull(value, path, issues) {
+        if (value === null) {
+            issues.push(createStructureIssue(path, 'Invalid null value'));
+        }
+        else if (Array.isArray(value)) {
+            checkArrayForNull(value, path, issues);
+        }
+        else if (typeof value === 'object') {
+            checkObjectForNull(value, path, issues);
+        }
+    }
+    function checkArrayForNull(array, path, issues) {
+        for (let i = 0; i < array.length; i++) {
+            if (array[i] === undefined) {
+                issues.push(createStructureIssue(`${path}[${i}]`, 'Invalid undefined value'));
+            }
+            else {
+                checkForNull(array[i], `${path}[${i}]`, issues);
+            }
+        }
+    }
+    function checkObjectForNull(obj, path, issues) {
+        for (const [key, value] of Object.entries(obj)) {
+            checkForNull(value, `${path}${path ? '.' : ''}${key}`, issues);
+        }
+    }
+    function createStructureIssue(expression, details) {
+        return {
+            severity: 'error',
+            code: 'structure',
+            details: {
+                text: details,
+            },
+            expression: [expression],
+        };
+    }
+
     exports.SearchParameterType = void 0;
     (function (SearchParameterType) {
         SearchParameterType["BOOLEAN"] = "BOOLEAN";
@@ -11386,7 +12220,7 @@
             return matchesBooleanFilter(resource, filter, searchParam);
         }
         else {
-            return matchesStringFilter(resource, filter, searchParam);
+            return matchesStringFilter(resource, filter, searchParam, true);
         }
     }
     function matchesBooleanFilter(resource, filter, searchParam) {
@@ -11395,13 +12229,13 @@
         const result = values.includes(expected);
         return isNegated(filter.operator) ? !result : result;
     }
-    function matchesStringFilter(resource, filter, searchParam) {
+    function matchesStringFilter(resource, filter, searchParam, asToken) {
         const resourceValues = evalFhirPath(searchParam.expression, resource);
         const filterValues = filter.value.split(',');
         const negated = isNegated(filter.operator);
         for (const resourceValue of resourceValues) {
             for (const filterValue of filterValues) {
-                const match = matchesStringValue(resourceValue, filter.operator, filterValue);
+                const match = matchesStringValue(resourceValue, filter.operator, filterValue, asToken);
                 if (match) {
                     return !negated;
                 }
@@ -11411,7 +12245,12 @@
         // If "equals" and no matches, then return false
         return negated;
     }
-    function matchesStringValue(resourceValue, operator, filterValue) {
+    function matchesStringValue(resourceValue, operator, filterValue, asToken) {
+        if (asToken && filterValue.includes('|')) {
+            const [system, code] = filterValue.split('|');
+            return (matchesStringValue(resourceValue, operator, system, false) &&
+                (!code || matchesStringValue(resourceValue, operator, code, false)));
+        }
         let str = '';
         if (resourceValue) {
             if (typeof resourceValue === 'string') {
@@ -11685,7 +12524,11 @@
     exports.EquivalentAtom = EquivalentAtom;
     exports.FHIRPATH_KEYWORDS = FHIRPATH_KEYWORDS;
     exports.FHIRPATH_OPERATORS = FHIRPATH_OPERATORS;
+    exports.FhirFilterComparison = FhirFilterComparison;
+    exports.FhirFilterConnective = FhirFilterConnective;
+    exports.FhirFilterNegation = FhirFilterNegation;
     exports.FhirPathAtom = FhirPathAtom;
+    exports.FhirSchemaValidator = FhirSchemaValidator;
     exports.FunctionAtom = FunctionAtom;
     exports.Hl7Context = Hl7Context;
     exports.Hl7Field = Hl7Field;
@@ -11693,6 +12536,7 @@
     exports.Hl7Segment = Hl7Segment;
     exports.InAtom = InAtom;
     exports.IndexerAtom = IndexerAtom;
+    exports.InfixOperatorAtom = InfixOperatorAtom;
     exports.IsAtom = IsAtom;
     exports.LRUCache = LRUCache;
     exports.LiteralAtom = LiteralAtom;
@@ -11702,8 +12546,12 @@
     exports.NotEquivalentAtom = NotEquivalentAtom;
     exports.OperationOutcomeError = OperationOutcomeError;
     exports.OrAtom = OrAtom;
+    exports.Parser = Parser;
+    exports.ParserBuilder = ParserBuilder;
+    exports.PrefixOperatorAtom = PrefixOperatorAtom;
     exports.ReadablePromise = ReadablePromise;
     exports.SymbolAtom = SymbolAtom;
+    exports.Tokenizer = Tokenizer;
     exports.UnaryOperatorAtom = UnaryOperatorAtom;
     exports.UnionAtom = UnionAtom;
     exports.XorAtom = XorAtom;
@@ -11717,7 +12565,9 @@
     exports.calculateAge = calculateAge;
     exports.calculateAgeString = calculateAgeString;
     exports.capitalize = capitalize;
+    exports.checkForNull = checkForNull;
     exports.createReference = createReference;
+    exports.createStructureIssue = createStructureIssue;
     exports.created = created;
     exports.deepClone = deepClone;
     exports.deepEquals = deepEquals$1;
@@ -11785,17 +12635,23 @@
     exports.isProfileResource = isProfileResource;
     exports.isQuantity = isQuantity;
     exports.isQuantityEquivalent = isQuantityEquivalent;
+    exports.isReference = isReference;
+    exports.isResource = isResource;
     exports.isResourceType = isResourceType;
+    exports.isResourceTypeSchema = isResourceTypeSchema;
     exports.isStringArray = isStringArray;
     exports.isUUID = isUUID;
     exports.isValidDate = isValidDate;
     exports.matchesRange = matchesRange;
     exports.matchesSearchRequest = matchesSearchRequest;
     exports.normalizeErrorString = normalizeErrorString;
+    exports.normalizeOperationOutcome = normalizeOperationOutcome;
     exports.notFound = notFound;
     exports.notModified = notModified;
     exports.parseFhirPath = parseFhirPath;
+    exports.parseFilterParameter = parseFilterParameter;
     exports.parseJWTPayload = parseJWTPayload;
+    exports.parseMappingLanguage = parseMappingLanguage;
     exports.parseSearchDefinition = parseSearchDefinition;
     exports.parseSearchRequest = parseSearchRequest;
     exports.parseSearchUrl = parseSearchUrl;
@@ -11811,9 +12667,12 @@
     exports.stringify = stringify;
     exports.toJsBoolean = toJsBoolean;
     exports.toTypedValue = toTypedValue;
-    exports.tokenize = tokenize;
+    exports.tokenize = tokenize$2;
     exports.tooManyRequests = tooManyRequests;
     exports.unauthorized = unauthorized;
+    exports.validateResource = validateResource;
+    exports.validateResourceType = validateResourceType;
+    exports.validationError = validationError;
 
 }));
 //# sourceMappingURL=index.cjs.map