@medplum/core 3.0.3 → 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;
 
 /**
@@ -520,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[];
@@ -1187,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.
@@ -1261,6 +1331,14 @@ export declare function getNestedProperty(value: TypedValue, key: string, option
     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.
  * @param path - The FHIR element definition path.
@@ -1361,6 +1439,10 @@ export declare interface GetTypedPropertyValueOptions {
  */
 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.
  */
@@ -1782,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;
@@ -1921,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.
@@ -2212,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?;
@@ -3333,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;
@@ -3546,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;
 }
 
 /**
@@ -4516,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";
 
 /**
@@ -4559,6 +4731,8 @@ export declare interface SearchRequest<T extends Resource = Resource> {
     include?: IncludeTarget[];
     revInclude?: IncludeTarget[];
     summary?: 'true' | 'text' | 'data';
+    format?: string;
+    pretty?: boolean;
 }
 
 /**
@@ -4618,6 +4792,11 @@ export declare interface SliceDefinition {
     binding?: ElementDefinitionBinding;
 }
 
+export declare type SliceDefinitionWithTypes = SliceDefinition & {
+    type: NonNullable<SliceDefinition['type']>;
+    typeSchema?: InternalTypeSchema;
+};
+
 export declare interface SliceDiscriminator {
     path: string;
     type: string;
@@ -4689,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.
  *