@medplum/core 5.1.22 → 5.1.23

package/dist/cjs/index.d.ts

@@ -115,6 +115,21 @@ export declare const AckCode: {
 
 export declare type AckCode = keyof typeof AckCode;
 
+/**
+ *  o  If the target location specifies an array index, a new value is
+ *     inserted into the array at the specified index.
+ *  o  If the target location specifies an object member that does not
+ *     already exist, a new member is added to the object.
+ *  o  If the target location specifies an object member that does exist,
+ *     that member's value is replaced.
+ *
+ * @param object - The object being patched.
+ * @param operation - The operation to perform on the object.
+ * @param options - Optional params.
+ * @returns null on success, or error if one occurred.
+ */
+export declare function add(object: any, operation: AddOperation, options?: PatchOptions): MissingError | null;
+
 /**
  * Parameters for adding a pharmacy to a patient's favorites.
  */
@@ -124,6 +139,12 @@ export declare interface AddFavoriteParams {
     setAsPrimary: boolean;
 }
 
+export declare interface AddOperation {
+    op: 'add';
+    path: string;
+    value: any;
+}
+
 /**
  * Response from adding a pharmacy to a patient's favorites.
  */
@@ -303,6 +324,17 @@ export declare class AndAtom extends InfixOperatorAtom {
 
 export declare function append<T>(array: T[] | undefined, value: T): T[];
 
+/**
+ * Switch on `operation.op`, applying the corresponding patch function for each
+ * case to `object`.
+ *
+ * @param object - The object being patched.
+ * @param operation - The operation to perform on the object.
+ * @param options - Optional params.
+ * @returns null on success, or error if one occurred.
+ */
+export declare function apply(object: any, operation: Operation, options?: PatchOptions): MissingError | InvalidOperationError | TestError | null;
+
 /**
  * Adds default values to `existingValue` for the given `key` and its children. If `key` is undefined,
  * default values are added to all elements in `elements`. Default values consist of all fixed and pattern
@@ -328,6 +360,26 @@ export declare function applyDefaultValuesToResource(resource: Resource, schema:
 
 export declare function applyFixedOrPatternValue(inputValue: any, key: string, element: InternalSchemaElement, elements: Record<string, InternalSchemaElement>): any;
 
+/**
+ * Apply a 'application/json-patch+json'-type patch to an object.
+ *
+ * `patch` *must* be an array of operations.
+ *
+ *   Operation objects MUST have exactly one "op" member, whose value
+ *   indicates the operation to perform.  Its value MUST be one of "add",
+ *   "remove", "replace", "move", "copy", or "test"; other values are
+ *   errors.
+ *
+ * This method mutates the target object in-place.
+ *
+ * @param object - The object to apply the patch to
+ * @param patch - Array of operations to apply
+ * @param options - Optional customization of patch application behavior
+ * @returns list of results, one for each operation: `null` indicated success,
+ *     otherwise, the result will be an instance of one of the Error classes.
+ */
+export declare function applyPatch(object: any, patch: Operation[], options?: PatchOptions): (null | MissingError | InvalidOperationError | TestError)[];
+
 export declare class ArithmeticOperatorAtom extends InfixOperatorAtom {
     readonly impl: (x: number, y: number) => number | boolean;
     constructor(operator: string, left: Atom, right: Atom, impl: (x: number, y: number) => number | boolean);
@@ -882,6 +934,7 @@ export declare const ContentType: {
     readonly HL7_V2: "x-application/hl7-v2+er7";
     readonly HTML: "text/html";
     readonly JAVASCRIPT: "text/javascript";
+    readonly JOSE: "application/jose";
     readonly JSON: "application/json";
     readonly JSON_PATCH: "application/json-patch+json";
     readonly JWT: "application/jwt";
@@ -933,6 +986,32 @@ export declare function convertToSearchableUris(typedValues: TypedValue[]): stri
  */
 export declare function convertToTransactionBundle(bundle: Bundle): Bundle;
 
+/**
+ * The "copy" operation copies the value at a specified location to the
+ * target location.
+ * The operation object MUST contain a "from" member, which is a string
+ * containing a JSON Pointer value that references the location in the
+ * target document to copy the value from.
+ * The "from" location MUST exist for the operation to be successful.
+ *
+ * This operation is functionally identical to an "add" operation at the
+ * target location using the value specified in the "from" member.
+ *
+ * Alternatively, it's like 'move' without the 'remove'.
+ *
+ * @param object - The object being patched.
+ * @param operation - The operation to perform on the object.
+ * @param _options - Optional params.
+ * @returns null on success, or error if one occurred.
+ */
+export declare function copy(object: any, operation: CopyOperation, _options?: PatchOptions): MissingError | null;
+
+export declare interface CopyOperation {
+    op: 'copy';
+    from: string;
+    path: string;
+}
+
 export declare const CPT = "http://www.ama-assn.org/go/cpt";
 
 export declare interface CrawlerOptions {
@@ -1023,6 +1102,26 @@ export declare interface CreateMediaOptions extends CreateBinaryOptions {
 
 export declare function createOperationOutcomeIssue(severity: IssueSeverity, code: IssueType, message: string, path: string, data?: Record<string, any>): OperationOutcomeIssue;
 
+/**
+ * Produce a 'application/json-patch+json'-type patch to get from one object to
+ * another.
+ *
+ * This does not alter `input` or `output` unless they have a property getter with
+ * side-effects (which is not a good idea anyway).
+ *
+ * `diff` is called on each pair of comparable non-primitive nodes in the
+ * `input`/`output` object trees, producing nested patches. Return `undefined`
+ * to fall back to default behaviour.
+ *
+ * Returns list of operations to perform on `input` to produce `output`.
+ *
+ * @param input - The input value.
+ * @param output - The target value.
+ * @param diff - Optional diff function.
+ * @returns The list of patch operations.
+ */
+export declare function createPatch(input: any, output: any, diff?: VoidableDiff): Operation[];
+
 export declare interface CreatePdfFunction {
     (docDefinition: TDocumentDefinitions, tableLayouts?: Record<string, CustomTableLayout>, fonts?: TFontDictionary): Promise<any>;
 }
@@ -1069,6 +1168,22 @@ export declare function createReference<T extends Resource>(resource: T): Refere
 
 export declare function createStructureIssue(expression: string, details: string): OperationOutcomeIssue;
 
+/**
+ * Produce an 'application/json-patch+json'-type list of tests, to verify that
+ * existing values in an object are identical to the those captured at some
+ * checkpoint (whenever this function is called).
+ *
+ * This does not alter `input` or `output` unless they have a property getter with
+ * side-effects (which is not a good idea anyway).
+ *
+ * Returns list of test operations.
+ *
+ * @param input - The input value.
+ * @param patch - The list of patch operations.
+ * @returns A list of test operations corresponding to the current values.
+ */
+export declare function createTests(input: any, patch: Operation[]): TestOperation[];
+
 export declare type CriteriaState = 'idle' | 'connecting' | 'active' | 'refreshing' | 'removed';
 
 export declare type CurrentContext<T extends FhircastAnchorResourceType | '' = FhircastAnchorResourceType | ''> = T extends '' ? {
@@ -1183,6 +1298,75 @@ export declare const DEFAULT_SEARCH_COUNT = 20;
  */
 export declare function deriveIdentifierSearchParameter(inputParam: SearchParameter): SearchParameter;
 
+export declare type Diff = (input: any, output: any, ptr: Pointer) => Operation[];
+
+/**
+ * `diffAny()` returns an empty array if `input` and `output` are materially equal
+ * (i.e., would produce equivalent JSON); otherwise it produces an array of patches
+ * that would transform `input` into `output`.
+ *
+ *   Here, "equal" means that the value at the target location and the
+ *   value conveyed by "value" are of the same JSON type, and that they
+ *   are considered equal by the following rules for that type:
+ *   o  strings: are considered equal if they contain the same number of
+ *      Unicode characters and their code points are byte-by-byte equal.
+ *   o  numbers: are considered equal if their values are numerically
+ *      equal.
+ *   o  arrays: are considered equal if they contain the same number of
+ *      values, and if each value can be considered equal to the value at
+ *      the corresponding position in the other array, using this list of
+ *      type-specific rules.
+ *   o  objects: are considered equal if they contain the same number of
+ *      members, and if each member can be considered equal to a member in
+ *      the other object, by comparing their keys (as strings) and their
+ *      values (using this list of type-specific rules).
+ *   o  literals (false, true, and null): are considered equal if they are
+ *      the same.
+ *
+ * @param input - The original value.
+ * @param output - The target value.
+ * @param ptr - JSON Pointer.
+ * @param diff - Diff function.
+ * @returns The list of operations to get form the original to target value.
+ */
+export declare function diffAny(input: any, output: any, ptr: Pointer, diff?: Diff): Operation[];
+
+/**
+ * Calculate the shortest sequence of operations to get from `input` to `output`,
+ * using a dynamic programming implementation of the Levenshtein distance algorithm.
+ *
+ * To get from the input ABC to the output AZ we could just delete all the input
+ * and say "insert A, insert Z" and be done with it. That's what we do if the
+ * input is empty. But we can be smarter.
+ *
+ *           output
+ *                A   Z
+ *                -   -
+ *           [0]  1   2
+ * input A |  1  [0]  1
+ *       B |  2  [1]  1
+ *       C |  3   2  [2]
+ *
+ * 1) start at 0,0 (+0)
+ * 2) keep A (+0)
+ * 3) remove B (+1)
+ * 4) replace C with Z (+1)
+ *
+ * If the `input` (source) is empty, they'll all be in the top row, resulting in an
+ * array of 'add' operations.
+ * If the `output` (target) is empty, everything will be in the left column,
+ * resulting in an array of 'remove' operations.
+ *
+ * @param input - The original array.
+ * @param output - The target array.
+ * @param ptr - JSON Pointer.
+ * @param diff - Diff function.
+ * @returns A list of add/remove/replace operations.
+ */
+export declare function diffArrays<T>(input: T[], output: T[], ptr: Pointer, diff?: Diff): Operation[];
+
+export declare function diffObjects(input: any, output: any, ptr: Pointer, diff?: Diff): Operation[];
+
 export declare class DotAtom extends InfixOperatorAtom {
     constructor(left: Atom, right: Atom);
     eval(context: AtomContext, input: TypedValue[]): TypedValue[];
@@ -1270,6 +1454,8 @@ export declare function encodeBase64(data: string): string;
  */
 export declare function encodeBase64Url(data: string): string;
 
+export declare function encodeSmartHealthLink(payload: SmartHealthLinkPayload): string;
+
 /**
  * Encrypts a string with SHA256 encryption.
  * @param str - The unencrypted input string.
@@ -1314,13 +1500,29 @@ export { ErrorEvent_2 as ErrorEvent }
  */
 export declare function escapeHtml(unsafe: string): string;
 
+/**
+ * Escape token part of a JSON Pointer string
+ *
+ * '~' needs to be encoded as '~0' and '/'
+ * needs to be encoded as '~1' when these characters appear in a
+ * reference token.
+ *
+ * This is the exact inverse of `unescapeToken()`, so the reverse replacements must take place in reverse order.
+ *
+ * @param token - The token to escape.
+ * @returns The escaped token.
+ */
+export declare function escapeToken(token: string): string;
+
 /**
  * Evaluates a FHIRPath expression against a resource or other object.
  * @param expression - The FHIRPath expression to evaluate.
  * @param input - The resource or object to evaluate the expression against.
+ * @param variables - A map of variables for eval input.
+ * @param cache - Cache for parsed ASTs.
  * @returns The result of the FHIRPath expression against the resource or object.
  */
-export declare function evalFhirPath(expression: string | FhirPathAtom, input: unknown): unknown[];
+export declare function evalFhirPath(expression: string | FhirPathAtom, input: unknown, variables?: Record<string, TypedValue>, cache?: LRUCache<FhirPathAtom> | undefined): unknown[];
 
 /**
  * Evaluates a FHIRPath expression against a resource or other object.
@@ -2107,6 +2309,15 @@ export declare class FunctionAtom implements Atom {
  */
 export declare function generateId(): string;
 
+export declare interface GenerateSmartHealthLinkParams {
+    mode?: SmartHealthLinkMode;
+    _type?: string;
+    exp?: number;
+    label?: string;
+    passcode?: string;
+    includeQrCode?: boolean;
+}
+
 export declare function getAllDataTypes(): DataTypesMap;
 
 /**
@@ -2360,6 +2571,8 @@ export declare function getSearchParameterDetails(resourceType: string, searchPa
  */
 export declare function getSearchParameters(resourceType: string): Record<string, SearchParameter> | undefined;
 
+export declare function getSmartHealthLinkId(manifestUrl: string): string | undefined;
+
 export declare function getStatus(outcome: OperationOutcome): number;
 
 /**
@@ -2973,6 +3186,18 @@ export declare interface InternalTypeSchema {
     mandatoryProperties?: Set<string>;
 }
 
+/**
+ * List the keys that shared by all `objects`.
+ *
+ * The semantics of what constitutes a "key" is described in {@link subtract}.
+ *
+ * @param objects - Array of objects to compare
+ * @returns Array of keys that are in ("own-properties" of) every object in `objects`.
+ */
+export declare function intersection(objects: ArrayLike<{
+    [index: string]: any;
+}>): string[];
+
 /**
  * Stable error when a bot response does not match {@link MedicationOrderResponse}.
  */
@@ -2988,6 +3213,11 @@ export declare const INVALID_MEDICATION_ORDER_SET_RESPONSE = "Invalid response f
  */
 export declare const INVALID_MEDICATION_SEARCH_RESPONSE = "Invalid response from medication search bot";
 
+export declare class InvalidOperationError extends Error {
+    operation: Operation;
+    constructor(operation: Operation);
+}
+
 export declare function invalidSearchOperator(operator: Operator, searchParameterCodeOrId: string): OperationOutcome;
 
 export declare interface InviteRequest {
@@ -2996,6 +3226,12 @@ export declare interface InviteRequest {
     lastName: string;
     email?: string;
     externalId?: string;
+    /**
+     * The patient that a newly provisioned `RelatedPerson` is related to.
+     * Required when inviting a `RelatedPerson` without an existing
+     * `membership.profile`, since `RelatedPerson.patient` is a required FHIR field.
+     */
+    patient?: Reference<Patient>;
     scope?: 'project' | 'server';
     password?: string;
     sendEmail?: boolean;
@@ -3106,6 +3342,8 @@ export declare function isDateTimeString(input: unknown): input is string;
  */
 export declare function isDefined<T>(value: T | undefined | null): value is T;
 
+export declare function isDestructive({ op }: Operation): boolean;
+
 /**
  * Returns true if the value is empty (null, undefined, empty string, or empty object).
  * @param v - Any value.
@@ -3535,6 +3773,12 @@ export declare interface LoginAuthenticationResponse {
     readonly mfaEnrollRequired?: boolean;
     readonly mfaRequired?: boolean;
     readonly enrollQrCode?: string;
+    /** MFA enrollment methods the project allows (e.g. 'totp', 'email'). */
+    readonly allowedMfaMethods?: ('totp' | 'email')[];
+    /** MFA methods the user is enrolled in, returned when an MFA challenge is required. */
+    readonly mfaMethods?: ('totp' | 'email')[];
+    /** The user's email address, returned with an MFA challenge so the UI can show where a magic link was sent. */
+    readonly email?: string;
     readonly code?: string;
     readonly memberships?: ProjectMembership[];
 }
@@ -5332,11 +5576,17 @@ export declare class MedplumClient extends TypedEventTarget<MedplumClientEventMa
      */
     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.
+     * Handles an unauthenticated (HTTP 401) response from the server.
+     *
+     * Bounded and terminal: at most {@link MAX_AUTH_ATTEMPTS} attempts per request (1 initial
+     * + 1 recovery, tracked via {@link RequestState.authAttempt}). The recovery re-mints via a
+     * forced {@link MedplumClient.refresh} (bypassing the {@link MedplumClient.isAuthenticated}
+     * short-circuit on the rejected token), single-flight so concurrent 401s share one re-mint.
+     * A second 401 is terminal: clear auth, `onUnauthenticated`, reject — never recurse.
+     *
      * @param url - The URL of the original request.
      * @param options - Optional fetch request init options.
+     * @param state - The request state carrying the per-request attempt count.
      * @returns The result of the retry.
      */
     private handleUnauthenticated;
@@ -5383,6 +5633,7 @@ export declare class MedplumClient extends TypedEventTarget<MedplumClientEventMa
      * has already refreshed.
      *
      * @param gracePeriod - Optional grace period in milliseconds threaded through to the post-lock authentication check.
+     * @param force - When true, re-mint even if the current token still looks locally valid — used by the 401 recovery path, where the server has rejected a token that has not locally expired. A newer token already in storage (e.g. from a peer tab) is still preferred over a fresh mint.
      * @returns The refresh promise if available; otherwise undefined.
      * @see https://openid.net/specs/openid-connect-core-1_0.html#RefreshTokens
      */
@@ -5392,6 +5643,7 @@ export declare class MedplumClient extends TypedEventTarget<MedplumClientEventMa
      * Tabs that wait on the lock check storage on acquisition and skip the network call
      * if a peer tab has already produced a fresh access token.
      * @param gracePeriod - Optional grace period in milliseconds used by the post-lock authentication check to decide whether the current token still has enough life left to skip the network refresh.
+     * @param force - When true, bypass the post-lock expiry short-circuit for the current token (still preferring a newer token a peer tab produced).
      * @returns Promise that resolves when the refresh (or short-circuit) is complete.
      */
     private runRefreshWithLock;
@@ -6382,6 +6634,11 @@ export declare class MemoryStorage implements Storage {
 
 export declare type Message = string | ArrayBuffer | Blob | ArrayBufferView;
 
+export declare class MissingError extends Error {
+    path: string;
+    constructor(path: string);
+}
+
 /**
  * The MockAsyncClientStorage class is a mock implementation of the ClientStorage class.
  * This can be used for testing async initialization of the MedplumClient.
@@ -6396,6 +6653,34 @@ export declare class MockAsyncClientStorage extends ClientStorage implements ICl
     get isInitialized(): boolean;
 }
 
+/**
+ * The "move" operation removes the value at a specified location and
+ * adds it to the target location.
+ * The operation object MUST contain a "from" member, which is a string
+ * containing a JSON Pointer value that references the location in the
+ * target document to move the value from.
+ * This operation is functionally identical to a "remove" operation on
+ * the "from" location, followed immediately by an "add" operation at
+ * the target location with the value that was just removed.
+ *
+ * The "from" location MUST NOT be a proper prefix of the "path"
+ * location; i.e., a location cannot be moved into one of its children.
+ *
+ * TODO: throw if the check described in the previous paragraph fails.
+ *
+ * @param object - The object being patched.
+ * @param operation - The operation to perform on the object.
+ * @param _options - Optional params.
+ * @returns null on success, or error if one occurred.
+ */
+export declare function move(object: any, operation: MoveOperation, _options?: PatchOptions): MissingError | null;
+
+export declare interface MoveOperation {
+    op: 'move';
+    from: string;
+    path: string;
+}
+
 export declare const multipleMatches: OperationOutcome;
 
 export declare const NDC = "http://hl7.org/fhir/sid/ndc";
@@ -6562,6 +6847,8 @@ export declare const OAuthTokenType: {
 
 export declare type OAuthTokenType = (typeof OAuthTokenType)[keyof typeof OAuthTokenType];
 
+export declare type Operation = AddOperation | RemoveOperation | ReplaceOperation | MoveOperation | CopyOperation | TestOperation;
+
 export declare class OperationOutcomeError extends Error {
     readonly outcome: OperationOutcome;
     constructor(outcome: OperationOutcome, options?: ErrorOptions);
@@ -6797,6 +7084,8 @@ export declare class ParserBuilder {
   */
  export declare function parseSearchRequest<T extends Resource = Resource>(url: URL | string, query?: Record<string, string[] | string | undefined>): SearchRequest<T>;
 
+ export declare function parseSmartHealthLink(input: string): SmartHealthLinkPayload;
+
  /**
   * Parses a StructureDefinition resource into an internal schema better suited for
   * programmatic validation and usage in internal systems
@@ -6826,6 +7115,8 @@ export declare class ParserBuilder {
   */
  export declare function parseXFhirQuery(query: string, variables: Record<string, TypedValue>, context?: TypedValue[]): SearchRequest;
 
+ export declare type Patch = Operation[];
+
  /**
   * JSONPatch patch operation.
   * Compatible with fast-json-patch and rfc6902 Operation.
@@ -6836,6 +7127,25 @@ export declare class ParserBuilder {
      readonly value?: any;
  }
 
+ export declare interface PatchOptions {
+     /**
+      * When true, "add" operations with path ending in "/-" will implicitly
+      * create an empty array where possible.
+      *
+      * For example, with this option enabled, for the object `{live: true}`,
+      * the operation `add "/tag/-" 123` will result in `{live: true, tag: [123]}`.
+      * Subsequent operations behave normally: another `add "/tag/-" 456` will result
+      * in `{live: true, tag: [123, 456]}`.
+      *
+      * If the indicated array property already exists but is not an array, this will
+      * produce an error.
+      *
+      * Only the leaf array will be inferred; missing parent objects will still
+      * produce errors.
+      */
+     implicitArrayCreation?: boolean;
+ }
+
  /**
   * Translates a path emitted by this crawler into an RFC6902 JSON Patch pointer
   *
@@ -6871,6 +7181,52 @@ export declare class ParserBuilder {
      ncpdpID?: string;
  }
 
+ /**
+  * JSON Pointer representation
+  */
+ export declare class Pointer {
+     tokens: string[];
+     constructor(tokens?: string[]);
+     /**
+      * @param path - The JSON path: *must* be a properly escaped string.
+      * @returns The JSON pointer object.
+      */
+     static fromJSON(path: string): Pointer;
+     toString(): string;
+     /**
+      * Returns an object with 'parent', 'key', and 'value' properties.
+      * In the special case that this Pointer's path == "",
+      * this object will be `{parent: null, key: '', value: object}`.
+      * Otherwise, parent and key will have the property such that parent[key] == value.
+      *
+      * @param object - The object against which to evaluate the pointer.
+      * @returns The evaluation result.
+      */
+     evaluate(object: any): PointerEvaluation;
+     get(object: any): any;
+     set(object: any, value: any): void;
+     push(token: string): void;
+     /**
+      * @param token - The token to add to the pointer.
+      * @returns An updated pointer.
+      */
+     add(token: string): Pointer;
+     /**
+      * Create a new Pointer representing the parent of this one.
+      *
+      * The parent of the empty pointer is the empty pointer.
+      *
+      * @returns The parent pointer.
+      */
+     parent(): Pointer;
+ }
+
+ export declare interface PointerEvaluation {
+     parent: any;
+     key: string;
+     value: any;
+ }
+
  /**
   * Returns true if the two numbers are equal to the given precision.
   * @param a - The first number.
@@ -7252,6 +7608,17 @@ export declare class ParserBuilder {
      }[];
  };
 
+ /**
+  * The "remove" operation removes the value at the target location.
+  * The target location MUST exist for the operation to be successful.
+  *
+  * @param object - The object being patched.
+  * @param operation - The operation to perform on the object.
+  * @param _options - Optional params.
+  * @returns null on success, or error if one occurred.
+  */
+ export declare function remove(object: any, operation: RemoveOperation, _options?: PatchOptions): MissingError | null;
+
  /**
   * Removes duplicates in array using FHIRPath equality rules.
   * @param arr - The input array.
@@ -7259,6 +7626,11 @@ export declare class ParserBuilder {
   */
  export declare function removeDuplicates(arr: TypedValue[]): TypedValue[];
 
+ export declare interface RemoveOperation {
+     op: 'remove';
+     path: string;
+ }
+
  /**
   * Removes a preferred pharmacy extension from a Patient.
   *
@@ -7288,6 +7660,31 @@ export declare class ParserBuilder {
   */
  export declare function reorderBundle(bundle: Bundle): Bundle;
 
+ /**
+  * The "replace" operation replaces the value at the target location
+  * with a new value.  The operation object MUST contain a "value" member
+  * whose content specifies the replacement value.
+  * The target location MUST exist for the operation to be successful.
+  *
+  * This operation is functionally identical to a "remove" operation for
+  * a value, followed immediately by an "add" operation at the same
+  * location with the replacement value.
+  *
+  * Even more simply, it's like the add operation with an existence check.
+  *
+  * @param object - The object being patched.
+  * @param operation - The operation to perform on the object.
+  * @param _options - Optional params.
+  * @returns null on success, or error if one occurred.
+  */
+ export declare function replace(object: any, operation: ReplaceOperation, _options?: PatchOptions): MissingError | null;
+
+ export declare interface ReplaceOperation {
+     op: 'replace';
+     path: string;
+     value: any;
+ }
+
  /**
   * Replaces prefetch query variables with values from the context or user profile.
   *
@@ -7329,6 +7726,12 @@ export declare class ParserBuilder {
   */
  export declare function resolveId(input: Reference | Resource | undefined): string | undefined;
 
+ export declare interface ResolveSmartHealthLinkParams {
+     shlink?: string;
+     recipient?: string;
+     passcode?: string;
+ }
+
  /**
   * ResourceArray is an array of resources with a bundle property.
   * The bundle property is a FHIR Bundle containing the search results.
@@ -7532,6 +7935,23 @@ export declare class ParserBuilder {
      slices: SliceDefinition[];
  }
 
+ export declare interface SmartHealthLinkManifestFile {
+     contentType: string;
+     embedded: string;
+     lastUpdated?: string;
+ }
+
+ export declare type SmartHealthLinkMode = 'manifest' | 'direct';
+
+ export declare interface SmartHealthLinkPayload {
+     url: string;
+     key: string;
+     exp?: number;
+     flag?: string;
+     label?: string;
+     v?: 1;
+ }
+
  export declare const SNOMED = "http://snomed.info/sct";
 
  export declare interface SortRule {
@@ -7761,6 +8181,23 @@ export declare class ParserBuilder {
   */
  export declare function subsetResource<T extends Resource>(resource: T | undefined, properties: string[]): T | undefined;
 
+ /**
+  * List the keys in `minuend` that are not in `subtrahend`.
+  *
+  * A key is only considered if it is both 1) an own-property (o.hasOwnProperty(k))
+  * of the object, and 2) has a value that is not undefined. This is to match JSON
+  * semantics, where JSON object serialization drops keys with undefined values.
+  *
+  * @param minuend - Object of interest
+  * @param subtrahend - Object of comparison
+  * @returns Array of keys that are in `minuend` but not in `subtrahend`.
+  */
+ export declare function subtract(minuend: {
+     [index: string]: any;
+ }, subtrahend: {
+     [index: string]: any;
+ }): string[];
+
  /**
   * Summarizes a group of Observations into a single computed summary value, with the individual values
   * preserved in `Observation.component.valueSampledData`.
@@ -7781,6 +8218,34 @@ export declare class ParserBuilder {
      toString(): string;
  }
 
+ /**
+  * The "test" operation tests that a value at the target location is
+  * equal to a specified value.
+  * The operation object MUST contain a "value" member that conveys the
+  * value to be compared to the target location's value.
+  * The target location MUST be equal to the "value" value for the
+  * operation to be considered successful.
+  *
+  * @param object - The object being patched.
+  * @param operation - The add operation to perform on the object.
+  * @param _options - Optional params.
+  * @returns null on success, or error if one occurred.
+  */
+ declare function test_2(object: any, operation: TestOperation, _options?: PatchOptions): TestError | null;
+ export { test_2 as test }
+
+ export declare class TestError extends Error {
+     actual: any;
+     expected: any;
+     constructor(actual: any, expected: any);
+ }
+
+ export declare interface TestOperation {
+     op: 'test';
+     path: string;
+     value: any;
+ }
+
  /**
   * Converts unknown object into a JavaScript boolean.
   * Note that this is different than the FHIRPath "toBoolean",
@@ -7957,6 +8422,31 @@ export declare class ParserBuilder {
 
  export declare const unauthorizedTokenExpired: OperationOutcome;
 
+ /**
+  * Unescape token part of a JSON Pointer string
+  *
+  * `token` should *not* contain any '/' characters.
+  *
+  * Evaluation of each reference token begins by decoding any escaped
+  * character sequence.  This is performed by first transforming any
+  * occurrence of the sequence '~1' to '/', and then transforming any
+  * occurrence of the sequence '~0' to '~'.  By performing the
+  * substitutions in this order, an implementation avoids the error of
+  * turning '~01' first into '~1' and then into '/', which would be
+  * incorrect (the string '~01' correctly becomes '~1' after
+  * transformation).
+  *
+  * Here's my take:
+  *
+  * ~1 is unescaped with higher priority than ~0 because it is a lower-order escape character.
+  * I say "lower order" because '/' needs escaping due to the JSON Pointer serialization technique.
+  * Whereas, '~' is escaped because escaping '/' uses the '~' character.
+  *
+  * @param token - The token to unescape.
+  * @returns The unescaped token.
+  */
+ export declare function unescapeToken(token: string): string;
+
  export declare class UnionAtom extends InfixOperatorAtom {
      constructor(left: Atom, right: Atom);
      eval(context: AtomContext, input: TypedValue[]): TypedValue[];
@@ -8044,6 +8534,13 @@ export declare class ParserBuilder {
      displayLanguage?: string;
  }
 
+ /**
+  * VoidableDiff exists to allow the user to provide a partial diff(...) function,
+  * falling back to the built-in diffAny(...) function if the user-provided function
+  * returns void.
+  */
+ export declare type VoidableDiff = (input: any, output: any, ptr: Pointer) => Operation[] | undefined;
+
  /**
   * Checks if a newer version of Medplum is available and logs a warning if so.
   * @param appName - The name of the app to check the version for.