@medplum/core 2.0.24 → 2.0.26

package/dist/esm/client.mjs

@@ -1,2168 +0,0 @@
-import { encodeBase64 } from './base64.mjs';
-import { LRUCache } from './cache.mjs';
-import { getRandomString, encryptSHA256 } from './crypto.mjs';
-import { EventTarget } from './eventtarget.mjs';
-import { parseJWTPayload } from './jwt.mjs';
-import { isOperationOutcome, OperationOutcomeError, notFound, normalizeOperationOutcome, isOk, badRequest } from './outcomes.mjs';
-import { ReadablePromise } from './readablepromise.mjs';
-import { ClientStorage } from './storage.mjs';
-import { globalSchema, indexStructureDefinition, indexSearchParameter } from './types.mjs';
-import { createReference, arrayBufferToBase64 } from './utils.mjs';
-
-// PKCE auth based on:
-// https://aws.amazon.com/blogs/security/how-to-add-authentication-single-page-web-application-with-amazon-cognito-oauth2-implementation/
-const MEDPLUM_VERSION = "2.0.24-8a2dc16" ;
-const DEFAULT_BASE_URL = 'https://api.medplum.com/';
-const DEFAULT_RESOURCE_CACHE_SIZE = 1000;
-const DEFAULT_CACHE_TIME = 60000; // 60 seconds
-const JSON_CONTENT_TYPE = 'application/json';
-const FHIR_CONTENT_TYPE = 'application/fhir+json';
-const PATCH_CONTENT_TYPE = 'application/json-patch+json';
-const system = { resourceType: 'Device', id: 'system', deviceName: [{ name: 'System' }] };
-/**
- * OAuth 2.0 Grant Type Identifiers
- * Standard identifiers defined here: https://datatracker.ietf.org/doc/html/draft-ietf-oauth-v2-1-07#name-grant-types
- * Token exchange extension defined here: https://datatracker.ietf.org/doc/html/rfc8693
- */
-var OAuthGrantType;
-(function (OAuthGrantType) {
-    OAuthGrantType["ClientCredentials"] = "client_credentials";
-    OAuthGrantType["AuthorizationCode"] = "authorization_code";
-    OAuthGrantType["RefreshToken"] = "refresh_token";
-    OAuthGrantType["TokenExchange"] = "urn:ietf:params:oauth:grant-type:token-exchange";
-})(OAuthGrantType || (OAuthGrantType = {}));
-/**
- * OAuth 2.0 Token Type Identifiers
- * See: https://datatracker.ietf.org/doc/html/rfc8693#name-token-type-identifiers
- */
-var OAuthTokenType;
-(function (OAuthTokenType) {
-    /** Indicates that the token is an OAuth 2.0 access token issued by the given authorization server. */
-    OAuthTokenType["AccessToken"] = "urn:ietf:params:oauth:token-type:access_token";
-    /** Indicates that the token is an OAuth 2.0 refresh token issued by the given authorization server. */
-    OAuthTokenType["RefreshToken"] = "urn:ietf:params:oauth:token-type:refresh_token";
-    /** Indicates that the token is an ID Token as defined in Section 2 of [OpenID.Core]. */
-    OAuthTokenType["IdToken"] = "urn:ietf:params:oauth:token-type:id_token";
-    /** Indicates that the token is a base64url-encoded SAML 1.1 [OASIS.saml-core-1.1] assertion. */
-    OAuthTokenType["Saml1Token"] = "urn:ietf:params:oauth:token-type:saml1";
-    /** Indicates that the token is a base64url-encoded SAML 2.0 [OASIS.saml-core-2.0-os] assertion. */
-    OAuthTokenType["Saml2Token"] = "urn:ietf:params:oauth:token-type:saml2";
-})(OAuthTokenType || (OAuthTokenType = {}));
-/**
- * The MedplumClient class provides a client for the Medplum FHIR server.
- *
- * The client can be used in the browser, in a Node.js application, or in a Medplum Bot.
- *
- * The client provides helpful methods for common operations such as:
- *   1) Authenticating
- *   2) Creating resources
- *   2) Reading resources
- *   3) Updating resources
- *   5) Deleting resources
- *   6) Searching
- *   7) Making GraphQL queries
- *
- * Here is a quick example of how to use the client:
- *
- * ```typescript
- * import { MedplumClient } from '@medplum/core';
- * const medplum = new MedplumClient();
- * ```
- *
- * Create a `Patient`:
- *
- * ```typescript
- * const patient = await medplum.createResource({
- *   resourceType: 'Patient',
- *   name: [{
- *     given: ['Alice'],
- *     family: 'Smith'
- *   }]
- * });
- * ```
- *
- * Read a `Patient` by ID:
- *
- * ```typescript
- * const patient = await medplum.readResource('Patient', '123');
- * console.log(patient.name[0].given[0]);
- * ```
- *
- * Search for a `Patient` by name:
- *
- * ```typescript
- * const bundle = await medplum.search('Patient', 'name=Alice');
- * console.log(bundle.total);
- * ```
- *
- *  <head>
- *    <meta name="algolia:pageRank" content="100" />
- *  </head>
- */
-class MedplumClient extends EventTarget {
-    constructor(options) {
-        super();
-        if (options?.baseUrl) {
-            if (!options.baseUrl.startsWith('http')) {
-                throw new Error('Base URL must start with http or https');
-            }
-        }
-        this.fetch = options?.fetch ?? getDefaultFetch();
-        this.storage = options?.storage || new ClientStorage();
-        this.createPdfImpl = options?.createPdf;
-        this.baseUrl = ensureTrailingSlash(options?.baseUrl) || DEFAULT_BASE_URL;
-        this.fhirBaseUrl = this.baseUrl + (ensureTrailingSlash(options?.fhirUrlPath) || 'fhir/R4/');
-        this.clientId = options?.clientId || '';
-        this.authorizeUrl = options?.authorizeUrl || this.baseUrl + 'oauth2/authorize';
-        this.tokenUrl = options?.tokenUrl || this.baseUrl + 'oauth2/token';
-        this.logoutUrl = options?.logoutUrl || this.baseUrl + 'oauth2/logout';
-        this.onUnauthenticated = options?.onUnauthenticated;
-        this.cacheTime = options?.cacheTime ?? DEFAULT_CACHE_TIME;
-        if (this.cacheTime > 0) {
-            this.requestCache = new LRUCache(options?.resourceCacheSize ?? DEFAULT_RESOURCE_CACHE_SIZE);
-        }
-        else {
-            this.requestCache = undefined;
-        }
-        if (options?.autoBatchTime) {
-            this.autoBatchTime = options.autoBatchTime ?? 0;
-            this.autoBatchQueue = [];
-        }
-        else {
-            this.autoBatchTime = 0;
-            this.autoBatchQueue = undefined;
-        }
-        const activeLogin = this.getActiveLogin();
-        if (activeLogin) {
-            this.accessToken = activeLogin.accessToken;
-            this.refreshToken = activeLogin.refreshToken;
-            this.refreshProfile().catch(console.log);
-        }
-        this.setupStorageListener();
-    }
-    /**
-     * Returns the current base URL for all API requests.
-     * By default, this is set to `https://api.medplum.com/`.
-     * This can be overridden by setting the `baseUrl` option when creating the client.
-     * @category HTTP
-     * @returns The current base URL for all API requests.
-     */
-    getBaseUrl() {
-        return this.baseUrl;
-    }
-    /**
-     * Returns the current authorize URL.
-     * By default, this is set to `https://api.medplum.com/oauth2/authorize`.
-     * This can be overridden by setting the `authorizeUrl` option when creating the client.
-     * @category HTTP
-     * @returns The current authorize URL.
-     */
-    getAuthorizeUrl() {
-        return this.authorizeUrl;
-    }
-    /**
-     * Clears all auth state including local storage and session storage.
-     * @category Authentication
-     */
-    clear() {
-        this.storage.clear();
-        this.clearActiveLogin();
-    }
-    /**
-     * Clears the active login from local storage.
-     * Does not clear all local storage (such as other logins).
-     * @category Authentication
-     */
-    clearActiveLogin() {
-        if (this.basicAuth) {
-            return;
-        }
-        this.storage.setString('activeLogin', undefined);
-        this.requestCache?.clear();
-        this.accessToken = undefined;
-        this.refreshToken = undefined;
-        this.sessionDetails = undefined;
-        this.dispatchEvent({ type: 'change' });
-    }
-    /**
-     * Invalidates any cached values or cached requests for the given URL.
-     * @category Caching
-     * @param url The URL to invalidate.
-     */
-    invalidateUrl(url) {
-        url = url.toString();
-        this.requestCache?.delete(url);
-    }
-    /**
-     * Invalidates all cached values and flushes the cache.
-     * @category Caching
-     */
-    invalidateAll() {
-        this.requestCache?.clear();
-    }
-    /**
-     * Invalidates all cached search results or cached requests for the given resourceType.
-     * @category Caching
-     * @param resourceType The resource type to invalidate.
-     */
-    invalidateSearches(resourceType) {
-        const url = this.fhirBaseUrl + resourceType;
-        if (this.requestCache) {
-            for (const key of this.requestCache.keys()) {
-                if (key.endsWith(url) || key.includes(url + '?')) {
-                    this.requestCache.delete(key);
-                }
-            }
-        }
-    }
-    /**
-     * Makes an HTTP GET request to the specified URL.
-     *
-     * This is a lower level method for custom requests.
-     * For common operations, we recommend using higher level methods
-     * such as `readResource()`, `search()`, etc.
-     * @category HTTP
-     * @param url The target URL.
-     * @param options Optional fetch options.
-     * @returns Promise to the response content.
-     */
-    get(url, options = {}) {
-        url = url.toString();
-        const cached = this.getCacheEntry(url, options);
-        if (cached) {
-            return cached.value;
-        }
-        let promise;
-        if (url.startsWith(this.fhirBaseUrl) && this.autoBatchQueue) {
-            promise = new Promise((resolve, reject) => {
-                this.autoBatchQueue.push({
-                    method: 'GET',
-                    url: url.replace(this.fhirBaseUrl, ''),
-                    options,
-                    resolve,
-                    reject,
-                });
-                if (!this.autoBatchTimerId) {
-                    this.autoBatchTimerId = setTimeout(() => this.executeAutoBatch(), this.autoBatchTime);
-                }
-            });
-        }
-        else {
-            promise = this.request('GET', url, options);
-        }
-        const readablePromise = new ReadablePromise(promise);
-        this.setCacheEntry(url, readablePromise);
-        return readablePromise;
-    }
-    /**
-     * Makes an HTTP POST request to the specified URL.
-     *
-     * This is a lower level method for custom requests.
-     * For common operations, we recommend using higher level methods
-     * such as `createResource()`.
-     * @category HTTP
-     * @param url The target URL.
-     * @param body The content body. Strings and `File` objects are passed directly. Other objects are converted to JSON.
-     * @param contentType The content type to be included in the "Content-Type" header.
-     * @param options Optional fetch options.
-     * @returns Promise to the response content.
-     */
-    post(url, body, contentType, options = {}) {
-        url = url.toString();
-        if (body) {
-            this.setRequestBody(options, body);
-        }
-        if (contentType) {
-            this.setRequestContentType(options, contentType);
-        }
-        this.invalidateUrl(url);
-        return this.request('POST', url, options);
-    }
-    /**
-     * Makes an HTTP PUT request to the specified URL.
-     *
-     * This is a lower level method for custom requests.
-     * For common operations, we recommend using higher level methods
-     * such as `updateResource()`.
-     * @category HTTP
-     * @param url The target URL.
-     * @param body The content body. Strings and `File` objects are passed directly. Other objects are converted to JSON.
-     * @param contentType The content type to be included in the "Content-Type" header.
-     * @param options Optional fetch options.
-     * @returns Promise to the response content.
-     */
-    put(url, body, contentType, options = {}) {
-        url = url.toString();
-        if (body) {
-            this.setRequestBody(options, body);
-        }
-        if (contentType) {
-            this.setRequestContentType(options, contentType);
-        }
-        this.invalidateUrl(url);
-        return this.request('PUT', url, options);
-    }
-    /**
-     * Makes an HTTP PATCH request to the specified URL.
-     *
-     * This is a lower level method for custom requests.
-     * For common operations, we recommend using higher level methods
-     * such as `patchResource()`.
-     * @category HTTP
-     * @param url The target URL.
-     * @param operations Array of JSONPatch operations.
-     * @param options Optional fetch options.
-     * @returns Promise to the response content.
-     */
-    patch(url, operations, options = {}) {
-        url = url.toString();
-        this.setRequestBody(options, operations);
-        this.setRequestContentType(options, PATCH_CONTENT_TYPE);
-        this.invalidateUrl(url);
-        return this.request('PATCH', url, options);
-    }
-    /**
-     * Makes an HTTP DELETE request to the specified URL.
-     *
-     *
-     * This is a lower level method for custom requests.
-     * For common operations, we recommend using higher level methods
-     * such as `deleteResource()`.
-     * @category HTTP
-     * @param url The target URL.
-     * @param options Optional fetch options.
-     * @returns Promise to the response content.
-     */
-    delete(url, options) {
-        url = url.toString();
-        this.invalidateUrl(url);
-        return this.request('DELETE', url, options);
-    }
-    /**
-     * Initiates a new user flow.
-     *
-     * This method is part of the two different user registration flows:
-     * 1) New Practitioner and new Project
-     * 2) New Patient registration
-     * @category Authentication
-     * @param newUserRequest Register request including email and password.
-     * @param options Optional fetch options.
-     * @returns Promise to the authentication response.
-     */
-    async startNewUser(newUserRequest, options) {
-        const { codeChallengeMethod, codeChallenge } = await this.startPkce();
-        return this.post('auth/newuser', {
-            ...newUserRequest,
-            codeChallengeMethod,
-            codeChallenge,
-        }, undefined, options);
-    }
-    /**
-     * Initiates a new project flow.
-     *
-     * This requires a partial login from `startNewUser` or `startNewGoogleUser`.
-     * @param newProjectRequest Register request including email and password.
-     * @param options Optional fetch options.
-     * @returns Promise to the authentication response.
-     */
-    async startNewProject(newProjectRequest, options) {
-        return this.post('auth/newproject', newProjectRequest, undefined, options);
-    }
-    /**
-     * Initiates a new patient flow.
-     *
-     * This requires a partial login from `startNewUser` or `startNewGoogleUser`.
-     * @param newPatientRequest Register request including email and password.
-     * @param options Optional fetch options.
-     * @returns Promise to the authentication response.
-     */
-    async startNewPatient(newPatientRequest, options) {
-        return this.post('auth/newpatient', newPatientRequest, undefined, options);
-    }
-    /**
-     * Initiates a user login flow.
-     * @category Authentication
-     * @param loginRequest Login request including email and password.
-     * @param options Optional fetch options.
-     * @returns Promise to the authentication response.
-     */
-    async startLogin(loginRequest, options) {
-        return this.post('auth/login', {
-            ...(await this.ensureCodeChallenge(loginRequest)),
-            clientId: loginRequest.clientId ?? this.clientId,
-            scope: loginRequest.scope,
-        }, undefined, options);
-    }
-    /**
-     * 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
-     * @category Authentication
-     * @param loginRequest Login request including Google credential response.
-     * @param options Optional fetch options.
-     * @returns Promise to the authentication response.
-     */
-    async startGoogleLogin(loginRequest, options) {
-        return this.post('auth/google', {
-            ...(await this.ensureCodeChallenge(loginRequest)),
-            clientId: loginRequest.clientId ?? this.clientId,
-            scope: loginRequest.scope,
-        }, undefined, options);
-    }
-    /**
-     * Returns the PKCE code challenge and method.
-     * If the login request already includes a code challenge, it is returned.
-     * Otherwise, a new PKCE code challenge is generated.
-     * @category Authentication
-     * @param loginRequest The original login request.
-     * @returns The PKCE code challenge and method.
-     */
-    async ensureCodeChallenge(loginRequest) {
-        if (loginRequest.codeChallenge) {
-            return loginRequest;
-        }
-        return { ...loginRequest, ...(await this.startPkce()) };
-    }
-    /**
-     * Signs out locally.
-     * Does not invalidate tokens with the server.
-     * @category Authentication
-     */
-    async signOut() {
-        await this.post(this.logoutUrl, {});
-        this.clear();
-    }
-    /**
-     * 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.
-     * @category Authentication
-     * @param loginParams Optional login parameters.
-     * @returns The user profile resource if available.
-     */
-    async signInWithRedirect(loginParams) {
-        const urlParams = new URLSearchParams(window.location.search);
-        const code = urlParams.get('code');
-        if (!code) {
-            await this.requestAuthorization(loginParams);
-            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
-     * @category Authentication
-     */
-    signOutWithRedirect() {
-        window.location.assign(this.logoutUrl);
-    }
-    /**
-     * Initiates sign in with an external identity provider.
-     * @param authorizeUrl The external authorization URL.
-     * @param clientId The external client ID.
-     * @param redirectUri The external identity provider redirect URI.
-     * @param baseLogin The Medplum login request.
-     * @category Authentication
-     */
-    async signInWithExternalAuth(authorizeUrl, clientId, redirectUri, baseLogin) {
-        const loginRequest = await this.ensureCodeChallenge(baseLogin);
-        window.location.assign(this.getExternalAuthRedirectUri(authorizeUrl, clientId, redirectUri, loginRequest));
-    }
-    /**
-     * Exchange an external access token for a Medplum access token.
-     * @param token The access token that was generated by the external identity provider.
-     * @param clientId The ID of the `ClientApplication` in your Medplum project that will be making the exchange request.
-     * @returns The user profile resource.
-     * @category Authentication
-     */
-    async exchangeExternalAccessToken(token, clientId) {
-        clientId = clientId || this.clientId;
-        if (!clientId) {
-            throw new Error('MedplumClient is missing clientId');
-        }
-        const formBody = new URLSearchParams();
-        formBody.set('grant_type', OAuthGrantType.TokenExchange);
-        formBody.set('subject_token_type', OAuthTokenType.AccessToken);
-        formBody.set('client_id', clientId);
-        formBody.set('subject_token', token);
-        return this.fetchTokens(formBody);
-    }
-    /**
-     * Builds the external identity provider redirect URI.
-     * @param authorizeUrl The external authorization URL.
-     * @param clientId The external client ID.
-     * @param redirectUri The external identity provider redirect URI.
-     * @param loginRequest  The Medplum login request.
-     * @returns The external identity provider redirect URI.
-     * @category Authentication
-     */
-    getExternalAuthRedirectUri(authorizeUrl, clientId, redirectUri, loginRequest) {
-        const url = new URL(authorizeUrl);
-        url.searchParams.set('response_type', 'code');
-        url.searchParams.set('client_id', clientId);
-        url.searchParams.set('redirect_uri', redirectUri);
-        url.searchParams.set('scope', 'openid profile email');
-        url.searchParams.set('state', JSON.stringify(loginRequest));
-        return url.toString();
-    }
-    /**
-     * Builds a FHIR URL from a collection of URL path components.
-     * For example, `buildUrl('/Patient', '123')` returns `fhir/R4/Patient/123`.
-     * @category HTTP
-     * @param path The path component of the URL.
-     * @returns The well-formed FHIR URL.
-     */
-    fhirUrl(...path) {
-        return new URL(this.fhirBaseUrl + path.join('/'));
-    }
-    /**
-     * Builds a FHIR search URL from a search query or structured query object.
-     * @category HTTP
-     * @category Search
-     * @param resourceType The FHIR resource type.
-     * @param query The FHIR search query or structured query object. Can be any valid input to the URLSearchParams() constructor.
-     * @returns The well-formed FHIR URL.
-     */
-    fhirSearchUrl(resourceType, query) {
-        const url = this.fhirUrl(resourceType);
-        if (query) {
-            url.search = new URLSearchParams(query).toString();
-        }
-        return url;
-    }
-    /**
-     * Sends a FHIR search request.
-     *
-     * Example using a FHIR search string:
-     *
-     * ```typescript
-     * const bundle = await client.search('Patient', 'name=Alice');
-     * console.log(bundle);
-     * ```
-     *
-     * The return value is a FHIR bundle:
-     *
-     * ```json
-     * {
-     *    "resourceType": "Bundle",
-     *    "type": "searchset",
-     *    "entry": [
-     *       {
-     *          "resource": {
-     *             "resourceType": "Patient",
-     *             "name": [
-     *                {
-     *                   "given": [
-     *                      "George"
-     *                   ],
-     *                   "family": "Washington"
-     *                }
-     *             ],
-     *          }
-     *       }
-     *    ]
-     * }
-     * ```
-     *
-     * To query the count of a search, use the summary feature like so:
-     *
-     * ```typescript
-     * const patients = medplum.search('Patient', '_summary=count');
-     * ```
-     *
-     * See FHIR search for full details: https://www.hl7.org/fhir/search.html
-     * @category Search
-     * @param resourceType The FHIR resource type.
-     * @param query Optional FHIR search query or structured query object. Can be any valid input to the URLSearchParams() constructor.
-     * @param options Optional fetch options.
-     * @returns Promise to the search result bundle.
-     */
-    search(resourceType, query, options) {
-        const url = this.fhirSearchUrl(resourceType, query);
-        const cacheKey = url.toString() + '-search';
-        const cached = this.getCacheEntry(cacheKey, options);
-        if (cached) {
-            return cached.value;
-        }
-        const promise = new ReadablePromise((async () => {
-            const bundle = await this.get(url, options);
-            if (bundle.entry) {
-                for (const entry of bundle.entry) {
-                    this.cacheResource(entry.resource);
-                }
-            }
-            return bundle;
-        })());
-        this.setCacheEntry(cacheKey, promise);
-        return promise;
-    }
-    /**
-     * Sends a FHIR search request for a single resource.
-     *
-     * This is a convenience method for `search()` that returns the first resource rather than a `Bundle`.
-     *
-     * Example using a FHIR search string:
-     *
-     * ```typescript
-     * const patient = await client.searchOne('Patient', 'identifier=123');
-     * console.log(patient);
-     * ```
-     *
-     * The return value is the resource, if available; otherwise, undefined.
-     *
-     * See FHIR search for full details: https://www.hl7.org/fhir/search.html
-     * @category Search
-     * @param resourceType The FHIR resource type.
-     * @param query Optional FHIR search query or structured query object. Can be any valid input to the URLSearchParams() constructor.
-     * @param options Optional fetch options.
-     * @returns Promise to the first search result.
-     */
-    searchOne(resourceType, query, options) {
-        const url = this.fhirSearchUrl(resourceType, query);
-        url.searchParams.set('_count', '1');
-        url.searchParams.sort();
-        const cacheKey = url.toString() + '-searchOne';
-        const cached = this.getCacheEntry(cacheKey, options);
-        if (cached) {
-            return cached.value;
-        }
-        const promise = new ReadablePromise(this.search(resourceType, url.searchParams, options).then((b) => b.entry?.[0]?.resource));
-        this.setCacheEntry(cacheKey, promise);
-        return promise;
-    }
-    /**
-     * Sends a FHIR search request for an array of resources.
-     *
-     * This is a convenience method for `search()` that returns the resources as an array rather than a `Bundle`.
-     *
-     * Example using a FHIR search string:
-     *
-     * ```typescript
-     * const patients = await client.searchResources('Patient', 'name=Alice');
-     * console.log(patients);
-     * ```
-     *
-     * The return value is an array of resources.
-     *
-     * See FHIR search for full details: https://www.hl7.org/fhir/search.html
-     * @category Search
-     * @param resourceType The FHIR resource type.
-     * @param query Optional FHIR search query or structured query object. Can be any valid input to the URLSearchParams() constructor.
-     * @param options Optional fetch options.
-     * @returns Promise to the array of search results.
-     */
-    searchResources(resourceType, query, options) {
-        const url = this.fhirSearchUrl(resourceType, query);
-        const cacheKey = url.toString() + '-searchResources';
-        const cached = this.getCacheEntry(cacheKey, options);
-        if (cached) {
-            return cached.value;
-        }
-        const promise = new ReadablePromise(this.search(resourceType, query, options).then((b) => b.entry?.map((e) => e.resource) ?? []));
-        this.setCacheEntry(cacheKey, promise);
-        return promise;
-    }
-    /**
-     * Creates an
-     * [async generator](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/AsyncGenerator)
-     * over a series of FHIR search requests for paginated search results. Each iteration of the generator yields
-     * the array of resources on each page.
-     *
-     *
-     * ```typescript
-     * for await (const page of medplum.searchResourcePages('Patient', { _count: 10 })) {
-     *  for (const patient of page) {
-     *    console.log(`Processing Patient resource with ID: ${patient.id}`);
-     *  }
-     * }
-     * ```
-     * @category Search
-     * @param resourceType The FHIR resource type.
-     * @param query Optional FHIR search query or structured query object. Can be any valid input to the URLSearchParams() constructor.
-     * @param options Optional fetch options.
-     * @yields An async generator, where each result is an array of resources for each page.
-     */
-    async *searchResourcePages(resourceType, query, options) {
-        let url = this.fhirSearchUrl(resourceType, query);
-        while (url) {
-            const searchParams = new URL(url).searchParams;
-            const bundle = await this.search(resourceType, searchParams, options);
-            const nextLink = bundle.link?.find((link) => link.relation === 'next');
-            if (!bundle.entry?.length && !nextLink) {
-                break;
-            }
-            yield bundle.entry?.map((e) => e.resource) ?? [];
-            url = nextLink?.url ? new URL(nextLink.url) : undefined;
-        }
-    }
-    /**
-     * Searches a ValueSet resource using the "expand" operation.
-     * See: https://www.hl7.org/fhir/operation-valueset-expand.html
-     * @category Search
-     * @param system The ValueSet system url.
-     * @param filter The search string.
-     * @param options Optional fetch options.
-     * @returns Promise to expanded ValueSet.
-     */
-    searchValueSet(system, filter, options) {
-        const url = this.fhirUrl('ValueSet', '$expand');
-        url.searchParams.set('url', system);
-        url.searchParams.set('filter', filter);
-        return this.get(url.toString(), options);
-    }
-    /**
-     * Returns a cached resource if it is available.
-     * @category Caching
-     * @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.requestCache?.get(this.fhirUrl(resourceType, id).toString())?.value;
-        return cached?.isOk() ? cached.read() : undefined;
-    }
-    /**
-     * Returns a cached resource if it is available.
-     * @category Caching
-     * @param reference The FHIR reference.
-     * @returns The resource if it is available in the cache; undefined otherwise.
-     */
-    getCachedReference(reference) {
-        const refString = reference.reference;
-        if (!refString) {
-            return undefined;
-        }
-        if (refString === 'system') {
-            return system;
-        }
-        const [resourceType, id] = refString.split('/');
-        if (!resourceType || !id) {
-            return undefined;
-        }
-        return this.getCached(resourceType, id);
-    }
-    /**
-     * Reads a resource by resource type and ID.
-     *
-     * Example:
-     *
-     * ```typescript
-     * const patient = await medplum.readResource('Patient', '123');
-     * console.log(patient);
-     * ```
-     *
-     * See the FHIR "read" operation for full details: https://www.hl7.org/fhir/http.html#read
-     * @category Read
-     * @param resourceType The FHIR resource type.
-     * @param id The resource ID.
-     * @param options Optional fetch options.
-     * @returns The resource if available; undefined otherwise.
-     */
-    readResource(resourceType, id, options) {
-        return this.get(this.fhirUrl(resourceType, id), options);
-    }
-    /**
-     * Reads a resource by `Reference`.
-     *
-     * This is a convenience method for `readResource()` that accepts a `Reference` object.
-     *
-     * Example:
-     *
-     * ```typescript
-     * const serviceRequest = await medplum.readResource('ServiceRequest', '123');
-     * const patient = await medplum.readReference(serviceRequest.subject);
-     * console.log(patient);
-     * ```
-     *
-     * See the FHIR "read" operation for full details: https://www.hl7.org/fhir/http.html#read
-     * @category Read
-     * @param reference The FHIR reference object.
-     * @param options Optional fetch options.
-     * @returns The resource if available; undefined otherwise.
-     */
-    readReference(reference, options) {
-        const refString = reference.reference;
-        if (!refString) {
-            return new ReadablePromise(Promise.reject(new Error('Missing reference')));
-        }
-        if (refString === 'system') {
-            return new ReadablePromise(Promise.resolve(system));
-        }
-        const [resourceType, id] = refString.split('/');
-        if (!resourceType || !id) {
-            return new ReadablePromise(Promise.reject(new Error('Invalid reference')));
-        }
-        return this.readResource(resourceType, id, options);
-    }
-    /**
-     * 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.
-     * @category Schema
-     * @returns The schema if immediately available, undefined otherwise.
-     * @deprecated Use globalSchema instead.
-     */
-    getSchema() {
-        return globalSchema;
-    }
-    /**
-     * Requests the schema for a resource type.
-     * If the schema is already cached, the promise is resolved immediately.
-     * @category Schema
-     * @param resourceType The FHIR resource type.
-     * @returns Promise to a schema with the requested resource type.
-     */
-    requestSchema(resourceType) {
-        if (resourceType in globalSchema.types) {
-            return Promise.resolve(globalSchema);
-        }
-        const cacheKey = resourceType + '-requestSchema';
-        const cached = this.getCacheEntry(cacheKey, undefined);
-        if (cached) {
-            return cached.value;
-        }
-        const promise = new ReadablePromise((async () => {
-            const query = `{
-      StructureDefinitionList(name: "${resourceType}") {
-        name,
-        description,
-        snapshot {
-          element {
-            id,
-            path,
-            min,
-            max,
-            type {
-              code,
-              targetProfile
-            },
-            binding {
-              valueSet
-            },
-            definition
-          }
-        }
-      }
-      SearchParameterList(base: "${resourceType}", _count: 100) {
-        base,
-        code,
-        type,
-        expression,
-        target
-      }
-    }`.replace(/\s+/g, ' ');
-            const response = (await this.graphql(query));
-            for (const structureDefinition of response.data.StructureDefinitionList) {
-                indexStructureDefinition(structureDefinition);
-            }
-            for (const searchParameter of response.data.SearchParameterList) {
-                indexSearchParameter(searchParameter);
-            }
-            return globalSchema;
-        })());
-        this.setCacheEntry(cacheKey, promise);
-        return promise;
-    }
-    /**
-     * Reads resource history by resource type and ID.
-     *
-     * The return value is a bundle of all versions of the resource.
-     *
-     * Example:
-     *
-     * ```typescript
-     * const history = await medplum.readHistory('Patient', '123');
-     * console.log(history);
-     * ```
-     *
-     * See the FHIR "history" operation for full details: https://www.hl7.org/fhir/http.html#history
-     * @category Read
-     * @param resourceType The FHIR resource type.
-     * @param id The resource ID.
-     * @param options Optional fetch options.
-     * @returns Promise to the resource history.
-     */
-    readHistory(resourceType, id, options) {
-        return this.get(this.fhirUrl(resourceType, id, '_history'), options);
-    }
-    /**
-     * Reads a specific version of a resource by resource type, ID, and version ID.
-     *
-     * Example:
-     *
-     * ```typescript
-     * const version = await medplum.readVersion('Patient', '123', '456');
-     * console.log(version);
-     * ```
-     *
-     * See the FHIR "vread" operation for full details: https://www.hl7.org/fhir/http.html#vread
-     * @category Read
-     * @param resourceType The FHIR resource type.
-     * @param id The resource ID.
-     * @param vid The version ID.
-     * @param options Optional fetch options.
-     * @returns The resource if available; undefined otherwise.
-     */
-    readVersion(resourceType, id, vid, options) {
-        return this.get(this.fhirUrl(resourceType, id, '_history', vid), options);
-    }
-    /**
-     * Executes the Patient "everything" operation for a patient.
-     *
-     * Example:
-     *
-     * ```typescript
-     * const bundle = await medplum.readPatientEverything('123');
-     * console.log(bundle);
-     * ```
-     *
-     * See the FHIR "patient-everything" operation for full details: https://hl7.org/fhir/operation-patient-everything.html
-     * @category Read
-     * @param id The Patient Id
-     * @param options Optional fetch options.
-     * @returns A Bundle of all Resources related to the Patient
-     */
-    readPatientEverything(id, options) {
-        return this.get(this.fhirUrl('Patient', id, '$everything'), options);
-    }
-    /**
-     * Creates a new FHIR resource.
-     *
-     * The return value is the newly created resource, including the ID and meta.
-     *
-     * Example:
-     *
-     * ```typescript
-     * const result = await medplum.createResource({
-     *   resourceType: 'Patient',
-     *   name: [{
-     *    family: 'Smith',
-     *    given: ['John']
-     *   }]
-     * });
-     * console.log(result.id);
-     * ```
-     *
-     * See the FHIR "create" operation for full details: https://www.hl7.org/fhir/http.html#create
-     * @category Create
-     * @param resource The FHIR resource to create.
-     * @param options Optional fetch options.
-     * @returns The result of the create operation.
-     */
-    createResource(resource, options) {
-        if (!resource.resourceType) {
-            throw new Error('Missing resourceType');
-        }
-        this.invalidateSearches(resource.resourceType);
-        return this.post(this.fhirUrl(resource.resourceType), resource, undefined, options);
-    }
-    /**
-     * Conditionally create a new FHIR resource only if some equivalent resource does not already exist on the server.
-     *
-     * The return value is the existing resource or the newly created resource, including the ID and meta.
-     *
-     * Example:
-     *
-     * ```typescript
-     * const result = await medplum.createResourceIfNoneExist(
-     *   {
-     *     resourceType: 'Patient',
-     *     identifier: [{
-     *      system: 'http://example.com/mrn',
-     *      value: '123'
-     *     }]
-     *     name: [{
-     *      family: 'Smith',
-     *      given: ['John']
-     *     }]
-     *   },
-     *   'identifier=123'
-     * );
-     * console.log(result.id);
-     * ```
-     *
-     * This method is syntactic sugar for:
-     *
-     * ```typescript
-     * return searchOne(resourceType, query) ?? createResource(resource);
-     * ```
-     *
-     * The query parameter only contains the search parameters (what would be in the URL following the "?").
-     *
-     * See the FHIR "conditional create" operation for full details: https://www.hl7.org/fhir/http.html#ccreate
-     * @category Create
-     * @param resource The FHIR resource to create.
-     * @param query The search query for an equivalent resource (should not include resource type or "?").
-     * @param options Optional fetch options.
-     * @returns The result of the create operation.
-     */
-    async createResourceIfNoneExist(resource, query, options) {
-        return ((await this.searchOne(resource.resourceType, query, options)) ??
-            this.createResource(resource, options));
-    }
-    /**
-     * Creates a FHIR `Binary` resource with the provided data content.
-     *
-     * The return value is the newly created resource, including the ID and meta.
-     *
-     * The `data` parameter can be a string or a `File` object.
-     *
-     * A `File` object often comes from a `<input type="file">` element.
-     *
-     * Example:
-     *
-     * ```typescript
-     * const result = await medplum.createBinary(myFile, 'test.jpg', 'image/jpeg');
-     * console.log(result.id);
-     * ```
-     *
-     * See the FHIR "create" operation for full details: https://www.hl7.org/fhir/http.html#create
-     * @category Create
-     * @param data The binary data to upload.
-     * @param filename Optional filename for the binary.
-     * @param contentType Content type for the binary.
-     * @param onProgress Optional callback for progress events.
-     * @returns The result of the create operation.
-     */
-    createBinary(data, filename, contentType, onProgress) {
-        const url = this.fhirUrl('Binary');
-        if (filename) {
-            url.searchParams.set('_filename', filename);
-        }
-        if (onProgress) {
-            return this.uploadwithProgress(url, data, contentType, onProgress);
-        }
-        else {
-            return this.post(url, data, contentType);
-        }
-    }
-    uploadwithProgress(url, data, contentType, onProgress) {
-        return new Promise((resolve, reject) => {
-            const xhr = new XMLHttpRequest();
-            xhr.responseType = 'json';
-            xhr.onabort = () => reject(new Error('Request aborted'));
-            xhr.onerror = () => reject(new Error('Request error'));
-            if (onProgress) {
-                xhr.upload.onprogress = (e) => onProgress(e);
-                xhr.upload.onload = (e) => onProgress(e);
-            }
-            xhr.onload = () => {
-                if (xhr.status >= 200 && xhr.status < 300) {
-                    resolve(xhr.response);
-                }
-                else {
-                    reject(new Error(xhr.statusText));
-                }
-            };
-            xhr.open('POST', url);
-            xhr.withCredentials = true;
-            xhr.setRequestHeader('Authorization', 'Bearer ' + this.accessToken);
-            xhr.setRequestHeader('Cache-Control', 'no-cache, no-store, max-age=0');
-            xhr.setRequestHeader('Content-Type', contentType);
-            xhr.setRequestHeader('X-Medplum', 'extended');
-            xhr.send(data);
-        });
-    }
-    /**
-     * Creates a PDF as a FHIR `Binary` resource based on pdfmake document definition.
-     *
-     * The return value is the newly created resource, including the ID and meta.
-     *
-     * The `docDefinition` parameter is a pdfmake document definition.
-     *
-     * Example:
-     *
-     * ```typescript
-     * const result = await medplum.createPdf({
-     *   content: ['Hello world']
-     * });
-     * console.log(result.id);
-     * ```
-     *
-     * See the pdfmake document definition for full details: https://pdfmake.github.io/docs/0.1/document-definition-object/
-     * @category Media
-     * @param docDefinition The PDF document definition.
-     * @param filename Optional filename for the PDF binary resource.
-     * @param tableLayouts Optional pdfmake custom table layout.
-     * @param fonts Optional pdfmake custom font dictionary.
-     * @returns The result of the create operation.
-     */
-    async createPdf(docDefinition, filename, tableLayouts, fonts) {
-        if (!this.createPdfImpl) {
-            throw new Error('PDF creation not enabled');
-        }
-        const blob = await this.createPdfImpl(docDefinition, tableLayouts, fonts);
-        return this.createBinary(blob, filename, 'application/pdf');
-    }
-    /**
-     * Creates a FHIR `Communication` resource with the provided data content.
-     *
-     * This is a convenience method to handle commmon cases where a `Communication` resource is created with a `payload`.
-     * @category Create
-     * @param resource The FHIR resource to comment on.
-     * @param text The text of the comment.
-     * @param options Optional fetch options.
-     * @returns The result of the create operation.
-     */
-    createComment(resource, text, options) {
-        const profile = this.getProfile();
-        let encounter = undefined;
-        let subject = undefined;
-        if (resource.resourceType === 'Encounter') {
-            encounter = createReference(resource);
-            subject = resource.subject;
-        }
-        if (resource.resourceType === 'ServiceRequest') {
-            encounter = resource.encounter;
-            subject = resource.subject;
-        }
-        if (resource.resourceType === 'Patient') {
-            subject = createReference(resource);
-        }
-        return this.createResource({
-            resourceType: 'Communication',
-            basedOn: [createReference(resource)],
-            encounter,
-            subject,
-            sender: profile ? createReference(profile) : undefined,
-            sent: new Date().toISOString(),
-            payload: [{ contentString: text }],
-        }, options);
-    }
-    /**
-     * Updates a FHIR resource.
-     *
-     * The return value is the updated resource, including the ID and meta.
-     *
-     * Example:
-     *
-     * ```typescript
-     * const result = await medplum.updateResource({
-     *   resourceType: 'Patient',
-     *   id: '123',
-     *   name: [{
-     *    family: 'Smith',
-     *    given: ['John']
-     *   }]
-     * });
-     * console.log(result.meta.versionId);
-     * ```
-     *
-     * See the FHIR "update" operation for full details: https://www.hl7.org/fhir/http.html#update
-     * @category Write
-     * @param resource The FHIR resource to update.
-     * @param options Optional fetch options.
-     * @returns The result of the update operation.
-     */
-    async updateResource(resource, options) {
-        if (!resource.resourceType) {
-            throw new Error('Missing resourceType');
-        }
-        if (!resource.id) {
-            throw new Error('Missing id');
-        }
-        this.invalidateSearches(resource.resourceType);
-        let result = await this.put(this.fhirUrl(resource.resourceType, resource.id), resource, undefined, options);
-        if (!result) {
-            // On 304 not modified, result will be undefined
-            // Return the user input instead
-            // return result ?? resource;
-            result = resource;
-        }
-        this.cacheResource(result);
-        return result;
-    }
-    /**
-     * Updates a FHIR resource using JSONPatch operations.
-     *
-     * The return value is the updated resource, including the ID and meta.
-     *
-     * Example:
-     *
-     * ```typescript
-     * const result = await medplum.patchResource('Patient', '123', [
-     *   {op: 'replace', path: '/name/0/family', value: 'Smith'},
-     * ]);
-     * console.log(result.meta.versionId);
-     * ```
-     *
-     * See the FHIR "update" operation for full details: https://www.hl7.org/fhir/http.html#patch
-     *
-     * See the JSONPatch specification for full details: https://tools.ietf.org/html/rfc6902
-     * @category Write
-     * @param resourceType The FHIR resource type.
-     * @param id The resource ID.
-     * @param operations The JSONPatch operations.
-     * @param options Optional fetch options.
-     * @returns The result of the patch operations.
-     */
-    patchResource(resourceType, id, operations, options) {
-        this.invalidateSearches(resourceType);
-        return this.patch(this.fhirUrl(resourceType, id), operations, options);
-    }
-    /**
-     * Deletes a FHIR resource by resource type and ID.
-     *
-     * Example:
-     *
-     * ```typescript
-     * await medplum.deleteResource('Patient', '123');
-     * ```
-     *
-     * See the FHIR "delete" operation for full details: https://www.hl7.org/fhir/http.html#delete
-     * @category Delete
-     * @param resourceType The FHIR resource type.
-     * @param id The resource ID.
-     * @param options Optional fetch options.
-     * @returns The result of the delete operation.
-     */
-    deleteResource(resourceType, id, options) {
-        this.deleteCacheEntry(this.fhirUrl(resourceType, id).toString());
-        this.invalidateSearches(resourceType);
-        return this.delete(this.fhirUrl(resourceType, id), options);
-    }
-    /**
-     * Executes the validate operation with the provided resource.
-     *
-     * Example:
-     *
-     * ```typescript
-     * const result = await medplum.validateResource({
-     *   resourceType: 'Patient',
-     *   name: [{ given: ['Alice'], family: 'Smith' }],
-     * });
-     * ```
-     *
-     * See the FHIR "$validate" operation for full details: https://www.hl7.org/fhir/resource-operation-validate.html
-     * @param resource The FHIR resource.
-     * @param options Optional fetch options.
-     * @returns The validate operation outcome.
-     */
-    validateResource(resource, options) {
-        return this.post(this.fhirUrl(resource.resourceType, '$validate'), resource, undefined, options);
-    }
-    /**
-     * Executes a bot by ID or Identifier.
-     * @param idOrIdentifier The Bot ID or Identifier.
-     * @param body The content body. Strings and `File` objects are passed directly. Other objects are converted to JSON.
-     * @param contentType The content type to be included in the "Content-Type" header.
-     * @param options Optional fetch options.
-     * @returns The Bot return value.
-     */
-    executeBot(idOrIdentifier, body, contentType, options) {
-        let url;
-        if (typeof idOrIdentifier === 'string') {
-            const id = idOrIdentifier;
-            url = this.fhirUrl('Bot', id, '$execute');
-        }
-        else {
-            const identifier = idOrIdentifier;
-            url = this.fhirUrl('Bot', '$execute') + `?identifier=${identifier.system}|${identifier.value}`;
-        }
-        return this.post(url, body, contentType, options);
-    }
-    /**
-     * Executes a batch or transaction of FHIR operations.
-     *
-     * Example:
-     *
-     * ```typescript
-     * await medplum.executeBatch({
-     *   "resourceType": "Bundle",
-     *   "type": "transaction",
-     *   "entry": [
-     *     {
-     *       "fullUrl": "urn:uuid:61ebe359-bfdc-4613-8bf2-c5e300945f0a",
-     *       "resource": {
-     *         "resourceType": "Patient",
-     *         "name": [{ "use": "official", "given": ["Alice"], "family": "Smith" }],
-     *         "gender": "female",
-     *         "birthDate": "1974-12-25"
-     *       },
-     *       "request": {
-     *         "method": "POST",
-     *         "url": "Patient"
-     *       }
-     *     },
-     *     {
-     *       "fullUrl": "urn:uuid:88f151c0-a954-468a-88bd-5ae15c08e059",
-     *       "resource": {
-     *         "resourceType": "Patient",
-     *         "identifier": [{ "system": "http:/example.org/fhir/ids", "value": "234234" }],
-     *         "name": [{ "use": "official", "given": ["Bob"], "family": "Jones" }],
-     *         "gender": "male",
-     *         "birthDate": "1974-12-25"
-     *       },
-     *       "request": {
-     *         "method": "POST",
-     *         "url": "Patient",
-     *         "ifNoneExist": "identifier=http:/example.org/fhir/ids|234234"
-     *       }
-     *     }
-     *   ]
-     * });
-     * ```
-     *
-     * See The FHIR "batch/transaction" section for full details: https://hl7.org/fhir/http.html#transaction
-     * @category Batch
-     * @param bundle The FHIR batch/transaction bundle.
-     * @param options Optional fetch options.
-     * @returns The FHIR batch/transaction response bundle.
-     */
-    executeBatch(bundle, options) {
-        return this.post(this.fhirBaseUrl.slice(0, -1), bundle, undefined, options);
-    }
-    /**
-     * Sends an email using the Medplum Email API.
-     *
-     * Builds the email using nodemailer MailComposer.
-     *
-     * Examples:
-     *
-     * Send a simple text email:
-     *
-     * ```typescript
-     * await medplum.sendEmail({
-     *   to: 'alice@example.com',
-     *   cc: 'bob@example.com',
-     *   subject: 'Hello',
-     *   text: 'Hello Alice',
-     * });
-     * ```
-     *
-     * Send an email with a `Binary` attachment:
-     *
-     * ```typescript
-     * await medplum.sendEmail({
-     *   to: 'alice@example.com',
-     *   subject: 'Email with attachment',
-     *   text: 'See the attached report',
-     *   attachments: [{
-     *     filename: 'report.pdf',
-     *     path: "Binary/" + binary.id
-     *   }]
-     * });
-     * ```
-     *
-     * See options here: https://nodemailer.com/extras/mailcomposer/
-     * @category Media
-     * @param email The MailComposer options.
-     * @param options Optional fetch options.
-     * @returns Promise to the operation outcome.
-     */
-    sendEmail(email, options) {
-        return this.post('email/v1/send', email, 'application/json', options);
-    }
-    /**
-     * Executes a GraphQL query.
-     *
-     * Example:
-     *
-     * ```typescript
-     * const result = await medplum.graphql(`{
-     *   Patient(id: "123") {
-     *     resourceType
-     *     id
-     *     name {
-     *       given
-     *       family
-     *     }
-     *   }
-     * }`);
-     * ```
-     *
-     * Advanced queries such as named operations and variable substitution are supported:
-     *
-     * ```typescript
-     * const result = await medplum.graphql(
-     *   `query GetPatientById($patientId: ID!) {
-     *     Patient(id: $patientId) {
-     *       resourceType
-     *       id
-     *       name {
-     *         given
-     *         family
-     *       }
-     *     }
-     *   }`,
-     *   'GetPatientById',
-     *   { patientId: '123' }
-     * );
-     * ```
-     *
-     * See the GraphQL documentation for more details: https://graphql.org/learn/
-     *
-     * See the FHIR GraphQL documentation for FHIR specific details: https://www.hl7.org/fhir/graphql.html
-     * @category Read
-     * @param query The GraphQL query.
-     * @param operationName Optional GraphQL operation name.
-     * @param variables Optional GraphQL variables.
-     * @param options Optional fetch options.
-     * @returns The GraphQL result.
-     */
-    graphql(query, operationName, variables, options) {
-        return this.post(this.fhirUrl('$graphql'), { query, operationName, variables }, JSON_CONTENT_TYPE, options);
-    }
-    /**
-     *
-     * Executes the $graph operation on this resource to fetch a Bundle of resources linked to the target resource
-     * according to a graph definition
-     * @category Read
-     * @param resourceType The FHIR resource type.
-     * @param id The resource ID.
-     * @param graphName `name` parameter of the GraphDefinition
-     * @param options Optional fetch options.
-     * @returns A Bundle
-     */
-    readResourceGraph(resourceType, id, graphName, options) {
-        return this.get(`${this.fhirUrl(resourceType, id)}/$graph?graph=${graphName}`, options);
-    }
-    /**
-     * @category Authentication
-     * @returns The Login State
-     */
-    getActiveLogin() {
-        return this.storage.getObject('activeLogin');
-    }
-    /**
-     * Sets the active login.
-     * @param login The new active login state.
-     * @category Authentication
-     */
-    async setActiveLogin(login) {
-        this.clearActiveLogin();
-        this.accessToken = login.accessToken;
-        if (this.basicAuth) {
-            return;
-        }
-        this.refreshToken = login.refreshToken;
-        this.storage.setObject('activeLogin', login);
-        this.addLogin(login);
-        this.refreshPromise = undefined;
-        await this.refreshProfile();
-    }
-    /**
-     * Returns the current access token.
-     * @returns The current access token.
-     * @category Authentication
-     */
-    getAccessToken() {
-        return this.accessToken;
-    }
-    /**
-     * Sets the current access token.
-     * @param accessToken The new access token.
-     * @category Authentication
-     */
-    setAccessToken(accessToken) {
-        this.accessToken = accessToken;
-        this.refreshToken = undefined;
-        this.sessionDetails = undefined;
-    }
-    /**
-     * Returns the list of available logins.
-     * @returns The list of available logins.
-     * @category Authentication
-     */
-    getLogins() {
-        return this.storage.getObject('logins') ?? [];
-    }
-    addLogin(newLogin) {
-        const logins = this.getLogins().filter((login) => login.profile?.reference !== newLogin.profile?.reference);
-        logins.push(newLogin);
-        this.storage.setObject('logins', logins);
-    }
-    async refreshProfile() {
-        this.profilePromise = new Promise((resolve, reject) => {
-            if (this.basicAuth) {
-                return;
-            }
-            this.get('auth/me')
-                .then((result) => {
-                this.profilePromise = undefined;
-                this.sessionDetails = result;
-                this.dispatchEvent({ type: 'change' });
-                resolve(result.profile);
-            })
-                .catch(reject);
-        });
-        return this.profilePromise;
-    }
-    /**
-     * Returns true if the client is waiting for authentication.
-     * @returns True if the client is waiting for authentication.
-     * @category Authentication
-     */
-    isLoading() {
-        return !!this.profilePromise;
-    }
-    /**
-     * Returns true if the current user is authenticated as a super admin.
-     * @returns True if the current user is authenticated as a super admin.
-     * @category Authentication
-     */
-    isSuperAdmin() {
-        return !!this.sessionDetails?.project.superAdmin;
-    }
-    /**
-     * Returns true if the current user is authenticated as a project admin.
-     * @returns True if the current user is authenticated as a project admin.
-     * @category Authentication
-     */
-    isProjectAdmin() {
-        return !!this.sessionDetails?.membership.admin;
-    }
-    /**
-     * Returns the current project if available.
-     * @returns The current project if available.
-     * @category User Profile
-     */
-    getProject() {
-        return this.sessionDetails?.project;
-    }
-    /**
-     * Returns the current project membership if available.
-     * @returns The current project membership if available.
-     * @category User Profile
-     */
-    getProjectMembership() {
-        return this.sessionDetails?.membership;
-    }
-    /**
-     * Returns the current user profile resource if available.
-     * This method does not wait for loading promises.
-     * @returns The current user profile resource if available.
-     * @category User Profile
-     */
-    getProfile() {
-        return this.sessionDetails?.profile;
-    }
-    /**
-     * Returns the current user profile resource if available.
-     * This method waits for loading promises.
-     * @returns The current user profile resource if available.
-     * @category User Profile
-     */
-    async getProfileAsync() {
-        if (this.profilePromise) {
-            await this.profilePromise;
-        }
-        return this.getProfile();
-    }
-    /**
-     * Returns the current user configuration if available.
-     * @returns The current user configuration if available.
-     * @category User Profile
-     */
-    getUserConfiguration() {
-        return this.sessionDetails?.config;
-    }
-    /**
-     * Returns the current user access policy if available.
-     * @returns The current user access policy if available.
-     * @category User Profile
-     */
-    getAccessPolicy() {
-        return this.sessionDetails?.accessPolicy;
-    }
-    /**
-     * Downloads the URL as a blob.
-     * @category Read
-     * @param url The URL to request.
-     * @param options Optional fetch request init options.
-     * @returns Promise to the response body as a blob.
-     */
-    async download(url, options = {}) {
-        if (this.refreshPromise) {
-            await this.refreshPromise;
-        }
-        this.addFetchOptionsDefaults(options);
-        const response = await this.fetch(url.toString(), options);
-        return response.blob();
-    }
-    /**
-     * Upload media to the server and create a Media instance for the uploaded content.
-     * @param contents The contents of the media file, as a string, Uint8Array, File, or Blob.
-     * @param contentType The media type of the content.
-     * @param filename The name of the file to be uploaded, or undefined if not applicable.
-     * @param additionalFields Additional fields for Media.
-     * @param options Optional fetch options.
-     * @returns Promise that resolves to the created Media
-     */
-    async uploadMedia(contents, contentType, filename, additionalFields, options) {
-        const binary = await this.createBinary(contents, filename, contentType);
-        return this.createResource({
-            ...additionalFields,
-            resourceType: 'Media',
-            content: {
-                contentType: contentType,
-                url: 'Binary/' + binary.id,
-                title: filename,
-            },
-        }, options);
-    }
-    /**
-     * Performs Bulk Data Export operation request flow. See The FHIR "Bulk Data Export" for full details: https://build.fhir.org/ig/HL7/bulk-data/export.html#bulk-data-export
-     * @param exportLevel Optional export level. Defaults to system level export. 'Group/:id' - Group of Patients, 'Patient' - All Patients.
-     * @param resourceTypes A string of comma-delimited FHIR resource types.
-     * @param since Resources will be included in the response if their state has changed after the supplied time (e.g. if Resource.meta.lastUpdated is later than the supplied _since time).
-     * @param options Optional fetch options.
-     * @returns Bulk Data Response containing links to Bulk Data files. See "Response - Complete Status" for full details: https://build.fhir.org/ig/HL7/bulk-data/export.html#response---complete-status
-     */
-    async bulkExport(
-    //eslint-disable-next-line default-param-last
-    exportLevel = '', resourceTypes, since, options) {
-        const fhirPath = exportLevel ? `${exportLevel}/` : exportLevel;
-        const url = this.fhirUrl(`${fhirPath}$export`);
-        if (resourceTypes) {
-            url.searchParams.set('_type', resourceTypes);
-        }
-        if (since) {
-            url.searchParams.set('_since', since);
-        }
-        return this.startAsyncRequest(url.toString(), options);
-    }
-    /**
-     * Starts an async request following the FHIR "Asynchronous Request Pattern".
-     * See: https://hl7.org/fhir/r4/async.html
-     * @param url The URL to request.
-     * @param options Optional fetch options.
-     * @returns The response body.
-     */
-    async startAsyncRequest(url, options = {}) {
-        this.addFetchOptionsDefaults(options);
-        const headers = options.headers;
-        headers['Prefer'] = 'respond-async';
-        const response = await this.fetchWithRetry(url, options);
-        if (response.status === 202) {
-            // Accepted content location can come from multiple sources
-            // The authoritative source is the "Content-Location" HTTP header.
-            const contentLocation = response.headers.get('content-location');
-            if (contentLocation) {
-                return this.pollStatus(contentLocation);
-            }
-            // However, "Content-Location" may not be available due to CORS limitations.
-            // In this case, we use the OperationOutcome.diagnostics field.
-            const body = await response.json();
-            if (isOperationOutcome(body) && body.issue?.[0]?.diagnostics) {
-                return this.pollStatus(body.issue[0].diagnostics);
-            }
-        }
-        return this.parseResponse(response, 'POST', url);
-    }
-    //
-    // Private helpers
-    //
-    /**
-     * Returns the cache entry if available and not expired.
-     * @param key The cache key to retrieve.
-     * @param options Optional fetch options for cache settings.
-     * @returns The cached entry if found.
-     */
-    getCacheEntry(key, options) {
-        if (!this.requestCache || options?.cache === 'no-cache' || options?.cache === 'reload') {
-            return undefined;
-        }
-        const entry = this.requestCache.get(key);
-        if (!entry || entry.requestTime + this.cacheTime < Date.now()) {
-            return undefined;
-        }
-        return entry;
-    }
-    /**
-     * Adds a readable promise to the cache.
-     * @param key The cache key to store.
-     * @param value The readable promise to store.
-     */
-    setCacheEntry(key, value) {
-        if (this.requestCache) {
-            this.requestCache.set(key, { requestTime: Date.now(), value });
-        }
-    }
-    /**
-     * Adds a concrete value as the cache entry for the given resource.
-     * This is used in cases where the resource is loaded indirectly.
-     * For example, when a resource is loaded as part of a Bundle.
-     * @param resource The resource to cache.
-     */
-    cacheResource(resource) {
-        if (resource?.id) {
-            this.setCacheEntry(this.fhirUrl(resource.resourceType, resource.id).toString(), new ReadablePromise(Promise.resolve(resource)));
-        }
-    }
-    /**
-     * Deletes a cache entry.
-     * @param key The cache key to delete.
-     */
-    deleteCacheEntry(key) {
-        if (this.requestCache) {
-            this.requestCache.delete(key);
-        }
-    }
-    /**
-     * Makes an HTTP request.
-     * @param method The HTTP method (GET, POST, etc).
-     * @param url The target URL.
-     * @param options Optional fetch request init options.
-     * @returns The JSON content body if available.
-     */
-    async request(method, url, options = {}) {
-        if (this.refreshPromise) {
-            await this.refreshPromise;
-        }
-        options.method = method;
-        this.addFetchOptionsDefaults(options);
-        const response = await this.fetchWithRetry(url, options);
-        return this.parseResponse(response, method, url, options);
-    }
-    async parseResponse(response, method, url, options = {}) {
-        if (response.status === 401) {
-            // Refresh and try again
-            return this.handleUnauthenticated(method, url, options);
-        }
-        if (response.status === 204 || response.status === 304) {
-            // No content or change
-            return undefined;
-        }
-        if (response.status === 404) {
-            const contentType = response.headers.get('content-type');
-            if (!contentType?.includes('application/fhir+json')) {
-                throw new OperationOutcomeError(notFound);
-            }
-        }
-        let obj = undefined;
-        try {
-            obj = await response.json();
-        }
-        catch (err) {
-            console.error('Error parsing response', response.status, err);
-            throw err;
-        }
-        if (response.status >= 400) {
-            throw new OperationOutcomeError(normalizeOperationOutcome(obj));
-        }
-        return obj;
-    }
-    async fetchWithRetry(url, options) {
-        if (!url.startsWith('http')) {
-            url = this.baseUrl + url;
-        }
-        const maxRetries = 3;
-        const retryDelay = 200;
-        let response = undefined;
-        for (let retry = 0; retry < maxRetries; retry++) {
-            try {
-                response = (await this.fetch(url, options));
-                if (response.status < 500) {
-                    return response;
-                }
-            }
-            catch (err) {
-                this.retryCatch(retry, maxRetries, err);
-            }
-            await new Promise((resolve) => {
-                setTimeout(resolve, retryDelay);
-            });
-        }
-        return response;
-    }
-    async pollStatus(statusUrl) {
-        let checkStatus = true;
-        let resultResponse;
-        const retryDelay = 2000;
-        while (checkStatus) {
-            const fetchOptions = {};
-            this.addFetchOptionsDefaults(fetchOptions);
-            const statusResponse = await this.fetchWithRetry(statusUrl, fetchOptions);
-            if (statusResponse.status !== 202) {
-                checkStatus = false;
-                resultResponse = statusResponse;
-            }
-            await new Promise((resolve) => {
-                setTimeout(resolve, retryDelay);
-            });
-        }
-        return this.parseResponse(resultResponse, 'POST', statusUrl);
-    }
-    /**
-     * Executes a batch of requests that were automatically batched together.
-     */
-    async executeAutoBatch() {
-        // Get the current queue
-        const entries = [...this.autoBatchQueue];
-        // Clear the queue
-        this.autoBatchQueue.length = 0;
-        // Clear the timer
-        this.autoBatchTimerId = undefined;
-        // If there is only one request in the batch, just execute it
-        if (entries.length === 1) {
-            const entry = entries[0];
-            try {
-                entry.resolve(await this.request(entry.method, this.fhirBaseUrl + entry.url, entry.options));
-            }
-            catch (err) {
-                entry.reject(new OperationOutcomeError(normalizeOperationOutcome(err)));
-            }
-            return;
-        }
-        // Build the batch request
-        const batch = {
-            resourceType: 'Bundle',
-            type: 'batch',
-            entry: entries.map((e) => ({
-                request: {
-                    method: e.method,
-                    url: e.url,
-                },
-                resource: e.options.body ? JSON.parse(e.options.body) : undefined,
-            })),
-        };
-        // Execute the batch request
-        const response = (await this.post(this.fhirBaseUrl.slice(0, -1), batch));
-        // Process the response
-        for (let i = 0; i < entries.length; i++) {
-            const entry = entries[i];
-            const responseEntry = response.entry?.[i];
-            if (responseEntry?.response?.outcome && !isOk(responseEntry.response.outcome)) {
-                entry.reject(new OperationOutcomeError(responseEntry.response.outcome));
-            }
-            else {
-                entry.resolve(responseEntry?.resource);
-            }
-        }
-    }
-    /**
-     * Adds default options to the fetch options.
-     * @param options The options to add defaults to.
-     */
-    addFetchOptionsDefaults(options) {
-        let headers = options.headers;
-        if (!headers) {
-            headers = {};
-            options.headers = headers;
-        }
-        headers['Accept'] = FHIR_CONTENT_TYPE;
-        headers['X-Medplum'] = 'extended';
-        if (options.body && !headers['Content-Type']) {
-            headers['Content-Type'] = FHIR_CONTENT_TYPE;
-        }
-        if (this.accessToken) {
-            headers['Authorization'] = 'Bearer ' + this.accessToken;
-        }
-        else if (this.basicAuth) {
-            headers['Authorization'] = 'Basic ' + this.basicAuth;
-        }
-        if (!options.cache) {
-            options.cache = 'no-cache';
-        }
-        if (!options.credentials) {
-            options.credentials = 'include';
-        }
-    }
-    /**
-     * Sets the "Content-Type" header on fetch options.
-     * @param options The fetch options.
-     * @param contentType The new content type to set.
-     */
-    setRequestContentType(options, contentType) {
-        if (!options.headers) {
-            options.headers = {};
-        }
-        const headers = options.headers;
-        headers['Content-Type'] = contentType;
-    }
-    /**
-     * Sets the body on fetch options.
-     * @param options The fetch options.
-     * @param data The new content body.
-     */
-    setRequestBody(options, data) {
-        if (typeof data === 'string' ||
-            (typeof Blob !== 'undefined' && data instanceof Blob) ||
-            (typeof File !== 'undefined' && data instanceof File) ||
-            (typeof Uint8Array !== 'undefined' && data instanceof Uint8Array)) {
-            options.body = data;
-        }
-        else if (data) {
-            options.body = JSON.stringify(data);
-        }
-    }
-    /**
-     * 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 options Optional fetch request init options.
-     * @returns The result of the retry.
-     */
-    handleUnauthenticated(method, url, options) {
-        if (this.refresh()) {
-            return this.request(method, url, options);
-        }
-        this.clearActiveLogin();
-        if (this.onUnauthenticated) {
-            this.onUnauthenticated();
-        }
-        return Promise.reject(new Error('Unauthenticated'));
-    }
-    /**
-     * Starts a new PKCE flow.
-     * These PKCE values are stateful, and must survive redirects and page refreshes.
-     * @category Authentication
-     * @returns The PKCE code challenge details.
-     */
-    async startPkce() {
-        const pkceState = getRandomString();
-        sessionStorage.setItem('pkceState', pkceState);
-        const codeVerifier = getRandomString();
-        sessionStorage.setItem('codeVerifier', codeVerifier);
-        const arrayHash = await encryptSHA256(codeVerifier);
-        const codeChallenge = arrayBufferToBase64(arrayHash).replaceAll('+', '-').replaceAll('/', '_').replaceAll('=', '');
-        sessionStorage.setItem('codeChallenge', codeChallenge);
-        return { codeChallengeMethod: 'S256', codeChallenge };
-    }
-    /**
-     * Redirects the user to the login screen for authorization.
-     * Clears all auth state including local storage and session storage.
-     * @param loginParams The authorization login parameters.
-     * @see https://openid.net/specs/openid-connect-core-1_0.html#AuthorizationEndpoint
-     */
-    async requestAuthorization(loginParams) {
-        const loginRequest = await this.ensureCodeChallenge(loginParams || {});
-        const url = new URL(this.authorizeUrl);
-        url.searchParams.set('response_type', 'code');
-        url.searchParams.set('state', sessionStorage.getItem('pkceState'));
-        url.searchParams.set('client_id', loginRequest.clientId || this.clientId);
-        url.searchParams.set('redirect_uri', loginRequest.redirectUri || getWindowOrigin());
-        url.searchParams.set('code_challenge_method', loginRequest.codeChallengeMethod);
-        url.searchParams.set('code_challenge', loginRequest.codeChallenge);
-        url.searchParams.set('scope', loginRequest.scope || 'openid profile');
-        window.location.assign(url.toString());
-    }
-    /**
-     * 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.
-     * @param loginParams Optional login parameters.
-     * @returns The user profile resource.
-     * @category Authentication
-     */
-    processCode(code, loginParams) {
-        const formBody = new URLSearchParams();
-        formBody.set('grant_type', OAuthGrantType.AuthorizationCode);
-        formBody.set('code', code);
-        formBody.set('client_id', loginParams?.clientId || this.clientId);
-        formBody.set('redirect_uri', loginParams?.redirectUri || getWindowOrigin());
-        if (typeof sessionStorage !== 'undefined') {
-            const codeVerifier = sessionStorage.getItem('codeVerifier');
-            if (codeVerifier) {
-                formBody.set('code_verifier', codeVerifier);
-            }
-        }
-        return this.fetchTokens(formBody);
-    }
-    /**
-     * Tries to refresh the auth tokens.
-     * @returns The refresh promise if available; otherwise undefined.
-     * @see https://openid.net/specs/openid-connect-core-1_0.html#RefreshTokens
-     */
-    refresh() {
-        if (this.refreshPromise) {
-            return this.refreshPromise;
-        }
-        if (this.refreshToken) {
-            const formBody = new URLSearchParams();
-            formBody.set('grant_type', OAuthGrantType.RefreshToken);
-            formBody.set('client_id', this.clientId);
-            formBody.set('refresh_token', this.refreshToken);
-            this.refreshPromise = this.fetchTokens(formBody);
-            return this.refreshPromise;
-        }
-        if (this.clientId && this.clientSecret) {
-            this.refreshPromise = this.startClientLogin(this.clientId, this.clientSecret);
-            return this.refreshPromise;
-        }
-        return undefined;
-    }
-    /**
-     * Starts a new OAuth2 client credentials flow.
-     *
-     * ```typescript
-     * await medplum.startClientLogin(process.env.MEDPLUM_CLIENT_ID, process.env.MEDPLUM_CLIENT_SECRET)
-     * // Example Search
-     * await medplum.searchResources('Patient')
-     * ```
-     *
-     *
-     * See: https://datatracker.ietf.org/doc/html/rfc6749#section-4.4
-     * @category Authentication
-     * @param clientId The client ID.
-     * @param clientSecret The client secret.
-     * @returns Promise that resolves to the client profile.
-     */
-    async startClientLogin(clientId, clientSecret) {
-        this.clientId = clientId;
-        this.clientSecret = clientSecret;
-        const formBody = new URLSearchParams();
-        formBody.set('grant_type', OAuthGrantType.ClientCredentials);
-        formBody.set('client_id', clientId);
-        formBody.set('client_secret', clientSecret);
-        return this.fetchTokens(formBody);
-    }
-    /**
-     * Sets the client ID and secret for basic auth.
-     *
-     *  ```typescript
-     * medplum.setBasicAuth(process.env.MEDPLUM_CLIENT_ID, process.env.MEDPLUM_CLIENT_SECRET)
-     * // Example Search
-     * await medplum.searchResources('Patient')
-     * ```
-     * @category Authentication
-     * @param clientId The client ID.
-     * @param clientSecret The client secret.
-     */
-    setBasicAuth(clientId, clientSecret) {
-        this.clientId = clientId;
-        this.clientSecret = clientSecret;
-        this.basicAuth = encodeBase64(clientId + ':' + clientSecret);
-    }
-    /**
-     * Invite a user to a project.
-     * @param projectId The project ID.
-     * @param body The InviteBody.
-     * @returns Promise that returns a project membership or an operation outcome.
-     */
-    async invite(projectId, body) {
-        return this.post('admin/projects/' + projectId + '/invite', body);
-    }
-    /**
-     * 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.
-     * @returns The user profile resource.
-     */
-    async fetchTokens(formBody) {
-        const options = {
-            method: 'POST',
-            headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
-            body: formBody,
-            credentials: 'include',
-        };
-        const headers = options.headers;
-        if (this.basicAuth) {
-            headers['Authorization'] = `Basic ${this.basicAuth}`;
-        }
-        const response = await this.fetch(this.tokenUrl, options);
-        if (!response.ok) {
-            this.clearActiveLogin();
-            try {
-                const error = await response.json();
-                throw new OperationOutcomeError(badRequest(error.error_description));
-            }
-            catch (err) {
-                throw new OperationOutcomeError(badRequest('Failed to fetch tokens'), err);
-            }
-        }
-        const tokens = await response.json();
-        await this.verifyTokens(tokens);
-        return 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 The token response.
-     * @returns Promise to complete.
-     */
-    async verifyTokens(tokens) {
-        const token = tokens.access_token;
-        // Verify token has not expired
-        const tokenPayload = parseJWTPayload(token);
-        if (Date.now() >= tokenPayload.exp * 1000) {
-            this.clearActiveLogin();
-            throw new Error('Token expired');
-        }
-        // Verify app_client_id
-        // external tokenPayload
-        if (tokenPayload.cid) {
-            if (tokenPayload.cid !== this.clientId) {
-                this.clearActiveLogin();
-                throw new Error('Token was not issued for this audience');
-            }
-        }
-        else if (this.clientId && tokenPayload.client_id !== this.clientId) {
-            this.clearActiveLogin();
-            throw new Error('Token was not issued for this audience');
-        }
-        return 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
-        }
-    }
-    retryCatch(retryNumber, maxRetries, err) {
-        // This is for the 1st retry to avoid multiple notifications
-        if (err.message === 'Failed to fetch' && retryNumber === 1) {
-            this.dispatchEvent({ type: 'offline' });
-        }
-        if (retryNumber >= maxRetries - 1) {
-            throw err;
-        }
-    }
-}
-/**
- * Returns the default fetch method.
- * The default fetch is currently only available in browser environments.
- * If you want to use SSR such as Next.js, you should pass a custom fetch function.
- * @returns The default fetch function for the current environment.
- */
-function getDefaultFetch() {
-    if (!globalThis.fetch) {
-        throw new Error('Fetch not available in this environment');
-    }
-    return globalThis.fetch.bind(globalThis);
-}
-/**
- * Returns the base URL for the current page.
- * @returns The window origin string.
- * @category HTTP
- */
-function getWindowOrigin() {
-    if (typeof window === 'undefined') {
-        return '';
-    }
-    return window.location.protocol + '//' + window.location.host + '/';
-}
-function ensureTrailingSlash(url) {
-    if (!url) {
-        return url;
-    }
-    return url.endsWith('/') ? url : url + '/';
-}
-
-export { MEDPLUM_VERSION, MedplumClient, OAuthGrantType, OAuthTokenType };
-//# sourceMappingURL=client.mjs.map