@medplum/core 2.1.8 → 2.1.10

package/dist/types.d.ts

@@ -0,0 +1,4181 @@
+/// <reference types="node" />
+
+import { AccessPolicy } from '@medplum/fhirtypes';
+import { AccessPolicyResource } from '@medplum/fhirtypes';
+import { Address } from '@medplum/fhirtypes';
+import { Agent } from '@medplum/fhirtypes';
+import { Attachment } from '@medplum/fhirtypes';
+import { Binary } from '@medplum/fhirtypes';
+import { BulkDataExport } from '@medplum/fhirtypes';
+import { Bundle } from '@medplum/fhirtypes';
+import { CodeableConcept } from '@medplum/fhirtypes';
+import { Coding } from '@medplum/fhirtypes';
+import { Communication } from '@medplum/fhirtypes';
+import type { CustomTableLayout } from 'pdfmake/interfaces';
+import { Device } from '@medplum/fhirtypes';
+import { ElementDefinition } from '@medplum/fhirtypes';
+import { ElementDefinitionBinding } from '@medplum/fhirtypes';
+import { Extension } from '@medplum/fhirtypes';
+import { ExtractResource } from '@medplum/fhirtypes';
+import { HumanName } from '@medplum/fhirtypes';
+import { Identifier } from '@medplum/fhirtypes';
+import { Media } from '@medplum/fhirtypes';
+import { Money } from '@medplum/fhirtypes';
+import { Observation } from '@medplum/fhirtypes';
+import { ObservationComponent } from '@medplum/fhirtypes';
+import { ObservationDefinition } from '@medplum/fhirtypes';
+import { ObservationDefinitionQualifiedInterval } from '@medplum/fhirtypes';
+import { OperationOutcome } from '@medplum/fhirtypes';
+import { OperationOutcomeIssue } from '@medplum/fhirtypes';
+import { Patient } from '@medplum/fhirtypes';
+import { Period } from '@medplum/fhirtypes';
+import { Practitioner } from '@medplum/fhirtypes';
+import { Project } from '@medplum/fhirtypes';
+import { ProjectMembership } from '@medplum/fhirtypes';
+import { ProjectMembershipAccess } from '@medplum/fhirtypes';
+import { ProjectSecret } from '@medplum/fhirtypes';
+import { Quantity } from '@medplum/fhirtypes';
+import { QuestionnaireResponse } from '@medplum/fhirtypes';
+import { QuestionnaireResponseItemAnswer } from '@medplum/fhirtypes';
+import { Range as Range_2 } from '@medplum/fhirtypes';
+import { Readable } from 'stream';
+import { Reference } from '@medplum/fhirtypes';
+import { RelatedPerson } from '@medplum/fhirtypes';
+import { Resource } from '@medplum/fhirtypes';
+import { ResourceType } from '@medplum/fhirtypes';
+import { SearchParameter } from '@medplum/fhirtypes';
+import { StructureDefinition } from '@medplum/fhirtypes';
+import { StructureMap } from '@medplum/fhirtypes';
+import type { TDocumentDefinitions } from 'pdfmake/interfaces';
+import type { TFontDictionary } from 'pdfmake/interfaces';
+import { Timing } from '@medplum/fhirtypes';
+import { UserConfiguration } from '@medplum/fhirtypes';
+import { ValueSet } from '@medplum/fhirtypes';
+
+export declare function accepted(location: string): OperationOutcome;
+
+/**
+ * Interactions with a resource that can be controlled via an access policy.
+ *
+ * Codes taken from http://hl7.org/fhir/codesystem-restful-interaction.html
+ */
+export declare enum AccessPolicyInteraction {
+    READ = "read",
+    VREAD = "vread",
+    UPDATE = "update",
+    PATCH = "patch",
+    DELETE = "delete",
+    HISTORY = "history",
+    HISTORY_INSTANCE = "history-instance",
+    HISTORY_TYPE = "history-type",
+    HISTORY_SYSTEM = "history-system",
+    CREATE = "create",
+    SEARCH = "search",
+    SEARCH_TYPE = "search-type",
+    SEARCH_SYSTEM = "search-system",
+    SEARCH_COMPARTMENT = "search-compartment",
+    CAPABILITIES = "capabilities",
+    TRANSACTION = "transaction",
+    BATCH = "batch",
+    OPERATION = "operation"
+}
+
+export declare interface AddressFormatOptions {
+    all?: boolean;
+    use?: boolean;
+    lineSeparator?: string;
+}
+
+export declare const allOk: OperationOutcome;
+
+/**
+ * Converts an ArrayBuffer to a base-64 encoded string.
+ * @param arrayBuffer The input array buffer.
+ * @returns The base-64 encoded string.
+ */
+export declare function arrayBufferToBase64(arrayBuffer: ArrayBuffer): string;
+
+/**
+ * Converts an ArrayBuffer to hex string.
+ * See: https://stackoverflow.com/a/55200387
+ * @param arrayBuffer The input array buffer.
+ * @returns The resulting hex string.
+ */
+export declare function arrayBufferToHex(arrayBuffer: ArrayBuffer): string;
+
+export declare function arrayify<T>(value: T | T[] | undefined): T[] | undefined;
+
+/**
+ * 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.
+ */
+export declare function assertOk<T>(outcome: OperationOutcome, resource: T | undefined): asserts resource is T;
+
+export declare interface Atom {
+    eval(context: AtomContext, input: TypedValue[]): TypedValue[];
+    toString(): string;
+}
+
+export declare interface AtomContext {
+    parent?: AtomContext;
+    variables: Record<string, TypedValue>;
+}
+
+export declare function badRequest(details: string, expression?: string): OperationOutcome;
+
+export declare interface BaseLoginRequest {
+    readonly projectId?: string;
+    readonly clientId?: string;
+    readonly resourceType?: string;
+    readonly scope?: string;
+    readonly nonce?: string;
+    readonly codeChallenge?: string;
+    readonly codeChallengeMethod?: CodeChallengeMethod;
+    readonly googleClientId?: string;
+    readonly launch?: string;
+    readonly redirectUri?: string;
+}
+
+export declare type BaseSchema = Record<string, {
+    elements: Record<string, Partial<InternalSchemaElement>>;
+}>;
+
+/**
+ * Source for a FHIR Binary.
+ */
+export declare type BinarySource = string | File | Blob | Uint8Array;
+
+/**
+ * Returns a single element array with a typed boolean value.
+ * @param value The primitive boolean value.
+ * @returns Single element array with a typed boolean value.
+ */
+export declare function booleanToTypedValue(value: boolean): [TypedValue];
+
+export declare interface BotEvent<T = Resource | Hl7Message | string | Record<string, any>> {
+    readonly contentType: string;
+    readonly input: T;
+    readonly secrets: Record<string, ProjectSecret>;
+}
+
+export declare function buildTypeName(components: string[]): string;
+
+/**
+ * Calculates the age in years from the birth date.
+ * @param birthDateStr The birth date or start date in ISO-8601 format YYYY-MM-DD.
+ * @param endDateStr Optional end date in ISO-8601 format YYYY-MM-DD. Default value is today.
+ * @returns The age in years, months, and days.
+ */
+export declare function calculateAge(birthDateStr: string, endDateStr?: string): {
+    years: number;
+    months: number;
+    days: number;
+};
+
+/**
+ * Calculates the age string for display using the age appropriate units.
+ * If the age is greater than or equal to 2 years, then the age is displayed in years.
+ * If the age is greater than or equal to 1 month, then the age is displayed in months.
+ * Otherwise, the age is displayed in days.
+ * @param birthDateStr The birth date or start date in ISO-8601 format YYYY-MM-DD.
+ * @param endDateStr Optional end date in ISO-8601 format YYYY-MM-DD. Default value is today.
+ * @returns The age string.
+ */
+export declare function calculateAgeString(birthDateStr: string, endDateStr?: string): string | undefined;
+
+/**
+ * Determines if the current user can read the specified resource type.
+ * @param accessPolicy The access policy.
+ * @param resourceType The resource type.
+ * @returns True if the current user can read the specified resource type.
+ */
+export declare function canReadResourceType(accessPolicy: AccessPolicy, resourceType: ResourceType): boolean;
+
+/**
+ * Determines if the current user can write the specified resource.
+ * This is a more in-depth check after building the candidate result of a write operation.
+ * @param accessPolicy The access policy.
+ * @param resource The resource.
+ * @returns True if the current user can write the specified resource type.
+ */
+export declare function canWriteResource(accessPolicy: AccessPolicy, resource: Resource): boolean;
+
+/**
+ * Determines if the current user can write the specified resource type.
+ * This is a preliminary check before evaluating a write operation in depth.
+ * If a user cannot write a resource type at all, then don't bother looking up previous versions.
+ * @param accessPolicy The access policy.
+ * @param resourceType The resource type.
+ * @returns True if the current user can write the specified resource type.
+ */
+export declare function canWriteResourceType(accessPolicy: AccessPolicy, resourceType: ResourceType): boolean;
+
+export declare function capitalize(word: string): string;
+
+/**
+ * Recursively checks for null values in an object.
+ *
+ * Note that "null" is a special value in JSON that is not allowed in FHIR.
+ * @param value Input value of any type.
+ * @param path Path string to the value for OperationOutcome.
+ * @param issues Output list of issues.
+ */
+export declare function checkForNull(value: unknown, path: string, issues: OperationOutcomeIssue[]): void;
+
+/**
+ * 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.  For example, the Medplum CLI uses `FileSystemStorage`.
+ */
+export declare class ClientStorage {
+    private readonly storage;
+    constructor();
+    clear(): void;
+    getString(key: string): string | undefined;
+    setString(key: string, value: string | undefined): void;
+    getObject<T>(key: string): T | undefined;
+    setObject<T>(key: string, value: T): void;
+}
+
+declare interface Code {
+    code?: CodeableConcept;
+}
+
+/**
+ * Allowed values for `code_challenge_method` in a PKCE exchange.
+ * @internal
+ */
+export declare type CodeChallengeMethod = 'plain' | 'S256';
+
+export declare function compressElement(element: InternalSchemaElement): Partial<InternalSchemaElement>;
+
+export declare interface Constraint {
+    key: string;
+    severity: 'error' | 'warning';
+    expression: string;
+    description: string;
+}
+
+/**
+ * Content type constants.
+ */
+export declare const ContentType: {
+    CSS: string;
+    FAVICON: string;
+    FHIR_JSON: string;
+    FORM_URL_ENCODED: string;
+    HL7_V2: string;
+    HTML: string;
+    JAVASCRIPT: string;
+    JSON: string;
+    JSON_PATCH: string;
+    PNG: string;
+    SVG: string;
+    TEXT: string;
+    TYPESCRIPT: string;
+};
+
+/**
+ * Converts a resource with contained resources to a transaction bundle.
+ * This function is useful when creating a resource that contains other resources.
+ * Handles local references and topological sorting.
+ * @param resource The input resource which may or may not include contained resources.
+ * @returns A bundle with the input resource and all contained resources.
+ */
+export declare function convertContainedResourcesToBundle(resource: Resource & {
+    contained?: Resource[];
+}): Bundle;
+
+/**
+ * More on Bundles can be found here
+ * http://hl7.org/fhir/R4/bundle.html
+ */
+/**
+ * Takes a bundle and creates a Transaction Type bundle
+ * @param bundle The Bundle object that we'll receive from the search query
+ * @returns transaction type bundle
+ */
+export declare function convertToTransactionBundle(bundle: Bundle): Bundle;
+
+export declare const CPT = "http://www.ama-assn.org/go/cpt";
+
+export declare function crawlResource(resource: Resource, visitor: ResourceVisitor, schema?: InternalTypeSchema, initialPath?: string): void;
+
+export declare function createConstraintIssue(expression: string, constraint: Constraint): OperationOutcomeIssue;
+
+export declare const created: OperationOutcome;
+
+/**
+ * Creates a serializable JSON payload for the `FHIRcast` protocol
+ *
+ * @param topic The topic that this message will be published on. Usually a UUID.
+ * @param event The event name, ie. "patient-open" or "patient-close".
+ * @param context The updated context, containing new versions of resources related to this event.
+ * @returns A serializable `FhircastMessagePayload`.
+ */
+export declare function createFhircastMessagePayload(topic: string, event: FhircastEventName, context: FhircastEventContext | FhircastEventContext[]): FhircastMessagePayload;
+
+export declare interface CreatePdfFunction {
+    (docDefinition: TDocumentDefinitions, tableLayouts?: Record<string, CustomTableLayout> | undefined, fonts?: TFontDictionary | undefined): Promise<any>;
+}
+
+export declare function createProcessingIssue(expression: string, message: string, err: Error, data?: Record<string, any>): OperationOutcomeIssue;
+
+/**
+ * Creates a reference resource.
+ * @param resource The FHIR reesource.
+ * @returns A reference resource.
+ */
+export declare function createReference<T extends Resource>(resource: T): Reference<T>;
+
+export declare function createStructureIssue(expression: string, details: string): OperationOutcomeIssue;
+
+/**
+ * Decodes a base64 string.
+ * Handles both browser and Node environments.
+ * @param data The base-64 encoded input string.
+ * @returns The decoded string.
+ */
+export declare function decodeBase64(data: string): string;
+
+/**
+ * Creates a deep clone of the input value.
+ *
+ * Limitations:
+ *  - Only supports JSON primitives and arrays.
+ *  - Does not support Functions, lambdas, etc.
+ *  - Does not support circular references.
+ *
+ * See: https://web.dev/structured-clone/
+ * See: https://stackoverflow.com/questions/40488190/how-is-structured-clone-algorithm-different-from-deep-copy
+ * @param input The input to clone.
+ * @returns A deep clone of the input.
+ */
+export declare function deepClone<T>(input: T): T;
+
+/**
+ * Resource equality.
+ * Ignores meta.versionId and meta.lastUpdated.
+ * @param object1 The first object.
+ * @param object2 The second object.
+ * @param path Optional path string.
+ * @returns True if the objects are equal.
+ */
+export declare function deepEquals(object1: unknown, object2: unknown, path?: string): boolean;
+
+/**
+ * Checks if object2 includes all fields and values of object1.
+ * It doesn't matter if object2 has extra fields.
+ * @param value The object to test if contained in pattern.
+ * @param pattern The object to test against.
+ * @returns True if pattern includes all fields and values of value.
+ */
+export declare function deepIncludes(value: any, pattern: any): boolean;
+
+export declare const DEFAULT_ACCEPT: string;
+
+export declare const DEFAULT_SEARCH_COUNT = 20;
+
+export declare interface ElementType {
+    code: string;
+    targetProfile?: string[];
+}
+
+export declare interface EmailPasswordLoginRequest extends BaseLoginRequest {
+    readonly email: string;
+    readonly password: string;
+    /** @deprecated Use scope of "offline" or "offline_access" instead. */
+    readonly remember?: boolean;
+}
+
+/**
+ * Encodes a base64 string.
+ * Handles both browser and Node environments.
+ * @param data The unencoded input string.
+ * @returns The base-64 encoded string.
+ */
+export declare function encodeBase64(data: string): string;
+
+/**
+ * Encrypts a string with SHA256 encryption.
+ * @param str The unencrypted input string.
+ * @returns The encrypted value in an ArrayBuffer.
+ */
+export declare function encryptSHA256(str: string): Promise<ArrayBuffer>;
+
+/**
+ * Evaluates a FHIRPath expression against a resource or other object.
+ * @param expression The FHIRPath expression to parse.
+ * @param input The resource or object to evaluate the expression against.
+ * @returns The result of the FHIRPath expression against the resource or object.
+ */
+export declare function evalFhirPath(expression: string, input: unknown): unknown[];
+
+/**
+ * Evaluates a FHIRPath expression against a resource or other object.
+ * @param expression The FHIRPath expression to parse.
+ * @param input The resource or object to evaluate the expression against.
+ * @param variables A map of variables for eval input.
+ * @returns The result of the FHIRPath expression against the resource or object.
+ */
+export declare function evalFhirPathTyped(expression: string, input: TypedValue[], variables?: Record<string, TypedValue>): TypedValue[];
+
+declare interface Event_2 {
+    readonly type: string;
+    readonly defaultPrevented?: boolean;
+}
+export { Event_2 as Event }
+
+declare type EventListener_2 = (e: Event_2) => void;
+export { EventListener_2 as EventListener }
+
+declare class EventTarget_2 {
+    private readonly listeners;
+    constructor();
+    addEventListener(type: string, callback: EventListener_2): void;
+    removeEventListener(type: string, callback: EventListener_2): void;
+    dispatchEvent(event: Event_2): boolean;
+}
+export { EventTarget_2 as EventTarget }
+
+export declare type ExternalSecret<T extends ExternalSecretPrimitive = ExternalSecretPrimitive> = {
+    system: ExternalSecretSystem;
+    key: string;
+    type: TypeName<T>;
+};
+
+export declare type ExternalSecretPrimitive = string | boolean | number;
+
+export declare type ExternalSecretPrimitiveType = 'string' | 'boolean' | 'number';
+
+export declare type ExternalSecretSystem = keyof typeof ExternalSecretSystems;
+
+export declare const ExternalSecretSystems: {
+    readonly aws_ssm_parameter_store: "aws_ssm_parameter_store";
+};
+
+export declare interface FetchLike {
+    (url: string, options?: any): Promise<any>;
+}
+
+declare const FHIRCAST_CONTEXT_KEY_LOOKUP: {
+    readonly study: "ImagingStudy";
+    readonly patient: "Patient";
+    readonly encounter: "Encounter";
+};
+
+declare const FHIRCAST_EVENT_NAMES: {
+    readonly 'patient-open': "patient-open";
+    readonly 'patient-close': "patient-close";
+    readonly 'imagingstudy-open': "imagingstudy-open";
+    readonly 'imagingstudy-close': "imagingstudy-close";
+};
+
+declare const FHIRCAST_RESOURCE_TYPES: readonly ["Patient", "Encounter", "ImagingStudy"];
+
+export declare type FhircastConnectEvent = {
+    type: 'connect';
+};
+
+/**
+ * A class representing a `FHIRcast` connection.
+ *
+ * `FhircastConnection` extends `EventTarget` and emits 3 lifecycle events:
+ * 1. `connect` - An event to signal when a WebSocket connection has been opened. Fired as soon as a WebSocket emits `open`.
+ * 2. `message` - Contains a `payload` field containing a `FHIRcast` message payload exactly as it comes in over WebSockets.
+ * 3. `disconnect` - An event to signal when a WebSocket connection has been closed. Fired as soon as a WebSocket emits `close`.
+ *
+ * To close the connection, call `connection.disconnect()` and listen to the `disconnect` event to know when the connection has been disconnected.
+ */
+export declare class FhircastConnection extends TypedEventTarget<FhircastSubscriptionEventMap> {
+    subRequest: SubscriptionRequest;
+    private websocket;
+    /**
+     * Creates a new `FhircastConnection`.
+     * @param subRequest The subscription request to initialize the connection from.
+     */
+    constructor(subRequest: SubscriptionRequest);
+    disconnect(): void;
+}
+
+export declare type FhircastDisconnectEvent = {
+    type: 'disconnect';
+};
+
+export declare type FhircastEventContext<K extends FhircastEventContextKey = FhircastEventContextKey> = {
+    key: K;
+    resource: Resource & {
+        resourceType: FhircastEventContextMap[K];
+        id: string;
+    };
+};
+
+declare type FhircastEventContextKey = keyof FhircastEventContextMap;
+
+declare type FhircastEventContextMap = typeof FHIRCAST_CONTEXT_KEY_LOOKUP;
+
+export declare type FhircastEventName = keyof typeof FHIRCAST_EVENT_NAMES;
+
+export declare type FhircastEventPayload = {
+    'hub.topic': string;
+    'hub.event': string;
+    context: FhircastEventContext[];
+};
+
+export declare type FhircastMessageEvent = {
+    type: 'message';
+    payload: FhircastMessagePayload;
+};
+
+export declare type FhircastMessagePayload = {
+    timestamp: string;
+    id: string;
+    event: FhircastEventPayload;
+};
+
+export declare type FhircastResourceType = (typeof FHIRCAST_RESOURCE_TYPES)[number];
+
+export declare type FhircastSubscriptionEventMap = {
+    connect: FhircastConnectEvent;
+    message: FhircastMessageEvent;
+    disconnect: FhircastDisconnectEvent;
+};
+
+/**
+ * The FhirFilterComparison class represents a comparison expression.
+ */
+export declare class FhirFilterComparison {
+    readonly path: string;
+    readonly operator: Operator;
+    readonly value: string;
+    constructor(path: string, operator: Operator, value: string);
+}
+
+/**
+ * The FhirFilterConnective class represents a connective expression.
+ * It contains a list of child expressions.
+ */
+export declare class FhirFilterConnective {
+    readonly keyword: 'and' | 'or';
+    readonly left: FhirFilterExpression;
+    readonly right: FhirFilterExpression;
+    constructor(keyword: 'and' | 'or', left: FhirFilterExpression, right: FhirFilterExpression);
+}
+
+/**
+ * The FhirFilterExpression type is the base type of all filter expressions.
+ */
+export declare type FhirFilterExpression = FhirFilterComparison | FhirFilterNegation | FhirFilterConnective;
+
+/**
+ * The FhirFilterNegation class represents a negation expression.
+ * It contains a single child expression.
+ */
+export declare class FhirFilterNegation {
+    readonly child: FhirFilterExpression;
+    constructor(child: FhirFilterExpression);
+}
+
+/**
+ * Determines if two arrays are equal according to FHIRPath equality rules.
+ * @param x The first array.
+ * @param y The second array.
+ * @returns FHIRPath true if the arrays are equal.
+ */
+export declare function fhirPathArrayEquals(x: TypedValue[], y: TypedValue[]): TypedValue[];
+
+/**
+ * Determines if two arrays are equivalent according to FHIRPath equality rules.
+ * @param x The first array.
+ * @param y The second array.
+ * @returns FHIRPath true if the arrays are equivalent.
+ */
+export declare function fhirPathArrayEquivalent(x: TypedValue[], y: TypedValue[]): TypedValue[];
+
+declare class FhirPathAtom implements Atom {
+    readonly original: string;
+    readonly child: Atom;
+    constructor(original: string, child: Atom);
+    eval(context: AtomContext, input: TypedValue[]): TypedValue[];
+    toString(): string;
+}
+
+/**
+ * Determines if two values are equal according to FHIRPath equality rules.
+ * @param x The first value.
+ * @param y The second value.
+ * @returns True if equal.
+ */
+export declare function fhirPathEquals(x: TypedValue, y: TypedValue): TypedValue[];
+
+/**
+ * Determines if two values are equivalent according to FHIRPath equality rules.
+ * @param x The first value.
+ * @param y The second value.
+ * @returns True if equivalent.
+ */
+export declare function fhirPathEquivalent(x: TypedValue, y: TypedValue): TypedValue[];
+
+/**
+ * Determines if the typed value is the desired type.
+ * @param typedValue The typed value to check.
+ * @param desiredType The desired type name.
+ * @returns True if the typed value is of the desired type.
+ */
+export declare function fhirPathIs(typedValue: TypedValue, desiredType: string): boolean;
+
+/**
+ * Returns a negated FHIRPath boolean expression.
+ * @param input The input array.
+ * @returns The negated type value array.
+ */
+export declare function fhirPathNot(input: TypedValue[]): TypedValue[];
+
+export declare const fhirTypeToJsType: {
+    readonly base64Binary: "string";
+    readonly boolean: "boolean";
+    readonly canonical: "string";
+    readonly code: "string";
+    readonly date: "string";
+    readonly dateTime: "string";
+    readonly decimal: "number";
+    readonly id: "string";
+    readonly instant: "string";
+    readonly integer: "number";
+    readonly markdown: "string";
+    readonly oid: "string";
+    readonly positiveInt: "number";
+    readonly string: "string";
+    readonly time: "string";
+    readonly unsignedInt: "number";
+    readonly uri: "string";
+    readonly url: "string";
+    readonly uuid: "string";
+    readonly xhtml: "string";
+    readonly 'http://hl7.org/fhirpath/System.String': "string";
+};
+
+export declare interface Filter {
+    code: string;
+    operator: Operator;
+    value: string;
+}
+
+/**
+ * Tries to find an observation interval for the given patient and value.
+ * @param definition The observation definition.
+ * @param patient The patient.
+ * @param value The observation value.
+ * @param category Optional interval category restriction.
+ * @returns The observation interval if found; otherwise undefined.
+ */
+export declare function findObservationInterval(definition: ObservationDefinition, patient: Patient, value: number, category?: 'reference' | 'critical' | 'absolute'): ObservationDefinitionQualifiedInterval | undefined;
+
+/**
+ * Tries to find an observation reference range for the given patient and condition names.
+ * @param definition The observation definition.
+ * @param patient The patient.
+ * @param names The condition names.
+ * @returns The observation interval if found; otherwise undefined.
+ */
+export declare function findObservationReferenceRange(definition: ObservationDefinition, patient: Patient, names: string[]): ObservationDefinitionQualifiedInterval | undefined;
+
+/**
+ * Finds the first resource in the input array that matches the specified code and system.
+ * @param resources - The array of resources to search.
+ * @param code - The code to search for.
+ * @param system - The system to search for.
+ * @returns The first resource in the input array that matches the specified code and system, or undefined if no such resource is found.
+ */
+export declare function findResourceByCode(resources: ResourceWithCode[], code: CodeableConcept | string, system: string): ResourceWithCode | undefined;
+
+export declare const forbidden: OperationOutcome;
+
+/**
+ * Formats a FHIR Address as a string.
+ * @param address The address to format.
+ * @param options Optional address format options.
+ * @returns The formatted address string.
+ */
+export declare function formatAddress(address: Address, options?: AddressFormatOptions): string;
+
+/**
+ * Formats a CodeableConcept element as a string.
+ * @param codeableConcept A FHIR CodeableConcept element
+ * @returns The codeable concept as a string.
+ */
+export declare function formatCodeableConcept(codeableConcept: CodeableConcept | undefined): string;
+
+/**
+ * Formats a Coding element as a string.
+ * @param coding A FHIR Coding element
+ * @returns The coding as a string.
+ */
+export declare function formatCoding(coding: Coding | undefined): string;
+
+/**
+ * Formats a FHIR date string as a human readable string.
+ * Handles missing values and invalid dates.
+ * @param date The date to format.
+ * @param locales Optional locales.
+ * @param options Optional date format options.
+ * @returns The formatted date string.
+ */
+export declare function formatDate(date: string | undefined, locales?: Intl.LocalesArgument, options?: Intl.DateTimeFormatOptions | undefined): string;
+
+/**
+ * Formats a FHIR dateTime string as a human readable string.
+ * Handles missing values and invalid dates.
+ * @param dateTime The dateTime to format.
+ * @param locales Optional locales.
+ * @param options Optional dateTime format options.
+ * @returns The formatted dateTime string.
+ */
+export declare function formatDateTime(dateTime: string | undefined, locales?: Intl.LocalesArgument, options?: Intl.DateTimeFormatOptions | undefined): string;
+
+/**
+ * Formats the family name portion of a FHIR HumanName element.
+ * @param name The name to format.
+ * @returns The formatted family name string.
+ */
+export declare function formatFamilyName(name: HumanName): string;
+
+/**
+ * Formats the given name portion of a FHIR HumanName element.
+ * @param name The name to format.
+ * @returns The formatted given name string.
+ */
+export declare function formatGivenName(name: HumanName): string;
+
+/**
+ * Formats an ISO date/time string into an HL7 date/time string.
+ * @param isoDate The ISO date/time string.
+ * @returns The HL7 date/time string.
+ */
+export declare function formatHl7DateTime(isoDate: Date | string): string;
+
+/**
+ * Formats a FHIR HumanName as a string.
+ * @param name The name to format.
+ * @param options Optional name format options.
+ * @returns The formatted name string.
+ */
+export declare function formatHumanName(name: HumanName, options?: HumanNameFormatOptions): string;
+
+export declare function formatMoney(money: Money | undefined): string;
+
+/**
+ * Formats a FHIR Observation resource value as a string.
+ * @param obs A FHIR Observation resource.
+ * @returns A human-readable string representation of the Observation.
+ */
+export declare function formatObservationValue(obs: Observation | ObservationComponent | undefined): string;
+
+/**
+ * Formats a FHIR Period as a human readable string.
+ * @param period The period to format.
+ * @param locales Optional locales.
+ * @param options Optional period format options.
+ * @returns The formatted period string.
+ */
+export declare function formatPeriod(period: Period | undefined, locales?: Intl.LocalesArgument, options?: Intl.DateTimeFormatOptions | undefined): string;
+
+/**
+ * Returns a human-readable string for a FHIR Quantity datatype, taking into account units and comparators
+ * @param quantity A FHIR Quantity element
+ * @param precision Number of decimal places to display in the rendered quantity values
+ * @returns A human-readable string representation of the Quantity
+ */
+export declare function formatQuantity(quantity: Quantity | undefined, precision?: number): string;
+
+/**
+ * Returns a human-readable string for a FHIR Range datatype, taking into account one-sided ranges
+ * @param range A FHIR Range element
+ * @param precision Number of decimal places to display in the rendered quantity values
+ * @param exclusive If true, one-sided ranges will be rendered with the '>' or '<' bounds rather than '>=' or '<='
+ * @returns A human-readable string representation of the Range
+ */
+export declare function formatRange(range: Range_2 | undefined, precision?: number, exclusive?: boolean): string;
+
+/**
+ * Formats a search definition object into a query string.
+ * Note: The return value does not include the resource type.
+ * @param definition The search definition.
+ * @returns Formatted URL.
+ */
+export declare function formatSearchQuery(definition: SearchRequest): string;
+
+/**
+ * Formats a FHIR time string as a human readable string.
+ * Handles missing values and invalid dates.
+ * @param time The date to format.
+ * @param locales Optional locales.
+ * @param options Optional time format options.
+ * @returns The formatted time string.
+ */
+export declare function formatTime(time: string | undefined, locales?: Intl.LocalesArgument, options?: Intl.DateTimeFormatOptions | undefined): string;
+
+/**
+ * Formats a FHIR Timing as a human readable string.
+ * @param timing The timing to format.
+ * @returns The formatted timing string.
+ */
+export declare function formatTiming(timing: Timing | undefined): string;
+
+/**
+ * Cross platform random UUID generator
+ * Note that this is not intended for production use, but rather for testing
+ * This should be replaced when crypto.randomUUID is fully supported
+ * See: https://stackoverflow.com/revisions/2117523/28
+ * @returns A random UUID.
+ */
+export declare function generateId(): string;
+
+export declare function getAllDataTypes(): Record<string, InternalTypeSchema>;
+
+/**
+ * Returns an array of  questionnaire answers as a map by link ID.
+ * @param response The questionnaire response resource.
+ * @returns Questionnaire answer arrays mapped by link ID.
+ */
+export declare function getAllQuestionnaireAnswers(response: QuestionnaireResponse): Record<string, QuestionnaireResponseItemAnswer[]>;
+
+/**
+ * Tries to find a code string for a given system within a given codeable concept.
+ * @param concept The codeable concept.
+ * @param system The system string.
+ * @returns The code if found; otherwise undefined.
+ */
+export declare function getCodeBySystem(concept: CodeableConcept, system: string): string | undefined;
+
+export declare function getDataType(type: string): InternalTypeSchema;
+
+/**
+ * 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.
+ */
+export declare function getDateProperty(date: string | undefined): Date | undefined;
+
+/**
+ * Returns a display string for the resource.
+ * @param resource The input resource.
+ * @returns Human friendly display string.
+ */
+export declare function getDisplayString(resource: Resource): string;
+
+/**
+ * Returns an element definition by type and property name.
+ * Handles content references.
+ * @param typeName The type name.
+ * @param propertyName The property name.
+ * @returns The element definition if found.
+ */
+export declare function getElementDefinition(typeName: string, propertyName: string): InternalSchemaElement | undefined;
+
+/**
+ * Returns the type name for an ElementDefinition.
+ * @param elementDefinition The element definition.
+ * @returns The Medplum type name.
+ */
+export declare function getElementDefinitionTypeName(elementDefinition: ElementDefinition): string;
+
+export declare function getExpressionForResourceType(resourceType: string, expression: string): string | undefined;
+
+export declare function getExpressionsForResourceType(resourceType: string, expression: string): Atom[];
+
+/**
+ * Returns an extension by extension URLs.
+ * @param resource The base resource.
+ * @param urls Array of extension URLs. Each entry represents a nested extension.
+ * @returns The extension object if found; undefined otherwise.
+ */
+export declare function getExtension(resource: any, ...urls: string[]): Extension | undefined;
+
+/**
+ * Returns an extension value by extension URLs.
+ * @param resource The base resource.
+ * @param urls Array of extension URLs.  Each entry represents a nested extension.
+ * @returns The extension value if found; undefined otherwise.
+ */
+export declare function getExtensionValue(resource: any, ...urls: string[]): string | undefined;
+
+/**
+ * Returns the resource identifier for the given system.
+ *
+ * If multiple identifiers exist with the same system, the first one is returned.
+ *
+ * If the system is not found, then returns undefined.
+ * @param resource The resource to check.
+ * @param system The identifier system.
+ * @returns The identifier value if found; otherwise undefined.
+ */
+export declare function getIdentifier(resource: Resource, system: string): string | 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.
+ */
+export declare function getImageSrc(resource: Resource): string | undefined;
+
+export declare function getNestedProperty(value: TypedValue, key: string): (TypedValue | TypedValue[] | undefined)[];
+
+/**
+ * Returns a human friendly display name for a FHIR element definition path.
+ * @param path The FHIR element definition path.
+ * @returns The best guess of the display name.
+ */
+export declare function getPropertyDisplayName(path: string): string;
+
+/**
+ * Returns all questionnaire answers as a map by link ID.
+ * @param response The questionnaire response resource.
+ * @returns Questionnaire answers mapped by link ID.
+ */
+export declare function getQuestionnaireAnswers(response: QuestionnaireResponse): Record<string, QuestionnaireResponseItemAnswer>;
+
+/**
+ * Returns a cryptographically secure random string.
+ * @returns A cryptographically secure random string.
+ */
+export declare function getRandomString(): string;
+
+/**
+ * Returns a reference string for a resource.
+ * @param input The FHIR resource or reference.
+ * @returns A reference string of the form resourceType/id.
+ */
+export declare function getReferenceString(input: Reference | Resource): string;
+
+/**
+ * Returns an array of all resource types.
+ * Note that this is based on globalSchema, and will only return resource types that are currently in memory.
+ * @returns An array of all resource types.
+ */
+export declare function getResourceTypes(): ResourceType[];
+
+/**
+ * Returns a search parameter for a resource type by search code.
+ * @param resourceType The FHIR resource type.
+ * @param code The search parameter code.
+ * @returns The search parameter if found, otherwise undefined.
+ */
+export declare function getSearchParameter(resourceType: string, code: string): SearchParameter | undefined;
+
+/**
+ * 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 resourceType The root resource type.
+ * @param searchParam The search parameter.
+ * @returns The search parameter type details.
+ */
+export declare function getSearchParameterDetails(resourceType: string, searchParam: SearchParameter): SearchParameterDetails;
+
+/**
+ * Returns the search parameters for the resource type indexed by search code.
+ * @param resourceType The resource type.
+ * @returns The search parameters for the resource type indexed by search code.
+ */
+export declare function getSearchParameters(resourceType: string): Record<string, SearchParameter> | undefined;
+
+export declare function getStatus(outcome: OperationOutcome): number;
+
+/**
+ * Returns the value of the property and the property type.
+ * Some property definitions support multiple types.
+ * For example, "Observation.value[x]" can be "valueString", "valueInteger", "valueQuantity", etc.
+ * According to the spec, there can only be one property for a given element definition.
+ * This function returns the value and the type.
+ * @param input The base context (FHIR resource or backbone element).
+ * @param path The property path.
+ * @returns The value of the property and the property type.
+ */
+export declare function getTypedPropertyValue(input: TypedValue, path: string): TypedValue[] | TypedValue | undefined;
+
+/**
+ * Global schema singleton.
+ */
+export declare const globalSchema: IndexedStructureDefinition;
+
+export declare const gone: OperationOutcome;
+
+export declare interface GoogleCredentialResponse {
+    readonly clientId: string;
+    readonly credential: string;
+}
+
+export declare interface GoogleLoginRequest extends BaseLoginRequest {
+    readonly googleClientId: string;
+    readonly googleCredential: string;
+    readonly createUser?: boolean;
+}
+
+/**
+ * The Hl7Context class represents the parsing context for an HL7 message.
+ *
+ * MSH-1:
+ * https://hl7-definition.caristix.com/v2/HL7v2.6/Fields/MSH.1
+ *
+ * MSH-2:
+ * https://hl7-definition.caristix.com/v2/HL7v2.6/Fields/MSH.2
+ *
+ * See this tutorial on MSH, and why it's a bad idea to use anything other than the default values:
+ * https://www.hl7soup.com/HL7TutorialMSH.html
+ */
+export declare class Hl7Context {
+    readonly segmentSeparator: string;
+    readonly fieldSeparator: string;
+    readonly componentSeparator: string;
+    readonly repetitionSeparator: string;
+    readonly escapeCharacter: string;
+    readonly subcomponentSeparator: string;
+    constructor(segmentSeparator?: string, fieldSeparator?: string, componentSeparator?: string, repetitionSeparator?: string, escapeCharacter?: string, subcomponentSeparator?: string);
+    /**
+     * Returns the MSH-1 field value based on the configured separators.
+     * @returns The HL7 MSH-1 field value.
+     */
+    getMsh1(): string;
+    /**
+     * Returns the MSH-2 field value based on the configured separators.
+     * @returns The HL7 MSH-2 field value.
+     */
+    getMsh2(): string;
+}
+
+export declare interface Hl7DateParseOptions {
+    /**
+     * Default timezone offset.
+     * Example: "-0500"
+     */
+    tzOffset?: string;
+}
+
+/**
+ * The Hl7Field class represents one HL7 field.
+ * A field is a collection of components.
+ */
+export declare class Hl7Field {
+    readonly context: Hl7Context;
+    readonly components: string[][];
+    /**
+     * Creates a new HL7 field.
+     * @param components The HL7 components.
+     * @param context Optional HL7 parsing context.
+     */
+    constructor(components: string[][], context?: Hl7Context);
+    /**
+     * Returns an HL7 component by index.
+     * @param component The component index.
+     * @param subcomponent Optional subcomponent index.
+     * @param repetition Optional repetition index.
+     * @returns The string value of the specified component.
+     * @deprecated Use getComponent() instead. This method will be removed in a future release.
+     */
+    get(component: number, subcomponent?: number, repetition?: number): string;
+    /**
+     * Returns an HL7 component by index.
+     *
+     * Note that the index is 1-based, not 0-based.
+     *
+     * For example, to get the first component, use `getComponent(1)`.
+     *
+     * This aligns with HL7 component names such as MSH.9.2.
+     *
+     * @param component The component index.
+     * @param subcomponent Optional subcomponent index.
+     * @param repetition Optional repetition index.
+     * @returns The string value of the specified component.
+     */
+    getComponent(component: number, subcomponent?: number, repetition?: number): string;
+    /**
+     * Returns the HL7 field as a string.
+     * @returns The HL7 field as a string.
+     */
+    toString(): string;
+    /**
+     * Parses an HL7 field string into an Hl7Field object.
+     * @param text The HL7 field text.
+     * @param context Optional HL7 parsing context.
+     * @returns The parsed HL7 field.
+     */
+    static parse(text: string, context?: Hl7Context): Hl7Field;
+}
+
+/**
+ * The Hl7Message class represents one HL7 message.
+ * A message is a collection of segments.
+ */
+export declare class Hl7Message {
+    readonly context: Hl7Context;
+    readonly segments: Hl7Segment[];
+    /**
+     * Creates a new HL7 message.
+     * @param segments The HL7 segments.
+     * @param context Optional HL7 parsing context.
+     */
+    constructor(segments: Hl7Segment[], context?: Hl7Context);
+    /**
+     * Returns the HL7 message header.
+     * @returns The HL7 message header.
+     */
+    get header(): Hl7Segment;
+    /**
+     * Returns an HL7 segment by index or by name.
+     * @param index The HL7 segment index or name.
+     * @returns The HL7 segment if found; otherwise, undefined.
+     * @deprecated Use getSegment() instead. This method will be removed in a future release.
+     */
+    get(index: number | string): Hl7Segment | undefined;
+    /**
+     * Returns all HL7 segments of a given name.
+     * @param name The HL7 segment name.
+     * @returns An array of HL7 segments with the specified name.
+     * @deprecated Use getAllSegments() instead. This method will be removed in a future release.
+     */
+    getAll(name: string): Hl7Segment[];
+    /**
+     * Returns an HL7 segment by index or by name.
+     *
+     * When using a numeric index, the first segment (usually the MSH header segment) is at index 0.
+     *
+     * When using a string index, this method returns the first segment with the specified name.
+     *
+     * @param index The HL7 segment index or name.
+     * @returns The HL7 segment if found; otherwise, undefined.
+     */
+    getSegment(index: number | string): Hl7Segment | undefined;
+    /**
+     * Returns all HL7 segments of a given name.
+     * @param name The HL7 segment name.
+     * @returns An array of HL7 segments with the specified name.
+     */
+    getAllSegments(name: string): Hl7Segment[];
+    /**
+     * Returns the HL7 message as a string.
+     * @returns The HL7 message as a string.
+     */
+    toString(): string;
+    /**
+     * Returns an HL7 "ACK" (acknowledgement) message for this message.
+     * @returns The HL7 "ACK" message.
+     */
+    buildAck(): Hl7Message;
+    private buildAckMessageType;
+    /**
+     * Parses an HL7 message string into an Hl7Message object.
+     * @param text The HL7 message text.
+     * @returns The parsed HL7 message.
+     */
+    static parse(text: string): Hl7Message;
+}
+
+/**
+ * The Hl7Segment class represents one HL7 segment.
+ * A segment is a collection of fields.
+ * The name field is the first field.
+ */
+export declare class Hl7Segment {
+    readonly context: Hl7Context;
+    readonly name: string;
+    readonly fields: Hl7Field[];
+    /**
+     * Creates a new HL7 segment.
+     * @param fields The HL7 fields. The first field is the segment name.
+     * @param context Optional HL7 parsing context.
+     */
+    constructor(fields: Hl7Field[] | string[], context?: Hl7Context);
+    /**
+     * Returns an HL7 field by index.
+     * @param index The HL7 field index.
+     * @returns The HL7 field.
+     * @deprecated Use getSegment() instead. This method includes the segment name in the index, which leads to confusing behavior. This method will be removed in a future release.
+     */
+    get(index: number): Hl7Field;
+    /**
+     * Returns an HL7 field by index.
+     *
+     * Note that the index is 1-based, not 0-based.
+     *
+     * For example, to get the first field, use `getField(1)`.
+     *
+     * This aligns with HL7 field names such as PID.1, PID.2, etc.
+     *
+     * Field zero is the segment name.
+     *
+     * @param index The HL7 field index.
+     * @returns The HL7 field.
+     */
+    getField(index: number): Hl7Field;
+    /**
+     * Returns an HL7 component by field index and component index.
+     *
+     * This is a shortcut for `getField(field).getComponent(component)`.
+     *
+     * Note that both indexex are 1-based, not 0-based.
+     *
+     * For example, to get the first component, use `getComponent(1, 1)`.
+     *
+     * This aligns with HL7 component names such as MSH.9.2.
+     *
+     * @param fieldIndex The HL7 field index.
+     * @param component The component index.
+     * @param subcomponent Optional subcomponent index.
+     * @param repetition Optional repetition index.
+     * @returns The string value of the specified component.
+     */
+    getComponent(fieldIndex: number, component: number, subcomponent?: number, repetition?: number): string;
+    /**
+     * Returns the HL7 segment as a string.
+     * @returns The HL7 segment as a string.
+     */
+    toString(): string;
+    /**
+     * Parses an HL7 segment string into an Hl7Segment object.
+     * @param text The HL7 segment text.
+     * @param context Optional HL7 parsing context.
+     * @returns The parsed HL7 segment.
+     */
+    static parse(text: string, context?: Hl7Context): Hl7Segment;
+}
+
+export declare interface HumanNameFormatOptions {
+    all?: boolean;
+    prefix?: boolean;
+    suffix?: boolean;
+    use?: boolean;
+}
+
+export declare const ICD10 = "http://hl7.org/fhir/sid/icd-10";
+
+export declare interface IncludeTarget {
+    resourceType: string;
+    searchParam: string;
+    targetType?: string;
+    modifier?: string;
+}
+
+/**
+ * An IndexedStructureDefinition is a lookup-optimized version of a StructureDefinition.
+ *
+ * StructureDefinition resources contain schema information for other resource types.
+ * These schemas can be used to automatically generate user interface elements for
+ * resources.
+ *
+ * However, a StructureDefinition resource is not optimized for realtime lookups.  All
+ * resource types, sub types, and property definitions are stored in a flat array of
+ * ElementDefinition objects.  Therefore, to lookup the schema for a property (i.e., "Patient.name")
+ * requires a linear scan of all ElementDefinition objects
+ *
+ * A StructureDefinition resource contains information about one or more types.
+ * For example, the "Patient" StructureDefinition includes "Patient", "Patient_Contact",
+ * "Patient_Communication", and "Patient_Link".  This is inefficient.
+ *
+ * Instead, we create an indexed version of the StructureDefinition, called IndexedStructureDefinition.
+ * In an IndexedStructureDefinition, retrieving a property definition is a hashtable lookup.
+ *
+ * The hierarchy is:
+ *   IndexedStructureDefinition - top level for one resource type
+ *   TypeSchema - one per resource type and all contained BackboneElements
+ *   PropertySchema - one per property/field
+ */
+export declare interface IndexedStructureDefinition {
+    types: {
+        [resourceType: string]: TypeInfo;
+    };
+}
+
+/**
+ * Indexes a SearchParameter resource for fast lookup.
+ * Indexes by SearchParameter.code, which is the query string parameter name.
+ * @param searchParam The SearchParameter resource.
+ * @see {@link IndexedStructureDefinition} for more details on indexed StructureDefinitions.
+ */
+export declare function indexSearchParameter(searchParam: SearchParameter): void;
+
+/**
+ * Indexes a bundle of SearchParameter resources for faster lookup.
+ * @param bundle A FHIR bundle SearchParameter resources.
+ * @see {@link IndexedStructureDefinition} for more details on indexed StructureDefinitions.
+ */
+export declare function indexSearchParameterBundle(bundle: Bundle<SearchParameter>): void;
+
+export declare function indexStructureDefinitionBundle(bundle: StructureDefinition[] | Bundle): void;
+
+export declare abstract class InfixOperatorAtom implements Atom {
+    readonly operator: string;
+    readonly left: Atom;
+    readonly right: Atom;
+    constructor(operator: string, left: Atom, right: Atom);
+    abstract eval(context: AtomContext, input: TypedValue[]): TypedValue[];
+    toString(): string;
+}
+
+export declare interface InfixParselet {
+    precedence: number;
+    parse?(parser: Parser, left: Atom, token: Token): Atom;
+}
+
+export declare function inflateBaseSchema(base: BaseSchema): Record<string, InternalTypeSchema>;
+
+export declare function inflateElement(partial: Partial<InternalSchemaElement>): InternalSchemaElement;
+
+export declare function initFhirPathParserBuilder(): ParserBuilder;
+
+export declare interface InternalSchemaElement {
+    description: string;
+    path: string;
+    min: number;
+    max: number;
+    isArray?: boolean;
+    constraints?: Constraint[];
+    type: ElementType[];
+    slicing?: SlicingRules;
+    fixed?: TypedValue;
+    pattern?: TypedValue;
+    binding?: ElementDefinitionBinding;
+}
+
+/**
+ * Internal representation of a non-primitive FHIR type, suitable for use in resource validation
+ */
+export declare interface InternalTypeSchema {
+    name: string;
+    url?: string;
+    kind?: string;
+    description?: string;
+    elements: Record<string, InternalSchemaElement>;
+    constraints?: Constraint[];
+    parentType?: InternalTypeSchema;
+    innerTypes: InternalTypeSchema[];
+    summaryProperties?: Set<string>;
+    mandatoryProperties?: Set<string>;
+}
+
+export declare interface InviteRequest {
+    resourceType: 'Patient' | 'Practitioner' | 'RelatedPerson';
+    firstName: string;
+    lastName: string;
+    email?: string;
+    externalId?: string;
+    password?: string;
+    sendEmail?: boolean;
+    membership?: Partial<ProjectMembership>;
+    /** @deprecated Use membership.accessPolicy instead. */
+    accessPolicy?: Reference<AccessPolicy>;
+    /** @deprecated Use membership.access instead. */
+    access?: ProjectMembershipAccess[];
+    /** @deprecated Use membership.admin instead. */
+    admin?: boolean;
+}
+
+export declare function isAccepted(outcome: OperationOutcome): boolean;
+
+export declare function isCompletedSubscriptionRequest(subscriptionRequest: SubscriptionRequest | PendingSubscriptionRequest): subscriptionRequest is SubscriptionRequest;
+
+export declare function isCreated(outcome: OperationOutcome): boolean;
+
+export declare function isDataTypeLoaded(type: string): boolean;
+
+/**
+ * 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.
+ */
+export declare function isEmpty(v: any): boolean;
+
+/**
+ * Checks if a `ResourceType` can be used in a `FHIRcast` context.
+ *
+ * @param resourceType A `ResourceType` to test.
+ * @returns `true` if this is a resource type associated with `FHIRcast` contexts, otherwise returns `false`.
+ */
+export declare function isFhircastResourceType(resourceType: FhircastResourceType): boolean;
+
+export declare function isGone(outcome: OperationOutcome): boolean;
+
+/**
+ * Returns true if the token is a JWT.
+ * @param token The potential JWT token.
+ * @returns True if the token is a JWT.
+ */
+export declare function isJwt(token: string): boolean;
+
+export declare function isLowerCase(c: string): boolean;
+
+/**
+ * Returns true if the access token was issued by a Medplum server.
+ * @param accessToken An access token of unknown origin.
+ * @returns True if the access token was issued by a Medplum server.
+ */
+export declare function isMedplumAccessToken(accessToken: string): boolean;
+
+export declare function isNotFound(outcome: OperationOutcome): boolean;
+
+/**
+ * Returns true if the input is an object.
+ * @param obj The candidate object.
+ * @returns True if the input is a non-null non-undefined object.
+ */
+export declare function isObject(obj: unknown): obj is Record<string, unknown>;
+
+export declare function isOk(outcome: OperationOutcome): boolean;
+
+export declare function isOperationOutcome(value: unknown): value is OperationOutcome;
+
+/**
+ * Determines if the input is a Period object.
+ * This is heuristic based, as we do not have strong typing at runtime.
+ * @param input The input value.
+ * @returns True if the input is a period.
+ */
+export declare function isPeriod(input: unknown): input is Period;
+
+/**
+ * Returns true if the resource is a "ProfileResource".
+ * @param resource The FHIR resource.
+ * @returns True if the resource is a "ProfileResource".
+ */
+export declare function isProfileResource(resource: Resource): resource is ProfileResource;
+
+/**
+ * Determines if the input is a Quantity object.
+ * This is heuristic based, as we do not have strong typing at runtime.
+ * @param input The input value.
+ * @returns True if the input is a quantity.
+ */
+export declare function isQuantity(input: unknown): input is Quantity;
+
+export declare function isQuantityEquivalent(x: Quantity, y: Quantity): boolean;
+
+/**
+ * Typeguard to validate that an object is a FHIR resource
+ * @param value The object to check
+ * @returns True if the input is of type 'object' and contains property 'reference'
+ */
+export declare function isReference(value: unknown): value is Reference & {
+    reference: string;
+};
+
+/**
+ * Typeguard to validate that an object is a FHIR resource
+ * @param value The object to check
+ * @returns True if the input is of type 'object' and contains property 'resourceType'
+ */
+export declare function isResource(value: unknown): value is Resource;
+
+/**
+ * Returns true if the given string is a valid FHIR resource type.
+ *
+ * ```ts
+ * isResourceType('Patient'); // true
+ * isResourceType('XYZ'); // false
+ * ```
+ *
+ * @param resourceType The candidate resource type string.
+ * @returns True if the resource type is a valid FHIR resource type.
+ */
+export declare function isResourceType(resourceType: string): boolean;
+
+/**
+ * Returns true if the type schema is a non-abstract FHIR resource.
+ * @param typeSchema The type schema to check.
+ * @returns True if the type schema is a non-abstract FHIR resource.
+ */
+export declare function isResourceTypeSchema(typeSchema: InternalTypeSchema): boolean;
+
+/**
+ * Returns true if the input array is an array of strings.
+ * @param arr Input array.
+ * @returns True if the input array is an array of strings.
+ */
+export declare function isStringArray(arr: any[]): arr is string[];
+
+/**
+ * Returns true if the input string is a UUID.
+ * @param input The input string.
+ * @returns True if the input string matches the UUID format.
+ */
+export declare function isUUID(input: string): input is `${string}-${string}-${string}-${string}-${string}`;
+
+/**
+ * Returns true if the given date object is a valid date.
+ * Dates can be invalid if created by parsing an invalid string.
+ * @param date A date object.
+ * @returns Returns true if the date is a valid date.
+ */
+export declare function isValidDate(date: Date): boolean;
+
+export declare function loadDataType(sd: StructureDefinition): void;
+
+export declare interface LoginAuthenticationResponse {
+    readonly login: string;
+    readonly mfaRequired?: boolean;
+    readonly code?: string;
+    readonly memberships?: ProjectMembership[];
+}
+
+export declare interface LoginProfileResponse {
+    readonly login: string;
+    readonly scope: string;
+}
+
+export declare interface LoginScopeResponse {
+    readonly login: string;
+    readonly code: string;
+}
+
+export declare interface LoginState {
+    readonly project: Reference<Project>;
+    readonly profile: Reference<ProfileResource>;
+    readonly accessToken: string;
+    readonly refreshToken: string;
+}
+
+export declare const LOINC = "http://loinc.org";
+
+/**
+ * LRU cache (least recently used)
+ * Source: https://stackoverflow.com/a/46432113
+ */
+export declare class LRUCache<T> {
+    private readonly max;
+    private readonly cache;
+    constructor(max?: number);
+    /**
+     * Deletes all values from the cache.
+     */
+    clear(): void;
+    /**
+     * Returns the value for the given key.
+     * @param key The key to retrieve.
+     * @returns The value if found; undefined otherwise.
+     */
+    get(key: string): T | undefined;
+    /**
+     * Sets the value for the given key.
+     * @param key The key to set.
+     * @param val The value to set.
+     */
+    set(key: string, val: T): void;
+    /**
+     * Deletes the value for the given key.
+     * @param key The key to delete.
+     */
+    delete(key: string): void;
+    /**
+     * Returns the list of all keys in the cache.
+     * @returns The array of keys in the cache.
+     */
+    keys(): IterableIterator<string>;
+    private first;
+}
+
+/**
+ * Email address definition.
+ * Compatible with nodemailer Mail.Address.
+ */
+export declare interface MailAddress {
+    readonly name: string;
+    readonly address: string;
+}
+
+/**
+ * Email attachment definition.
+ * Compatible with nodemailer Mail.Options.
+ */
+export declare interface MailAttachment {
+    /** String, Buffer or a Stream contents for the attachmentent */
+    readonly content?: string;
+    /** path to a file or an URL (data uris are allowed as well) if you want to stream the file instead of including it (better for larger attachments) */
+    readonly path?: string;
+    /** filename to be reported as the name of the attached file, use of unicode is allowed. If you do not want to use a filename, set this value as false, otherwise a filename is generated automatically */
+    readonly filename?: string | false;
+    /** optional content type for the attachment, if not set will be derived from the filename property */
+    readonly contentType?: string;
+}
+
+/**
+ * Email destination definition.
+ */
+export declare type MailDestination = string | MailAddress | string[] | MailAddress[];
+
+/**
+ * Email message definition.
+ * Compatible with nodemailer Mail.Options.
+ */
+export declare interface MailOptions {
+    /** The e-mail address of the sender. All e-mail addresses can be plain 'sender@server.com' or formatted 'Sender Name <sender@server.com>' */
+    readonly from?: string | MailAddress;
+    /** An e-mail address that will appear on the Sender: field */
+    readonly sender?: string | MailAddress;
+    /** Comma separated list or an array of recipients e-mail addresses that will appear on the To: field */
+    readonly to?: MailDestination;
+    /** Comma separated list or an array of recipients e-mail addresses that will appear on the Cc: field */
+    readonly cc?: MailDestination;
+    /** Comma separated list or an array of recipients e-mail addresses that will appear on the Bcc: field */
+    readonly bcc?: MailDestination;
+    /** An e-mail address that will appear on the Reply-To: field */
+    readonly replyTo?: string | MailAddress;
+    /** The subject of the e-mail */
+    readonly subject?: string;
+    /** The plaintext version of the message */
+    readonly text?: string;
+    /** The HTML version of the message */
+    readonly html?: string;
+    /** An array of attachment objects */
+    readonly attachments?: MailAttachment[];
+}
+
+declare interface Marker {
+    index: number;
+    line: number;
+    column: number;
+}
+
+/**
+ * Returns true if the resource satisfies the current access policy.
+ * @param accessPolicy The access policy.
+ * @param resource The resource.
+ * @param readonlyMode True if the resource is being read.
+ * @returns True if the resource matches the access policy.
+ * @deprecated Use satisfiedAccessPolicy() instead.
+ */
+export declare function matchesAccessPolicy(accessPolicy: AccessPolicy, resource: Resource, readonlyMode: boolean): boolean;
+
+/**
+ * Returns true if the value is in the range accounting for precision.
+ * @param value The numeric value.
+ * @param range The numeric range.
+ * @param precision Optional precision in number of digits.
+ * @returns True if the value is within the range.
+ */
+export declare function matchesRange(value: number, range: Range_2, precision?: number): boolean;
+
+/**
+ * Determines if the resource matches the search request.
+ * @param resource The resource that was created or updated.
+ * @param searchRequest The subscription criteria as a search request.
+ * @returns True if the resource satisfies the search request.
+ */
+export declare function matchesSearchRequest(resource: Resource, searchRequest: SearchRequest): boolean;
+
+export declare const MEDPLUM_VERSION: string;
+
+/**
+ * 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>
+ */
+export declare class MedplumClient extends EventTarget_2 {
+    private readonly options;
+    private readonly fetch;
+    private readonly createPdfImpl?;
+    private readonly storage;
+    private readonly requestCache;
+    private readonly cacheTime;
+    private readonly baseUrl;
+    private readonly fhirBaseUrl;
+    private readonly authorizeUrl;
+    private readonly tokenUrl;
+    private readonly logoutUrl;
+    private readonly onUnauthenticated?;
+    private readonly autoBatchTime;
+    private readonly autoBatchQueue;
+    private medplumServer?;
+    private clientId?;
+    private clientSecret?;
+    private autoBatchTimerId?;
+    private accessToken?;
+    private refreshToken?;
+    private refreshPromise?;
+    private profilePromise?;
+    private sessionDetails?;
+    private basicAuth?;
+    constructor(options?: MedplumClientOptions);
+    /**
+     * 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(): string;
+    /**
+     * 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(): string;
+    /**
+     * Returns the current token URL.
+     * By default, this is set to `https://api.medplum.com/oauth2/token`.
+     * This can be overridden by setting the `tokenUrl` option when creating the client.
+     * @category HTTP
+     * @returns The current token URL.
+     */
+    getTokenUrl(): string;
+    /**
+     * Returns the current logout URL.
+     * By default, this is set to `https://api.medplum.com/oauth2/logout`.
+     * This can be overridden by setting the `logoutUrl` option when creating the client.
+     * @category HTTP
+     * @returns The current logout URL.
+     */
+    getLogoutUrl(): string;
+    /**
+     * Clears all auth state including local storage and session storage.
+     * @category Authentication
+     */
+    clear(): void;
+    /**
+     * Clears the active login from local storage.
+     * Does not clear all local storage (such as other logins).
+     * @category Authentication
+     */
+    clearActiveLogin(): void;
+    /**
+     * Invalidates any cached values or cached requests for the given URL.
+     * @category Caching
+     * @param url The URL to invalidate.
+     */
+    invalidateUrl(url: URL | string): void;
+    /**
+     * Invalidates all cached values and flushes the cache.
+     * @category Caching
+     */
+    invalidateAll(): void;
+    /**
+     * Invalidates all cached search results or cached requests for the given resourceType.
+     * @category Caching
+     * @param resourceType The resource type to invalidate.
+     */
+    invalidateSearches<K extends ResourceType>(resourceType: K): void;
+    /**
+     * 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<T = any>(url: URL | string, options?: RequestInit): ReadablePromise<T>;
+    /**
+     * 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: URL | string, body: any, contentType?: string, options?: RequestInit): Promise<any>;
+    /**
+     * 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: URL | string, body: any, contentType?: string, options?: RequestInit): Promise<any>;
+    /**
+     * 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: URL | string, operations: PatchOperation[], options?: RequestInit): Promise<any>;
+    /**
+     * 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: URL | string, options?: RequestInit): Promise<any>;
+    /**
+     * 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.
+     */
+    startNewUser(newUserRequest: NewUserRequest, options?: RequestInit): Promise<LoginAuthenticationResponse>;
+    /**
+     * 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.
+     */
+    startNewProject(newProjectRequest: NewProjectRequest, options?: RequestInit): Promise<LoginAuthenticationResponse>;
+    /**
+     * 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.
+     */
+    startNewPatient(newPatientRequest: NewPatientRequest, options?: RequestInit): Promise<LoginAuthenticationResponse>;
+    /**
+     * 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.
+     */
+    startLogin(loginRequest: EmailPasswordLoginRequest, options?: RequestInit): Promise<LoginAuthenticationResponse>;
+    /**
+     * 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.
+     */
+    startGoogleLogin(loginRequest: GoogleLoginRequest, options?: RequestInit): Promise<LoginAuthenticationResponse>;
+    /**
+     * 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.
+     */
+    ensureCodeChallenge<T extends BaseLoginRequest>(loginRequest: T): Promise<T>;
+    /**
+     * Signs out locally.
+     * Does not invalidate tokens with the server.
+     * @category Authentication
+     */
+    signOut(): Promise<void>;
+    /**
+     * 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.
+     */
+    signInWithRedirect(loginParams?: Partial<BaseLoginRequest>): Promise<ProfileResource | undefined>;
+    /**
+     * Tries to sign out the user.
+     * See: https://docs.aws.amazon.com/cognito/latest/developerguide/logout-endpoint.html
+     * @category Authentication
+     */
+    signOutWithRedirect(): void;
+    /**
+     * 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
+     */
+    signInWithExternalAuth(authorizeUrl: string, clientId: string, redirectUri: string, baseLogin: BaseLoginRequest): Promise<void>;
+    /**
+     * 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
+     */
+    exchangeExternalAccessToken(token: string, clientId?: string): Promise<ProfileResource>;
+    /**
+     * 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: string, clientId: string, redirectUri: string, loginRequest: BaseLoginRequest): string;
+    /**
+     * 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: string[]): URL;
+    /**
+     * 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: ResourceType, query: QueryTypes): 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<K extends ResourceType>(resourceType: K, query?: QueryTypes, options?: RequestInit): ReadablePromise<Bundle<ExtractResource<K>>>;
+    /**
+     * 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<K extends ResourceType>(resourceType: K, query?: QueryTypes, options?: RequestInit): ReadablePromise<ExtractResource<K> | undefined>;
+    /**
+     * 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<K extends ResourceType>(resourceType: K, query?: QueryTypes, options?: RequestInit): ReadablePromise<ResourceArray<ExtractResource<K>>>;
+    /**
+     * 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.
+     */
+    searchResourcePages<K extends ResourceType>(resourceType: K, query?: QueryTypes, options?: RequestInit): AsyncGenerator<ResourceArray<ExtractResource<K>>>;
+    /**
+     * 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: string, filter: string, options?: RequestInit): ReadablePromise<ValueSet>;
+    /**
+     * 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<K extends ResourceType>(resourceType: K, id: string): ExtractResource<K> | 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<T extends Resource>(reference: Reference<T>): T | undefined;
+    /**
+     * 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<K extends ResourceType>(resourceType: K, id: string, options?: RequestInit): ReadablePromise<ExtractResource<K>>;
+    /**
+     * 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<T extends Resource>(reference: Reference<T>, options?: RequestInit): ReadablePromise<T>;
+    /**
+     * 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: string): Promise<void>;
+    /**
+     * 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<K extends ResourceType>(resourceType: K, id: string, options?: RequestInit): ReadablePromise<Bundle<ExtractResource<K>>>;
+    /**
+     * 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<K extends ResourceType>(resourceType: K, id: string, vid: string, options?: RequestInit): ReadablePromise<ExtractResource<K>>;
+    /**
+     * 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: string, options?: RequestInit): ReadablePromise<Bundle>;
+    /**
+     * 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<T extends Resource>(resource: T, options?: RequestInit): Promise<T>;
+    /**
+     * 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.
+     */
+    createResourceIfNoneExist<T extends Resource>(resource: T, query: string, options?: RequestInit): Promise<T>;
+    /**
+     * Creates a FHIR `Attachment` with the provided data content.
+     *
+     * This is a convenience method for creating a `Binary` resource and then creating an `Attachment` element.
+     *
+     * 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.createAttachment(myFile, 'test.jpg', 'image/jpeg');
+     * console.log(result);
+     * ```
+     *
+     * 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.
+     */
+    createAttachment(data: BinarySource, filename: string | undefined, contentType: string, onProgress?: (e: ProgressEvent) => void): Promise<Attachment>;
+    /**
+     * 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: BinarySource, filename: string | undefined, contentType: string, onProgress?: (e: ProgressEvent) => void): Promise<Binary>;
+    uploadwithProgress(url: URL, data: BinarySource, contentType: string, onProgress: (e: ProgressEvent) => void): Promise<any>;
+    /**
+     * 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.
+     */
+    createPdf(docDefinition: TDocumentDefinitions, filename?: string, tableLayouts?: Record<string, CustomTableLayout>, fonts?: TFontDictionary): Promise<Binary>;
+    /**
+     * 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: Resource, text: string, options?: RequestInit): Promise<Communication>;
+    /**
+     * 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.
+     */
+    updateResource<T extends Resource>(resource: T, options?: RequestInit): Promise<T>;
+    /**
+     * 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<K extends ResourceType>(resourceType: K, id: string, operations: PatchOperation[], options?: RequestInit): Promise<ExtractResource<K>>;
+    /**
+     * 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: ResourceType, id: string, options?: RequestInit): Promise<any>;
+    /**
+     * 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<T extends Resource>(resource: T, options?: RequestInit): Promise<OperationOutcome>;
+    /**
+     * 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: string | Identifier, body: any, contentType?: string, options?: RequestInit): Promise<any>;
+    /**
+     * 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: Bundle, options?: RequestInit): Promise<Bundle>;
+    /**
+     * 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: MailOptions, options?: RequestInit): Promise<OperationOutcome>;
+    /**
+     * 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: string, operationName?: string | null, variables?: any, options?: RequestInit): Promise<any>;
+    /**
+     * 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<K extends ResourceType>(resourceType: K, id: string, graphName: string, options?: RequestInit): ReadablePromise<Bundle>;
+    /**
+     * Pushes a message to an agent.
+     *
+     * @param agent The agent to push to.
+     * @param destination The destination device.
+     * @param body The message body.
+     * @param contentType Optional message content type.
+     * @param options Optional fetch options.
+     * @returns Promise to the operation outcome.
+     */
+    pushToAgent(agent: Agent | Reference<Agent>, destination: Device | Reference<Device>, body: any, contentType?: string, options?: RequestInit): Promise<OperationOutcome>;
+    /**
+     * @category Authentication
+     * @returns The Login State
+     */
+    getActiveLogin(): LoginState | undefined;
+    /**
+     * Sets the active login.
+     * @param login The new active login state.
+     * @category Authentication
+     */
+    setActiveLogin(login: LoginState): Promise<void>;
+    /**
+     * Returns the current access token.
+     * @returns The current access token.
+     * @category Authentication
+     */
+    getAccessToken(): string | undefined;
+    /**
+     * Sets the current access token.
+     * @param accessToken The new access token.
+     * @param refreshToken Optional refresh token.
+     * @category Authentication
+     */
+    setAccessToken(accessToken: string, refreshToken?: string): void;
+    /**
+     * Returns the list of available logins.
+     * @returns The list of available logins.
+     * @category Authentication
+     */
+    getLogins(): LoginState[];
+    private addLogin;
+    private refreshProfile;
+    /**
+     * Returns true if the client is waiting for authentication.
+     * @returns True if the client is waiting for authentication.
+     * @category Authentication
+     */
+    isLoading(): boolean;
+    /**
+     * 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(): boolean;
+    /**
+     * 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(): boolean;
+    /**
+     * Returns the current project if available.
+     * @returns The current project if available.
+     * @category User Profile
+     */
+    getProject(): Project | undefined;
+    /**
+     * Returns the current project membership if available.
+     * @returns The current project membership if available.
+     * @category User Profile
+     */
+    getProjectMembership(): ProjectMembership | undefined;
+    /**
+     * 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(): ProfileResource | undefined;
+    /**
+     * Returns the current user profile resource, retrieving form the server if necessary.
+     * This method waits for loading promises.
+     * @returns The current user profile resource.
+     * @category User Profile
+     */
+    getProfileAsync(): Promise<ProfileResource | undefined>;
+    /**
+     * Returns the current user configuration if available.
+     * @returns The current user configuration if available.
+     * @category User Profile
+     */
+    getUserConfiguration(): UserConfiguration | undefined;
+    /**
+     * Returns the current user access policy if available.
+     * @returns The current user access policy if available.
+     * @category User Profile
+     */
+    getAccessPolicy(): AccessPolicy | undefined;
+    /**
+     * Downloads the URL as a blob. Can accept binary URLs in the form of `Binary/{id}` as well.
+     * @category Read
+     * @param url The URL to request. Can be a standard URL or one in the form of `Binary/{id}`.
+     * @param options Optional fetch request init options.
+     * @returns Promise to the response body as a blob.
+     */
+    download(url: URL | string, options?: RequestInit): Promise<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
+     */
+    uploadMedia(contents: string | Uint8Array | File | Blob, contentType: string, filename: string | undefined, additionalFields?: Partial<Media>, options?: RequestInit): Promise<Media>;
+    /**
+     * 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
+     */
+    bulkExport(exportLevel?: string, resourceTypes?: string, since?: string, options?: RequestInit): Promise<Partial<BulkDataExport>>;
+    /**
+     * 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.
+     */
+    startAsyncRequest<T>(url: string, options?: RequestInit): Promise<T>;
+    /**
+     * 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.
+     */
+    private getCacheEntry;
+    /**
+     * Adds a readable promise to the cache.
+     * @param key The cache key to store.
+     * @param value The readable promise to store.
+     */
+    private setCacheEntry;
+    /**
+     * 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.
+     */
+    private cacheResource;
+    /**
+     * Deletes a cache entry.
+     * @param key The cache key to delete.
+     */
+    private deleteCacheEntry;
+    /**
+     * 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.
+     */
+    private request;
+    private parseResponse;
+    private fetchWithRetry;
+    private logRequest;
+    private logResponse;
+    private pollStatus;
+    /**
+     * Executes a batch of requests that were automatically batched together.
+     */
+    private executeAutoBatch;
+    /**
+     * Adds default options to the fetch options.
+     * @param options The options to add defaults to.
+     */
+    private addFetchOptionsDefaults;
+    /**
+     * Sets the "Content-Type" header on fetch options.
+     * @param options The fetch options.
+     * @param contentType The new content type to set.
+     */
+    private setRequestContentType;
+    /**
+     * Sets the body on fetch options.
+     * @param options The fetch options.
+     * @param data The new content body.
+     */
+    private setRequestBody;
+    /**
+     * 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.
+     */
+    private handleUnauthenticated;
+    /**
+     * 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.
+     */
+    startPkce(): Promise<{
+        codeChallengeMethod: CodeChallengeMethod;
+        codeChallenge: string;
+    }>;
+    /**
+     * 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
+     */
+    private requestAuthorization;
+    /**
+     * 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: string, loginParams?: Partial<BaseLoginRequest>): Promise<ProfileResource>;
+    /**
+     * 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
+     */
+    private refresh;
+    /**
+     * 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.
+     */
+    startClientLogin(clientId: string, clientSecret: string): Promise<ProfileResource>;
+    /**
+     * Starts a new OAuth2 JWT bearer flow.
+     *
+     * ```typescript
+     * await medplum.startJwtBearerLogin(process.env.MEDPLUM_CLIENT_ID, process.env.MEDPLUM_JWT_BEARER_ASSERTION, 'openid profile');
+     * // Example Search
+     * await medplum.searchResources('Patient')
+     * ```
+     *
+     * See: https://datatracker.ietf.org/doc/html/rfc7523#section-2.1
+     *
+     * @category Authentication
+     * @param clientId The client ID.
+     * @param assertion The JWT assertion.
+     * @param scope The OAuth scope.
+     * @returns Promise that resolves to the client profile.
+     */
+    startJwtBearerLogin(clientId: string, assertion: string, scope: string): Promise<ProfileResource>;
+    /**
+     * Starts a new OAuth2 JWT assertion flow.
+     *
+     * See: https://datatracker.ietf.org/doc/html/rfc7523#section-2.2
+     *
+     * @category Authentication
+     * @param jwt The JWT assertion.
+     * @returns Promise that resolves to the client profile.
+     */
+    startJwtAssertionLogin(jwt: string): Promise<ProfileResource>;
+    /**
+     * 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: string, clientSecret: string): void;
+    /**
+     * Subscribes to a specified topic, listening for a list of specified events.
+     *
+     * Once you have the `SubscriptionRequest` returned from this method, you can call `fhircastConnect(subscriptionRequest)` to connect to the subscription stream.
+     *
+     * @category FHIRcast
+     * @param topic The topic to publish to. Usually a UUID.
+     * @param events An array of event names to listen for.
+     * @returns A `Promise` that resolves once the request completes, or rejects if it fails.
+     */
+    fhircastSubscribe(topic: string, events: FhircastEventName[]): Promise<SubscriptionRequest>;
+    /**
+     * Unsubscribes from the specified topic.
+     *
+     * @category FHIRcast
+     * @param subRequest A `SubscriptionRequest` representing a subscription to cancel. Mode will be set to `unsubscribe` automatically.
+     * @returns A `Promise` that resolves when request to unsubscribe is completed.
+     */
+    fhircastUnsubscribe(subRequest: SubscriptionRequest): Promise<void>;
+    /**
+     * Connects to a `FHIRcast` session.
+     *
+     * @category FHIRcast
+     * @param subRequest The `SubscriptionRequest` to use for connecting.
+     * @returns A `FhircastConnection` which emits lifecycle events for the `FHIRcast` WebSocket connection.
+     */
+    fhircastConnect(subRequest: SubscriptionRequest): FhircastConnection;
+    /**
+     * Publishes a new context to a given topic for a specified event type.
+     *
+     * @category FHIRcast
+     * @param topic The topic to publish to. Usually a UUID.
+     * @param event The name of the event to publish an updated context for, ie. `patient-open`.
+     * @param context The updated context containing resources relevant to this event.
+     * @returns A `Promise` that resolves once the request completes, or rejects if it fails.
+     */
+    fhircastPublish(topic: string, event: FhircastEventName, context: FhircastEventContext | FhircastEventContext[]): Promise<void>;
+    /**
+     * Invite a user to a project.
+     * @param projectId The project ID.
+     * @param body The InviteRequest.
+     * @returns Promise that returns a project membership or an operation outcome.
+     */
+    invite(projectId: string, body: InviteRequest): Promise<ProjectMembership | OperationOutcome>;
+    /**
+     * 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.
+     */
+    private fetchTokens;
+    /**
+     * 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.
+     */
+    private verifyTokens;
+    /**
+     * Sets up a listener for window storage events.
+     * This synchronizes state across browser windows and browser tabs.
+     */
+    private setupStorageListener;
+    private retryCatch;
+}
+
+/**
+ * The MedplumClientOptions interface defines configuration options for MedplumClient.
+ *
+ * All configuration settings are optional.
+ */
+export declare interface MedplumClientOptions {
+    /**
+     * Base server URL.
+     *
+     * Default value is https://api.medplum.com/
+     *
+     * Use this to point to a custom Medplum deployment.
+     */
+    baseUrl?: string;
+    /**
+     * OAuth2 authorize URL.
+     *
+     * Default value is baseUrl + "/oauth2/authorize".
+     *
+     * Can be specified as absolute URL or relative to baseUrl.
+     *
+     * Use this if you want to use a separate OAuth server.
+     */
+    authorizeUrl?: string;
+    /**
+     * FHIR URL path.
+     *
+     * Default value is "fhir/R4/".
+     *
+     * Can be specified as absolute URL or relative to baseUrl.
+     *
+     * Use this if you want to use a different path when connecting to a FHIR server.
+     */
+    fhirUrlPath?: string;
+    /**
+     * OAuth2 token URL.
+     *
+     * Default value is baseUrl + "/oauth2/token".
+     *
+     * Can be specified as absolute URL or relative to baseUrl.
+     *
+     * Use this if you want to use a separate OAuth server.
+     */
+    tokenUrl?: string;
+    /**
+     * OAuth2 logout URL.
+     *
+     * Default value is baseUrl + "/oauth2/logout".
+     *
+     * Can be specified as absolute URL or relative to baseUrl.
+     *
+     * Use this if you want to use a separate OAuth server.
+     */
+    logoutUrl?: string;
+    /**
+     * The client ID.
+     *
+     * Client ID can be used for SMART-on-FHIR customization.
+     */
+    clientId?: string;
+    /**
+     * The client secret.
+     *
+     * Client secret can be used for FHIR Oauth Client Credential flows
+     */
+    clientSecret?: string;
+    /**
+     * The OAuth Access Token.
+     *
+     * Access Token used to connect to make request to FHIR servers
+     */
+    accessToken?: string;
+    /**
+     * Number of resources to store in the cache.
+     *
+     * Default value is 1000.
+     *
+     * Consider using this for performance of displaying Patient or Practitioner resources.
+     */
+    resourceCacheSize?: number;
+    /**
+     * The length of time in milliseconds to cache resources.
+     *
+     * Default value is 10000 (10 seconds).
+     *
+     * Cache time of zero disables all caching.
+     *
+     * For any individual request, the cache behavior can be overridden by setting the cache property on request options.
+     *
+     * See: https://developer.mozilla.org/en-US/docs/Web/API/Request/cache
+     */
+    cacheTime?: number;
+    /**
+     * The length of time in milliseconds to delay requests for auto batching.
+     *
+     * Auto batching attempts to group multiple requests together into a single batch request.
+     *
+     * Default value is 0, which disables auto batching.
+     */
+    autoBatchTime?: number;
+    /**
+     * Fetch implementation.
+     *
+     * Default is window.fetch (if available).
+     *
+     * For Node.js applications, consider the 'node-fetch' package.
+     */
+    fetch?: FetchLike;
+    /**
+     * Storage implementation.
+     *
+     * Default is window.localStorage (if available), this is the common implementation for use in the browser, or an in-memory storage implementation.  If using Medplum on a server it may be useful to provide a custom storage implementation, for example using redis, a database or a file based storage.  Medplum CLI is an an example of `FileSystemStorage`, for reference.
+     */
+    storage?: ClientStorage;
+    /**
+     * Create PDF implementation.
+     *
+     * Default is none, and PDF generation is disabled.
+     *
+     * In browser environments, import the client-side pdfmake library.
+     *
+     * ```html
+     * <script src="pdfmake.min.js"></script>
+     * <script>
+     * async function createPdf(docDefinition, tableLayouts, fonts) {
+     *   return new Promise((resolve) => {
+     *     pdfMake.createPdf(docDefinition, tableLayouts, fonts).getBlob(resolve);
+     *   });
+     * }
+     * </script>
+     * ```
+     *
+     * In Node.js applications:
+     *
+     * ```ts
+     * import type { CustomTableLayout, TDocumentDefinitions, TFontDictionary } from 'pdfmake/interfaces';
+     * function createPdf(
+     *   docDefinition: TDocumentDefinitions,
+     *   tableLayouts?: { [name: string]: CustomTableLayout },
+     *   fonts?: TFontDictionary
+     * ): Promise<Buffer> {
+     *   return new Promise((resolve, reject) => {
+     *     const printer = new PdfPrinter(fonts ?? {});
+     *     const pdfDoc = printer.createPdfKitDocument(docDefinition, { tableLayouts });
+     *     const chunks: Uint8Array[] = [];
+     *     pdfDoc.on('data', (chunk: Uint8Array) => chunks.push(chunk));
+     *     pdfDoc.on('end', () => resolve(Buffer.concat(chunks)));
+     *     pdfDoc.on('error', reject);
+     *     pdfDoc.end();
+     *   });
+     * }
+     * ```
+     */
+    createPdf?: CreatePdfFunction;
+    /**
+     * Callback for when the client is unauthenticated.
+     *
+     * Default is do nothing.
+     *
+     * For client side applications, consider redirecting to a sign in page.
+     */
+    onUnauthenticated?: () => void;
+    /**
+     * The default redirect behavior.
+     *
+     * The default behavior is to not follow redirects.
+     *
+     * Use "follow" to automatically follow redirects.
+     */
+    redirect?: RequestRedirect;
+    /**
+     * When the verbose flag is set, the client will log all requests and responses to the console.
+     */
+    verbose?: boolean;
+}
+
+export declare interface MedplumInfraConfig {
+    name: string;
+    stackName: string;
+    accountNumber: string;
+    region: string;
+    domainName: string;
+    vpcId: string;
+    apiPort: number;
+    apiDomainName: string;
+    apiSslCertArn: string;
+    apiInternetFacing?: boolean;
+    appDomainName: string;
+    appSslCertArn: string;
+    appApiProxy?: boolean;
+    appLoggingBucket?: string;
+    appLoggingPrefix?: string;
+    storageBucketName: string;
+    storageDomainName: string;
+    storageSslCertArn: string;
+    signingKeyId: string;
+    storagePublicKey: string;
+    storageLoggingBucket?: string;
+    storageLoggingPrefix?: string;
+    baseUrl: string;
+    maxAzs: number;
+    rdsInstances: number;
+    rdsInstanceType: string;
+    rdsSecretsArn?: string;
+    cacheNodeType?: string;
+    desiredServerCount: number;
+    serverImage: string;
+    serverMemory: number;
+    serverCpu: number;
+    loadBalancerLoggingBucket?: string;
+    loadBalancerLoggingPrefix?: string;
+    clamscanEnabled: boolean;
+    clamscanLoggingBucket: string;
+    clamscanLoggingPrefix: string;
+    skipDns?: boolean;
+    additionalContainers?: {
+        name: string;
+        image: string;
+        cpu?: number;
+        memory?: number;
+        essential?: boolean;
+        command?: string[];
+        environment?: {
+            [key: string]: string;
+        };
+    }[];
+    cloudTrailAlarms?: {
+        logGroupName: string;
+        logGroupCreate?: boolean;
+        snsTopicArn?: string;
+        snsTopicName?: string;
+    };
+}
+
+export declare interface MedplumSourceInfraConfig {
+    name: ValueOrExternalSecret<string>;
+    stackName: ValueOrExternalSecret<string>;
+    accountNumber: ValueOrExternalSecret<string>;
+    region: string;
+    domainName: ValueOrExternalSecret<string>;
+    vpcId: ValueOrExternalSecret<string>;
+    apiPort: ValueOrExternalSecret<number>;
+    apiDomainName: ValueOrExternalSecret<string>;
+    apiSslCertArn: ValueOrExternalSecret<string>;
+    apiInternetFacing?: ValueOrExternalSecret<boolean>;
+    appDomainName: ValueOrExternalSecret<string>;
+    appSslCertArn: ValueOrExternalSecret<string>;
+    appApiProxy?: ValueOrExternalSecret<boolean>;
+    appLoggingBucket?: ValueOrExternalSecret<string>;
+    appLoggingPrefix?: ValueOrExternalSecret<string>;
+    storageBucketName: ValueOrExternalSecret<string>;
+    storageDomainName: ValueOrExternalSecret<string>;
+    storageSslCertArn: ValueOrExternalSecret<string>;
+    signingKeyId: ValueOrExternalSecret<string>;
+    storagePublicKey: ValueOrExternalSecret<string>;
+    storageLoggingBucket?: ValueOrExternalSecret<string>;
+    storageLoggingPrefix?: ValueOrExternalSecret<string>;
+    baseUrl: ValueOrExternalSecret<string>;
+    maxAzs: ValueOrExternalSecret<number>;
+    rdsInstances: ValueOrExternalSecret<number>;
+    rdsInstanceType: ValueOrExternalSecret<string>;
+    rdsSecretsArn?: ValueOrExternalSecret<string>;
+    cacheNodeType?: ValueOrExternalSecret<string>;
+    desiredServerCount: ValueOrExternalSecret<number>;
+    serverImage: ValueOrExternalSecret<string>;
+    serverMemory: ValueOrExternalSecret<number>;
+    serverCpu: ValueOrExternalSecret<number>;
+    loadBalancerLoggingBucket?: ValueOrExternalSecret<string>;
+    loadBalancerLoggingPrefix?: ValueOrExternalSecret<string>;
+    clamscanEnabled: ValueOrExternalSecret<boolean>;
+    clamscanLoggingBucket: ValueOrExternalSecret<string>;
+    clamscanLoggingPrefix: ValueOrExternalSecret<string>;
+    skipDns?: ValueOrExternalSecret<boolean>;
+    additionalContainers?: {
+        name: ValueOrExternalSecret<string>;
+        image: ValueOrExternalSecret<string>;
+        cpu?: ValueOrExternalSecret<number>;
+        memory?: ValueOrExternalSecret<number>;
+        essential?: ValueOrExternalSecret<boolean>;
+        command?: ValueOrExternalSecret<string>[];
+        environment?: {
+            [key: string]: ValueOrExternalSecret<string>;
+        };
+    }[];
+    cloudTrailAlarms?: {
+        logGroupName: ValueOrExternalSecret<string>;
+        logGroupCreate?: ValueOrExternalSecret<boolean>;
+        snsTopicArn?: ValueOrExternalSecret<string>;
+        snsTopicName?: ValueOrExternalSecret<string>;
+    };
+}
+
+/**
+ * The MemoryStorage class is a minimal in-memory implementation of the Storage interface.
+ */
+export declare class MemoryStorage implements Storage {
+    private data;
+    constructor();
+    /**
+     * Returns the number of key/value pairs.
+     * @returns The number of key/value pairs.
+     */
+    get length(): number;
+    /**
+     * Removes all key/value pairs, if there are any.
+     */
+    clear(): void;
+    /**
+     * Returns the current value associated with the given key, or null if the given key does not exist.
+     * @param key The specified storage key.
+     * @returns The current value associated with the given key, or null if the given key does not exist.
+     */
+    getItem(key: string): string | null;
+    /**
+     * Sets the value of the pair identified by key to value, creating a new key/value pair if none existed for key previously.
+     * @param key The storage key.
+     * @param value The new value.
+     */
+    setItem(key: string, value: string | null): void;
+    /**
+     * Removes the key/value pair with the given key, if a key/value pair with the given key exists.
+     * @param key The storage key.
+     */
+    removeItem(key: string): void;
+    /**
+     * Returns the name of the nth key, or null if n is greater than or equal to the number of key/value pairs.
+     * @param index The numeric index.
+     * @returns The nth key.
+     */
+    key(index: number): string | null;
+}
+
+export declare interface NewPatientRequest {
+    readonly login: string;
+    readonly projectId: string;
+}
+
+export declare interface NewProjectRequest {
+    readonly login: string;
+    readonly projectName: string;
+}
+
+export declare interface NewUserRequest {
+    readonly firstName: string;
+    readonly lastName: string;
+    readonly email: string;
+    readonly password: string;
+    readonly recaptchaToken: string;
+    readonly recaptchaSiteKey?: string;
+    readonly remember?: boolean;
+    readonly projectId?: string;
+    readonly clientId?: string;
+}
+
+/**
+ * Normalizes an error object into a displayable error string.
+ * @param error The error value which could be a string, Error, OperationOutcome, or other unknown type.
+ * @returns A display string for the error.
+ */
+export declare function normalizeErrorString(error: unknown): string;
+
+/**
+ * Normalizes an error object into an OperationOutcome.
+ * @param error The error value which could be a string, Error, OperationOutcome, or other unknown type.
+ * @returns The normalized OperationOutcome.
+ */
+export declare function normalizeOperationOutcome(error: unknown): OperationOutcome;
+
+export declare const notFound: OperationOutcome;
+
+export declare const notModified: OperationOutcome;
+
+/**
+ * OAuth 2.0 Client Authentication Methods
+ * See: https://datatracker.ietf.org/doc/html/rfc7523#section-2.2
+ */
+export declare enum OAuthClientAssertionType {
+    /** Using JWTs for Client Authentication */
+    JwtBearer = "urn:ietf:params:oauth:client-assertion-type:jwt-bearer"
+}
+
+/**
+ * OAuth 2.0 Grant Type Identifiers
+ * Standard identifiers: https://datatracker.ietf.org/doc/html/draft-ietf-oauth-v2-1-07#name-grant-types
+ * JWT bearer extension: https://datatracker.ietf.org/doc/html/rfc7523
+ * Token exchange extension: https://datatracker.ietf.org/doc/html/rfc8693
+ */
+export declare enum OAuthGrantType {
+    ClientCredentials = "client_credentials",
+    AuthorizationCode = "authorization_code",
+    RefreshToken = "refresh_token",
+    JwtBearer = "urn:ietf:params:oauth:grant-type:jwt-bearer",
+    TokenExchange = "urn:ietf:params:oauth:grant-type:token-exchange"
+}
+
+/**
+ * OAuth 2.0 Token Type Identifiers
+ * See: https://datatracker.ietf.org/doc/html/rfc8693#name-token-type-identifiers
+ */
+export declare enum OAuthTokenType {
+    /** Indicates that the token is an OAuth 2.0 access token issued by the given authorization server. */
+    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. */
+    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]. */
+    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. */
+    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. */
+    Saml2Token = "urn:ietf:params:oauth:token-type:saml2"
+}
+
+export declare class OperationOutcomeError extends Error {
+    readonly outcome: OperationOutcome;
+    constructor(outcome: OperationOutcome, cause?: unknown);
+}
+
+/**
+ * Returns a string represenation of the operation outcome issue.
+ * @param issue The operation outcome issue.
+ * @returns The string representation of the operation outcome issue.
+ */
+export declare function operationOutcomeIssueToString(issue: OperationOutcomeIssue): string;
+
+/**
+ * Returns a string represenation of the operation outcome.
+ * @param outcome The operation outcome.
+ * @returns The string representation of the operation outcome.
+ */
+export declare function operationOutcomeToString(outcome: OperationOutcome): string;
+
+/**
+ * Search operators.
+ * These operators represent "modifiers" and "prefixes" in FHIR search.
+ * See: https://www.hl7.org/fhir/search.html
+ */
+export declare enum Operator {
+    EQUALS = "eq",
+    NOT_EQUALS = "ne",
+    GREATER_THAN = "gt",
+    LESS_THAN = "lt",
+    GREATER_THAN_OR_EQUALS = "ge",
+    LESS_THAN_OR_EQUALS = "le",
+    STARTS_AFTER = "sa",
+    ENDS_BEFORE = "eb",
+    APPROXIMATELY = "ap",
+    CONTAINS = "contains",
+    EXACT = "exact",
+    TEXT = "text",
+    NOT = "not",
+    ABOVE = "above",
+    BELOW = "below",
+    IN = "in",
+    NOT_IN = "not-in",
+    OF_TYPE = "of-type",
+    MISSING = "missing",
+    IDENTIFIER = "identifier",
+    ITERATE = "iterate"
+}
+
+/**
+ * Operator precedence
+ * See: https://hl7.org/fhirpath/#operator-precedence
+ */
+export declare const OperatorPrecedence: {
+    FunctionCall: number;
+    Dot: number;
+    Indexer: number;
+    UnaryAdd: number;
+    UnarySubtract: number;
+    Multiply: number;
+    Divide: number;
+    IntegerDivide: number;
+    Modulo: number;
+    Add: number;
+    Subtract: number;
+    Ampersand: number;
+    Is: number;
+    As: number;
+    Union: number;
+    GreaterThan: number;
+    GreaterThanOrEquals: number;
+    LessThan: number;
+    LessThanOrEquals: number;
+    Equals: number;
+    Equivalent: number;
+    NotEquals: number;
+    NotEquivalent: number;
+    In: number;
+    Contains: number;
+    And: number;
+    Xor: number;
+    Or: number;
+    Implies: number;
+    Arrow: number;
+    Semicolon: number;
+};
+
+/**
+ * Parses a FHIR criteria string into a SearchRequest.
+ * FHIR criteria strings are found on resources such as Subscription.
+ * @param criteria The FHIR criteria string.
+ * @returns Parsed search definition.
+ */
+export declare function parseCriteriaAsSearchRequest(criteria: string): SearchRequest;
+
+/**
+ * Parses a FHIRPath expression into an AST.
+ * The result can be used to evaluate the expression against a resource or other object.
+ * This method is useful if you know that you will evaluate the same expression many times
+ * against different resources.
+ * @param input The FHIRPath expression to parse.
+ * @returns The AST representing the expression.
+ */
+export declare function parseFhirPath(input: string): FhirPathAtom;
+
+/**
+ * Parses a FHIR _filter parameter expression into an AST.
+ * @param input The FHIR _filter parameter expression.
+ * @returns The AST representing the filters.
+ */
+export declare function parseFilterParameter(input: string): FhirFilterExpression;
+
+/**
+ * Returns a formatted string representing the date in ISO-8601 format.
+ *
+ * HL7-Definition V2
+ * Specifies a point in time using a 24-hour clock notation.
+ *
+ * Format: YYYY[MM[DD[HH[MM[SS[. S[S[S[S]]]]]]]]][+/-ZZZZ].
+ *
+ * @param hl7DateTime Date/time string.
+ * @param options Optional parsing options.
+ * @returns The date in ISO-8601 format.
+ */
+export declare function parseHl7DateTime(hl7DateTime: string | undefined, options?: Hl7DateParseOptions): string | undefined;
+
+/**
+ * Parses the JWT payload.
+ * @param token JWT token.
+ * @returns Collection of key value claims in the JWT payload.
+ */
+export declare function parseJWTPayload(token: string): Record<string, number | string>;
+
+/**
+ * Parses a FHIR Mapping Language document into an AST.
+ * @param input The FHIR Mapping Language document to parse.
+ * @returns The AST representing the document.
+ */
+export declare function parseMappingLanguage(input: string): StructureMap;
+
+export declare class Parser {
+    private tokens;
+    private prefixParselets;
+    private infixParselets;
+    constructor(tokens: Token[], prefixParselets: Record<string, PrefixParselet>, infixParselets: Record<string, InfixParselet>);
+    hasMore(): boolean;
+    match(expected: string): boolean;
+    consumeAndParse(precedence?: number): Atom;
+    getPrecedence(): number;
+    consume(expectedId?: string, expectedValue?: string): Token;
+    peek(): Token | undefined;
+    removeComments(): void;
+    getInfixParselet(token: Token): InfixParselet | undefined;
+}
+
+export declare class ParserBuilder {
+    private readonly prefixParselets;
+    private readonly infixParselets;
+    registerInfix(tokenType: string, parselet: InfixParselet): this;
+    registerPrefix(tokenType: string, parselet: PrefixParselet): this;
+    prefix(tokenType: string, precedence: number, builder: (token: Token, right: Atom) => Atom): this;
+    infixLeft(tokenType: string, precedence: number, builder: (left: Atom, token: Token, right: Atom) => Atom): this;
+    construct(input: Token[]): Parser;
+}
+
+/**
+ * Parses a reference and returns a tuple of [ResourceType, ID].
+ * @param reference A reference to a FHIR resource.
+ * @returns A tuple containing the `ResourceType` and the ID of the resource or `undefined` when `undefined` or an invalid reference is passed.
+ */
+export declare function parseReference(reference: Reference): [ResourceType, string] | undefined;
+
+export declare function parseReference(reference: undefined): undefined;
+
+/**
+ * Parses a URL string into a SearchRequest.
+ * @param url The URL to parse.
+ * @returns Parsed search definition.
+ */
+export declare function parseSearchDefinition<T extends Resource = Resource>(url: string): SearchRequest<T>;
+
+/**
+ * Parses a search URL into a search request.
+ * @param resourceType The FHIR resource type.
+ * @param query The collection of query string parameters.
+ * @returns A parsed SearchRequest.
+ */
+export declare function parseSearchRequest<T extends Resource = Resource>(resourceType: T['resourceType'], query: Record<string, string[] | string | undefined>): SearchRequest<T>;
+
+/**
+ * Parses a search URL into a search request.
+ * @param url The search URL.
+ * @returns A parsed SearchRequest.
+ */
+export declare function parseSearchUrl<T extends Resource = Resource>(url: URL): SearchRequest<T>;
+
+/**
+ * Parses a StructureDefinition resource into an internal schema better suited for
+ * programmatic validation and usage in internal systems
+ * @param sd The StructureDefinition resource to parse
+ * @returns The parsed schema for the given resource type
+ * @experimental
+ */
+export declare function parseStructureDefinition(sd: StructureDefinition): InternalTypeSchema;
+
+/**
+ * Parses an extended FHIR search criteria string (i.e. application/x-fhir-query), evaluating
+ * any embedded FHIRPath subexpressions (e.g. `{{ %patient.id }}`) with the provided variables.
+ *
+ * @see https://hl7.org/fhir/fhir-xquery.html
+ * @param query The X-Fhir-Query string to parse
+ * @param variables Values to pass into embedded FHIRPath expressions
+ * @returns The parsed search request
+ */
+export declare function parseXFhirQuery(query: string, variables: Record<string, TypedValue>): SearchRequest;
+
+/**
+ * JSONPatch patch operation.
+ * Compatible with fast-json-patch and rfc6902 Operation.
+ */
+export declare interface PatchOperation {
+    readonly op: 'add' | 'remove' | 'replace' | 'copy' | 'move' | 'test';
+    readonly path: string;
+    readonly value?: any;
+}
+
+export declare type PendingSubscriptionRequest = Omit<SubscriptionRequest, 'endpoint'>;
+
+/**
+ * Returns true if the two numbers are equal to the given precision.
+ * @param a The first number.
+ * @param b The second number.
+ * @param precision Optional precision in number of digits.
+ * @returns True if the two numbers are equal to the given precision.
+ */
+export declare function preciseEquals(a: number, b: number, precision?: number): boolean;
+
+/**
+ * Returns true if the first number is greater than the second number to the given precision.
+ * @param a The first number.
+ * @param b The second number.
+ * @param precision Optional precision in number of digits.
+ * @returns True if the first number is greater than the second number to the given precision.
+ */
+export declare function preciseGreaterThan(a: number, b: number, precision?: number): boolean;
+
+/**
+ * Returns true if the first number is greater than or equal to the second number to the given precision.
+ * @param a The first number.
+ * @param b The second number.
+ * @param precision Optional precision in number of digits.
+ * @returns True if the first number is greater than or equal to the second number to the given precision.
+ */
+export declare function preciseGreaterThanOrEquals(a: number, b: number, precision?: number): boolean;
+
+/**
+ * Returns true if the first number is less than the second number to the given precision.
+ * @param a The first number.
+ * @param b The second number.
+ * @param precision Optional precision in number of digits.
+ * @returns True if the first number is less than the second number to the given precision.
+ */
+export declare function preciseLessThan(a: number, b: number, precision?: number): boolean;
+
+/**
+ * Returns true if the first number is less than or equal to the second number to the given precision.
+ * @param a The first number.
+ * @param b The second number.
+ * @param precision Optional precision in number of digits.
+ * @returns True if the first number is less than or equal to the second number to the given precision.
+ */
+export declare function preciseLessThanOrEquals(a: number, b: number, precision?: number): boolean;
+
+/**
+ * Returns the input number rounded to the specified number of digits.
+ * @param a The input number.
+ * @param precision The precision in number of digits.
+ * @returns The number rounded to the specified number of digits.
+ */
+export declare function preciseRound(a: number, precision: number): number;
+
+export declare abstract class PrefixOperatorAtom implements Atom {
+    readonly operator: string;
+    readonly child: Atom;
+    constructor(operator: string, child: Atom);
+    abstract eval(context: AtomContext, input: TypedValue[]): TypedValue[];
+    toString(): string;
+}
+
+export declare interface PrefixParselet {
+    parse(parser: Parser, token: Token): Atom;
+}
+
+/**
+ * @internal
+ */
+export declare type ProfileResource = Patient | Practitioner | RelatedPerson;
+
+/**
+ * Project admin resource types are special resources that are only
+ * accessible to project administrators.
+ */
+export declare const projectAdminResourceTypes: string[];
+
+/**
+ * List of property types.
+ * http://www.hl7.org/fhir/valueset-defined-types.html
+ * The list here includes additions found from StructureDefinition resources.
+ */
+export declare const PropertyType: {
+    Address: string;
+    Age: string;
+    Annotation: string;
+    Attachment: string;
+    BackboneElement: string;
+    CodeableConcept: string;
+    Coding: string;
+    ContactDetail: string;
+    ContactPoint: string;
+    Contributor: string;
+    Count: string;
+    DataRequirement: string;
+    Distance: string;
+    Dosage: string;
+    Duration: string;
+    Expression: string;
+    Extension: string;
+    HumanName: string;
+    Identifier: string;
+    MarketingStatus: string;
+    Meta: string;
+    Money: string;
+    Narrative: string;
+    ParameterDefinition: string;
+    Period: string;
+    Population: string;
+    ProdCharacteristic: string;
+    ProductShelfLife: string;
+    Quantity: string;
+    Range: string;
+    Ratio: string;
+    Reference: string;
+    RelatedArtifact: string;
+    SampledData: string;
+    Signature: string;
+    SubstanceAmount: string;
+    SystemString: string;
+    Timing: string;
+    TriggerDefinition: string;
+    UsageContext: string;
+    base64Binary: string;
+    boolean: string;
+    canonical: string;
+    code: string;
+    date: string;
+    dateTime: string;
+    decimal: string;
+    id: string;
+    instant: string;
+    integer: string;
+    markdown: string;
+    oid: string;
+    positiveInt: string;
+    string: string;
+    time: string;
+    unsignedInt: string;
+    uri: string;
+    url: string;
+    uuid: string;
+};
+
+/**
+ * Protected resource types are in the "medplum" project.
+ * Reading and writing is limited to the system account.
+ */
+export declare const protectedResourceTypes: string[];
+
+/**
+ * QueryTypes defines the different ways to specify FHIR search parameters.
+ *
+ * Can be any valid input to the URLSearchParams() constructor.
+ *
+ * TypeScript definitions for URLSearchParams do not match runtime behavior.
+ * The official spec only accepts string values.
+ * Web browsers and Node.js automatically coerce values to strings.
+ * See: https://github.com/microsoft/TypeScript/issues/32951
+ */
+export declare type QueryTypes = URLSearchParams | string[][] | Record<string, any> | string | undefined;
+
+/**
+ * The ReadablePromise class wraps a request promise suitable for React Suspense.
+ * See: https://blog.logrocket.com/react-suspense-data-fetching/#wrappromise-js
+ * See: https://github.com/ovieokeh/suspense-data-fetching/blob/master/lib/api/wrapPromise.js
+ */
+export declare class ReadablePromise<T> implements Promise<T> {
+    readonly [Symbol.toStringTag]: string;
+    private suspender;
+    private status;
+    private response;
+    private error;
+    constructor(requestPromise: Promise<T>);
+    /**
+     * Returns true if the promise is pending.
+     * @returns True if the Promise is pending.
+     */
+    isPending(): boolean;
+    /**
+     * Returns true if the promise resolved successfully.
+     * @returns True if the Promise resolved successfully.
+     */
+    isOk(): boolean;
+    /**
+     * Attempts to read the value of the promise.
+     * If the promise is pending, this method will throw a promise.
+     * If the promise rejected, this method will throw the rejection reason.
+     * If the promise resolved, this method will return the resolved value.
+     * @returns The resolved value of the Promise.
+     */
+    read(): T;
+    /**
+     * Attaches callbacks for the resolution and/or rejection of the Promise.
+     * @param onfulfilled The callback to execute when the Promise is resolved.
+     * @param onrejected The callback to execute when the Promise is rejected.
+     * @returns A Promise for the completion of which ever callback is executed.
+     */
+    then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): Promise<TResult1 | TResult2>;
+    /**
+     * Attaches a callback for only the rejection of the Promise.
+     * @param onrejected The callback to execute when the Promise is rejected.
+     * @returns A Promise for the completion of the callback.
+     */
+    catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | undefined | null): Promise<T | TResult>;
+    /**
+     * Attaches a callback that is invoked when the Promise is settled (fulfilled or rejected). The
+     * resolved value cannot be modified from the callback.
+     * @param onfinally The callback to execute when the Promise is settled (fulfilled or rejected).
+     * @returns A Promise for the completion of the callback.
+     */
+    finally(onfinally?: (() => void) | undefined | null): Promise<T>;
+}
+
+/**
+ * Removes duplicates in array using FHIRPath equality rules.
+ * @param arr The input array.
+ * @returns The result array with duplicates removed.
+ */
+export declare function removeDuplicates(arr: TypedValue[]): TypedValue[];
+
+/**
+ * Topologically sorts a `batch` or `transaction` bundle to improve reference resolution.
+ * The bundle is sorted such that a resource is created _before_ references to that resource appear in the bundle.
+ *
+ * In the event of cycles, this function will first create a POST request for each resource in the cycle, and then will
+ * append a PUT request to the bundle. This ensures that each resources in the cycle is visited twice, and all
+ * references can be resolved
+ * @param bundle Input bundle with type `batch` or `transaction`
+ * @returns Bundle of the same type, with Bundle.entry reordered
+ */
+export declare function reorderBundle(bundle: Bundle): Bundle;
+
+/**
+ * Returns the ID portion of a reference.
+ * @param input A FHIR reference or resource.
+ * @returns The ID portion of a reference.
+ */
+export declare function resolveId(input: Reference | Resource | undefined): string | undefined;
+
+/**
+ * ResourceArray is an array of resources with a bundle property.
+ * The bundle property is a FHIR Bundle containing the search results.
+ * This is useful for retrieving bundle metadata such as total, offset, and next link.
+ */
+export declare type ResourceArray<T extends Resource = Resource> = T[] & {
+    bundle: Bundle<T>;
+};
+
+export declare interface ResourceVisitor {
+    onEnterObject?: (path: string, value: TypedValue, schema: InternalTypeSchema) => void;
+    onExitObject?: (path: string, value: TypedValue, schema: InternalTypeSchema) => void;
+    onEnterResource?: (path: string, value: TypedValue, schema: InternalTypeSchema) => void;
+    onExitResource?: (path: string, value: TypedValue, schema: InternalTypeSchema) => void;
+    visitProperty?: (parent: TypedValue, key: string, path: string, propertyValues: (TypedValue | TypedValue[] | undefined)[], schema: InternalTypeSchema) => void;
+}
+
+/**
+ * @internal
+ */
+export declare type ResourceWithCode = Resource & Code;
+
+export declare const RXNORM = "http://www.nlm.nih.gov/research/umls/rxnorm";
+
+/**
+ * Checks that there is an access policy permitting the given resource interaction, returning the matching policy object.
+ * @param resource The resource being acted upon.
+ * @param interaction The interaction being performed on the resource.
+ * @param accessPolicy The relevant access policy for the current user.
+ * @returns The satisfied access policy, or undefined if the access policy does not permit the given interaction.
+ */
+export declare function satisfiedAccessPolicy(resource: Resource, interaction: AccessPolicyInteraction, accessPolicy: AccessPolicy | undefined): AccessPolicyResource | undefined;
+
+export declare interface SearchParameterDetails {
+    readonly columnName: string;
+    readonly type: SearchParameterType;
+    readonly elementDefinitions?: InternalSchemaElement[];
+    readonly array?: boolean;
+}
+
+export declare enum SearchParameterType {
+    BOOLEAN = "BOOLEAN",
+    NUMBER = "NUMBER",
+    QUANTITY = "QUANTITY",
+    TEXT = "TEXT",
+    REFERENCE = "REFERENCE",
+    CANONICAL = "CANONICAL",
+    DATE = "DATE",
+    DATETIME = "DATETIME",
+    PERIOD = "PERIOD",
+    UUID = "UUID"
+}
+
+export declare interface SearchRequest<T extends Resource = Resource> {
+    readonly resourceType: T['resourceType'];
+    filters?: Filter[];
+    sortRules?: SortRule[];
+    offset?: number;
+    count?: number;
+    fields?: string[];
+    name?: string;
+    total?: 'none' | 'estimate' | 'accurate';
+    include?: IncludeTarget[];
+    revInclude?: IncludeTarget[];
+    summary?: 'true' | 'text' | 'data';
+}
+
+/**
+ * Creates a serialized url-encoded payload for a `FHIRcast` subscription from a `SubscriptionRequest` object that can be directly used in an HTTP request to the Hub.
+ *
+ * @param subscriptionRequest An object representing a subscription request.
+ * @returns A serialized subscription in url-encoded form.
+ */
+export declare function serializeFhircastSubscriptionRequest(subscriptionRequest: SubscriptionRequest | PendingSubscriptionRequest): string;
+
+export declare function serverError(err: Error): OperationOutcome;
+
+/**
+ * Sets a code for a given system within a given codeable concept.
+ * @param concept The codeable concept.
+ * @param system The system string.
+ * @param code The code value.
+ */
+export declare function setCodeBySystem(concept: CodeableConcept, system: string, code: string): void;
+
+/**
+ * Sets a resource identifier for the given system.
+ *
+ * Note that this method is only available on resources that have an "identifier" property,
+ * and that property must be an array of Identifier objects,
+ * which is not true for all FHIR resources.
+ *
+ * If the identifier already exists, then the value is updated.
+ *
+ * Otherwise a new identifier is added.
+ *
+ * @param resource The resource to add the identifier to.
+ * @param system The identifier system.
+ * @param value The identifier value.
+ */
+export declare function setIdentifier(resource: Resource & {
+    identifier?: Identifier[];
+}, system: string, value: string): void;
+
+export declare function singleton(collection: TypedValue[], type?: string): TypedValue | undefined;
+
+/**
+ * Sleeps for the specified number of milliseconds.
+ * @param ms Time delay in milliseconds
+ * @returns A promise that resolves after the specified number of milliseconds.
+ */
+export declare const sleep: (ms: number) => Promise<void>;
+
+export declare interface SliceDefinition {
+    name: string;
+    type?: ElementType[];
+    elements: Record<string, InternalSchemaElement>;
+    min: number;
+    max: number;
+}
+
+export declare interface SliceDiscriminator {
+    path: string;
+    type: string;
+}
+
+export declare interface SlicingRules {
+    discriminator: SliceDiscriminator[];
+    ordered: boolean;
+    rule?: 'open' | 'closed' | 'openAtEnd';
+    slices: SliceDefinition[];
+}
+
+export declare const SNOMED = "http://snomed.info/sct";
+
+export declare interface SortRule {
+    code: string;
+    descending?: boolean;
+}
+
+/**
+ * Reads data from a Readable stream and returns a Promise that resolves with a Buffer containing all the data.
+ * @param stream - The Readable stream to read from.
+ * @returns A Promise that resolves with a Buffer containing all the data from the Readable stream.
+ */
+export declare function streamToBuffer(stream: Readable): Promise<Buffer>;
+
+/**
+ * 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.
+ */
+export declare function stringify(value: any, pretty?: boolean): string;
+
+/**
+ * Output the string representation of a value, suitable for use as part of a search query.
+ * @param v The value to format as a string
+ * @returns The stringified value
+ */
+export declare function stringifyTypedValue(v: TypedValue): string;
+
+/**
+ * A `FHIRcast` subscription request.
+ *
+ * Can be passed to `MedplumClient.fhircastConnect` or `MedplumClient.fhircastUnsubscribe` to either open a `FHIRcast` connection, or unsubscribe from the subscription.
+ */
+export declare type SubscriptionRequest = {
+    channelType: 'websocket';
+    mode: 'subscribe' | 'unsubscribe';
+    events: FhircastEventName[];
+    topic: string;
+    endpoint: string;
+};
+
+/**
+ * Construct the subset of a resource containing a minimum set of fields.  The returned resource is not guaranteed
+ * to contain only the provided properties, and may contain others (e.g. `resourceType` and `id`)
+ *
+ * @param resource The resource to subset
+ * @param properties The minimum properties to include in the subset
+ * @returns The modified resource, containing the listed properties and possibly other mandatory ones
+ */
+export declare function subsetResource<T extends Resource>(resource: T | undefined, properties: string[]): T | undefined;
+
+/**
+ * Converts unknown object into a JavaScript boolean.
+ * Note that this is different than the FHIRPath "toBoolean",
+ * which has particular semantics around arrays, empty arrays, and type conversions.
+ * @param obj Any value or array of values.
+ * @returns The converted boolean value according to FHIRPath rules.
+ */
+export declare function toJsBoolean(obj: TypedValue[]): boolean;
+
+declare interface Token extends Marker {
+    id: string;
+    value: string;
+}
+
+export declare interface TokenResponse {
+    readonly token_type: string;
+    readonly id_token: string;
+    readonly access_token: string;
+    readonly refresh_token: string;
+    readonly expires_in: number;
+    readonly project: Reference<Project>;
+    readonly profile: Reference<ProfileResource>;
+}
+
+export declare const tooManyRequests: OperationOutcome;
+
+/**
+ * Returns a "best guess" TypedValue for a given value.
+ * @param value The unknown value to check.
+ * @returns A "best guess" TypedValue for the given value.
+ */
+export declare function toTypedValue(value: unknown): TypedValue;
+
+export declare function tryGetDataType(type: string): InternalTypeSchema | undefined;
+
+export declare class TypedEventTarget<TEvents extends Record<string, Event_2>> {
+    private emitter;
+    dispatchEvent<TEventType extends keyof TEvents & string>(event: TEvents[TEventType]): void;
+    addEventListener<TEventType extends keyof TEvents & string>(type: TEventType, handler: (event: TEvents[TEventType]) => void): void;
+    removeEventListener<TEventType extends keyof TEvents & string>(type: TEventType, handler: (event: TEvents[TEventType]) => void): void;
+}
+
+export declare interface TypedValue {
+    readonly type: string;
+    readonly value: any;
+}
+
+/**
+ * An indexed TypeSchema.
+ *
+ * Example:  The IndexedStructureDefinition for "Patient" would include the following TypeSchemas:
+ *   1) Patient
+ *   2) Patient_Contact
+ *   3) Patient_Communication
+ *   4) Patient_Link
+ */
+export declare interface TypeInfo {
+    searchParams?: {
+        [code: string]: SearchParameter;
+    };
+    searchParamsDetails?: {
+        [code: string]: SearchParameterDetails;
+    };
+}
+
+export declare type TypeName<T> = T extends string ? 'string' : T extends number ? 'number' : T extends boolean ? 'boolean' : T extends undefined ? 'undefined' : 'object';
+
+export declare const UCUM = "http://unitsofmeasure.org";
+
+export declare const unauthorized: OperationOutcome;
+
+/**
+ * Validates that a `SubscriptionRequest`.
+ *
+ * @param subscriptionRequest The `SubscriptionRequest` to validate.
+ * @returns A `boolean` indicating whether or not the `SubscriptionRequest` is valid.
+ */
+export declare function validateFhircastSubscriptionRequest(subscriptionRequest: SubscriptionRequest | PendingSubscriptionRequest): boolean;
+
+export declare function validateResource(resource: Resource, profile?: StructureDefinition): void;
+
+/**
+ * Validates that the given string is a valid FHIR resource type.
+ * On success, silently returns void.
+ * On failure, throws an OperationOutcomeError.
+ *
+ * ```ts
+ * validateResourceType('Patient'); // nothing
+ * validateResourceType('XYZ'); // throws OperationOutcomeError
+ * ```
+ *
+ * Note that this depends on globalSchema, which is populated by the StructureDefinition loader.
+ *
+ * In a server context, you can load all schema definitions:
+ *
+ * ```ts
+ * import { indexStructureDefinitionBundle } from '@medplum/core';
+ * import { readJson } from '@medplum/definitions';
+ * import { Bundle } from '@medplum/fhirtypes';
+ *
+ * indexStructureDefinitionBundle(readJson('fhir/r4/profiles-resources.json') as Bundle);
+ * ```
+ *
+ * In a client context, you can load the schema definitions using MedplumClient:
+ *
+ * ```ts
+ * import { MedplumClient } from '@medplum/core';
+ *
+ * const medplum = new MedplumClient();
+ * await medplum.requestSchema('Patient');
+ * ```
+ * @param resourceType The candidate resource type string.
+ */
+export declare function validateResourceType(resourceType: string): void;
+
+export declare function validationError(details: string): OperationOutcome;
+
+export declare type ValueOrExternalSecret<T extends ExternalSecretPrimitive> = T | ExternalSecret<T>;
+
+export { }