@medplum/core 0.3.0 → 0.5.0

package/dist/esm/index.js

@@ -0,0 +1,1792 @@
+/*! *****************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+
+function __awaiter(thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+}
+
+function __classPrivateFieldGet(receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+}
+
+function __classPrivateFieldSet(receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+}
+
+var _LRUCache_instances, _LRUCache_max, _LRUCache_cache, _LRUCache_first;
+/**
+ * LRU cache (least recently used)
+ * Source: https://stackoverflow.com/a/46432113
+ */
+class LRUCache {
+    constructor(max = 10) {
+        _LRUCache_instances.add(this);
+        _LRUCache_max.set(this, void 0);
+        _LRUCache_cache.set(this, void 0);
+        __classPrivateFieldSet(this, _LRUCache_max, max, "f");
+        __classPrivateFieldSet(this, _LRUCache_cache, new Map(), "f");
+    }
+    clear() {
+        __classPrivateFieldGet(this, _LRUCache_cache, "f").clear();
+    }
+    get(key) {
+        const item = __classPrivateFieldGet(this, _LRUCache_cache, "f").get(key);
+        if (item) {
+            __classPrivateFieldGet(this, _LRUCache_cache, "f").delete(key);
+            __classPrivateFieldGet(this, _LRUCache_cache, "f").set(key, item);
+        }
+        return item;
+    }
+    set(key, val) {
+        if (__classPrivateFieldGet(this, _LRUCache_cache, "f").has(key)) {
+            __classPrivateFieldGet(this, _LRUCache_cache, "f").delete(key);
+        }
+        else if (__classPrivateFieldGet(this, _LRUCache_cache, "f").size >= __classPrivateFieldGet(this, _LRUCache_max, "f")) {
+            __classPrivateFieldGet(this, _LRUCache_cache, "f").delete(__classPrivateFieldGet(this, _LRUCache_instances, "m", _LRUCache_first).call(this));
+        }
+        __classPrivateFieldGet(this, _LRUCache_cache, "f").set(key, val);
+    }
+}
+_LRUCache_max = new WeakMap(), _LRUCache_cache = new WeakMap(), _LRUCache_instances = new WeakSet(), _LRUCache_first = function _LRUCache_first() {
+    // This works because the Map class maintains ordered keys.
+    return __classPrivateFieldGet(this, _LRUCache_cache, "f").keys().next().value;
+};
+
+function formatAddress(address, options) {
+    const builder = [];
+    if (address.line) {
+        builder.push(...address.line);
+    }
+    if (address.city) {
+        builder.push(address.city);
+    }
+    if (address.state) {
+        builder.push(address.state);
+    }
+    if (address.postalCode) {
+        builder.push(address.postalCode);
+    }
+    if (address.use && ((options === null || options === void 0 ? void 0 : options.all) || (options === null || options === void 0 ? void 0 : options.use))) {
+        builder.push('[' + address.use + ']');
+    }
+    return builder.join(', ').trim();
+}
+function formatHumanName(name, options) {
+    const builder = [];
+    if (name.prefix && ((options === null || options === void 0 ? void 0 : options.all) || (options === null || options === void 0 ? void 0 : options.prefix))) {
+        builder.push(...name.prefix);
+    }
+    if (name.given) {
+        builder.push(...name.given);
+    }
+    if (name.family) {
+        builder.push(name.family);
+    }
+    if (name.suffix && ((options === null || options === void 0 ? void 0 : options.all) || (options === null || options === void 0 ? void 0 : options.suffix))) {
+        builder.push(...name.suffix);
+    }
+    if (name.use && ((options === null || options === void 0 ? void 0 : options.all) || (options === null || options === void 0 ? void 0 : options.use))) {
+        builder.push('[' + name.use + ']');
+    }
+    return builder.join(' ').trim();
+}
+function formatGivenName(name) {
+    const builder = [];
+    if (name.given) {
+        builder.push(...name.given);
+    }
+    return builder.join(' ').trim();
+}
+function formatFamilyName(name) {
+    return name.family || '';
+}
+
+/**
+ * Creates a reference resource.
+ * @param resource The FHIR reesource.
+ * @returns A reference resource.
+ */
+function createReference(resource) {
+    const reference = getReferenceString(resource);
+    const display = getDisplayString(resource);
+    return display === reference ? { reference } : { reference, display };
+}
+/**
+ * Returns a reference string for a resource.
+ * @param resource The FHIR resource.
+ * @returns A reference string of the form resourceType/id.
+ */
+function getReferenceString(resource) {
+    return resource.resourceType + '/' + resource.id;
+}
+/**
+ * Returns the ID portion of a reference.
+ * @param reference A FHIR reference.
+ * @returns The ID portion of a reference.
+ */
+function resolveId(reference) {
+    var _a;
+    return (_a = reference === null || reference === void 0 ? void 0 : reference.reference) === null || _a === void 0 ? void 0 : _a.split('/')[1];
+}
+/**
+ * Returns true if the resource is a "ProfileResource".
+ * @param resource The FHIR resource.
+ * @returns True if the resource is a "ProfileResource".
+ */
+function isProfileResource(resource) {
+    return (resource.resourceType === 'Patient' ||
+        resource.resourceType === 'Practitioner' ||
+        resource.resourceType === 'RelatedPerson');
+}
+/**
+ * Returns a display string for the resource.
+ * @param resource The input resource.
+ * @return Human friendly display string.
+ */
+function getDisplayString(resource) {
+    if (isProfileResource(resource)) {
+        const profileName = getProfileResourceDisplayString(resource);
+        if (profileName) {
+            return profileName;
+        }
+    }
+    if (resource.resourceType === 'Device') {
+        const deviceName = getDeviceDisplayString(resource);
+        if (deviceName) {
+            return deviceName;
+        }
+    }
+    if (resource.resourceType === 'User') {
+        if (resource.email) {
+            return resource.email;
+        }
+    }
+    if ('name' in resource && resource.name && typeof resource.name === 'string') {
+        return resource.name;
+    }
+    return getReferenceString(resource);
+}
+/**
+ * Returns a display string for a profile resource if one is found.
+ * @param resource The profile resource.
+ * @returns The display name if one is found.
+ */
+function getProfileResourceDisplayString(resource) {
+    const names = resource.name;
+    if (names && names.length > 0) {
+        return formatHumanName(names[0]);
+    }
+    return undefined;
+}
+/**
+ * Returns a display string for a device resource if one is found.
+ * @param device The device resource.
+ * @returns The display name if one is found.
+ */
+function getDeviceDisplayString(device) {
+    const names = device.deviceName;
+    if (names && names.length > 0) {
+        return names[0].name;
+    }
+    return undefined;
+}
+/**
+ * Returns an image URL for the resource, if one is available.
+ * @param resource The input resource.
+ * @returns The image URL for the resource or undefined.
+ */
+function getImageSrc(resource) {
+    if (isProfileResource(resource)) {
+        const photos = resource.photo;
+        if (photos) {
+            for (const photo of photos) {
+                if (photo.url && photo.contentType && photo.contentType.startsWith('image/')) {
+                    return photo.url;
+                }
+            }
+        }
+    }
+    return undefined;
+}
+/**
+ * Returns a Date property as a Date.
+ * When working with JSON objects, Dates are often serialized as ISO-8601 strings.
+ * When that happens, we need to safely convert to a proper Date object.
+ * @param date The date property value, which could be a string or a Date object.
+ * @returns A Date object.
+ */
+function getDateProperty(date) {
+    return date ? new Date(date) : undefined;
+}
+/**
+ * FHIR JSON stringify.
+ * Removes properties with empty string values.
+ * Removes objects with zero properties.
+ * See: https://www.hl7.org/fhir/json.html
+ * @param value The input value.
+ * @param pretty Optional flag to pretty-print the JSON.
+ * @returns The resulting JSON string.
+ */
+function stringify(value, pretty) {
+    return JSON.stringify(value, stringifyReplacer, pretty ? 2 : undefined);
+}
+/**
+ * Evaluates JSON key/value pairs for FHIR JSON stringify.
+ * Removes properties with empty string values.
+ * Removes objects with zero properties.
+ * @param {string} k Property key.
+ * @param {*} v Property value.
+ */
+function stringifyReplacer(k, v) {
+    return isEmpty(v) ? undefined : v;
+}
+/**
+ * Returns true if the value is empty (null, undefined, empty string, or empty object).
+ * @param v Any value.
+ * @returns True if the value is an empty string or an empty object.
+ */
+function isEmpty(v) {
+    if (v === null || v === undefined) {
+        return true;
+    }
+    const t = typeof v;
+    return (t === 'string' && v === '') || (t === 'object' && Object.keys(v).length === 0);
+}
+/**
+ * Resource equality.
+ * Ignores meta.versionId and meta.lastUpdated.
+ * See: https://dmitripavlutin.com/how-to-compare-objects-in-javascript/#4-deep-equality
+ * @param object1 The first object.
+ * @param object2 The second object.
+ * @returns True if the objects are equal.
+ */
+function deepEquals(object1, object2, path) {
+    let keys1 = Object.keys(object1);
+    let keys2 = Object.keys(object2);
+    if (path === 'meta') {
+        keys1 = keys1.filter((k) => k !== 'versionId' && k !== 'lastUpdated' && k !== 'author');
+        keys2 = keys2.filter((k) => k !== 'versionId' && k !== 'lastUpdated' && k !== 'author');
+    }
+    if (keys1.length !== keys2.length) {
+        return false;
+    }
+    for (const key of keys1) {
+        const val1 = object1[key];
+        const val2 = object2[key];
+        if (isObject(val1) && isObject(val2)) {
+            if (!deepEquals(val1, val2, key)) {
+                return false;
+            }
+        }
+        else {
+            if (val1 !== val2) {
+                return false;
+            }
+        }
+    }
+    return true;
+}
+function isObject(object) {
+    return object !== null && typeof object === 'object';
+}
+// Precompute hex octets
+// See: https://stackoverflow.com/a/55200387
+const byteToHex = [];
+for (let n = 0; n < 256; n++) {
+    byteToHex.push(n.toString(16).padStart(2, '0'));
+}
+/**
+ * Converts an ArrayBuffer to hex string.
+ * See: https://stackoverflow.com/a/55200387
+ * @param arrayBuffer The input array buffer.
+ * @returns The resulting hex string.
+ */
+function arrayBufferToHex(arrayBuffer) {
+    const bytes = new Uint8Array(arrayBuffer);
+    const result = new Array(bytes.length);
+    for (let i = 0; i < bytes.length; i++) {
+        result[i] = byteToHex[bytes[i]];
+    }
+    return result.join('');
+}
+/**
+ * Converts an ArrayBuffer to a base-64 encoded string.
+ * @param arrayBuffer The input array buffer.
+ * @returns The base-64 encoded string.
+ */
+function arrayBufferToBase64(arrayBuffer) {
+    const bytes = new Uint8Array(arrayBuffer);
+    const result = [];
+    for (let i = 0; i < bytes.length; i++) {
+        result[i] = String.fromCharCode(bytes[i]);
+    }
+    return window.btoa(result.join(''));
+}
+function capitalize(word) {
+    return word.charAt(0).toUpperCase() + word.substr(1);
+}
+function isLowerCase(c) {
+    return c === c.toLowerCase();
+}
+
+/**
+ * Returns a cryptographically secure random string.
+ */
+function getRandomString() {
+    const randomItems = new Uint32Array(28);
+    crypto.getRandomValues(randomItems);
+    return arrayBufferToHex(randomItems.buffer);
+}
+/**
+ * Encrypts a string with SHA256 encryption.
+ * @param str
+ */
+function encryptSHA256(str) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return crypto.subtle.digest('SHA-256', new TextEncoder().encode(str));
+    });
+}
+
+/*
+ * Based on: https://developer.mozilla.org/en-US/docs/Web/API/EventTarget
+ */
+var _EventTarget_listeners;
+class EventTarget {
+    constructor() {
+        _EventTarget_listeners.set(this, void 0);
+        __classPrivateFieldSet(this, _EventTarget_listeners, {}, "f");
+    }
+    addEventListener(type, callback) {
+        if (!__classPrivateFieldGet(this, _EventTarget_listeners, "f")[type]) {
+            __classPrivateFieldGet(this, _EventTarget_listeners, "f")[type] = [];
+        }
+        __classPrivateFieldGet(this, _EventTarget_listeners, "f")[type].push(callback);
+    }
+    removeEventListeneer(type, callback) {
+        const array = __classPrivateFieldGet(this, _EventTarget_listeners, "f")[type];
+        if (!array) {
+            return;
+        }
+        for (let i = 0; i < array.length; i++) {
+            if (array[i] === callback) {
+                array.splice(i, 1);
+                return;
+            }
+        }
+    }
+    dispatchEvent(event) {
+        const array = __classPrivateFieldGet(this, _EventTarget_listeners, "f")[event.type];
+        if (array) {
+            array.forEach((listener) => listener.call(this, event));
+        }
+        return !event.defaultPrevented;
+    }
+}
+_EventTarget_listeners = new WeakMap();
+
+/**
+ * Decodes a section of a JWT.
+ * See: https://tools.ietf.org/html/rfc7519
+ * @param payload
+ */
+function decodePayload(payload) {
+    const cleanedPayload = payload.replace(/-/g, '+').replace(/_/g, '/');
+    const decodedPayload = window.atob(cleanedPayload);
+    const uriEncodedPayload = Array.from(decodedPayload).reduce((acc, char) => {
+        const uriEncodedChar = ('00' + char.charCodeAt(0).toString(16)).slice(-2);
+        return `${acc}%${uriEncodedChar}`;
+    }, '');
+    const jsonPayload = decodeURIComponent(uriEncodedPayload);
+    return JSON.parse(jsonPayload);
+}
+/**
+ * Parses the JWT payload.
+ * @param token JWT token
+ */
+function parseJWTPayload(token) {
+    const [_header, payload, _signature] = token.split('.');
+    return decodePayload(payload);
+}
+
+const OK_ID = 'ok';
+const CREATED_ID = 'created';
+const GONE_ID = 'gone';
+const NOT_MODIFIED_ID = 'not-modified';
+const NOT_FOUND_ID = 'not-found';
+const ACCESS_DENIED = 'access-denied';
+const allOk = {
+    resourceType: 'OperationOutcome',
+    id: OK_ID,
+    issue: [
+        {
+            severity: 'information',
+            code: 'information',
+            details: {
+                text: 'All OK',
+            },
+        },
+    ],
+};
+const created = {
+    resourceType: 'OperationOutcome',
+    id: CREATED_ID,
+    issue: [
+        {
+            severity: 'information',
+            code: 'information',
+            details: {
+                text: 'Created',
+            },
+        },
+    ],
+};
+const notModified = {
+    resourceType: 'OperationOutcome',
+    id: NOT_MODIFIED_ID,
+    issue: [
+        {
+            severity: 'information',
+            code: 'information',
+            details: {
+                text: 'Not Modified',
+            },
+        },
+    ],
+};
+const notFound = {
+    resourceType: 'OperationOutcome',
+    id: NOT_FOUND_ID,
+    issue: [
+        {
+            severity: 'error',
+            code: 'not-found',
+            details: {
+                text: 'Not found',
+            },
+        },
+    ],
+};
+const gone = {
+    resourceType: 'OperationOutcome',
+    id: GONE_ID,
+    issue: [
+        {
+            severity: 'error',
+            code: 'gone',
+            details: {
+                text: 'Gone',
+            },
+        },
+    ],
+};
+const accessDenied = {
+    resourceType: 'OperationOutcome',
+    id: ACCESS_DENIED,
+    issue: [
+        {
+            severity: 'error',
+            code: 'access-denied',
+            details: {
+                text: 'Access Denied',
+            },
+        },
+    ],
+};
+function badRequest(details, expression) {
+    return {
+        resourceType: 'OperationOutcome',
+        issue: [
+            {
+                severity: 'error',
+                code: 'invalid',
+                details: {
+                    text: details,
+                },
+                expression: expression ? [expression] : undefined,
+            },
+        ],
+    };
+}
+function isOk(outcome) {
+    return outcome.id === OK_ID || outcome.id === CREATED_ID || outcome.id === NOT_MODIFIED_ID;
+}
+function isNotFound(outcome) {
+    return outcome.id === NOT_FOUND_ID;
+}
+function isGone(outcome) {
+    return outcome.id === GONE_ID;
+}
+function getStatus(outcome) {
+    if (outcome.id === OK_ID) {
+        return 200;
+    }
+    else if (outcome.id === CREATED_ID) {
+        return 201;
+    }
+    else if (outcome.id === NOT_MODIFIED_ID) {
+        return 304;
+    }
+    else if (outcome.id === ACCESS_DENIED) {
+        return 403;
+    }
+    else if (outcome.id === NOT_FOUND_ID) {
+        return 404;
+    }
+    else if (outcome.id === GONE_ID) {
+        return 410;
+    }
+    else {
+        return 400;
+    }
+}
+/**
+ * Asserts that the operation completed successfully and that the resource is defined.
+ * @param outcome The operation outcome.
+ * @param resource The resource that may or may not have been returned.
+ */
+function assertOk(outcome, resource) {
+    if (!isOk(outcome) || resource === undefined) {
+        throw new OperationOutcomeError(outcome);
+    }
+}
+class OperationOutcomeError extends Error {
+    constructor(outcome) {
+        var _a, _b;
+        super((_b = (_a = outcome === null || outcome === void 0 ? void 0 : outcome.issue) === null || _a === void 0 ? void 0 : _a[0].details) === null || _b === void 0 ? void 0 : _b.text);
+        this.outcome = outcome;
+    }
+}
+
+/**
+ * Search operators.
+ * These operators represent "modifiers" and "prefixes" in FHIR search.
+ * See: https://www.hl7.org/fhir/search.html
+ */
+var Operator;
+(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["ABOVE"] = "above";
+    Operator["BELOW"] = "below";
+    Operator["IN"] = "in";
+    Operator["NOT_IN"] = "not-in";
+    Operator["OF_TYPE"] = "of-type";
+})(Operator || (Operator = {}));
+const MODIFIER_OPERATORS = [
+    Operator.CONTAINS,
+    Operator.EXACT,
+    Operator.TEXT,
+    Operator.ABOVE,
+    Operator.BELOW,
+    Operator.IN,
+    Operator.NOT_IN,
+    Operator.OF_TYPE,
+];
+const PREFIX_OPERATORS = [
+    Operator.NOT_EQUALS,
+    Operator.GREATER_THAN,
+    Operator.LESS_THAN,
+    Operator.GREATER_THAN_OR_EQUALS,
+    Operator.LESS_THAN_OR_EQUALS,
+    Operator.STARTS_AFTER,
+    Operator.ENDS_BEFORE,
+    Operator.APPROXIMATELY,
+];
+/**
+ * Parses a URL into a SearchRequest.
+ *
+ * See the FHIR search spec: http://hl7.org/fhir/r4/search.html
+ *
+ * @param location The URL to parse.
+ * @returns Parsed search definition.
+ */
+function parseSearchDefinition(location) {
+    const resourceType = location.pathname
+        .replace(/(^\/)|(\/$)/g, '') // Remove leading and trailing slashes
+        .split('/')
+        .pop();
+    const params = new URLSearchParams(location.search);
+    let filters = undefined;
+    let sortRules = undefined;
+    let fields = undefined;
+    let page = undefined;
+    let count = undefined;
+    let total = undefined;
+    params.forEach((value, key) => {
+        if (key === '_fields') {
+            fields = value.split(',');
+        }
+        else if (key === '_page') {
+            page = parseInt(value);
+        }
+        else if (key === '_count') {
+            count = parseInt(value);
+        }
+        else if (key === '_total') {
+            total = value;
+        }
+        else if (key === '_sort') {
+            sortRules = sortRules || [];
+            sortRules.push(parseSortRule(value));
+        }
+        else {
+            filters = filters || [];
+            filters.push(parseSearchFilter(key, value));
+        }
+    });
+    return {
+        resourceType,
+        filters,
+        fields,
+        page,
+        count,
+        total,
+        sortRules,
+    };
+}
+/**
+ * Parses a URL query parameter into a sort rule.
+ *
+ * By default, the sort rule is the field name.
+ *
+ * Sort rules can be reversed into descending order by prefixing the field name with a minus sign.
+ *
+ * See sorting: http://hl7.org/fhir/r4/search.html#_sort
+ *
+ * @param value The URL parameter value.
+ * @returns The parsed sort rule.
+ */
+function parseSortRule(value) {
+    if (value.startsWith('-')) {
+        return { code: value.substring(1), descending: true };
+    }
+    else {
+        return { code: value };
+    }
+}
+/**
+ * Parses a URL query parameter into a search filter.
+ *
+ * FHIR search filters can be specified as modifiers or prefixes.
+ *
+ * For string properties, modifiers are appended to the key, e.g. "name:contains=eve".
+ *
+ * For date and numeric properties, prefixes are prepended to the value, e.g. "birthdate=gt2000".
+ *
+ * See the FHIR search spec: http://hl7.org/fhir/r4/search.html
+ *
+ * @param key The URL parameter key.
+ * @param value The URL parameter value.
+ * @returns The parsed search filter.
+ */
+function parseSearchFilter(key, value) {
+    let code = key;
+    let operator = Operator.EQUALS;
+    for (const modifier of MODIFIER_OPERATORS) {
+        const modifierIndex = code.indexOf(':' + modifier);
+        if (modifierIndex !== -1) {
+            operator = modifier;
+            code = code.substring(0, modifierIndex);
+        }
+    }
+    for (const prefix of PREFIX_OPERATORS) {
+        if (value.match(new RegExp('^' + prefix + '\\d'))) {
+            operator = prefix;
+            value = value.substring(prefix.length);
+        }
+    }
+    return { code, operator, value };
+}
+/**
+ * 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.page && definition.page > 0) {
+        params.push('_page=' + definition.page);
+    }
+    if (definition.count && definition.count > 0) {
+        params.push('_count=' + definition.count);
+    }
+    if (definition.total) {
+        params.push('_total=' + encodeURIComponent(definition.total));
+    }
+    if (params.length === 0) {
+        return '';
+    }
+    params.sort();
+    return '?' + params.join('&');
+}
+function formatFilter(filter) {
+    const modifier = MODIFIER_OPERATORS.includes(filter.operator) ? ':' + filter.operator : '';
+    const prefix = PREFIX_OPERATORS.includes(filter.operator) ? filter.operator : '';
+    return `${filter.code}${modifier}=${prefix}${encodeURIComponent(filter.value)}`;
+}
+function formatSortRules(sortRules) {
+    if (!sortRules || sortRules.length === 0) {
+        return '';
+    }
+    return '_sort=' + sortRules.map((sr) => (sr.descending ? '-' + sr.code : sr.code)).join(',');
+}
+
+var _ClientStorage_storage, _MemoryStorage_data;
+/**
+ * The ClientStorage class is a utility class for storing strings and objects.
+ *
+ * When using MedplumClient in the browser, it will be backed by browser localStorage.
+ *
+ * When Using MedplumClient in the server, it will be backed by the MemoryStorage class.
+ */
+class ClientStorage {
+    constructor() {
+        _ClientStorage_storage.set(this, void 0);
+        __classPrivateFieldSet(this, _ClientStorage_storage, typeof localStorage !== 'undefined' ? localStorage : new MemoryStorage(), "f");
+    }
+    clear() {
+        __classPrivateFieldGet(this, _ClientStorage_storage, "f").clear();
+    }
+    getString(key) {
+        return __classPrivateFieldGet(this, _ClientStorage_storage, "f").getItem(key) || undefined;
+    }
+    setString(key, value) {
+        if (value) {
+            __classPrivateFieldGet(this, _ClientStorage_storage, "f").setItem(key, value);
+        }
+        else {
+            __classPrivateFieldGet(this, _ClientStorage_storage, "f").removeItem(key);
+        }
+    }
+    getObject(key) {
+        const str = this.getString(key);
+        return str ? JSON.parse(str) : undefined;
+    }
+    setObject(key, value) {
+        this.setString(key, value ? stringify(value) : undefined);
+    }
+}
+_ClientStorage_storage = new WeakMap();
+/**
+ * The MemoryStorage class is a minimal in-memory implementation of the Storage interface.
+ */
+class MemoryStorage {
+    constructor() {
+        _MemoryStorage_data.set(this, void 0);
+        __classPrivateFieldSet(this, _MemoryStorage_data, new Map(), "f");
+    }
+    /**
+     * Returns the number of key/value pairs.
+     */
+    get length() {
+        return __classPrivateFieldGet(this, _MemoryStorage_data, "f").size;
+    }
+    /**
+     * Removes all key/value pairs, if there are any.
+     */
+    clear() {
+        __classPrivateFieldGet(this, _MemoryStorage_data, "f").clear();
+    }
+    /**
+     * Returns the current value associated with the given key, or null if the given key does not exist.
+     */
+    getItem(key) {
+        var _a;
+        return (_a = __classPrivateFieldGet(this, _MemoryStorage_data, "f").get(key)) !== null && _a !== void 0 ? _a : null;
+    }
+    /**
+     * Sets the value of the pair identified by key to value, creating a new key/value pair if none existed for key previously.
+     */
+    setItem(key, value) {
+        if (value) {
+            __classPrivateFieldGet(this, _MemoryStorage_data, "f").set(key, value);
+        }
+        else {
+            __classPrivateFieldGet(this, _MemoryStorage_data, "f").delete(key);
+        }
+    }
+    /**
+     * Removes the key/value pair with the given key, if a key/value pair with the given key exists.
+     */
+    removeItem(key) {
+        __classPrivateFieldGet(this, _MemoryStorage_data, "f").delete(key);
+    }
+    /**
+     * Returns the name of the nth key, or null if n is greater than or equal to the number of key/value pairs.
+     */
+    key(index) {
+        return Array.from(__classPrivateFieldGet(this, _MemoryStorage_data, "f").keys())[index];
+    }
+}
+_MemoryStorage_data = new WeakMap();
+
+/**
+ * List of property types.
+ * http://www.hl7.org/fhir/valueset-defined-types.html
+ * The list here includes additions found from StructureDefinition resources.
+ */
+var PropertyType;
+(function (PropertyType) {
+    PropertyType["Address"] = "Address";
+    PropertyType["Age"] = "Age";
+    PropertyType["Annotation"] = "Annotation";
+    PropertyType["Attachment"] = "Attachment";
+    PropertyType["BackboneElement"] = "BackboneElement";
+    PropertyType["CodeableConcept"] = "CodeableConcept";
+    PropertyType["Coding"] = "Coding";
+    PropertyType["ContactDetail"] = "ContactDetail";
+    PropertyType["ContactPoint"] = "ContactPoint";
+    PropertyType["Contributor"] = "Contributor";
+    PropertyType["Count"] = "Count";
+    PropertyType["DataRequirement"] = "DataRequirement";
+    PropertyType["Distance"] = "Distance";
+    PropertyType["Dosage"] = "Dosage";
+    PropertyType["Duration"] = "Duration";
+    PropertyType["Expression"] = "Expression";
+    PropertyType["Extension"] = "Extension";
+    PropertyType["HumanName"] = "HumanName";
+    PropertyType["Identifier"] = "Identifier";
+    PropertyType["MarketingStatus"] = "MarketingStatus";
+    PropertyType["Meta"] = "Meta";
+    PropertyType["Money"] = "Money";
+    PropertyType["Narrative"] = "Narrative";
+    PropertyType["ParameterDefinition"] = "ParameterDefinition";
+    PropertyType["Period"] = "Period";
+    PropertyType["Population"] = "Population";
+    PropertyType["ProdCharacteristic"] = "ProdCharacteristic";
+    PropertyType["ProductShelfLife"] = "ProductShelfLife";
+    PropertyType["Quantity"] = "Quantity";
+    PropertyType["Range"] = "Range";
+    PropertyType["Ratio"] = "Ratio";
+    PropertyType["Reference"] = "Reference";
+    PropertyType["RelatedArtifact"] = "RelatedArtifact";
+    PropertyType["Resource"] = "Resource";
+    PropertyType["SampledData"] = "SampledData";
+    PropertyType["Signature"] = "Signature";
+    PropertyType["SubstanceAmount"] = "SubstanceAmount";
+    PropertyType["SystemString"] = "http://hl7.org/fhirpath/System.String";
+    PropertyType["Timing"] = "Timing";
+    PropertyType["TriggerDefinition"] = "TriggerDefinition";
+    PropertyType["UsageContext"] = "UsageContext";
+    PropertyType["base64Binary"] = "base64Binary";
+    PropertyType["boolean"] = "boolean";
+    PropertyType["canonical"] = "canonical";
+    PropertyType["code"] = "code";
+    PropertyType["date"] = "date";
+    PropertyType["dateTime"] = "dateTime";
+    PropertyType["decimal"] = "decimal";
+    PropertyType["id"] = "id";
+    PropertyType["instant"] = "instant";
+    PropertyType["integer"] = "integer";
+    PropertyType["markdown"] = "markdown";
+    PropertyType["oid"] = "oid";
+    PropertyType["positiveInt"] = "positiveInt";
+    PropertyType["string"] = "string";
+    PropertyType["time"] = "time";
+    PropertyType["unsignedInt"] = "unsignedInt";
+    PropertyType["uri"] = "uri";
+    PropertyType["url"] = "url";
+    PropertyType["uuid"] = "uuid";
+})(PropertyType || (PropertyType = {}));
+/**
+ * Creates a new empty IndexedStructureDefinition.
+ * @returns The empty IndexedStructureDefinition.
+ */
+function createSchema() {
+    return { types: {} };
+}
+function createTypeSchema(typeName, description) {
+    return {
+        display: typeName,
+        description,
+        properties: {},
+        searchParams: {
+            _lastUpdated: {
+                base: [typeName],
+                code: '_lastUpdated',
+                type: 'date',
+                expression: typeName + '.meta.lastUpdated',
+            },
+        },
+    };
+}
+/**
+ * Indexes a StructureDefinition for fast lookup.
+ * See comments on IndexedStructureDefinition for more details.
+ * @param schema The output IndexedStructureDefinition.
+ * @param structureDefinition The original StructureDefinition.
+ */
+function indexStructureDefinition(schema, structureDefinition) {
+    var _a;
+    const typeName = structureDefinition.name;
+    if (!typeName) {
+        return;
+    }
+    schema.types[typeName] = createTypeSchema(typeName, structureDefinition.description);
+    const elements = (_a = structureDefinition.snapshot) === null || _a === void 0 ? void 0 : _a.element;
+    if (elements) {
+        // Filter out any elements missing path or type
+        const filtered = elements.filter((e) => e.path !== typeName && e.path);
+        // First pass, build types
+        filtered.forEach((element) => indexType(schema, element));
+        // Second pass, build properties
+        filtered.forEach((element) => indexProperty(schema, element));
+    }
+}
+/**
+ * Indexes TypeSchema from an ElementDefinition.
+ * In the common case, there will be many ElementDefinition instances per TypeSchema.
+ * Only the first occurrence is saved.
+ * @param schema The output IndexedStructureDefinition.
+ * @param element The input ElementDefinition.
+ */
+function indexType(schema, element) {
+    var _a, _b;
+    const path = element.path;
+    const typeCode = (_b = (_a = element.type) === null || _a === void 0 ? void 0 : _a[0]) === null || _b === void 0 ? void 0 : _b.code;
+    if (typeCode !== 'Element' && typeCode !== 'BackboneElement') {
+        return;
+    }
+    const parts = path.split('.');
+    const typeName = buildTypeName(parts);
+    if (!(typeName in schema.types)) {
+        schema.types[typeName] = createTypeSchema(typeName, element.definition);
+        schema.types[typeName].parentType = buildTypeName(parts.slice(0, parts.length - 1));
+    }
+}
+/**
+ * Indexes PropertySchema from an ElementDefinition.
+ * @param schema The output IndexedStructureDefinition.
+ * @param element The input ElementDefinition.
+ */
+function indexProperty(schema, element) {
+    const path = element.path;
+    const parts = path.split('.');
+    if (parts.length === 1) {
+        return;
+    }
+    const typeName = buildTypeName(parts.slice(0, parts.length - 1));
+    const typeSchema = schema.types[typeName];
+    const key = parts[parts.length - 1];
+    typeSchema.properties[key] = element;
+}
+/**
+ * Indexes a SearchParameter resource for fast lookup.
+ * Indexes by SearchParameter.code, which is the query string parameter name.
+ * @param schema The output IndexedStructureDefinition.
+ * @param searchParam The SearchParameter resource.
+ */
+function indexSearchParameter(schema, searchParam) {
+    if (!searchParam.base) {
+        return;
+    }
+    for (const resourceType of searchParam.base) {
+        const typeSchema = schema.types[resourceType];
+        if (!typeSchema) {
+            continue;
+        }
+        if (!typeSchema.searchParams) {
+            typeSchema.searchParams = {};
+        }
+        typeSchema.searchParams[searchParam.code] = searchParam;
+    }
+}
+function buildTypeName(components) {
+    return components.map(capitalize).join('');
+}
+function getPropertyDisplayName(property) {
+    // Get the property name, which is the remainder after the last period
+    // For example, for path "Patient.birthDate"
+    // the property name is "birthDate"
+    const propertyName = property.path.replaceAll('[x]', '').split('.').pop();
+    // Special case for ID
+    if (propertyName === 'id') {
+        return 'ID';
+    }
+    // Split by capital letters
+    // Capitalize the first letter of each word
+    // Join together with spaces in between
+    // Then normalize whitespace to single space character
+    // For example, for property name "birthDate",
+    // the display name is "Birth Date".
+    return propertyName
+        .split(/(?=[A-Z])/)
+        .map(capitalize)
+        .join(' ')
+        .replace('_', ' ')
+        .replace(/\s+/g, ' ');
+}
+
+// PKCE auth ased 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_storage, _MedplumClient_schema, _MedplumClient_resourceCache, _MedplumClient_baseUrl, _MedplumClient_clientId, _MedplumClient_authorizeUrl, _MedplumClient_tokenUrl, _MedplumClient_logoutUrl, _MedplumClient_onUnauthenticated, _MedplumClient_accessToken, _MedplumClient_refreshToken, _MedplumClient_refreshPromise, _MedplumClient_profilePromise, _MedplumClient_profile, _MedplumClient_config, _MedplumClient_addLogin, _MedplumClient_refreshProfile, _MedplumClient_request, _MedplumClient_buildFetchOptions, _MedplumClient_handleUnauthenticated, _MedplumClient_startPkce, _MedplumClient_requestAuthorization, _MedplumClient_refresh, _MedplumClient_fetchTokens, _MedplumClient_verifyTokens, _MedplumClient_setupStorageListener;
+const DEFAULT_BASE_URL = 'https://api.medplum.com/';
+const DEFAULT_SCOPE = 'launch/patient openid fhirUser offline_access user/*.*';
+const DEFAULT_RESOURCE_CACHE_SIZE = 1000;
+const JSON_CONTENT_TYPE = 'application/json';
+const FHIR_CONTENT_TYPE = 'application/fhir+json';
+const PATCH_CONTENT_TYPE = 'application/json-patch+json';
+class MedplumClient extends EventTarget {
+    constructor(options) {
+        var _a;
+        super();
+        _MedplumClient_instances.add(this);
+        _MedplumClient_fetch.set(this, void 0);
+        _MedplumClient_storage.set(this, void 0);
+        _MedplumClient_schema.set(this, void 0);
+        _MedplumClient_resourceCache.set(this, void 0);
+        _MedplumClient_baseUrl.set(this, void 0);
+        _MedplumClient_clientId.set(this, void 0);
+        _MedplumClient_authorizeUrl.set(this, void 0);
+        _MedplumClient_tokenUrl.set(this, void 0);
+        _MedplumClient_logoutUrl.set(this, void 0);
+        _MedplumClient_onUnauthenticated.set(this, void 0);
+        _MedplumClient_accessToken.set(this, void 0);
+        _MedplumClient_refreshToken.set(this, void 0);
+        _MedplumClient_refreshPromise.set(this, void 0);
+        _MedplumClient_profilePromise.set(this, void 0);
+        _MedplumClient_profile.set(this, void 0);
+        _MedplumClient_config.set(this, void 0);
+        if (options === null || options === void 0 ? void 0 : options.baseUrl) {
+            if (!options.baseUrl.startsWith('http')) {
+                throw new Error('Base URL must start with http or https');
+            }
+            if (!options.baseUrl.endsWith('/')) {
+                throw new Error('Base URL must end with a trailing slash');
+            }
+        }
+        __classPrivateFieldSet(this, _MedplumClient_fetch, (options === null || options === void 0 ? void 0 : options.fetch) || window.fetch.bind(window), "f");
+        __classPrivateFieldSet(this, _MedplumClient_storage, new ClientStorage(), "f");
+        __classPrivateFieldSet(this, _MedplumClient_schema, createSchema(), "f");
+        __classPrivateFieldSet(this, _MedplumClient_resourceCache, new LRUCache((_a = options === null || options === void 0 ? void 0 : options.resourceCacheSize) !== null && _a !== void 0 ? _a : DEFAULT_RESOURCE_CACHE_SIZE), "f");
+        __classPrivateFieldSet(this, _MedplumClient_baseUrl, (options === null || options === void 0 ? void 0 : options.baseUrl) || DEFAULT_BASE_URL, "f");
+        __classPrivateFieldSet(this, _MedplumClient_clientId, (options === null || options === void 0 ? void 0 : options.clientId) || '', "f");
+        __classPrivateFieldSet(this, _MedplumClient_authorizeUrl, (options === null || options === void 0 ? void 0 : options.authorizeUrl) || __classPrivateFieldGet(this, _MedplumClient_baseUrl, "f") + 'oauth2/authorize', "f");
+        __classPrivateFieldSet(this, _MedplumClient_tokenUrl, (options === null || options === void 0 ? void 0 : options.tokenUrl) || __classPrivateFieldGet(this, _MedplumClient_baseUrl, "f") + 'oauth2/token', "f");
+        __classPrivateFieldSet(this, _MedplumClient_logoutUrl, (options === null || options === void 0 ? void 0 : options.logoutUrl) || __classPrivateFieldGet(this, _MedplumClient_baseUrl, "f") + 'oauth2/logout', "f");
+        __classPrivateFieldSet(this, _MedplumClient_onUnauthenticated, options === null || options === void 0 ? void 0 : options.onUnauthenticated, "f");
+        const activeLogin = this.getActiveLogin();
+        if (activeLogin) {
+            __classPrivateFieldSet(this, _MedplumClient_accessToken, activeLogin.accessToken, "f");
+            __classPrivateFieldSet(this, _MedplumClient_refreshToken, activeLogin.refreshToken, "f");
+            __classPrivateFieldGet(this, _MedplumClient_instances, "m", _MedplumClient_refreshProfile).call(this).catch(console.log);
+        }
+        __classPrivateFieldGet(this, _MedplumClient_instances, "m", _MedplumClient_setupStorageListener).call(this);
+    }
+    /**
+     * Clears all auth state including local storage and session storage.
+     */
+    clear() {
+        __classPrivateFieldGet(this, _MedplumClient_storage, "f").clear();
+        __classPrivateFieldGet(this, _MedplumClient_resourceCache, "f").clear();
+        __classPrivateFieldSet(this, _MedplumClient_accessToken, undefined, "f");
+        __classPrivateFieldSet(this, _MedplumClient_refreshToken, undefined, "f");
+        __classPrivateFieldSet(this, _MedplumClient_profile, undefined, "f");
+        __classPrivateFieldSet(this, _MedplumClient_config, undefined, "f");
+        this.dispatchEvent({ type: 'change' });
+    }
+    get(url) {
+        return __classPrivateFieldGet(this, _MedplumClient_instances, "m", _MedplumClient_request).call(this, 'GET', url);
+    }
+    post(url, body, contentType) {
+        return __classPrivateFieldGet(this, _MedplumClient_instances, "m", _MedplumClient_request).call(this, 'POST', url, contentType, body);
+    }
+    put(url, body, contentType) {
+        return __classPrivateFieldGet(this, _MedplumClient_instances, "m", _MedplumClient_request).call(this, 'PUT', url, contentType, body);
+    }
+    delete(url) {
+        return __classPrivateFieldGet(this, _MedplumClient_instances, "m", _MedplumClient_request).call(this, 'DELETE', url);
+    }
+    /**
+     * Tries to register a new user.
+     * @param request The registration request.
+     * @returns Promise to the authentication response.
+     */
+    register(request) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.post('auth/register', request);
+            yield this.setActiveLogin(response);
+        });
+    }
+    /**
+     * Initiates a user login flow.
+     * @param email The email address of the user.
+     * @param password The password of the user.
+     * @param remember Optional flag to remember the user.
+     * @returns Promise to the authentication response.
+     */
+    startLogin(email, password, remember) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield __classPrivateFieldGet(this, _MedplumClient_instances, "m", _MedplumClient_startPkce).call(this);
+            return this.post('auth/login', {
+                clientId: __classPrivateFieldGet(this, _MedplumClient_clientId, "f"),
+                scope: DEFAULT_SCOPE,
+                codeChallengeMethod: 'S256',
+                codeChallenge: __classPrivateFieldGet(this, _MedplumClient_storage, "f").getString('codeChallenge'),
+                email,
+                password,
+                remember: !!remember,
+            });
+        });
+    }
+    /**
+     * Tries to sign in with Google authentication.
+     * The response parameter is the result of a Google authentication.
+     * See: https://developers.google.com/identity/gsi/web/guides/handle-credential-responses-js-functions
+     * @param googleResponse The Google credential response.
+     * @returns Promise to the authentication response.
+     */
+    startGoogleLogin(googleResponse) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield __classPrivateFieldGet(this, _MedplumClient_instances, "m", _MedplumClient_startPkce).call(this);
+            return this.post('auth/google', googleResponse);
+        });
+    }
+    /**
+     * Signs out locally.
+     * Does not invalidate tokens with the server.
+     */
+    signOut() {
+        this.clear();
+        return Promise.resolve();
+    }
+    /**
+     * Tries to sign in the user.
+     * Returns true if the user is signed in.
+     * This may result in navigating away to the sign in page.
+     */
+    signInWithRedirect() {
+        const urlParams = new URLSearchParams(window.location.search);
+        const code = urlParams.get('code');
+        if (!code) {
+            __classPrivateFieldGet(this, _MedplumClient_instances, "m", _MedplumClient_requestAuthorization).call(this);
+            return undefined;
+        }
+        else {
+            return this.processCode(code);
+        }
+    }
+    /**
+     * Tries to sign out the user.
+     * See: https://docs.aws.amazon.com/cognito/latest/developerguide/logout-endpoint.html
+     */
+    signOutWithRedirect() {
+        window.location.assign(__classPrivateFieldGet(this, _MedplumClient_logoutUrl, "f"));
+    }
+    /**
+     * Builds a FHIR URL from a collection of URL path components.
+     * For example, `buildUrl('/Patient', '123')` returns `fhir/R4/Patient/123`.
+     * @param path The path component of the URL.
+     * @returns The well-formed FHIR URL.
+     */
+    fhirUrl(...path) {
+        const builder = [__classPrivateFieldGet(this, _MedplumClient_baseUrl, "f"), 'fhir/R4'];
+        path.forEach((p) => builder.push('/', encodeURIComponent(p)));
+        return builder.join('');
+    }
+    /**
+     * Sends a FHIR search request.
+     * @param search The search query.
+     * @returns Promise to the search result bundle.
+     */
+    search(search) {
+        return this.get(this.fhirUrl(search.resourceType) + formatSearchQuery(search));
+    }
+    /**
+     * Searches a ValueSet resource using the "expand" operation.
+     * See: https://www.hl7.org/fhir/operation-valueset-expand.html
+     * @param system The ValueSet system url.
+     * @param filter The search string.
+     * @returns Promise to expanded ValueSet.
+     */
+    searchValueSet(system, filter) {
+        return this.get(this.fhirUrl('ValueSet', '$expand') +
+            `?url=${encodeURIComponent(system)}` +
+            `&filter=${encodeURIComponent(filter)}`);
+    }
+    /**
+     * Returns a cached resource if it is available.
+     * @param resourceType The FHIR resource type.
+     * @param id The FHIR resource ID.
+     * @returns The resource if it is available in the cache; undefined otherwise.
+     */
+    getCached(resourceType, id) {
+        const cached = __classPrivateFieldGet(this, _MedplumClient_resourceCache, "f").get(resourceType + '/' + id);
+        if (cached && !('then' in cached)) {
+            return cached;
+        }
+        return undefined;
+    }
+    /**
+     * Returns a cached resource if it is available.
+     * @param resourceType The FHIR resource type.
+     * @param id The FHIR resource ID.
+     * @returns The resource if it is available in the cache; undefined otherwise.
+     */
+    getCachedReference(reference) {
+        const cached = __classPrivateFieldGet(this, _MedplumClient_resourceCache, "f").get(reference.reference);
+        if (cached && !('then' in cached)) {
+            return cached;
+        }
+        return undefined;
+    }
+    read(resourceType, id) {
+        const cacheKey = resourceType + '/' + id;
+        const promise = this.get(this.fhirUrl(resourceType, id)).then((resource) => {
+            __classPrivateFieldGet(this, _MedplumClient_resourceCache, "f").set(cacheKey, resource);
+            return resource;
+        });
+        __classPrivateFieldGet(this, _MedplumClient_resourceCache, "f").set(cacheKey, promise);
+        return promise;
+    }
+    readCached(resourceType, id) {
+        const cached = __classPrivateFieldGet(this, _MedplumClient_resourceCache, "f").get(resourceType + '/' + id);
+        return cached ? Promise.resolve(cached) : this.read(resourceType, id);
+    }
+    readReference(reference) {
+        const refString = reference === null || reference === void 0 ? void 0 : reference.reference;
+        if (!refString) {
+            return Promise.reject('Missing reference');
+        }
+        const [resourceType, id] = refString.split('/');
+        return this.read(resourceType, id);
+    }
+    readCachedReference(reference) {
+        const refString = reference === null || reference === void 0 ? void 0 : reference.reference;
+        if (!refString) {
+            return Promise.reject('Missing reference');
+        }
+        const [resourceType, id] = refString.split('/');
+        return this.readCached(resourceType, id);
+    }
+    /**
+     * Returns a cached schema for a resource type.
+     * If the schema is not cached, returns undefined.
+     * It is assumed that a client will call requestSchema before using this method.
+     * @param resourceType The FHIR resource type.
+     * @returns The schema if immediately available, undefined otherwise.
+     */
+    getSchema() {
+        return __classPrivateFieldGet(this, _MedplumClient_schema, "f");
+    }
+    /**
+     * Requests the schema for a resource type.
+     * If the schema is already cached, the promise is resolved immediately.
+     * @param resourceType The FHIR resource type.
+     * @returns Promise to a schema with the requested resource type.
+     */
+    requestSchema(resourceType) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (resourceType in __classPrivateFieldGet(this, _MedplumClient_schema, "f").types) {
+                return Promise.resolve(__classPrivateFieldGet(this, _MedplumClient_schema, "f"));
+            }
+            const query = `{
+      StructureDefinitionList(name: "${encodeURIComponent(resourceType)}") {
+        name,
+        description,
+        snapshot {
+          element {
+            id,
+            path,
+            min,
+            max,
+            type {
+              code,
+              targetProfile
+            },
+            binding {
+              valueSet
+            },
+            definition
+          }
+        }
+      }
+      SearchParameterList(base: "${encodeURIComponent(resourceType)}") {
+        base,
+        code,
+        type,
+        expression,
+        target
+      }
+    }`.replace(/\s+/g, ' ');
+            const response = (yield this.graphql(query));
+            for (const structureDefinition of response.data.StructureDefinitionList) {
+                indexStructureDefinition(__classPrivateFieldGet(this, _MedplumClient_schema, "f"), structureDefinition);
+            }
+            for (const searchParameter of response.data.SearchParameterList) {
+                indexSearchParameter(__classPrivateFieldGet(this, _MedplumClient_schema, "f"), searchParameter);
+            }
+            return __classPrivateFieldGet(this, _MedplumClient_schema, "f");
+        });
+    }
+    readHistory(resourceType, id) {
+        return this.get(this.fhirUrl(resourceType, id, '_history'));
+    }
+    readPatientEverything(id) {
+        return this.get(this.fhirUrl('Patient', id, '$everything'));
+    }
+    create(resource) {
+        if (!resource.resourceType) {
+            throw new Error('Missing resourceType');
+        }
+        return this.post(this.fhirUrl(resource.resourceType), resource);
+    }
+    createBinary(data, filename, contentType) {
+        return this.post(this.fhirUrl('Binary') + '?_filename=' + encodeURIComponent(filename), data, contentType);
+    }
+    update(resource) {
+        if (!resource.resourceType) {
+            throw new Error('Missing resourceType');
+        }
+        if (!resource.id) {
+            throw new Error('Missing id');
+        }
+        return this.put(this.fhirUrl(resource.resourceType, resource.id), resource);
+    }
+    patch(resourceType, id, operations) {
+        return __classPrivateFieldGet(this, _MedplumClient_instances, "m", _MedplumClient_request).call(this, 'PATCH', this.fhirUrl(resourceType, id), PATCH_CONTENT_TYPE, operations);
+    }
+    deleteResource(resourceType, id) {
+        return this.delete(this.fhirUrl(resourceType, id));
+    }
+    graphql(query) {
+        return this.post(this.fhirUrl('$graphql'), { query }, JSON_CONTENT_TYPE);
+    }
+    getActiveLogin() {
+        return __classPrivateFieldGet(this, _MedplumClient_storage, "f").getObject('activeLogin');
+    }
+    setActiveLogin(login) {
+        return __awaiter(this, void 0, void 0, function* () {
+            __classPrivateFieldSet(this, _MedplumClient_accessToken, login.accessToken, "f");
+            __classPrivateFieldSet(this, _MedplumClient_refreshToken, login.refreshToken, "f");
+            __classPrivateFieldSet(this, _MedplumClient_profile, undefined, "f");
+            __classPrivateFieldSet(this, _MedplumClient_config, undefined, "f");
+            __classPrivateFieldGet(this, _MedplumClient_storage, "f").setObject('activeLogin', login);
+            __classPrivateFieldGet(this, _MedplumClient_instances, "m", _MedplumClient_addLogin).call(this, login);
+            __classPrivateFieldGet(this, _MedplumClient_resourceCache, "f").clear();
+            __classPrivateFieldSet(this, _MedplumClient_refreshPromise, undefined, "f");
+            yield __classPrivateFieldGet(this, _MedplumClient_instances, "m", _MedplumClient_refreshProfile).call(this);
+        });
+    }
+    getLogins() {
+        var _a;
+        return (_a = __classPrivateFieldGet(this, _MedplumClient_storage, "f").getObject('logins')) !== null && _a !== void 0 ? _a : [];
+    }
+    isLoading() {
+        return !!__classPrivateFieldGet(this, _MedplumClient_profilePromise, "f");
+    }
+    getProfile() {
+        return __classPrivateFieldGet(this, _MedplumClient_profile, "f");
+    }
+    getProfileAsync() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (__classPrivateFieldGet(this, _MedplumClient_profilePromise, "f")) {
+                yield __classPrivateFieldGet(this, _MedplumClient_profilePromise, "f");
+            }
+            return this.getProfile();
+        });
+    }
+    getUserConfiguration() {
+        return __classPrivateFieldGet(this, _MedplumClient_config, "f");
+    }
+    /**
+     * Downloads the URL as a blob.
+     * @param url The URL to request.
+     * @returns Promise to the response body as a blob.
+     */
+    download(url) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (__classPrivateFieldGet(this, _MedplumClient_refreshPromise, "f")) {
+                yield __classPrivateFieldGet(this, _MedplumClient_refreshPromise, "f");
+            }
+            const options = __classPrivateFieldGet(this, _MedplumClient_instances, "m", _MedplumClient_buildFetchOptions).call(this, 'GET');
+            const response = yield __classPrivateFieldGet(this, _MedplumClient_fetch, "f").call(this, url, options);
+            return response.blob();
+        });
+    }
+    /**
+     * Processes an OAuth authorization code.
+     * See: https://openid.net/specs/openid-connect-core-1_0.html#TokenRequest
+     * @param code The authorization code received by URL parameter.
+     */
+    processCode(code) {
+        const pkceState = __classPrivateFieldGet(this, _MedplumClient_storage, "f").getString('pkceState');
+        if (!pkceState) {
+            this.clear();
+            throw new Error('Invalid PCKE state');
+        }
+        const codeVerifier = __classPrivateFieldGet(this, _MedplumClient_storage, "f").getString('codeVerifier');
+        if (!codeVerifier) {
+            this.clear();
+            throw new Error('Invalid PCKE code verifier');
+        }
+        return __classPrivateFieldGet(this, _MedplumClient_instances, "m", _MedplumClient_fetchTokens).call(this, 'grant_type=authorization_code' +
+            (__classPrivateFieldGet(this, _MedplumClient_clientId, "f") ? '&client_id=' + encodeURIComponent(__classPrivateFieldGet(this, _MedplumClient_clientId, "f")) : '') +
+            '&code_verifier=' +
+            encodeURIComponent(codeVerifier) +
+            '&redirect_uri=' +
+            encodeURIComponent(getBaseUrl()) +
+            '&code=' +
+            encodeURIComponent(code));
+    }
+}
+_MedplumClient_fetch = new WeakMap(), _MedplumClient_storage = new WeakMap(), _MedplumClient_schema = new WeakMap(), _MedplumClient_resourceCache = new WeakMap(), _MedplumClient_baseUrl = new WeakMap(), _MedplumClient_clientId = new WeakMap(), _MedplumClient_authorizeUrl = new WeakMap(), _MedplumClient_tokenUrl = new WeakMap(), _MedplumClient_logoutUrl = new WeakMap(), _MedplumClient_onUnauthenticated = new WeakMap(), _MedplumClient_accessToken = new WeakMap(), _MedplumClient_refreshToken = new WeakMap(), _MedplumClient_refreshPromise = new WeakMap(), _MedplumClient_profilePromise = new WeakMap(), _MedplumClient_profile = new WeakMap(), _MedplumClient_config = new WeakMap(), _MedplumClient_instances = new WeakSet(), _MedplumClient_addLogin = function _MedplumClient_addLogin(newLogin) {
+    const logins = this.getLogins().filter((login) => { var _a, _b; return ((_a = login.profile) === null || _a === void 0 ? void 0 : _a.reference) !== ((_b = newLogin.profile) === null || _b === void 0 ? void 0 : _b.reference); });
+    logins.push(newLogin);
+    __classPrivateFieldGet(this, _MedplumClient_storage, "f").setObject('logins', logins);
+}, _MedplumClient_refreshProfile = function _MedplumClient_refreshProfile() {
+    return __awaiter(this, void 0, void 0, function* () {
+        __classPrivateFieldSet(this, _MedplumClient_profilePromise, new Promise((resolve, reject) => {
+            this.get('auth/me')
+                .then((result) => {
+                __classPrivateFieldSet(this, _MedplumClient_profilePromise, undefined, "f");
+                __classPrivateFieldSet(this, _MedplumClient_profile, result.profile, "f");
+                __classPrivateFieldSet(this, _MedplumClient_config, result.config, "f");
+                this.dispatchEvent({ type: 'change' });
+                resolve(__classPrivateFieldGet(this, _MedplumClient_profile, "f"));
+            })
+                .catch(reject);
+        }), "f");
+        return __classPrivateFieldGet(this, _MedplumClient_profilePromise, "f");
+    });
+}, _MedplumClient_request = function _MedplumClient_request(method, url, contentType, body) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (__classPrivateFieldGet(this, _MedplumClient_refreshPromise, "f")) {
+            yield __classPrivateFieldGet(this, _MedplumClient_refreshPromise, "f");
+        }
+        if (!url.startsWith('http')) {
+            url = __classPrivateFieldGet(this, _MedplumClient_baseUrl, "f") + url;
+        }
+        const options = __classPrivateFieldGet(this, _MedplumClient_instances, "m", _MedplumClient_buildFetchOptions).call(this, method, contentType, body);
+        const response = yield __classPrivateFieldGet(this, _MedplumClient_fetch, "f").call(this, url, options);
+        if (response.status === 401) {
+            // Refresh and try again
+            return __classPrivateFieldGet(this, _MedplumClient_instances, "m", _MedplumClient_handleUnauthenticated).call(this, method, url, contentType, body);
+        }
+        if (response.status === 204 || response.status === 304) {
+            // No content or change
+            return undefined;
+        }
+        const obj = yield response.json();
+        if (obj.resourceType === 'OperationOutcome' && !isOk(obj)) {
+            return Promise.reject(obj);
+        }
+        return obj;
+    });
+}, _MedplumClient_buildFetchOptions = function _MedplumClient_buildFetchOptions(method, contentType, body) {
+    const headers = {
+        'Content-Type': contentType || FHIR_CONTENT_TYPE,
+    };
+    if (__classPrivateFieldGet(this, _MedplumClient_accessToken, "f")) {
+        headers['Authorization'] = 'Bearer ' + __classPrivateFieldGet(this, _MedplumClient_accessToken, "f");
+    }
+    const options = {
+        method: method,
+        cache: 'no-cache',
+        credentials: 'include',
+        headers,
+    };
+    if (body) {
+        if (typeof body === 'string' || (typeof File !== 'undefined' && body instanceof File)) {
+            options.body = body;
+        }
+        else {
+            options.body = stringify(body);
+        }
+    }
+    return options;
+}, _MedplumClient_handleUnauthenticated = function _MedplumClient_handleUnauthenticated(method, url, contentType, body) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return __classPrivateFieldGet(this, _MedplumClient_instances, "m", _MedplumClient_refresh).call(this)
+            .then(() => __classPrivateFieldGet(this, _MedplumClient_instances, "m", _MedplumClient_request).call(this, method, url, contentType, body))
+            .catch((error) => {
+            this.clear();
+            if (__classPrivateFieldGet(this, _MedplumClient_onUnauthenticated, "f")) {
+                __classPrivateFieldGet(this, _MedplumClient_onUnauthenticated, "f").call(this);
+            }
+            return Promise.reject(error);
+        });
+    });
+}, _MedplumClient_startPkce = function _MedplumClient_startPkce() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const pkceState = getRandomString();
+        __classPrivateFieldGet(this, _MedplumClient_storage, "f").setString('pkceState', pkceState);
+        const codeVerifier = getRandomString();
+        __classPrivateFieldGet(this, _MedplumClient_storage, "f").setString('codeVerifier', codeVerifier);
+        const arrayHash = yield encryptSHA256(codeVerifier);
+        const codeChallenge = arrayBufferToBase64(arrayHash).replace(/\+/g, '-').replace(/\//g, '_').replace(/=/g, '');
+        __classPrivateFieldGet(this, _MedplumClient_storage, "f").setString('codeChallenge', codeChallenge);
+    });
+}, _MedplumClient_requestAuthorization = function _MedplumClient_requestAuthorization() {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (!__classPrivateFieldGet(this, _MedplumClient_authorizeUrl, "f")) {
+            throw new Error('Missing authorize URL');
+        }
+        __classPrivateFieldGet(this, _MedplumClient_instances, "m", _MedplumClient_startPkce).call(this);
+        window.location.assign(__classPrivateFieldGet(this, _MedplumClient_authorizeUrl, "f") +
+            '?response_type=code' +
+            '&state=' +
+            encodeURIComponent(__classPrivateFieldGet(this, _MedplumClient_storage, "f").getString('pkceState')) +
+            '&client_id=' +
+            encodeURIComponent(__classPrivateFieldGet(this, _MedplumClient_clientId, "f")) +
+            '&redirect_uri=' +
+            encodeURIComponent(getBaseUrl()) +
+            '&scope=' +
+            encodeURIComponent(DEFAULT_SCOPE) +
+            '&code_challenge_method=S256' +
+            '&code_challenge=' +
+            encodeURIComponent(__classPrivateFieldGet(this, _MedplumClient_storage, "f").getString('codeChallenge')));
+    });
+}, _MedplumClient_refresh = function _MedplumClient_refresh() {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (__classPrivateFieldGet(this, _MedplumClient_refreshPromise, "f")) {
+            return __classPrivateFieldGet(this, _MedplumClient_refreshPromise, "f");
+        }
+        if (!__classPrivateFieldGet(this, _MedplumClient_refreshToken, "f")) {
+            this.clear();
+            return Promise.reject('Invalid refresh token');
+        }
+        __classPrivateFieldSet(this, _MedplumClient_refreshPromise, __classPrivateFieldGet(this, _MedplumClient_instances, "m", _MedplumClient_fetchTokens).call(this, 'grant_type=refresh_token' +
+            '&client_id=' +
+            encodeURIComponent(__classPrivateFieldGet(this, _MedplumClient_clientId, "f")) +
+            '&refresh_token=' +
+            encodeURIComponent(__classPrivateFieldGet(this, _MedplumClient_refreshToken, "f"))), "f");
+        yield __classPrivateFieldGet(this, _MedplumClient_refreshPromise, "f");
+    });
+}, _MedplumClient_fetchTokens = function _MedplumClient_fetchTokens(formBody) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (!__classPrivateFieldGet(this, _MedplumClient_tokenUrl, "f")) {
+            return Promise.reject('Missing token URL');
+        }
+        return __classPrivateFieldGet(this, _MedplumClient_fetch, "f").call(this, __classPrivateFieldGet(this, _MedplumClient_tokenUrl, "f"), {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
+            body: formBody,
+        })
+            .then((response) => {
+            if (!response.ok) {
+                return Promise.reject('Failed to fetch tokens');
+            }
+            return response.json();
+        })
+            .then((tokens) => __classPrivateFieldGet(this, _MedplumClient_instances, "m", _MedplumClient_verifyTokens).call(this, tokens))
+            .then(() => this.getProfile());
+    });
+}, _MedplumClient_verifyTokens = function _MedplumClient_verifyTokens(tokens) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const token = tokens.access_token;
+        // Verify token has not expired
+        const tokenPayload = parseJWTPayload(token);
+        if (Date.now() >= tokenPayload.exp * 1000) {
+            this.clear();
+            return Promise.reject('Token expired');
+        }
+        // Verify app_client_id
+        if (__classPrivateFieldGet(this, _MedplumClient_clientId, "f") && tokenPayload.client_id !== __classPrivateFieldGet(this, _MedplumClient_clientId, "f")) {
+            this.clear();
+            return Promise.reject('Token was not issued for this audience');
+        }
+        yield this.setActiveLogin({
+            accessToken: token,
+            refreshToken: tokens.refresh_token,
+            project: tokens.project,
+            profile: tokens.profile,
+        });
+    });
+}, _MedplumClient_setupStorageListener = function _MedplumClient_setupStorageListener() {
+    try {
+        window.addEventListener('storage', (e) => {
+            if (e.key === null || e.key === 'activeLogin') {
+                // Storage events fire when different tabs make changes.
+                // On storage clear (key === null) or activeLogin change (key === 'activeLogin')
+                // Refresh the page to ensure the active login is up to date.
+                window.location.reload();
+            }
+        });
+    }
+    catch (err) {
+        // Silently ignore if this environment does not support storage events
+    }
+};
+/**
+ * Returns the base URL for the current page.
+ */
+function getBaseUrl() {
+    return window.location.protocol + '//' + window.location.host + '/';
+}
+
+var SearchParameterType;
+(function (SearchParameterType) {
+    SearchParameterType["BOOLEAN"] = "BOOLEAN";
+    SearchParameterType["NUMBER"] = "NUMBER";
+    SearchParameterType["QUANTITY"] = "QUANTITY";
+    SearchParameterType["TEXT"] = "TEXT";
+    SearchParameterType["REFERENCE"] = "REFERENCE";
+    SearchParameterType["DATE"] = "DATE";
+    SearchParameterType["DATETIME"] = "DATETIME";
+    SearchParameterType["PERIOD"] = "PERIOD";
+})(SearchParameterType || (SearchParameterType = {}));
+/**
+ * Returns the type details of a SearchParameter.
+ *
+ * The SearchParameter resource has a "type" parameter, but that is missing some critical information.
+ *
+ * For example:
+ *   1) The "date" type includes "date", "datetime", and "period".
+ *   2) The "token" type includes enums and booleans.
+ *   3) Arrays/multiple values are not reflected at all.
+ *
+ * @param structureDefinitions Collection of StructureDefinition resources indexed by name.
+ * @param resourceType The root resource type.
+ * @param searchParam The search parameter.
+ * @returns The search parameter type details.
+ */
+function getSearchParameterDetails(structureDefinitions, resourceType, searchParam) {
+    var _a, _b, _c, _d;
+    if (searchParam.code === '_lastUpdated') {
+        return { columnName: 'lastUpdated', type: SearchParameterType.DATETIME };
+    }
+    const columnName = convertCodeToColumnName(searchParam.code);
+    const expression = (_a = getExpressionForResourceType(resourceType, searchParam.expression)) === null || _a === void 0 ? void 0 : _a.split('.');
+    if (!expression) {
+        // This happens on compound types
+        // In the future, explore returning multiple column definitions
+        return { columnName, type: SearchParameterType.TEXT };
+    }
+    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 = (_c = (_b = structureDefinitions.types[baseType]) === null || _b === void 0 ? void 0 : _b.properties) === null || _c === void 0 ? void 0 : _c[propertyName];
+        if (!elementDefinition) {
+            // This happens on complex properties such as "collected[x]"/"collectedDateTime"/"collectedPeriod"
+            // In the future, explore returning multiple column definitions
+            return { columnName, type: SearchParameterType.TEXT, array };
+        }
+        if (elementDefinition.max === '*') {
+            array = true;
+        }
+        propertyType = (_d = elementDefinition.type) === null || _d === void 0 ? void 0 : _d[0].code;
+        if (!propertyType) {
+            // This happens when one of parent properties uses contentReference
+            // In the future, explore following the reference
+            return { columnName, type: SearchParameterType.TEXT, array };
+        }
+        if (i < expression.length - 1) {
+            if (propertyType === 'Element' || propertyType === 'BackboneElement') {
+                baseType = baseType + capitalize(propertyName);
+            }
+            else {
+                baseType = propertyType;
+            }
+        }
+    }
+    const type = getSearchParameterType(searchParam, propertyType);
+    return { columnName, type, elementDefinition, array };
+}
+/**
+ * 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 = SearchParameterType.TEXT;
+    switch (searchParam.type) {
+        case 'date':
+            type = SearchParameterType.DATE;
+            break;
+        case 'number':
+            type = SearchParameterType.NUMBER;
+            break;
+        case 'quantity':
+            type = SearchParameterType.QUANTITY;
+            break;
+        case 'reference':
+            type = SearchParameterType.REFERENCE;
+            break;
+        case 'token':
+            if (propertyType === 'boolean') {
+                type = SearchParameterType.BOOLEAN;
+            }
+            break;
+    }
+    return type;
+}
+function getExpressionForResourceType(resourceType, expression) {
+    const expressions = expression.split(' | ');
+    for (const e of expressions) {
+        const simplified = simplifyExpression(e);
+        if (simplified.startsWith(resourceType + '.')) {
+            return simplified;
+        }
+    }
+    return undefined;
+}
+function simplifyExpression(input) {
+    let result = input.trim();
+    if (result.startsWith('(') && result.endsWith(')')) {
+        result = result.substring(1, result.length - 1);
+    }
+    if (result.includes(' as ')) {
+        result = result.substring(0, result.indexOf(' as '));
+    }
+    if (result.includes('.where(')) {
+        result = result.substring(0, result.indexOf('.where('));
+    }
+    return result;
+}
+
+export { MedplumClient, OperationOutcomeError, Operator, PropertyType, SearchParameterType, accessDenied, allOk, arrayBufferToBase64, arrayBufferToHex, assertOk, badRequest, buildTypeName, capitalize, createReference, createSchema, createTypeSchema, created, deepEquals, formatAddress, formatFamilyName, formatGivenName, formatHumanName, formatSearchQuery, getDateProperty, getDisplayString, getExpressionForResourceType, getImageSrc, getPropertyDisplayName, getReferenceString, getSearchParameterDetails, getStatus, gone, indexSearchParameter, indexStructureDefinition, isGone, isLowerCase, isNotFound, isOk, isProfileResource, notFound, notModified, parseSearchDefinition, resolveId, stringify };
+//# sourceMappingURL=index.js.map