@medplum/core 3.0.2 → 3.0.4

package/dist/esm/index.d.ts

@@ -142,6 +142,33 @@ export declare class AndAtom extends BooleanInfixOperatorAtom {
 
 export declare function append<T>(array: T[] | undefined, value: T): T[];
 
+/**
+ * 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
+ * values defined in the relevant elements.
+ * @param existingValue - The
+ * @param elements - The elements to which default values should be added.
+ * @param key - (optional) The key of the element(s) for which default values should be added. Elements with nested
+ * keys are also included. If undefined, default values for all elements are added.
+ * @returns `existingValue` with default values added
+ */
+export declare function applyDefaultValuesToElement(existingValue: object, elements: Record<string, InternalSchemaElement>, key?: string): object;
+
+export declare function applyDefaultValuesToElementWithVisitor(existingValue: any, path: string, element: InternalSchemaElement, elements: Record<string, InternalSchemaElement>, schema: InternalTypeSchema): any;
+
+/**
+ * Adds default values to `resource` based on the supplied `schema`. Default values includes all required fixed and pattern
+ * values specified on elements in the schema. If an element has a fixed/pattern value but is optional, i.e.
+ * `element.min === 0`, the default value is not added.
+ *
+ * @param resource - The resource to which default values should be added.
+ * @param schema - The schema to use for adding default values.
+ * @returns A clone of `resource` with default values added.
+ */
+export declare function applyDefaultValuesToResource(resource: Resource, schema: InternalTypeSchema): Resource;
+
+export declare function applyFixedOrPatternValue(inputValue: any, key: string, element: InternalSchemaElement, elements: Record<string, InternalSchemaElement>): any;
+
 export declare class ArithemticOperatorAtom extends BooleanInfixOperatorAtom {
     readonly impl: (x: number, y: number) => number | boolean;
     constructor(operator: string, left: Atom, right: Atom, impl: (x: number, y: number) => number | boolean);
@@ -237,8 +264,25 @@ export declare interface BotEvent<T = Resource | Hl7Message | string | Record<st
     readonly contentType: string;
     readonly input: T;
     readonly secrets: Record<string, ProjectSecret>;
+    readonly traceId?: string;
 }
 
+export declare function buildElementsContext({ parentContext, path, elements, profileUrl, debugMode, }: {
+    /** The most recent `ElementsContextType` in which this context is being built. */
+    parentContext: ElementsContextType | undefined;
+    /** The FHIR path from the root resource to which the keys of `elements` are relative. */
+    path: string;
+    /**
+     * The mapping of keys to `InternalSchemaElement` at the current `path` relative to the
+     * root resource. This should be either `InternalTypeSchema.elements` or `SliceDefinition.elements`.
+     */
+    elements: Record<string, InternalSchemaElement>;
+    /** The URL, if any, of the resource profile or extension from which the `elements` collection originated. */
+    profileUrl?: string;
+    /** Whether debug logging is enabled */
+    debugMode?: boolean;
+}): ElementsContextType | undefined;
+
 export declare function buildTypeName(components: string[]): string;
 
 /**
@@ -395,6 +439,7 @@ export declare const ContentType: {
     readonly SVG: "image/svg+xml";
     readonly TEXT: "text/plain";
     readonly TYPESCRIPT: "text/typescript";
+    readonly PING: "x-application/ping";
 };
 
 /**
@@ -519,6 +564,30 @@ export declare class DotAtom extends InfixOperatorAtom {
     toString(): string;
 }
 
+/**
+ * Information for the set of elements at a given path within in a resource. This mostly exists to
+ * normalize access to elements regardless of whether they are from a profile, extension, or slice.
+ */
+export declare type ElementsContextType = {
+    /** The FHIR path from the root resource to which the keys of `elements` are relative. */
+    path: string;
+    /**
+     * The mapping of keys to `InternalSchemaElement` at the current `path` relative to the
+     * root resource. `elements` originate from either `InternalTypeSchema.elements` or
+     * `SliceDefinition.elements` when the elements context is created within a slice.
+     */
+    elements: Record<string, InternalSchemaElement>;
+    /**
+     * Similar mapping as `elements`, but with keys being the full path from the root resource rather
+     * than relative to `path`, in other words, the keys of the Record are `${path}.${key}`.
+     */
+    elementsByPath: Record<string, InternalSchemaElement>;
+    /** The URL, if any, of the resource profile or extension from which the `elements` collection originated. */
+    profileUrl: string | undefined;
+    /** Whether debug logging is enabled */
+    debugMode: boolean;
+};
+
 export declare interface ElementType {
     code: string;
     targetProfile?: string[];
@@ -1186,6 +1255,8 @@ export declare function getDataType(type: string, profileUrl?: string): Internal
  */
 export declare function getDateProperty(date: string | undefined): Date | undefined;
 
+export declare function getDefaultValuesForNewSliceEntry(key: string, slice: SliceDefinition, slicing: SlicingRules, schema: InternalTypeSchema): Resource;
+
 /**
  * Returns a display string for the resource.
  * @param resource - The input resource.
@@ -1197,9 +1268,10 @@ export declare function getDisplayString(resource: Resource): string;
  * Returns an element definition by type and property name.
  * @param typeName - The type name.
  * @param propertyName - The property name.
+ * @param profileUrl - (optional) The URL of the current resource profile
  * @returns The element definition if found.
  */
-export declare function getElementDefinition(typeName: string, propertyName: string): InternalSchemaElement | undefined;
+export declare function getElementDefinition(typeName: string, propertyName: string, profileUrl?: string): InternalSchemaElement | undefined;
 
 /**
  * Returns an element definition from mapping of elements by property name.
@@ -1255,7 +1327,17 @@ export declare function getIdentifier(resource: Resource, system: string): strin
  */
 export declare function getImageSrc(resource: Resource): string | undefined;
 
-export declare function getNestedProperty(value: TypedValue, key: string): (TypedValue | TypedValue[] | undefined)[];
+export declare function getNestedProperty(value: TypedValue, key: string, options?: {
+    profileUrl?: string;
+}): (TypedValue | TypedValue[] | undefined)[];
+
+/**
+ * Returns the difference between two paths which is often suitable to use as a key in a `Record<string, InternalSchemaElement>`
+ * @param parentPath - The parent path that will be removed from `path`.
+ * @param path - The element path that should be a child of `parentPath`.
+ * @returns - The difference between `path` and `parentPath` or `undefined` if `path` is not a child of `parentPath`.
+ */
+export declare function getPathDifference(parentPath: string, path: string): string | undefined;
 
 /**
  * Returns a human friendly display name for a FHIR element definition path.
@@ -1338,18 +1420,28 @@ export declare function getStatus(outcome: OperationOutcome): number;
  * This function returns the value and the type.
  * @param input - The base context (FHIR resource or backbone element).
  * @param path - The property path.
+ * @param options - (optional) Additional options
  * @returns The value of the property and the property type.
  */
-export declare function getTypedPropertyValue(input: TypedValue, path: string): TypedValue[] | TypedValue | undefined;
+export declare function getTypedPropertyValue(input: TypedValue, path: string, options?: GetTypedPropertyValueOptions): TypedValue[] | TypedValue | undefined;
+
+export declare interface GetTypedPropertyValueOptions {
+    /** (optional) URL of a resource profile for type resolution */
+    profileUrl?: string;
+}
 
 /**
  * Returns the value of the property and the property type using a type schema.
- * @param value - The base context (FHIR resource or backbone element).
+ * @param typedValue - The base context (FHIR resource or backbone element).
  * @param path - The property path.
  * @param element - The property element definition.
  * @returns The value of the property and the property type.
  */
-export declare function getTypedPropertyValueWithSchema(value: TypedValue['value'], path: string, element: InternalSchemaElement): TypedValue[] | TypedValue | undefined;
+export declare function getTypedPropertyValueWithSchema(typedValue: TypedValue, path: string, element: InternalSchemaElement): TypedValue[] | TypedValue | undefined;
+
+export declare function getValueSliceName(value: any, slices: SliceDefinitionWithTypes[], discriminators: SliceDiscriminator[], profileUrl: string | undefined): string | undefined;
+
+export declare function getWebSocketUrl(path: string, baseUrl: URL | string): string;
 
 /**
  * Global schema singleton.
@@ -1772,6 +1864,8 @@ export declare class IsAtom extends BooleanInfixOperatorAtom {
 
 export declare function isCompletedSubscriptionRequest(subscriptionRequest: SubscriptionRequest | PendingSubscriptionRequest): subscriptionRequest is SubscriptionRequest;
 
+export declare function isComplexTypeCode(code: string): boolean;
+
 export declare function isContextVersionRequired(event: string): event is FhircastEventVersionRequired;
 
 export declare function isCreated(outcome: OperationOutcome): boolean;
@@ -1911,6 +2005,8 @@ export declare function isResourceType(resourceType: string): boolean;
  */
 export declare function isResourceTypeSchema(typeSchema: InternalTypeSchema): boolean;
 
+export declare function isSliceDefinitionWithTypes(slice: SliceDefinition): slice is SliceDefinitionWithTypes;
+
 /**
  * Returns true if the input array is an array of strings.
  * @param arr - Input array.
@@ -2202,6 +2298,7 @@ export declare class MedplumClient extends EventTarget_2 {
     private readonly onUnauthenticated?;
     private readonly autoBatchTime;
     private readonly autoBatchQueue;
+    private subscriptionManager?;
     private medplumServer?;
     private clientId?;
     private clientSecret?;
@@ -2647,7 +2744,7 @@ export declare class MedplumClient extends EventTarget_2 {
      * @param resourceType - The FHIR resource type.
      * @param id - The resource ID.
      * @param options - Optional fetch options.
-     * @returns The resource if available; undefined otherwise.
+     * @returns The resource if available.
      */
     readResource<K extends ResourceType>(resourceType: K, id: string, options?: RequestInit): ReadablePromise<ExtractResource<K>>;
     /**
@@ -2668,7 +2765,7 @@ export declare class MedplumClient extends EventTarget_2 {
      * @category Read
      * @param reference - The FHIR reference object.
      * @param options - Optional fetch options.
-     * @returns The resource if available; undefined otherwise.
+     * @returns The resource if available.
      */
     readReference<T extends Resource>(reference: Reference<T>, options?: RequestInit): ReadablePromise<T>;
     /**
@@ -2684,9 +2781,10 @@ export declare class MedplumClient extends EventTarget_2 {
      * If the schema is already cached, the promise is resolved immediately.
      * @category Schema
      * @param profileUrl - The FHIR URL of the profile
-     * @returns Promise to a schema with the requested profile.
+     * @param options - (optional) Additional options
+     * @returns Promise with an array of URLs of the profile(s) loaded.
      */
-    requestProfileSchema(profileUrl: string): Promise<void>;
+    requestProfileSchema(profileUrl: string, options?: RequestProfileSchemaOptions): Promise<string[]>;
     /**
      * Reads resource history by resource type and ID.
      *
@@ -2725,7 +2823,7 @@ export declare class MedplumClient extends EventTarget_2 {
      * @param id - The resource ID.
      * @param vid - The version ID.
      * @param options - Optional fetch options.
-     * @returns The resource if available; undefined otherwise.
+     * @returns The resource if available.
      */
     readVersion<K extends ResourceType>(resourceType: K, id: string, vid: string, options?: RequestInit): ReadablePromise<ExtractResource<K>>;
     /**
@@ -3168,7 +3266,7 @@ export declare class MedplumClient extends EventTarget_2 {
      * @param options - Optional fetch options.
      * @returns Promise to the result. If waiting for response, the result is the response body. Otherwise, it is an operation outcome.
      */
-    pushToAgent(agent: Agent | Reference<Agent>, destination: Device | Reference<Device>, body: any, contentType?: string, waitForResponse?: boolean, options?: RequestInit): Promise<any>;
+    pushToAgent(agent: Agent | Reference<Agent>, destination: Device | Reference<Device> | string, body: any, contentType?: string, waitForResponse?: boolean, options?: RequestInit): Promise<any>;
     /**
      * @category Authentication
      * @returns The Login State
@@ -3322,10 +3420,11 @@ export declare class MedplumClient extends EventTarget_2 {
      * @param method - The HTTP method (GET, POST, etc).
      * @param url - The target URL.
      * @param options - Optional fetch request init options.
+     * @param state - Optional request state.
      * @returns The JSON content body if available.
      */
     private request;
-    private parseResponse;
+    private parseBody;
     private fetchWithRetry;
     private logRequest;
     private logResponse;
@@ -3535,6 +3634,70 @@ export declare class MedplumClient extends EventTarget_2 {
      */
     private setupStorageListener;
     private retryCatch;
+    /**
+     * Gets the `SubscriptionManager` for WebSocket subscriptions.
+     *
+     * @category Subscriptions
+     * @returns the `SubscriptionManager` for this client.
+     */
+    getSubscriptionManager(): SubscriptionManager;
+    /**
+     * Subscribes to a given criteria, listening to notifications over WebSockets.
+     *
+     * This uses Medplum's `WebSocket Subscriptions` under the hood.
+     *
+     * A `SubscriptionEmitter` is returned from this function, which can be used to listen for updates to resources described by the given criteria.
+     *
+     * When subscribing to the same criteria multiple times, the same `SubscriptionEmitter` will be returned, and a reference count will be incremented.
+     *
+     * -----
+     * @example
+     * ```ts
+     * const emitter = medplum.subscribeToCriteria('Communication');
+     *
+     * emitter.addEventListener('message', (bundle: Bundle) => {
+     *   // Called when a `Communication` resource is created or modified
+     *   console.log(bundle?.entry?.[1]?.resource); // Logs the `Communication` resource that was updated
+     * });
+     * ```
+     *
+     * @category Subscriptions
+     * @param criteria - The criteria to subscribe to.
+     * @returns a `SubscriptionEmitter` that emits `Bundle` resources containing changes to resources based on the given criteria.
+     */
+    subscribeToCriteria(criteria: string): SubscriptionEmitter;
+    /**
+     * Unsubscribes from the given criteria.
+     *
+     * When called the same amount of times as proceeding calls to `subscribeToCriteria` on a given `criteria`,
+     * the criteria is fully removed from the `SubscriptionManager`.
+     *
+     * @category Subscriptions
+     * @param criteria - The criteria to unsubscribe from.
+     */
+    unsubscribeFromCriteria(criteria: string): void;
+    /**
+     * Get the master `SubscriptionEmitter` for the `SubscriptionManager`.
+     *
+     * The master `SubscriptionEmitter` gets messages for all subscribed `criteria` as well as WebSocket errors, `connect` and `disconnect` events, and the `close` event.
+     *
+     * It can also be used to listen for `heartbeat` messages.
+     *
+     *------
+     * @example
+     * ### Listening for `heartbeat`:
+     * ```ts
+     * const masterEmitter = medplum.getMasterSubscriptionEmitter();
+     *
+     * masterEmitter.addEventListener('heartbeat', (bundle: Bundle<SubscriptionStatus>) => {
+     *   console.log(bundle?.entry?.[0]?.resource); // A `SubscriptionStatus` of type `heartbeat`
+     * });
+     *
+     * ```
+     * @category Subscriptions
+     * @returns the master `SubscriptionEmitter` from the `SubscriptionManager`.
+     */
+    getMasterSubscriptionEmitter(): SubscriptionEmitter;
 }
 
 /**
@@ -4474,6 +4637,11 @@ export declare function removeDuplicates(arr: TypedValue[]): TypedValue[];
  */
 export declare function reorderBundle(bundle: Bundle): Bundle;
 
+export declare interface RequestProfileSchemaOptions {
+    /** (optional) Whether to include nested profiles, e.g. from extensions. Defaults to false. */
+    expandProfile?: boolean;
+}
+
 /**
  * Returns the ID portion of a reference.
  * @param input - A FHIR reference or resource.
@@ -4500,6 +4668,26 @@ export declare interface ResourceVisitor {
 
 export declare type ResourceWithCode = Resource & Code;
 
+export declare class RobustWebSocket extends TypedEventTarget<RobustWebSocketEventMap> {
+    private ws;
+    private messageBuffer;
+    bufferedAmount: number;
+    extensions: string;
+    constructor(url: string);
+    get readyState(): number;
+    close(): void;
+    send(message: string): void;
+}
+
+export declare type RobustWebSocketEventMap = {
+    open: {
+        type: 'open';
+    };
+    message: MessageEvent;
+    error: Event;
+    close: CloseEvent;
+};
+
 export declare const RXNORM = "http://www.nlm.nih.gov/research/umls/rxnorm";
 
 /**
@@ -4543,6 +4731,8 @@ export declare interface SearchRequest<T extends Resource = Resource> {
     include?: IncludeTarget[];
     revInclude?: IncludeTarget[];
     summary?: 'true' | 'text' | 'data';
+    format?: string;
+    pretty?: boolean;
 }
 
 /**
@@ -4599,8 +4789,14 @@ export declare interface SliceDefinition {
     elements: Record<string, InternalSchemaElement>;
     min: number;
     max: number;
+    binding?: ElementDefinitionBinding;
 }
 
+export declare type SliceDefinitionWithTypes = SliceDefinition & {
+    type: NonNullable<SliceDefinition['type']>;
+    typeSchema?: InternalTypeSchema;
+};
+
 export declare interface SliceDiscriminator {
     path: string;
     type: string;
@@ -4620,6 +4816,15 @@ export declare interface SortRule {
     descending?: boolean;
 }
 
+/**
+ * Splits a string into an array of strings using the specified delimiter.
+ * Unlike the built-in split function, this function will split the string into a maximum of exactly n parts.
+ * Trailing empty strings are included in the result.
+ * @param str - The string to split.
+ * @param delim - The delimiter.
+ * @param n - The maximum number of parts to split the string into.
+ * @returns The resulting array of strings.
+ */
 export declare function splitN(str: string, delim: string, n: number): string[];
 
 /**
@@ -4663,6 +4868,85 @@ export declare type StringMap = {
  */
 export declare function structureMapTransform(structureMap: StructureMap, input: TypedValue[], loader?: (url: string) => StructureMap[]): TypedValue[];
 
+/**
+ * An `EventTarget` that emits events when new subscription notifications come in over WebSockets.
+ *
+ * -----
+ *
+ * ### Events emitted:
+ *
+ * - `connect` - A new subscription is connected to the `SubscriptionManager` and `message` events for this subscription can be expected.
+ * - `disconnect` - The specified subscription is no longer being monitored by the `SubscriptionManager`.
+ * - `error` - An error has occurred.
+ * - `message` - A message containing a notification `Bundle` has been received.
+ * - `close` - The WebSocket has been closed.
+ * - `heartbeat` - A `heartbeat` message has been received.
+ */
+export declare class SubscriptionEmitter extends TypedEventTarget<SubscriptionEventMap> {
+    private criteria;
+    constructor(...criteria: string[]);
+    getCriteria(): Set<string>;
+    /**
+     * @internal
+     * @param criteria - The criteria to add to this `SubscriptionEmitter`.
+     */
+    _addCriteria(criteria: string): void;
+    /**
+     * @internal
+     * @param criteria - The criteria to remove from this `SubscriptionEmitter`.
+     */
+    _removeCriteria(criteria: string): void;
+}
+
+export declare type SubscriptionEventMap = {
+    connect: {
+        type: 'connect';
+        payload: {
+            subscriptionId: string;
+        };
+    };
+    disconnect: {
+        type: 'disconnect';
+        payload: {
+            subscriptionId: string;
+        };
+    };
+    error: {
+        type: 'error';
+        payload: Error;
+    };
+    message: {
+        type: 'message';
+        payload: Bundle;
+    };
+    close: {
+        type: 'close';
+    };
+    heartbeat: {
+        type: 'heartbeat';
+        payload: Bundle;
+    };
+};
+
+export declare class SubscriptionManager {
+    private readonly medplum;
+    private ws;
+    private masterSubEmitter?;
+    private criteriaEntries;
+    private criteriaEntriesBySubscriptionId;
+    private wsClosed;
+    constructor(medplum: MedplumClient, wsUrl: URL | string);
+    private setupWebSocketListeners;
+    private emitConnect;
+    private emitError;
+    private getTokenForCriteria;
+    addCriteria(criteria: string): SubscriptionEmitter;
+    removeCriteria(criteria: string): void;
+    closeWebSocket(): void;
+    getCriteriaCount(): number;
+    getMasterEmitter(): SubscriptionEmitter;
+}
+
 /**
  * A `FHIRcast` subscription request.
  *