@medplum/core 2.0.3 → 2.0.5

package/dist/cjs/index.d.ts

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

package/dist/cjs/outcomes.d.ts

@@ -1,31 +0,0 @@
-import { OperationOutcome } from '@medplum/fhirtypes';
-export declare const allOk: OperationOutcome;
-export declare const created: OperationOutcome;
-export declare const notModified: OperationOutcome;
-export declare const notFound: OperationOutcome;
-export declare const unauthorized: OperationOutcome;
-export declare const forbidden: OperationOutcome;
-export declare const gone: OperationOutcome;
-export declare const tooManyRequests: OperationOutcome;
-export declare function badRequest(details: string, expression?: string): OperationOutcome;
-export declare function isOperationOutcome(value: unknown): value is OperationOutcome;
-export declare function isOk(outcome: OperationOutcome): boolean;
-export declare function isNotFound(outcome: OperationOutcome): boolean;
-export declare function isGone(outcome: OperationOutcome): boolean;
-export declare function getStatus(outcome: OperationOutcome): number;
-/**
- * Asserts that the operation completed successfully and that the resource is defined.
- * @param outcome The operation outcome.
- * @param resource The resource that may or may not have been returned.
- */
-export declare function assertOk<T>(outcome: OperationOutcome, resource: T | undefined): asserts resource is T;
-export declare class OperationOutcomeError extends Error {
-    readonly outcome: OperationOutcome;
-    constructor(outcome: OperationOutcome);
-}
-/**
- * Normalizes an error object into a displayable error string.
- * @param error The error value which could be a string, Error, OperationOutcome, or other unknown type.
- * @returns A display string for the error.
- */
-export declare function normalizeErrorString(error: unknown): string;

package/dist/esm/cache.d.ts

@@ -1,34 +0,0 @@
-/**
- * LRU cache (least recently used)
- * Source: https://stackoverflow.com/a/46432113
- */
-export declare class LRUCache<T> {
-    #private;
-    constructor(max?: number);
-    /**
-     * Deletes all values from the cache.
-     */
-    clear(): void;
-    /**
-     * Returns the value for the given key.
-     * @param key The key to retrieve.
-     * @returns The value if found; undefined otherwise.
-     */
-    get(key: string): T | undefined;
-    /**
-     * Sets the value for the given key.
-     * @param key The key to set.
-     * @param val The value to set.
-     */
-    set(key: string, val: T): void;
-    /**
-     * Deletes the value for the given key.
-     * @param key The key to delete.
-     */
-    delete(key: string): void;
-    /**
-     * Returns the list of all keys in the cache.
-     * @returns The array of keys in the cache.
-     */
-    keys(): IterableIterator<string>;
-}

package/dist/esm/crypto.d.ts

@@ -1,9 +0,0 @@
-/**
- * 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/esm/eventtarget.d.ts

@@ -1,13 +0,0 @@
-interface Event {
-    readonly type: string;
-    readonly defaultPrevented?: boolean;
-}
-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/esm/fhirlexer/index.d.ts

@@ -1,2 +0,0 @@
-export * from './parse';
-export * from './tokenize';

package/dist/esm/fhirlexer/parse.d.ts

@@ -1,47 +0,0 @@
-import { TypedValue } from '../types';
-import { Token } from './tokenize';
-export interface Atom {
-    eval(context: TypedValue[]): TypedValue[];
-}
-export declare abstract class PrefixOperatorAtom implements Atom {
-    readonly operator: string;
-    readonly child: Atom;
-    constructor(operator: string, child: Atom);
-    abstract eval(context: TypedValue[]): TypedValue[];
-    toString(): string;
-}
-export declare abstract class InfixOperatorAtom implements Atom {
-    readonly operator: string;
-    readonly left: Atom;
-    readonly right: Atom;
-    constructor(operator: string, left: Atom, right: Atom);
-    abstract eval(context: TypedValue[]): TypedValue[];
-    toString(): string;
-}
-export interface PrefixParselet {
-    parse(parser: Parser, token: Token): Atom;
-}
-export interface InfixParselet {
-    precedence: number;
-    parse?(parser: Parser, left: Atom, token: Token): Atom;
-}
-export declare class ParserBuilder {
-    #private;
-    registerInfix(tokenType: string, parselet: InfixParselet): ParserBuilder;
-    registerPrefix(tokenType: string, parselet: PrefixParselet): ParserBuilder;
-    prefix(tokenType: string, precedence: number, builder: (token: Token, right: Atom) => Atom): ParserBuilder;
-    infixLeft(tokenType: string, precedence: number, builder: (left: Atom, token: Token, right: Atom) => Atom): ParserBuilder;
-    construct(input: Token[]): Parser;
-}
-export declare class Parser {
-    #private;
-    constructor(tokens: Token[], prefixParselets: Record<string, PrefixParselet>, infixParselets: Record<string, InfixParselet>);
-    hasMore(): boolean;
-    match(expected: string): boolean;
-    consumeAndParse(precedence?: number): Atom;
-    getPrecedence(): number;
-    consume(expectedId?: string, expectedValue?: string): Token;
-    peek(): Token | undefined;
-    removeComments(): void;
-    getInfixParselet(token: Token): InfixParselet | undefined;
-}

package/dist/esm/fhirlexer/tokenize.d.ts

@@ -1,14 +0,0 @@
-export interface Marker {
-    index: number;
-    line: number;
-    column: number;
-}
-export interface Token extends Marker {
-    id: string;
-    value: string;
-}
-export declare class Tokenizer {
-    #private;
-    constructor(str: string, keywords: string[], operators: string[]);
-    tokenize(): Token[];
-}

package/dist/esm/fhirmapper/parse.d.ts

@@ -1,7 +0,0 @@
-import { StructureMap } from '@medplum/fhirtypes';
-/**
- * Parses a FHIR Mapping Language document into an AST.
- * @param input The FHIR Mapping Language document to parse.
- * @returns The AST representing the document.
- */
-export declare function parseMappingLanguage(input: string): StructureMap;

package/dist/esm/fhirmapper/tokenize.d.ts

@@ -1,2 +0,0 @@
-import { Token } from '../fhirlexer';
-export declare function tokenize(str: string): Token[];

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

@@ -1,120 +0,0 @@
-import { Atom, InfixOperatorAtom, PrefixOperatorAtom } from '../fhirlexer';
-import { TypedValue } from '../types';
-export declare class FhirPathAtom implements Atom {
-    readonly original: string;
-    readonly child: Atom;
-    constructor(original: string, child: Atom);
-    eval(context: TypedValue[]): TypedValue[];
-    toString(): string;
-}
-export declare class LiteralAtom implements Atom {
-    readonly value: TypedValue;
-    constructor(value: TypedValue);
-    eval(): TypedValue[];
-    toString(): string;
-}
-export declare class SymbolAtom implements Atom {
-    #private;
-    readonly name: string;
-    constructor(name: string);
-    eval(context: TypedValue[]): TypedValue[];
-    toString(): string;
-}
-export declare class EmptySetAtom implements Atom {
-    eval(): [];
-    toString(): string;
-}
-export declare class UnaryOperatorAtom extends PrefixOperatorAtom {
-    readonly impl: (x: TypedValue[]) => TypedValue[];
-    constructor(operator: string, child: Atom, impl: (x: TypedValue[]) => TypedValue[]);
-    eval(context: TypedValue[]): TypedValue[];
-    toString(): string;
-}
-export declare class AsAtom extends InfixOperatorAtom {
-    constructor(left: Atom, right: Atom);
-    eval(context: TypedValue[]): TypedValue[];
-}
-export declare class ArithemticOperatorAtom extends InfixOperatorAtom {
-    readonly impl: (x: number, y: number) => number | boolean;
-    constructor(operator: string, left: Atom, right: Atom, impl: (x: number, y: number) => number | boolean);
-    eval(context: TypedValue[]): TypedValue[];
-}
-export declare class ConcatAtom extends InfixOperatorAtom {
-    constructor(left: Atom, right: Atom);
-    eval(context: TypedValue[]): TypedValue[];
-}
-export declare class ContainsAtom extends InfixOperatorAtom {
-    constructor(left: Atom, right: Atom);
-    eval(context: TypedValue[]): TypedValue[];
-}
-export declare class InAtom extends InfixOperatorAtom {
-    constructor(left: Atom, right: Atom);
-    eval(context: TypedValue[]): TypedValue[];
-}
-export declare class DotAtom extends InfixOperatorAtom {
-    constructor(left: Atom, right: Atom);
-    eval(context: TypedValue[]): TypedValue[];
-    toString(): string;
-}
-export declare class UnionAtom extends InfixOperatorAtom {
-    constructor(left: Atom, right: Atom);
-    eval(context: TypedValue[]): TypedValue[];
-}
-export declare class EqualsAtom extends InfixOperatorAtom {
-    constructor(left: Atom, right: Atom);
-    eval(context: TypedValue[]): TypedValue[];
-}
-export declare class NotEqualsAtom extends InfixOperatorAtom {
-    constructor(left: Atom, right: Atom);
-    eval(context: TypedValue[]): TypedValue[];
-}
-export declare class EquivalentAtom extends InfixOperatorAtom {
-    constructor(left: Atom, right: Atom);
-    eval(context: TypedValue[]): TypedValue[];
-}
-export declare class NotEquivalentAtom extends InfixOperatorAtom {
-    constructor(left: Atom, right: Atom);
-    eval(context: TypedValue[]): TypedValue[];
-}
-export declare class IsAtom extends InfixOperatorAtom {
-    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 extends InfixOperatorAtom {
-    constructor(left: Atom, right: Atom);
-    eval(context: TypedValue[]): TypedValue[];
-}
-export declare class OrAtom extends InfixOperatorAtom {
-    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 extends InfixOperatorAtom {
-    constructor(left: Atom, right: Atom);
-    eval(context: TypedValue[]): TypedValue[];
-}
-export declare class FunctionAtom implements Atom {
-    readonly name: string;
-    readonly args: Atom[];
-    constructor(name: string, args: Atom[]);
-    eval(context: TypedValue[]): TypedValue[];
-    toString(): string;
-}
-export declare class IndexerAtom implements Atom {
-    readonly left: Atom;
-    readonly expr: Atom;
-    constructor(left: Atom, expr: Atom);
-    eval(context: TypedValue[]): TypedValue[];
-    toString(): string;
-}

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

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

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

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

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

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

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

@@ -1,64 +0,0 @@
-import { ParserBuilder } from '../fhirlexer';
-import { TypedValue } from '../types';
-import { FhirPathAtom } from './atoms';
-/**
- * Operator precedence
- * See: https://hl7.org/fhirpath/#operator-precedence
- */
-export declare const enum OperatorPrecedence {
-    FunctionCall = 0,
-    Dot = 1,
-    Indexer = 2,
-    UnaryAdd = 3,
-    UnarySubtract = 3,
-    Multiply = 4,
-    Divide = 4,
-    IntegerDivide = 4,
-    Modulo = 4,
-    Add = 5,
-    Subtract = 5,
-    Ampersand = 5,
-    Is = 6,
-    As = 6,
-    Union = 7,
-    GreaterThan = 8,
-    GreaterThanOrEquals = 8,
-    LessThan = 8,
-    LessThanOrEquals = 8,
-    Equals = 9,
-    Equivalent = 9,
-    NotEquals = 9,
-    NotEquivalent = 9,
-    In = 10,
-    Contains = 10,
-    And = 11,
-    Xor = 12,
-    Or = 12,
-    Implies = 13,
-    Arrow = 100,
-    Semicolon = 200
-}
-export declare function initFhirPathParserBuilder(): ParserBuilder;
-/**
- * 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 expression The FHIRPath expression to parse.
- * @param input 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 expression The FHIRPath expression to parse.
- * @param input 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/esm/fhirpath/tokenize.d.ts

@@ -1,4 +0,0 @@
-import { Token } from '../fhirlexer';
-export declare const FHIRPATH_KEYWORDS: string[];
-export declare const FHIRPATH_OPERATORS: string[];
-export declare function tokenize(str: string): Token[];

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

@@ -1,95 +0,0 @@
-import { Period, Quantity } from '@medplum/fhirtypes';
-import { TypedValue } from '../types';
-/**
- * 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/esm/format.d.ts

@@ -1,118 +0,0 @@
-import { Address, CodeableConcept, Coding, HumanName, Money, Observation, ObservationComponent, Period, Quantity, Range, Timing } from '@medplum/fhirtypes';
-export interface AddressFormatOptions {
-    all?: boolean;
-    use?: boolean;
-    lineSeparator?: string;
-}
-export interface HumanNameFormatOptions {
-    all?: boolean;
-    prefix?: boolean;
-    suffix?: boolean;
-    use?: boolean;
-}
-/**
- * Formats a FHIR Address as a string.
- * @param address The address to format.
- * @param options Optional address format options.
- * @returns The formatted address string.
- */
-export declare function formatAddress(address: Address, options?: AddressFormatOptions): string;
-/**
- * Formats a FHIR HumanName as a string.
- * @param name The name to format.
- * @param options Optional name format options.
- * @returns The formatted name string.
- */
-export declare function formatHumanName(name: HumanName, options?: HumanNameFormatOptions): string;
-/**
- * Formats the given name portion of a FHIR HumanName element.
- * @param name The name to format.
- * @returns The formatted given name string.
- */
-export declare function formatGivenName(name: HumanName): string;
-/**
- * Formats the family name portion of a FHIR HumanName element.
- * @param name The name to format.
- * @returns The formatted family name string.
- */
-export declare function formatFamilyName(name: HumanName): string;
-/**
- * Returns true if the given date object is a valid date.
- * Dates can be invalid if created by parsing an invalid string.
- * @param date A date object.
- * @returns Returns true if the date is a valid date.
- */
-export declare function isValidDate(date: Date): boolean;
-/**
- * Formats a FHIR date string as a human readable string.
- * Handles missing values and invalid dates.
- * @param date The date to format.
- * @param locales Optional locales.
- * @param options Optional date format options.
- * @returns The formatted date string.
- */
-export declare function formatDate(date: string | undefined, locales?: Intl.LocalesArgument, options?: Intl.DateTimeFormatOptions | undefined): string;
-/**
- * Formats a FHIR time string as a human readable string.
- * Handles missing values and invalid dates.
- * @param time The date to format.
- * @param locales Optional locales.
- * @param options Optional time format options.
- * @returns The formatted time string.
- */
-export declare function formatTime(time: string | undefined, locales?: Intl.LocalesArgument, options?: Intl.DateTimeFormatOptions | undefined): string;
-/**
- * Formats a FHIR dateTime string as a human readable string.
- * Handles missing values and invalid dates.
- * @param dateTime The dateTime to format.
- * @param locales Optional locales.
- * @param options Optional dateTime format options.
- * @returns The formatted dateTime string.
- */
-export declare function formatDateTime(dateTime: string | undefined, locales?: Intl.LocalesArgument, options?: Intl.DateTimeFormatOptions | undefined): string;
-/**
- * Formats a FHIR Period as a human readable string.
- * @param period The period to format.
- * @param locales Optional locales.
- * @param options Optional period format options.
- * @returns The formatted period string.
- */
-export declare function formatPeriod(period: Period | undefined, locales?: Intl.LocalesArgument, options?: Intl.DateTimeFormatOptions | undefined): string;
-/**
- * Formats a FHIR Timing as a human readable string.
- * @param timing The timing to format.
- * @returns The formatted timing string.
- */
-export declare function formatTiming(timing: Timing | undefined): string;
-/**
- * Returns a human-readable string for a FHIR Range datatype, taking into account comparators and one-sided ranges
- * @param range A FHIR Range element
- * @param exclusive If true, one-sided ranges will be rendered with the '>' or '<' bounds rather than '>=' or '<='
- * @returns A human-readable string representation of the Range
- */
-export declare function formatRange(range: Range | undefined, precision?: number, exclusive?: boolean): string;
-/**
- * Returns a human-readable string for a FHIR Quantity datatype, taking into account units and comparators
- * @param quantity A FHIR Quantity element
- * @returns A human-readable string representation of the Quantity
- */
-export declare function formatQuantity(quantity: Quantity | undefined, precision?: number): string;
-export declare function formatMoney(money: Money | undefined): string;
-/**
- * Formats a CodeableConcept element as a string.
- * @param codeableConcept A FHIR CodeableConcept element
- * @returns The codeable concept as a string.
- */
-export declare function formatCodeableConcept(codeableConcept: CodeableConcept | undefined): string;
-/**
- * Formats a Coding element as a string.
- * @param coding A FHIR Coding element
- * @returns The coding as a string.
- */
-export declare function formatCoding(coding: Coding | undefined): string;
-/**
- * Formats a FHIR Observation resource value as a string.
- * @param obs A FHIR Observation resource.
- * @returns A human-readable string representation of the Observation.
- */
-export declare function formatObservationValue(obs: Observation | ObservationComponent | undefined): string;