@medplum/core 3.2.5 → 3.2.6

package/dist/cjs/index.d.ts

@@ -234,6 +234,8 @@ export declare class AsAtom extends InfixOperatorAtom {
     eval(context: AtomContext, input: TypedValue[]): TypedValue[];
 }
 
+export declare function assert(condition: unknown, msg?: string): asserts condition;
+
 export declare function assertContextVersionOptional(event: string): asserts event is FhircastEventVersionOptional;
 
 /**
@@ -421,6 +423,13 @@ export declare class ClientStorage implements IClientStorage {
     setObject<T>(key: string, value: T): void;
 }
 
+declare interface CloseEvent_2 extends globalThis.Event {
+    code: number;
+    reason: string;
+    wasClean: boolean;
+}
+export { CloseEvent_2 as CloseEvent }
+
 export declare interface Code {
     code?: CodeableConcept;
 }
@@ -533,10 +542,42 @@ export declare type ConvertToUnion<T> = T[keyof T];
 
 export declare const CPT = "http://www.ama-assn.org/go/cpt";
 
+/**
+ * Crawls the resource synchronously.
+ * @param resource - The resource to crawl.
+ * @param visitor - The visitor functions to apply while crawling.
+ * @param schema - The schema to use for the resource.
+ * @param initialPath - The path within the resource form which to start crawling.
+ * @deprecated
+ */
 export declare function crawlResource(resource: Resource, visitor: ResourceVisitor, schema?: InternalTypeSchema, initialPath?: string): void;
 
+/**
+ * Crawls the resource asynchronously.
+ * @param resource - The resource to crawl.
+ * @param visitor - The visitor functions to apply while crawling.
+ * @param options - Options for how to crawl the resource.
+ * @returns void
+ * @deprecated
+ */
 export declare function crawlResource(resource: Resource, visitor: AsyncResourceVisitor, options: ResourceCrawlerOptions): Promise<void>;
 
+/**
+ * Crawls the resource synchronously.
+ * @param resource - The resource to crawl.
+ * @param visitor - The visitor functions to apply while crawling.
+ * @param options - Options for how to crawl the resource.
+ */
+export declare function crawlResource(resource: Resource, visitor: ResourceVisitor, options?: ResourceCrawlerOptions): void;
+
+/**
+ * Crawls the resource asynchronously.
+ * @param resource - The resource to crawl.
+ * @param visitor - The visitor functions to apply while crawling.
+ * @param options - Options for how to crawl the resource.
+ */
+export declare function crawlResourceAsync(resource: Resource, visitor: AsyncResourceVisitor, options: ResourceCrawlerOptions): Promise<void>;
+
 /**
  * Binary upload options.
  */
@@ -786,6 +827,12 @@ export declare class EquivalentAtom extends BooleanInfixOperatorAtom {
     eval(context: AtomContext, input: TypedValue[]): TypedValue[];
 }
 
+declare interface ErrorEvent_2 extends globalThis.Event {
+    message: string;
+    error: Error;
+}
+export { ErrorEvent_2 as ErrorEvent }
+
 /**
  * Evaluates a FHIRPath expression against a resource or other object.
  * @param expression - The FHIRPath expression to parse.
@@ -1990,9 +2037,8 @@ export declare function indexSearchParameterBundle(bundle: Bundle<SearchParamete
 /**
  * Parses and indexes structure definitions
  * @param bundle - Bundle or array of structure definitions to be parsed and indexed
- * @param profileUrl - (optional) URL of the profile the SDs are related to
  */
-export declare function indexStructureDefinitionBundle(bundle: StructureDefinition[] | Bundle, profileUrl?: string | undefined): void;
+export declare function indexStructureDefinitionBundle(bundle: StructureDefinition[] | Bundle): void;
 
 export declare abstract class InfixOperatorAtom implements Atom {
     readonly operator: string;
@@ -2033,10 +2079,10 @@ export declare interface InternalSchemaElement {
  */
 export declare interface InternalTypeSchema {
     name: string;
+    type: string;
     title?: string;
     url?: string;
     kind?: string;
-    type?: string;
     description?: string;
     elements: Record<string, InternalSchemaElement>;
     constraints?: Constraint[];
@@ -2064,14 +2110,15 @@ export declare interface InviteRequest {
     admin?: boolean;
 }
 
-export declare interface IRobustWebSocket extends TypedEventTarget<RobustWebSocketEventMap> {
+export declare interface IReconnectingWebSocket extends TypedEventTarget<WebSocketEventMap_2> {
     readyState: number;
-    close(): void;
+    close(code?: number, reason?: string): void;
     send(message: string): void;
+    reconnect(code?: number, reason?: string): void;
 }
 
-export declare interface IRobustWebSocketCtor {
-    new (url: string): IRobustWebSocket;
+export declare interface IReconnectingWebSocketCtor {
+    new (url: string, protocols?: ProtocolsProvider, options?: Options): IReconnectingWebSocket;
 }
 
 export declare function isAccepted(outcome: OperationOutcome): boolean;
@@ -2333,7 +2380,7 @@ export declare class LiteralAtom implements Atom {
     toString(): string;
 }
 
-export declare function loadDataType(sd: StructureDefinition, profileUrl?: string | undefined): void;
+export declare function loadDataType(sd: StructureDefinition): void;
 
 export declare class Logger {
     readonly write: (msg: string) => void;
@@ -3100,9 +3147,9 @@ export declare class MedplumClient extends TypedEventTarget<MedplumClientEventMa
      * @category Schema
      * @param profileUrl - The FHIR URL of the profile
      * @param options - (optional) Additional options
-     * @returns Promise with an array of URLs of the profile(s) loaded.
+     * @returns Promise for schema request.
      */
-    requestProfileSchema(profileUrl: string, options?: RequestProfileSchemaOptions): Promise<string[]>;
+    requestProfileSchema(profileUrl: string, options?: RequestProfileSchemaOptions): Promise<void>;
     /**
      * Reads resource history by resource type and ID.
      *
@@ -4519,6 +4566,8 @@ export declare class MemoryStorage implements Storage {
     key(index: number): string | null;
 }
 
+export declare type Message = string | ArrayBuffer | Blob | ArrayBufferView;
+
 /**
  * The MockAsyncClientStorage class is a mock implementation of the ClientStorage class.
  * This can be used for testing async initialization of the MedplumClient.
@@ -4728,6 +4777,20 @@ export declare const OperatorPrecedence: {
     Semicolon: number;
 };
 
+export declare type Options = {
+    WebSocket?: any;
+    maxReconnectionDelay?: number;
+    minReconnectionDelay?: number;
+    reconnectionDelayGrowFactor?: number;
+    minUptime?: number;
+    connectionTimeout?: number;
+    maxRetries?: number;
+    maxEnqueuedMessages?: number;
+    startClosed?: boolean;
+    debug?: boolean;
+    debugLogger?: (...args: any[]) => void;
+};
+
 /**
  * 6.5.2. or
  * Returns false if both operands evaluate to false,
@@ -5046,6 +5109,8 @@ export declare const PropertyType: {
  */
 export declare const protectedResourceTypes: string[];
 
+export declare type ProtocolsProvider = null | string | string[];
+
 /**
  * QueryTypes defines the different ways to specify FHIR search parameters.
  *
@@ -5110,6 +5175,118 @@ export declare class ReadablePromise<T> implements Promise<T> {
     finally(onfinally?: (() => void) | undefined | null): Promise<T>;
 }
 
+export declare class ReconnectingWebSocket extends TypedEventTarget<WebSocketEventMap_2> implements IReconnectingWebSocket {
+    private _ws;
+    private _retryCount;
+    private _uptimeTimeout;
+    private _connectTimeout;
+    private _shouldReconnect;
+    private _connectLock;
+    private _binaryType;
+    private _closeCalled;
+    private _messageQueue;
+    private _debugLogger;
+    protected _url: string;
+    protected _protocols?: ProtocolsProvider;
+    protected _options: Options;
+    constructor(url: string, protocols?: ProtocolsProvider, options?: Options);
+    static get CONNECTING(): number;
+    static get OPEN(): number;
+    static get CLOSING(): number;
+    static get CLOSED(): number;
+    get CONNECTING(): number;
+    get OPEN(): number;
+    get CLOSING(): number;
+    get CLOSED(): number;
+    get binaryType(): 'arraybuffer' | 'blob';
+    set binaryType(value: BinaryType);
+    /**
+     * @returns The number or connection retries.
+     */
+    get retryCount(): number;
+    /**
+     * @returns The number of bytes of data that have been queued using calls to send() but not yet
+     * transmitted to the network. This value resets to zero once all queued data has been sent.
+     * This value does not reset to zero when the connection is closed; if you keep calling send(),
+     * this will continue to climb. Read only
+     *
+     */
+    get bufferedAmount(): number;
+    /**
+     * @returns The extensions selected by the server. This is currently only the empty string or a list of
+     * extensions as negotiated by the connection
+     */
+    get extensions(): string;
+    /**
+     * @returns A string indicating the name of the sub-protocol the server selected;
+     * this will be one of the strings specified in the protocols parameter when creating the
+     * WebSocket object.
+     */
+    get protocol(): string;
+    /**
+     * @returns The current state of the connection; this is one of the Ready state constants.
+     */
+    get readyState(): number;
+    /**
+     * @returns The URL as resolved by the constructor.
+     */
+    get url(): string;
+    /**
+     * @returns Whether the websocket object is now in reconnectable state.
+     */
+    get shouldReconnect(): boolean;
+    /**
+     * An event listener to be called when the WebSocket connection's readyState changes to CLOSED
+     */
+    onclose: ((event: CloseEvent_2) => void) | null;
+    /**
+     * An event listener to be called when an error occurs
+     */
+    onerror: ((event: ErrorEvent_2) => void) | null;
+    /**
+     * An event listener to be called when a message is received from the server
+     */
+    onmessage: ((event: MessageEvent) => void) | null;
+    /**
+     * An event listener to be called when the WebSocket connection's readyState changes to OPEN;
+     * this indicates that the connection is ready to send and receive data
+     */
+    onopen: ((event: Event) => void) | null;
+    /**
+     * Closes the WebSocket connection or connection attempt, if any. If the connection is already
+     * CLOSED, this method does nothing
+     * @param code - The code to close with. Default is 1000.
+     * @param reason - An optional reason for closing the connection.
+     */
+    close(code?: number, reason?: string): void;
+    /**
+     * Closes the WebSocket connection or connection attempt and connects again.
+     * Resets retry counter;
+     * @param code - The code to disconnect with. Default is 1000.
+     * @param reason - An optional reason for disconnecting the connection.
+     */
+    reconnect(code?: number, reason?: string): void;
+    /**
+     * Enqueue specified data to be transmitted to the server over the WebSocket connection
+     * @param data - The data to enqueue.
+     */
+    send(data: Message): void;
+    private _debug;
+    private _getNextDelay;
+    private _wait;
+    private _connect;
+    private _handleTimeout;
+    private _disconnect;
+    private _acceptOpen;
+    private _handleOpen;
+    private _handleMessage;
+    private _handleError;
+    private _handleClose;
+    private _removeListeners;
+    private _addListeners;
+    private _clearTimeouts;
+}
+
 /**
  * Removes duplicates in array using FHIRPath equality rules.
  * @param arr - The input array.
@@ -5184,26 +5361,6 @@ export declare interface ResourceVisitor {
 
 export declare type ResourceWithCode = Resource & Code;
 
-export declare class RobustWebSocket extends TypedEventTarget<RobustWebSocketEventMap> implements IRobustWebSocket {
-    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";
 
 /**
@@ -5417,7 +5574,10 @@ export declare type StringMap = {
 export declare function structureMapTransform(structureMap: StructureMap, input: TypedValue[], loader?: (url: string) => StructureMap[]): TypedValue[];
 
 export declare interface SubManagerOptions {
-    RobustWebSocket: IRobustWebSocketCtor;
+    ReconnectingWebSocket?: IReconnectingWebSocketCtor;
+    pingIntervalMs?: number;
+    debug?: boolean;
+    debugLogger?: (...args: any[]) => void;
 }
 
 /**
@@ -5491,9 +5651,11 @@ export declare class SubscriptionManager {
     private criteriaEntries;
     private criteriaEntriesBySubscriptionId;
     private wsClosed;
+    private pingTimer;
+    private pingIntervalMs;
+    private waitingForPong;
     constructor(medplum: MedplumClient, wsUrl: URL | string, options?: SubManagerOptions);
     private setupWebSocketListeners;
-    private emitConnect;
     private emitError;
     private maybeEmitDisconnect;
     private getTokenForCriteria;
@@ -5501,9 +5663,13 @@ export declare class SubscriptionManager {
     private getAllCriteriaEmitters;
     private addCriteriaEntry;
     private removeCriteriaEntry;
+    private subscribeToCriteria;
+    private refreshAllSubscriptions;
     addCriteria(criteria: string, subscriptionProps?: Partial<Subscription>): SubscriptionEmitter;
     removeCriteria(criteria: string, subscriptionProps?: Partial<Subscription>): void;
+    getWebSocket(): IReconnectingWebSocket;
     closeWebSocket(): void;
+    reconnectWebSocket(): void;
     getCriteriaCount(): number;
     getMasterEmitter(): SubscriptionEmitter;
 }
@@ -5753,6 +5919,14 @@ export declare interface ValueSetExpandParams {
     count?: number;
 }
 
+declare type WebSocketEventMap_2 = {
+    close: CloseEvent_2;
+    error: ErrorEvent_2;
+    message: MessageEvent;
+    open: Event;
+};
+export { WebSocketEventMap_2 as WebSocketEventMap }
+
 /**
  * 6.5.4. xor
  * Returns true if exactly one of the operands evaluates to true,