@medplum/core 0.9.28 → 0.9.31

package/dist/cjs/crypto.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Returns a cryptographically secure random string.
+ */
+export declare function getRandomString(): string;
+/**
+ * Encrypts a string with SHA256 encryption.
+ * @param str
+ */
+export declare function encryptSHA256(str: string): Promise<ArrayBuffer>;

package/dist/cjs/eventtarget.d.ts

@@ -0,0 +1,13 @@
+interface Event {
+    readonly type: string;
+    readonly defaultPrevented?: boolean;
+}
+declare type EventListener = (e: Event) => void;
+export declare class EventTarget {
+    #private;
+    constructor();
+    addEventListener(type: string, callback: EventListener): void;
+    removeEventListeneer(type: string, callback: EventListener): void;
+    dispatchEvent(event: Event): boolean;
+}
+export {};

package/dist/cjs/fhirpath/atoms.d.ts

@@ -0,0 +1,150 @@
+import { FhirPathFunction } from './functions';
+export interface TypedValue {
+    readonly type: string;
+    readonly value: any;
+}
+export interface Atom {
+    eval(context: TypedValue[]): TypedValue[];
+}
+export declare class FhirPathAtom implements Atom {
+    readonly original: string;
+    readonly child: Atom;
+    constructor(original: string, child: Atom);
+    eval(context: TypedValue[]): TypedValue[];
+}
+export declare class LiteralAtom implements Atom {
+    readonly value: TypedValue;
+    constructor(value: TypedValue);
+    eval(): TypedValue[];
+}
+export declare class SymbolAtom implements Atom {
+    #private;
+    readonly name: string;
+    constructor(name: string);
+    eval(context: TypedValue[]): TypedValue[];
+}
+export declare class EmptySetAtom implements Atom {
+    eval(): [];
+}
+export declare class UnaryOperatorAtom implements Atom {
+    readonly child: Atom;
+    readonly impl: (x: TypedValue[]) => TypedValue[];
+    constructor(child: Atom, impl: (x: TypedValue[]) => TypedValue[]);
+    eval(context: TypedValue[]): TypedValue[];
+}
+export declare class AsAtom implements Atom {
+    readonly left: Atom;
+    readonly right: Atom;
+    constructor(left: Atom, right: Atom);
+    eval(context: TypedValue[]): TypedValue[];
+}
+export declare class ArithemticOperatorAtom implements Atom {
+    readonly left: Atom;
+    readonly right: Atom;
+    readonly impl: (x: number, y: number) => number | boolean;
+    constructor(left: Atom, right: Atom, impl: (x: number, y: number) => number | boolean);
+    eval(context: TypedValue[]): TypedValue[];
+}
+export declare class ConcatAtom implements Atom {
+    readonly left: Atom;
+    readonly right: Atom;
+    constructor(left: Atom, right: Atom);
+    eval(context: TypedValue[]): TypedValue[];
+}
+export declare class ContainsAtom implements Atom {
+    readonly left: Atom;
+    readonly right: Atom;
+    constructor(left: Atom, right: Atom);
+    eval(context: TypedValue[]): TypedValue[];
+}
+export declare class InAtom implements Atom {
+    readonly left: Atom;
+    readonly right: Atom;
+    constructor(left: Atom, right: Atom);
+    eval(context: TypedValue[]): TypedValue[];
+}
+export declare class DotAtom implements Atom {
+    readonly left: Atom;
+    readonly right: Atom;
+    constructor(left: Atom, right: Atom);
+    eval(context: TypedValue[]): TypedValue[];
+}
+export declare class UnionAtom implements Atom {
+    readonly left: Atom;
+    readonly right: Atom;
+    constructor(left: Atom, right: Atom);
+    eval(context: TypedValue[]): TypedValue[];
+}
+export declare class EqualsAtom implements Atom {
+    readonly left: Atom;
+    readonly right: Atom;
+    constructor(left: Atom, right: Atom);
+    eval(context: TypedValue[]): TypedValue[];
+}
+export declare class NotEqualsAtom implements Atom {
+    readonly left: Atom;
+    readonly right: Atom;
+    constructor(left: Atom, right: Atom);
+    eval(context: TypedValue[]): TypedValue[];
+}
+export declare class EquivalentAtom implements Atom {
+    readonly left: Atom;
+    readonly right: Atom;
+    constructor(left: Atom, right: Atom);
+    eval(context: TypedValue[]): TypedValue[];
+}
+export declare class NotEquivalentAtom implements Atom {
+    readonly left: Atom;
+    readonly right: Atom;
+    constructor(left: Atom, right: Atom);
+    eval(context: TypedValue[]): TypedValue[];
+}
+export declare class IsAtom implements Atom {
+    readonly left: Atom;
+    readonly right: Atom;
+    constructor(left: Atom, right: Atom);
+    eval(context: TypedValue[]): TypedValue[];
+}
+/**
+ * 6.5.1. and
+ * Returns true if both operands evaluate to true,
+ * false if either operand evaluates to false,
+ * and the empty collection otherwise.
+ */
+export declare class AndAtom implements Atom {
+    readonly left: Atom;
+    readonly right: Atom;
+    constructor(left: Atom, right: Atom);
+    eval(context: TypedValue[]): TypedValue[];
+}
+export declare class OrAtom implements Atom {
+    readonly left: Atom;
+    readonly right: Atom;
+    constructor(left: Atom, right: Atom);
+    eval(context: TypedValue[]): TypedValue[];
+}
+/**
+ * 6.5.4. xor
+ * Returns true if exactly one of the operands evaluates to true,
+ * false if either both operands evaluate to true or both operands evaluate to false,
+ * and the empty collection otherwise.
+ */
+export declare class XorAtom implements Atom {
+    readonly left: Atom;
+    readonly right: Atom;
+    constructor(left: Atom, right: Atom);
+    eval(context: TypedValue[]): TypedValue[];
+}
+export declare class FunctionAtom implements Atom {
+    readonly name: string;
+    readonly args: Atom[];
+    readonly impl: FhirPathFunction;
+    constructor(name: string, args: Atom[], impl: FhirPathFunction);
+    eval(context: TypedValue[]): TypedValue[];
+}
+export declare class IndexerAtom implements Atom {
+    readonly left: Atom;
+    readonly expr: Atom;
+    constructor(left: Atom, expr: Atom);
+    eval(context: TypedValue[]): TypedValue[];
+}

package/dist/cjs/fhirpath/date.d.ts

@@ -0,0 +1 @@
+export declare function parseDateString(str: string): string;

package/dist/cjs/fhirpath/functions.d.ts

@@ -0,0 +1,5 @@
+import { Atom, TypedValue } from './atoms';
+export interface FhirPathFunction {
+    (input: TypedValue[], ...args: Atom[]): TypedValue[];
+}
+export declare const functions: Record<string, FhirPathFunction>;

package/dist/cjs/fhirpath/index.d.ts

@@ -0,0 +1,4 @@
+export * from './atoms';
+export * from './parse';
+export * from './tokenize';
+export * from './utils';

package/dist/cjs/fhirpath/parse.d.ts

@@ -0,0 +1,24 @@
+import { FhirPathAtom, TypedValue } from './atoms';
+/**
+ * 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;
+/**
+ * Evaluates a FHIRPath expression against a resource or other object.
+ * @param input The FHIRPath expression to parse.
+ * @param context 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 input The FHIRPath expression to parse.
+ * @param context The resource or object to evaluate the expression against.
+ * @returns The result of the FHIRPath expression against the resource or object.
+ */
+export declare function evalFhirPathTyped(expression: string, input: TypedValue[]): TypedValue[];

package/dist/cjs/fhirpath/tokenize.d.ts

@@ -0,0 +1,5 @@
+export interface Token {
+    id: string;
+    value: string;
+}
+export declare function tokenize(str: string): Token[];

package/dist/cjs/fhirpath/utils.d.ts

@@ -0,0 +1,95 @@
+import { Period, Quantity } from '@medplum/fhirtypes';
+import { TypedValue } from './atoms';
+/**
+ * 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];
+/**
+ * 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;
+/**
+ * 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;
+/**
+ * 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;
+/**
+ * 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[];
+/**
+ * Returns a negated FHIRPath boolean expression.
+ * @param input The input array.
+ * @returns The negated type value array.
+ */
+export declare function fhirPathNot(input: TypedValue[]): TypedValue[];
+/**
+ * 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 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 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[];
+/**
+ * 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;
+/**
+ * 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;
+/**
+ * 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;

package/dist/cjs/format.d.ts

@@ -0,0 +1,21 @@
+import { Address, HumanName, Period, Timing } from '@medplum/fhirtypes';
+export interface AddressFormatOptions {
+    all?: boolean;
+    use?: boolean;
+}
+export interface HumanNameFormatOptions {
+    all?: boolean;
+    prefix?: boolean;
+    suffix?: boolean;
+    use?: boolean;
+}
+export declare function formatAddress(address: Address, options?: AddressFormatOptions): string;
+export declare function formatHumanName(name: HumanName, options?: HumanNameFormatOptions): string;
+export declare function formatGivenName(name: HumanName): string;
+export declare function formatFamilyName(name: HumanName): string;
+export declare function isValidDate(date: Date): boolean;
+export declare function formatDate(date: string | undefined, options?: Intl.DateTimeFormatOptions): string;
+export declare function formatTime(time: string | undefined, options?: Intl.DateTimeFormatOptions): string;
+export declare function formatDateTime(dateTime: string | undefined, options?: Intl.DateTimeFormatOptions): string;
+export declare function formatPeriod(period: Period | undefined): string;
+export declare function formatTiming(timing: Timing | undefined): string;

package/dist/cjs/hl7.d.ts

@@ -0,0 +1,43 @@
+export declare const SEGMENT_SEPARATOR = "\r";
+export declare const FIELD_SEPARATOR = "|";
+export declare const COMPONENT_SEPARATOR = "^";
+/**
+ * The Hl7Message class represents one HL7 message.
+ * A message is a collection of segments.
+ * Note that we do not strictly parse messages, and only use default delimeters.
+ */
+export declare class Hl7Message {
+    readonly segments: Hl7Segment[];
+    constructor(segments: Hl7Segment[]);
+    get(index: number | string): Hl7Segment | undefined;
+    getAll(name: string): Hl7Segment[];
+    toString(): string;
+    buildAck(): Hl7Message;
+    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.
+ * Note that we do not strictly parse messages, and only use default delimeters.
+ */
+export declare class Hl7Segment {
+    readonly name: string;
+    readonly fields: Hl7Field[];
+    constructor(fields: Hl7Field[] | string[]);
+    get(index: number): Hl7Field;
+    toString(): string;
+    static parse(text: string): Hl7Segment;
+}
+/**
+ * The Hl7Field class represents one HL7 field.
+ * A field is a collection of components.
+ * Note that we do not strictly parse messages, and only use default delimeters.
+ */
+export declare class Hl7Field {
+    readonly components: string[];
+    constructor(components: string[]);
+    get(index: number): string;
+    toString(): string;
+    static parse(text: string): Hl7Field;
+}

package/dist/cjs/index.d.ts

@@ -0,0 +1,12 @@
+export * from './cache';
+export * from './client';
+export * from './fhirpath';
+export * from './format';
+export * from './hl7';
+export * from './jwt';
+export * from './outcomes';
+export * from './readablepromise';
+export * from './search';
+export * from './searchparams';
+export * from './types';
+export * from './utils';