@medplum/core 0.9.35 → 0.9.36

package/dist/cjs/client.d.ts

@@ -461,6 +461,10 @@ export declare class MedplumClient extends EventTarget {
      * @returns Promise to the authentication response.
      */
     startGoogleLogin(loginRequest: GoogleLoginRequest): Promise<LoginAuthenticationResponse>;
+    getCodeChallenge(loginRequest: LoginRequest | GoogleLoginRequest): {
+        codeChallenge?: string;
+        codeChallengeMethod?: string;
+    };
     /**
      * Signs out locally.
      * Does not invalidate tokens with the server.
@@ -623,7 +627,7 @@ export declare class MedplumClient extends EventTarget {
      * @param id The resource ID.
      * @returns The resource if available; undefined otherwise.
      */
-    readResource<K extends ResourceType>(resourceType: K, id: string): ReadablePromise<ExtractResource<K>>;
+    readResource<K extends ResourceType>(resourceType: K, id: string, options?: RequestInit): ReadablePromise<ExtractResource<K>>;
     /**
      * Reads a resource by `Reference`.
      *
@@ -643,7 +647,7 @@ export declare class MedplumClient extends EventTarget {
      * @param reference The FHIR reference object.
      * @returns The resource if available; undefined otherwise.
      */
-    readReference<T extends Resource>(reference: Reference<T>): ReadablePromise<T>;
+    readReference<T extends Resource>(reference: Reference<T>, options?: RequestInit): ReadablePromise<T>;
     /**
      * Returns a cached schema for a resource type.
      * If the schema is not cached, returns undefined.
@@ -681,7 +685,7 @@ export declare class MedplumClient extends EventTarget {
      * @param id The resource ID.
      * @returns Promise to the resource history.
      */
-    readHistory<K extends ResourceType>(resourceType: K, id: string): ReadablePromise<Bundle<ExtractResource<K>>>;
+    readHistory<K extends ResourceType>(resourceType: K, id: string, options?: RequestInit): ReadablePromise<Bundle<ExtractResource<K>>>;
     /**
      * Reads a specific version of a resource by resource type, ID, and version ID.
      *
@@ -699,14 +703,14 @@ export declare class MedplumClient extends EventTarget {
      * @param id The resource ID.
      * @returns The resource if available; undefined otherwise.
      */
-    readVersion<K extends ResourceType>(resourceType: K, id: string, vid: string): ReadablePromise<ExtractResource<K>>;
+    readVersion<K extends ResourceType>(resourceType: K, id: string, vid: string, options?: RequestInit): ReadablePromise<ExtractResource<K>>;
     /**
      *
      * @category Read
      * @param id The Patient Id
      * @returns A Bundle of all Resources related to the Patient
      */
-    readPatientEverything(id: string): ReadablePromise<Bundle>;
+    readPatientEverything(id: string, options?: RequestInit): ReadablePromise<Bundle>;
     /**
      * Creates a new FHIR resource.
      *
@@ -1094,6 +1098,11 @@ export declare class MedplumClient extends EventTarget {
      * @returns Promise to the response body as a blob.
      */
     download(url: URL | string, options?: RequestInit): Promise<Blob>;
+    /**
+     * Starts a new PKCE flow.
+     * These PKCE values are stateful, and must survive redirects and page refreshes.
+     */
+    startPkce(): Promise<void>;
     /**
      * Processes an OAuth authorization code.
      * See: https://openid.net/specs/openid-connect-core-1_0.html#TokenRequest

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

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

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

@@ -0,0 +1,31 @@
+import { TypedValue } from '../types';
+import { Token } from './tokenize';
+export interface Atom {
+    eval(context: TypedValue[]): TypedValue[];
+}
+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(expected?: string): Token;
+    peek(): Token | undefined;
+    removeComments(): void;
+}

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

@@ -0,0 +1,14 @@
+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/cjs/fhirmapper/atoms.d.ts

@@ -0,0 +1,67 @@
+import { Atom } from '../fhirlexer';
+declare abstract class DefaultFhirMapperAtom implements Atom {
+    eval(): never;
+}
+export declare class MappingLanguageAtom extends DefaultFhirMapperAtom {
+    readonly original: string;
+    readonly child: Atom;
+    constructor(original: string, child: Atom);
+}
+export declare class MapAtom extends DefaultFhirMapperAtom {
+    readonly url: string;
+    readonly identifier: string;
+    constructor(url: string, identifier: string);
+}
+export declare class UsesAtom extends DefaultFhirMapperAtom {
+    readonly url: string;
+    readonly modelMode: string;
+    constructor(url: string, modelMode: string);
+}
+export declare class GroupAtom extends DefaultFhirMapperAtom {
+    readonly identifier: string;
+    readonly parameters: ParameterAtom[];
+    readonly rules: RuleAtom[];
+    constructor(identifier: string, parameters: ParameterAtom[], rules: RuleAtom[]);
+}
+export declare class ParameterAtom extends DefaultFhirMapperAtom {
+    readonly inputMode: string;
+    readonly identifier: string;
+    readonly type: string;
+    constructor(inputMode: string, identifier: string, type: string);
+}
+export declare class RuleAtom extends DefaultFhirMapperAtom {
+    readonly sources: RuleSourceAtom[];
+    readonly targets: RuleTargetAtom[] | undefined;
+    readonly dependent: RuleDependentAtom | undefined;
+    readonly name: string | undefined;
+    constructor(sources: RuleSourceAtom[], targets: RuleTargetAtom[] | undefined, dependent: RuleDependentAtom | undefined, name: string | undefined);
+}
+export declare class RuleSourceAtom extends DefaultFhirMapperAtom {
+    readonly context: string | undefined;
+    readonly sourceType: string | undefined;
+    readonly sourceDefault: Atom | undefined;
+    readonly sourceListMode: string | undefined;
+    readonly alias: string | undefined;
+    readonly whereClause: Atom | undefined;
+    readonly checkClause: Atom | undefined;
+    readonly log: Atom | undefined;
+    constructor(context: string | undefined, sourceType: string | undefined, sourceDefault: Atom | undefined, sourceListMode: string | undefined, alias: string | undefined, whereClause: Atom | undefined, checkClause: Atom | undefined, log: Atom | undefined);
+}
+export declare class RuleTargetAtom extends DefaultFhirMapperAtom {
+    readonly context: string;
+    readonly transform: Atom | undefined;
+    readonly alias: string | undefined;
+    readonly targetListMode: string | undefined;
+    constructor(context: string, transform: Atom | undefined, alias: string | undefined, targetListMode: string | undefined);
+}
+export declare class RuleInvocationAtom extends DefaultFhirMapperAtom {
+    readonly identifier: string;
+    readonly parameters: Atom[];
+    constructor(identifier: string, parameters: Atom[]);
+}
+export declare class RuleDependentAtom extends DefaultFhirMapperAtom {
+    readonly invocation: RuleInvocationAtom;
+    readonly rules: RuleAtom[];
+    constructor(invocation: RuleInvocationAtom, rules: RuleAtom[]);
+}
+export {};

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

@@ -0,0 +1,7 @@
+import { Atom } from '../fhirlexer';
+/**
+ * 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[];

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

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

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

@@ -1,11 +1,6 @@
+import { Atom } from '../fhirlexer';
+import { TypedValue } from '../types';
 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;

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

@@ -1,4 +1,5 @@
-import { Atom, TypedValue } from './atoms';
+import { Atom } from '../fhirlexer';
+import { TypedValue } from '../types';
 export interface FhirPathFunction {
     (input: TypedValue[], ...args: Atom[]): TypedValue[];
 }

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

@@ -1,4 +1,7 @@
-import { FhirPathAtom, TypedValue } from './atoms';
+import { ParserBuilder } from '../fhirlexer';
+import { TypedValue } from '../types';
+import { FhirPathAtom } from './atoms';
+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.
@@ -10,15 +13,15 @@ import { FhirPathAtom, TypedValue } from './atoms';
 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.
+ * @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 input The FHIRPath expression to parse.
- * @param context The resource or object to evaluate the expression against.
+ * @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/cjs/fhirpath/tokenize.d.ts

@@ -1,5 +1,4 @@
-export interface Token {
-    id: string;
-    value: string;
-}
+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/cjs/fhirpath/utils.d.ts

@@ -1,5 +1,5 @@
 import { Period, Quantity } from '@medplum/fhirtypes';
-import { TypedValue } from './atoms';
+import { TypedValue } from '../types';
 /**
  * Returns a single element array with a typed boolean value.
  * @param value The primitive boolean value.