@medplum/core 1.0.4 → 1.0.5

package/dist/cjs/client.d.ts

@@ -181,6 +181,7 @@ export interface GoogleLoginRequest extends BaseLoginRequest {
 }
 export interface LoginAuthenticationResponse {
     readonly login: string;
+    readonly mfaRequired?: boolean;
     readonly code?: string;
     readonly memberships?: ProjectMembership[];
 }

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

@@ -3,12 +3,27 @@ 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;
+    parse?(parser: Parser, left: Atom, token: Token): Atom;
 }
 export declare class ParserBuilder {
     #private;
@@ -25,7 +40,8 @@ export declare class Parser {
     match(expected: string): boolean;
     consumeAndParse(precedence?: number): Atom;
     getPrecedence(): number;
-    consume(expected?: string): Token;
+    consume(expectedId?: string, expectedValue?: string): Token;
     peek(): Token | undefined;
     removeComments(): void;
+    getInfixParselet(token: Token): InfixParselet | undefined;
 }

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

@@ -1,7 +1,7 @@
-import { Atom } from '../fhirlexer';
+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): Atom[];
+export declare function parseMappingLanguage(input: string): StructureMap;

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

@@ -1,102 +1,82 @@
-import { Atom } from '../fhirlexer';
+import { Atom, InfixOperatorAtom, PrefixOperatorAtom } from '../fhirlexer';
 import { TypedValue } from '../types';
-import { FhirPathFunction } from './functions';
 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 implements Atom {
-    readonly child: Atom;
+export declare class UnaryOperatorAtom extends PrefixOperatorAtom {
     readonly impl: (x: TypedValue[]) => TypedValue[];
-    constructor(child: Atom, impl: (x: TypedValue[]) => TypedValue[]);
+    constructor(operator: string, child: Atom, impl: (x: TypedValue[]) => TypedValue[]);
     eval(context: TypedValue[]): TypedValue[];
+    toString(): string;
 }
-export declare class AsAtom implements Atom {
-    readonly left: Atom;
-    readonly right: Atom;
+export declare class AsAtom extends InfixOperatorAtom {
     constructor(left: Atom, right: Atom);
     eval(context: TypedValue[]): TypedValue[];
 }
-export declare class ArithemticOperatorAtom implements Atom {
-    readonly left: Atom;
-    readonly right: Atom;
+export declare class ArithemticOperatorAtom extends InfixOperatorAtom {
     readonly impl: (x: number, y: number) => number | boolean;
-    constructor(left: Atom, right: Atom, 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 implements Atom {
-    readonly left: Atom;
-    readonly right: Atom;
+export declare class ConcatAtom extends InfixOperatorAtom {
     constructor(left: Atom, right: Atom);
     eval(context: TypedValue[]): TypedValue[];
 }
-export declare class ContainsAtom implements Atom {
-    readonly left: Atom;
-    readonly right: Atom;
+export declare class ContainsAtom extends InfixOperatorAtom {
     constructor(left: Atom, right: Atom);
     eval(context: TypedValue[]): TypedValue[];
 }
-export declare class InAtom implements Atom {
-    readonly left: Atom;
-    readonly right: Atom;
+export declare class InAtom extends InfixOperatorAtom {
     constructor(left: Atom, right: Atom);
     eval(context: TypedValue[]): TypedValue[];
 }
-export declare class DotAtom implements Atom {
-    readonly left: Atom;
-    readonly right: Atom;
+export declare class DotAtom extends InfixOperatorAtom {
     constructor(left: Atom, right: Atom);
     eval(context: TypedValue[]): TypedValue[];
+    toString(): string;
 }
-export declare class UnionAtom implements Atom {
-    readonly left: Atom;
-    readonly right: Atom;
+export declare class UnionAtom extends InfixOperatorAtom {
     constructor(left: Atom, right: Atom);
     eval(context: TypedValue[]): TypedValue[];
 }
-export declare class EqualsAtom implements Atom {
-    readonly left: Atom;
-    readonly right: Atom;
+export declare class EqualsAtom extends InfixOperatorAtom {
     constructor(left: Atom, right: Atom);
     eval(context: TypedValue[]): TypedValue[];
 }
-export declare class NotEqualsAtom implements Atom {
-    readonly left: Atom;
-    readonly right: Atom;
+export declare class NotEqualsAtom extends InfixOperatorAtom {
     constructor(left: Atom, right: Atom);
     eval(context: TypedValue[]): TypedValue[];
 }
-export declare class EquivalentAtom implements Atom {
-    readonly left: Atom;
-    readonly right: Atom;
+export declare class EquivalentAtom extends InfixOperatorAtom {
     constructor(left: Atom, right: Atom);
     eval(context: TypedValue[]): TypedValue[];
 }
-export declare class NotEquivalentAtom implements Atom {
-    readonly left: Atom;
-    readonly right: Atom;
+export declare class NotEquivalentAtom extends InfixOperatorAtom {
     constructor(left: Atom, right: Atom);
     eval(context: TypedValue[]): TypedValue[];
 }
-export declare class IsAtom implements Atom {
-    readonly left: Atom;
-    readonly right: Atom;
+export declare class IsAtom extends InfixOperatorAtom {
     constructor(left: Atom, right: Atom);
     eval(context: TypedValue[]): TypedValue[];
 }
@@ -106,15 +86,11 @@ export declare class IsAtom implements Atom {
  * false if either operand evaluates to false,
  * and the empty collection otherwise.
  */
-export declare class AndAtom implements Atom {
-    readonly left: Atom;
-    readonly right: Atom;
+export declare class AndAtom extends InfixOperatorAtom {
     constructor(left: Atom, right: Atom);
     eval(context: TypedValue[]): TypedValue[];
 }
-export declare class OrAtom implements Atom {
-    readonly left: Atom;
-    readonly right: Atom;
+export declare class OrAtom extends InfixOperatorAtom {
     constructor(left: Atom, right: Atom);
     eval(context: TypedValue[]): TypedValue[];
 }
@@ -124,22 +100,21 @@ export declare class OrAtom implements Atom {
  * 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;
+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[];
-    readonly impl: FhirPathFunction;
-    constructor(name: string, args: Atom[], impl: FhirPathFunction);
+    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/cjs/fhirpath/parse.d.ts

@@ -1,6 +1,43 @@
 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.