@medplum/core 0.2.0 → 0.4.0

package/dist/esm/index.js

@@ -0,0 +1,1721 @@
+/*! *****************************************************************************
+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());
+    });
+}
+
+/**
+ * LRU cache (least recently used)
+ * Source: https://stackoverflow.com/a/46432113
+ */
+class LRUCache {
+    constructor(max = 10) {
+        this.max = max;
+        this.cache = new Map();
+    }
+    clear() {
+        this.cache.clear();
+    }
+    get(key) {
+        const item = this.cache.get(key);
+        if (item) {
+            this.cache.delete(key);
+            this.cache.set(key, item);
+        }
+        return item;
+    }
+    set(key, val) {
+        if (this.cache.has(key)) {
+            this.cache.delete(key);
+        }
+        else if (this.cache.size >= this.max) {
+            this.cache.delete(this.first());
+        }
+        this.cache.set(key, val);
+    }
+    first() {
+        // This works because the Map class maintains ordered keys.
+        return this.cache.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 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
+ */
+class EventTarget {
+    constructor() {
+        this.listeners = {};
+    }
+    addEventListener(type, callback) {
+        if (!this.listeners[type]) {
+            this.listeners[type] = [];
+        }
+        this.listeners[type].push(callback);
+    }
+    removeEventListeneer(type, callback) {
+        const array = this.listeners[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 = this.listeners[event.type];
+        if (array) {
+            array.forEach((listener) => listener.call(this, event));
+        }
+        return !event.defaultPrevented;
+    }
+}
+
+/**
+ * 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.split('/').pop();
+    const params = new URLSearchParams(location.search);
+    const filters = [];
+    const sortRules = [];
+    let fields;
+    let page = 0;
+    let count = 10;
+    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 === '_sort') {
+            sortRules.push(parseSortRule(value));
+        }
+        else {
+            filters.push(parseSearchFilter(key, value));
+        }
+    });
+    return {
+        resourceType,
+        filters,
+        fields,
+        page,
+        count,
+        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) => {
+            const modifier = MODIFIER_OPERATORS.includes(filter.operator) ? ':' + filter.operator : '';
+            const prefix = PREFIX_OPERATORS.includes(filter.operator) ? filter.operator : '';
+            params.push(`${filter.code}${modifier}=${prefix}${encodeURIComponent(filter.value)}`);
+        });
+    }
+    if (definition.sortRules) {
+        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 (params.length === 0) {
+        return '';
+    }
+    params.sort();
+    return '?' + params.join('&');
+}
+function formatSortRules(sortRules) {
+    if (!sortRules || sortRules.length === 0) {
+        return '';
+    }
+    return '_sort=' + sortRules.map((sr) => (sr.descending ? '-' + sr.code : sr.code)).join(',');
+}
+
+/**
+ * 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() {
+        this.storage = typeof localStorage !== 'undefined' ? localStorage : new MemoryStorage();
+    }
+    clear() {
+        this.storage.clear();
+    }
+    getString(key) {
+        return this.storage.getItem(key) || undefined;
+    }
+    setString(key, value) {
+        if (value) {
+            this.storage.setItem(key, value);
+        }
+        else {
+            this.storage.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);
+    }
+}
+/**
+ * The MemoryStorage class is a minimal in-memory implementation of the Storage interface.
+ */
+class MemoryStorage {
+    constructor() {
+        this.data = new Map();
+    }
+    /**
+     * Returns the number of key/value pairs.
+     */
+    get length() {
+        return this.data.size;
+    }
+    /**
+     * Removes all key/value pairs, if there are any.
+     */
+    clear() {
+        this.data.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 = this.data.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) {
+            this.data.set(key, value);
+        }
+        else {
+            this.data.delete(key);
+        }
+    }
+    /**
+     * Removes the key/value pair with the given key, if a key/value pair with the given key exists.
+     */
+    removeItem(key) {
+        this.data.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(this.data.keys())[index];
+    }
+}
+
+/**
+ * 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: {} };
+}
+/**
+ * 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] = {
+        display: typeName,
+        description: structureDefinition.description,
+        properties: {},
+    };
+    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] = {
+            display: typeName,
+            description: element.definition,
+            parentType: buildTypeName(parts.slice(0, parts.length - 1)),
+            properties: {},
+        };
+    }
+}
+/**
+ * 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();
+    // 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:
+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();
+        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');
+            }
+        }
+        this.fetch = (options === null || options === void 0 ? void 0 : options.fetch) || window.fetch.bind(window);
+        this.storage = new ClientStorage();
+        this.schema = createSchema();
+        this.resourceCache = new LRUCache((_a = options === null || options === void 0 ? void 0 : options.resourceCacheSize) !== null && _a !== void 0 ? _a : DEFAULT_RESOURCE_CACHE_SIZE);
+        this.baseUrl = (options === null || options === void 0 ? void 0 : options.baseUrl) || DEFAULT_BASE_URL;
+        this.clientId = (options === null || options === void 0 ? void 0 : options.clientId) || '';
+        this.authorizeUrl = (options === null || options === void 0 ? void 0 : options.authorizeUrl) || this.baseUrl + 'oauth2/authorize';
+        this.tokenUrl = (options === null || options === void 0 ? void 0 : options.tokenUrl) || this.baseUrl + 'oauth2/token';
+        this.logoutUrl = (options === null || options === void 0 ? void 0 : options.logoutUrl) || this.baseUrl + 'oauth2/logout';
+        this.onUnauthenticated = options === null || options === void 0 ? void 0 : options.onUnauthenticated;
+        this.loading = false;
+        this.refreshProfile().catch(console.log);
+        this.setupStorageListener();
+    }
+    /**
+     * Clears all auth state including local storage and session storage.
+     */
+    clear() {
+        this.storage.clear();
+        this.resourceCache.clear();
+        this.dispatchEvent({ type: 'change' });
+    }
+    get(url) {
+        return this.request('GET', url);
+    }
+    post(url, body, contentType) {
+        return this.request('POST', url, contentType, body);
+    }
+    put(url, body, contentType) {
+        return this.request('PUT', url, contentType, body);
+    }
+    delete(url) {
+        return this.request('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 this.startPkce();
+            return this.post('auth/login', {
+                clientId: this.clientId,
+                scope: DEFAULT_SCOPE,
+                codeChallengeMethod: 'S256',
+                codeChallenge: this.storage.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 this.startPkce();
+            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) {
+            this.requestAuthorization();
+            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(this.logoutUrl);
+    }
+    /**
+     * 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 = [this.baseUrl, '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 = this.resourceCache.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 = this.resourceCache.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) => {
+            this.resourceCache.set(cacheKey, resource);
+            return resource;
+        });
+        this.resourceCache.set(cacheKey, promise);
+        return promise;
+    }
+    readCached(resourceType, id) {
+        const cached = this.resourceCache.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 this.schema;
+    }
+    /**
+     * 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 this.schema.types) {
+                return Promise.resolve(this.schema);
+            }
+            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
+      }
+    }`.replace(/\s+/g, ' ');
+            const response = (yield this.graphql(query));
+            for (const structureDefinition of response.data.StructureDefinitionList) {
+                indexStructureDefinition(this.schema, structureDefinition);
+            }
+            for (const searchParameter of response.data.SearchParameterList) {
+                indexSearchParameter(this.schema, searchParameter);
+            }
+            return this.schema;
+        });
+    }
+    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 this.request('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 this.storage.getObject('activeLogin');
+    }
+    setActiveLogin(login) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.storage.setObject('activeLogin', login);
+            this.addLogin(login);
+            this.resourceCache.clear();
+            this.refreshPromise = undefined;
+            yield this.refreshProfile();
+        });
+    }
+    getLogins() {
+        var _a;
+        return (_a = this.storage.getObject('logins')) !== null && _a !== void 0 ? _a : [];
+    }
+    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);
+        this.storage.setObject('logins', logins);
+    }
+    refreshProfile() {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            const reference = (_a = this.getActiveLogin()) === null || _a === void 0 ? void 0 : _a.profile;
+            if (reference === null || reference === void 0 ? void 0 : reference.reference) {
+                this.loading = true;
+                this.storage.setObject('profile', yield this.readCachedReference(reference));
+                this.loading = false;
+                this.dispatchEvent({ type: 'change' });
+            }
+            return this.getProfile();
+        });
+    }
+    getProfile() {
+        return this.storage.getObject('profile');
+    }
+    isLoading() {
+        return this.loading;
+    }
+    /**
+     * Makes an HTTP request.
+     * @param {string} method
+     * @param {string} url
+     * @param {string=} contentType
+     * @param {Object=} body
+     */
+    request(method, url, contentType, body) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.refreshPromise) {
+                yield this.refreshPromise;
+            }
+            if (!url.startsWith('http')) {
+                url = this.baseUrl + url;
+            }
+            const headers = {
+                'Content-Type': contentType || FHIR_CONTENT_TYPE,
+            };
+            const accessToken = (_a = this.getActiveLogin()) === null || _a === void 0 ? void 0 : _a.accessToken;
+            if (accessToken) {
+                headers['Authorization'] = 'Bearer ' + accessToken;
+            }
+            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);
+                }
+            }
+            const response = yield this.fetch(url, options);
+            if (response.status === 401) {
+                // Refresh and try again
+                return this.handleUnauthenticated(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;
+        });
+    }
+    /**
+     * Handles an unauthenticated response from the server.
+     * First, tries to refresh the access token and retry the request.
+     * Otherwise, calls unauthenticated callbacks and rejects.
+     * @param method The HTTP method of the original request.
+     * @param url The URL of the original request.
+     * @param contentType The content type of the original request.
+     * @param body The body of the original request.
+     */
+    handleUnauthenticated(method, url, contentType, body) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.refresh()
+                .then(() => this.request(method, url, contentType, body))
+                .catch((error) => {
+                this.clear();
+                if (this.onUnauthenticated) {
+                    this.onUnauthenticated();
+                }
+                return Promise.reject(error);
+            });
+        });
+    }
+    /**
+     * Starts a new PKCE flow.
+     * These PKCE values are stateful, and must survive redirects and page refreshes.
+     */
+    startPkce() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const pkceState = getRandomString();
+            this.storage.setString('pkceState', pkceState);
+            const codeVerifier = getRandomString();
+            this.storage.setString('codeVerifier', codeVerifier);
+            const arrayHash = yield encryptSHA256(codeVerifier);
+            const codeChallenge = arrayBufferToBase64(arrayHash).replace(/\+/g, '-').replace(/\//g, '_').replace(/=/g, '');
+            this.storage.setString('codeChallenge', codeChallenge);
+        });
+    }
+    /**
+     * Redirects the user to the login screen for authorization.
+     * Clears all auth state including local storage and session storage.
+     * See: https://openid.net/specs/openid-connect-core-1_0.html#AuthorizationEndpoint
+     */
+    requestAuthorization() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.authorizeUrl) {
+                throw new Error('Missing authorize URL');
+            }
+            this.startPkce();
+            window.location.assign(this.authorizeUrl +
+                '?response_type=code' +
+                '&state=' +
+                encodeURIComponent(this.storage.getString('pkceState')) +
+                '&client_id=' +
+                encodeURIComponent(this.clientId) +
+                '&redirect_uri=' +
+                encodeURIComponent(getBaseUrl()) +
+                '&scope=' +
+                encodeURIComponent(DEFAULT_SCOPE) +
+                '&code_challenge_method=S256' +
+                '&code_challenge=' +
+                encodeURIComponent(this.storage.getString('codeChallenge')));
+        });
+    }
+    /**
+     * 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 = this.storage.getString('pkceState');
+        if (!pkceState) {
+            this.clear();
+            throw new Error('Invalid PCKE state');
+        }
+        const codeVerifier = this.storage.getString('codeVerifier');
+        if (!codeVerifier) {
+            this.clear();
+            throw new Error('Invalid PCKE code verifier');
+        }
+        return this.fetchTokens('grant_type=authorization_code' +
+            (this.clientId ? '&client_id=' + encodeURIComponent(this.clientId) : '') +
+            '&code_verifier=' +
+            encodeURIComponent(codeVerifier) +
+            '&redirect_uri=' +
+            encodeURIComponent(getBaseUrl()) +
+            '&code=' +
+            encodeURIComponent(code));
+    }
+    /**
+     * Tries to refresh the auth tokens.
+     * See: https://openid.net/specs/openid-connect-core-1_0.html#RefreshTokens
+     */
+    refresh() {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.refreshPromise) {
+                return this.refreshPromise;
+            }
+            const refreshToken = (_a = this.getActiveLogin()) === null || _a === void 0 ? void 0 : _a.refreshToken;
+            if (!refreshToken) {
+                this.clear();
+                return Promise.reject('Invalid refresh token');
+            }
+            this.refreshPromise = this.fetchTokens('grant_type=refresh_token' +
+                '&client_id=' +
+                encodeURIComponent(this.clientId) +
+                '&refresh_token=' +
+                encodeURIComponent(refreshToken));
+            yield this.refreshPromise;
+        });
+    }
+    /**
+     * Makes a POST request to the tokens endpoint.
+     * See: https://openid.net/specs/openid-connect-core-1_0.html#TokenEndpoint
+     * @param formBody Token parameters in URL encoded format.
+     */
+    fetchTokens(formBody) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.tokenUrl) {
+                return Promise.reject('Missing token URL');
+            }
+            return this.fetch(this.tokenUrl, {
+                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) => this.verifyTokens(tokens))
+                .then(() => this.getProfile());
+        });
+    }
+    /**
+     * Verifies the tokens received from the auth server.
+     * Validates the JWT against the JWKS.
+     * See: https://openid.net/specs/openid-connect-core-1_0.html#TokenEndpoint
+     * @param tokens
+     */
+    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 (this.clientId && tokenPayload.client_id !== this.clientId) {
+                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,
+            });
+        });
+    }
+    /**
+     * Sets up a listener for window storage events.
+     * This synchronizes state across browser windows and browser tabs.
+     */
+    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;
+    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 propertyType = undefined;
+    let array = false;
+    for (let i = 1; i < expression.length; i++) {
+        const propertyName = expression[i];
+        const propertyDef = (_c = (_b = structureDefinitions.types[baseType]) === null || _b === void 0 ? void 0 : _b.properties) === null || _c === void 0 ? void 0 : _c[propertyName];
+        if (!propertyDef) {
+            // 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 (propertyDef.max === '*') {
+            array = true;
+        }
+        propertyType = (_d = propertyDef.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, 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, 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, stringify };
+//# sourceMappingURL=index.js.map