@ovok/core 0.2.53 → 0.2.55

package/dist/hooks/index.js

@@ -1,4 +1,5 @@
 "use strict";
+"use client";
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     var desc = Object.getOwnPropertyDescriptor(m, k);
@@ -34,6 +35,19 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.OvokProvider = exports.useClient = exports.useCachedBinaryUrl = exports.reactContext = exports.useSubscription = exports.useSearchResources = exports.useSearchOne = exports.useSearch = exports.useResource = exports.usePrevious = exports.useMedplumProfile = exports.useMedplumNavigate = exports.useMedplumContext = void 0;
+/*
+ * The only React-dependent module in the package.
+ *
+ * `@medplum/react-hooks` calls `createContext` at module scope, which does not
+ * exist in React's server build — so without this directive, importing
+ * anything from the package barrel crashes a React Server Component with
+ * `createContext is not a function`, including the plain, React-free
+ * `OvokClient` that most server-side callers actually want.
+ *
+ * The directive moves this module into the client graph. A server component
+ * may then import the barrel freely; only the hooks and provider below
+ * require a client component, which is where they were always usable.
+ */
 const react_hooks_1 = require("@medplum/react-hooks");
 const React = __importStar(require("react"));
 var react_hooks_2 = require("@medplum/react-hooks");

package/dist/index.d.ts

@@ -2,20 +2,28 @@ import * as MedplumCore from "@medplum/core";
 export * from "./types";
 declare const Medplum: {
     accepted(location: string): import("@medplum/fhirtypes").OperationOutcome;
+    accessPolicySupportsInteraction(accessPolicy: import("@medplum/fhirtypes").AccessPolicy, interaction: MedplumCore.AccessPolicyInteraction, resourceType: import("@medplum/fhirtypes").ResourceType): boolean;
+    add(object: any, operation: MedplumCore.AddOperation, options?: MedplumCore.PatchOptions): MedplumCore.MissingError | null;
+    addPreferredPharmacyToPatient(patient: import("@medplum/fhirtypes").Patient, orgRef: import("@medplum/fhirtypes").Reference<import("@medplum/fhirtypes").Organization>, isPrimary: boolean, preferenceTypeSystem?: string): import("@medplum/fhirtypes").Patient;
     addProfileToResource<T extends import("@medplum/fhirtypes").Resource = import("@medplum/fhirtypes").Resource>(resource: T, profileUrl: string): T;
     append<T>(array: T[] | undefined, value: T): T[];
+    apply(object: any, operation: MedplumCore.Operation, options?: MedplumCore.PatchOptions): MedplumCore.MissingError | MedplumCore.InvalidOperationError | MedplumCore.TestError | null;
     applyDefaultValuesToElement(existingValue: object, elements: Record<string, MedplumCore.InternalSchemaElement>, key?: string): object;
     applyDefaultValuesToResource(resource: import("@medplum/fhirtypes").Resource, schema: MedplumCore.InternalTypeSchema): import("@medplum/fhirtypes").Resource;
     applyFixedOrPatternValue(inputValue: any, key: string, element: MedplumCore.InternalSchemaElement, elements: Record<string, MedplumCore.InternalSchemaElement>): any;
+    applyPatch(object: any, patch: MedplumCore.Operation[], options?: MedplumCore.PatchOptions): (null | MedplumCore.MissingError | MedplumCore.InvalidOperationError | MedplumCore.TestError)[];
     arrayBufferToBase64(arrayBuffer: ArrayBufferLike | ArrayBufferView): string;
     arrayBufferToHex(arrayBuffer: ArrayBufferLike | ArrayBufferView): string;
+    arrayify<T>(value: NonNullable<T> | NonNullable<T>[]): T[];
     arrayify<T>(value: T | T[] | undefined): T[] | undefined;
-    assert(condition: unknown, msg?: string): asserts condition;
     assertContextVersionOptional(event: string): asserts event is MedplumCore.FhircastEventVersionOptional;
+    assertNever(value: never): never;
     assertOk<T>(outcome: import("@medplum/fhirtypes").OperationOutcome, resource: T | undefined): asserts resource is T;
     assertReleaseManifest(candidate: unknown): asserts candidate is MedplumCore.ReleaseManifest;
-    badRequest(details: string, expression?: string): import("@medplum/fhirtypes").OperationOutcome;
+    assertValidMedplumSemver(version: string): asserts version is MedplumCore.MedplumSemver;
+    badRequest(details: string, expression?: string | string[]): import("@medplum/fhirtypes").OperationOutcome;
     booleanToTypedValue(value: boolean): [MedplumCore.TypedValue];
+    buildCdsRequest(medplum: MedplumCore.MedplumClient, user: MedplumCore.CdsUserResource, service: MedplumCore.CdsService, context: Record<string, unknown>): Promise<MedplumCore.CdsRequest>;
     buildElementsContext({ parentContext, path, elements, profileUrl, debugMode, accessPolicyResource, }: {
         parentContext: MedplumCore.ElementsContextType | undefined;
         path: string;
@@ -24,7 +32,9 @@ declare const Medplum: {
         debugMode?: boolean;
         accessPolicyResource?: import("@medplum/fhirtypes").AccessPolicyResource;
     }): MedplumCore.ElementsContextType | undefined;
+    buildMedicationRequestResponseLostStatusReason(): import("@medplum/fhirtypes").CodeableConcept;
     buildTypeName(components: string[]): string;
+    businessRule(key: string, message: string): import("@medplum/fhirtypes").OperationOutcome;
     calculateAge(birthDateStr: string, endDateStr?: string): {
         years: number;
         months: number;
@@ -38,41 +48,68 @@ declare const Medplum: {
     checkForNull(value: unknown, path: string, issues: import("@medplum/fhirtypes").OperationOutcomeIssue[]): void;
     checkIfValidMedplumVersion(appName: string, version: string): Promise<boolean>;
     clearReleaseCache(): void;
+    clearScheduleParameter(schedule: import("@medplum/fhirtypes").Schedule, service: MedplumCore.WithId<import("@medplum/fhirtypes").HealthcareService>, url: string): import("@medplum/fhirtypes").Schedule;
+    codeableConceptMatchesToken(codeableConcept: import("@medplum/fhirtypes").CodeableConcept, token: string): boolean;
+    codingMatchesToken(coding: import("@medplum/fhirtypes").Coding, token: string): boolean;
+    compareVersions(a: MedplumCore.MedplumSemver, b: MedplumCore.MedplumSemver): number;
     compressElement(element: MedplumCore.InternalSchemaElement): Partial<MedplumCore.InternalSchemaElement>;
     concatUrls(baseUrl: string | URL, path: string): string;
     conceptMapTranslate(map: import("@medplum/fhirtypes").ConceptMap, params: MedplumCore.ConceptMapTranslateParameters): MedplumCore.ConceptMapTranslateOutput;
     conflict(details: string, code?: string): import("@medplum/fhirtypes").OperationOutcome;
+    contentTooLarge(text: string): import("@medplum/fhirtypes").OperationOutcome;
     convertContainedResourcesToBundle(resource: import("@medplum/fhirtypes").Resource & {
         contained?: import("@medplum/fhirtypes").Resource[];
     }): import("@medplum/fhirtypes").Bundle;
+    convertToSearchableDates(typedValues: MedplumCore.TypedValue[]): import("@medplum/fhirtypes").Period[];
+    convertToSearchableNumbers(typedValues: MedplumCore.TypedValue[]): [number | undefined, number | undefined][];
+    convertToSearchableQuantities(typedValues: MedplumCore.TypedValue[]): import("@medplum/fhirtypes").Quantity[];
+    convertToSearchableReferences(typedValues: MedplumCore.TypedValue[]): string[];
+    convertToSearchableStrings(typedValues: MedplumCore.TypedValue[]): string[];
+    convertToSearchableTokens(typedValues: MedplumCore.TypedValue[], context?: MedplumCore.TokensContext): MedplumCore.SearchableToken[];
+    convertToSearchableUris(typedValues: MedplumCore.TypedValue[]): string[];
     convertToTransactionBundle(bundle: import("@medplum/fhirtypes").Bundle): import("@medplum/fhirtypes").Bundle;
-    crawlResource(resource: import("@medplum/fhirtypes").Resource, visitor: MedplumCore.CrawlerVisitor, schema?: MedplumCore.InternalTypeSchema, initialPath?: string): void;
-    crawlResource(resource: import("@medplum/fhirtypes").Resource, visitor: MedplumCore.AsyncCrawlerVisitor, options: MedplumCore.CrawlerOptions): Promise<void>;
-    crawlResource(resource: import("@medplum/fhirtypes").Resource, visitor: MedplumCore.CrawlerVisitor, options?: MedplumCore.CrawlerOptions): void;
-    crawlResourceAsync(resource: import("@medplum/fhirtypes").Resource, visitor: MedplumCore.AsyncCrawlerVisitor, options: MedplumCore.CrawlerOptions): Promise<void>;
+    copy(object: any, operation: MedplumCore.CopyOperation, _options?: MedplumCore.PatchOptions): MedplumCore.MissingError | null;
+    countBy<T, K extends keyof any>(items: Iterable<T>, keyFn: (value: T) => K): Partial<Record<K, number>>;
+    countWhere<T>(items: Iterable<T>, fn: (value: T) => boolean): number;
     crawlTypedValue(typedValue: MedplumCore.TypedValue, visitor: MedplumCore.CrawlerVisitor, options?: MedplumCore.CrawlerOptions): void;
     crawlTypedValueAsync(typedValue: MedplumCore.TypedValue, visitor: MedplumCore.AsyncCrawlerVisitor, options?: MedplumCore.CrawlerOptions): Promise<void>;
     createConstraintIssue(expression: string, constraint: MedplumCore.Constraint): import("@medplum/fhirtypes").OperationOutcomeIssue;
-    createFhircastMessagePayload<EventName extends MedplumCore.FhircastEventVersionOptional>(topic: string, event: EventName, context: MedplumCore.FhircastEventContext<EventName> | MedplumCore.FhircastEventContext<EventName>[], versionId?: never): MedplumCore.FhircastMessagePayload<EventName>;
-    createFhircastMessagePayload<EventName extends MedplumCore.FhircastEventVersionRequired>(topic: string, event: EventName, context: MedplumCore.FhircastEventContext<EventName> | MedplumCore.FhircastEventContext<EventName>[], versionId: string): MedplumCore.FhircastMessagePayload<EventName>;
+    createFhircastMessagePayload<EventName extends MedplumCore.FhircastEventVersionOptional | MedplumCore.FhircastEventVersionRequired>(topic: string, event: EventName, context: MedplumCore.FhircastEventContext<EventName> | MedplumCore.FhircastEventContext<EventName>[], versionId?: string): MedplumCore.FhircastMessagePayload<EventName>;
     createOperationOutcomeIssue(severity: MedplumCore.IssueSeverity, code: MedplumCore.IssueType, message: string, path: string, data?: Record<string, any>): import("@medplum/fhirtypes").OperationOutcomeIssue;
+    createPatch(input: any, output: any, diff?: MedplumCore.VoidableDiff): MedplumCore.Operation[];
+    createPreferredPharmacyExtension(orgRef: import("@medplum/fhirtypes").Reference<import("@medplum/fhirtypes").Organization>, isPrimary: boolean, preferenceTypeSystem?: string): import("@medplum/fhirtypes").Extension;
     createProcessingIssue(expression: string, message: string, err: Error, data?: Record<string, any>): import("@medplum/fhirtypes").OperationOutcomeIssue;
     createReference<T extends import("@medplum/fhirtypes").Resource>(resource: T): import("@medplum/fhirtypes").Reference<T> & {
         reference: string;
     };
     createStructureIssue(expression: string, details: string): import("@medplum/fhirtypes").OperationOutcomeIssue;
+    createTests(input: any, patch: MedplumCore.Operation[]): MedplumCore.TestOperation[];
     decodeBase64(data: string): string;
+    decodeBase64Url(data: string): string;
     deepClone<T>(input: T): T;
     deepEquals(object1: unknown, object2: unknown, path?: string): boolean;
     deepIncludes(value: any, pattern: any): boolean;
+    deriveIdentifierSearchParameter(inputParam: import("@medplum/fhirtypes").SearchParameter): import("@medplum/fhirtypes").SearchParameter;
+    diffAny(input: any, output: any, ptr: MedplumCore.Pointer, diff?: MedplumCore.Diff): MedplumCore.Operation[];
+    diffArrays<T>(input: T[], output: T[], ptr: MedplumCore.Pointer, diff?: MedplumCore.Diff): MedplumCore.Operation[];
+    diffObjects(input: any, output: any, ptr: MedplumCore.Pointer, diff?: MedplumCore.Diff): MedplumCore.Operation[];
     encodeBase64(data: string): string;
+    encodeBase64Url(data: string): string;
+    encodeSmartHealthLink(payload: MedplumCore.SmartHealthLinkPayload): string;
     encryptSHA256(str: string): Promise<ArrayBuffer>;
     ensureNoLeadingSlash(url: string): string;
     ensureTrailingSlash(url: string): string;
-    evalFhirPath(expression: string, input: unknown): unknown[];
-    evalFhirPathTyped(expression: string, input: MedplumCore.TypedValue[], variables?: Record<string, MedplumCore.TypedValue>): MedplumCore.TypedValue[];
+    escapeHtml(unsafe: string): string;
+    escapeToken(token: string): string;
+    evalFhirPath(expression: string | MedplumCore.FhirPathAtom, input: unknown, variables?: Record<string, MedplumCore.TypedValue>, cache?: MedplumCore.LRUCache<MedplumCore.FhirPathAtom> | undefined): unknown[];
+    evalFhirPathTyped(expression: string | MedplumCore.FhirPathAtom, input: MedplumCore.TypedValue[], variables?: Record<string, MedplumCore.TypedValue>, cache?: MedplumCore.LRUCache<MedplumCore.FhirPathAtom> | undefined): (MedplumCore.TypedValue | MedplumCore.TypedValueWithPath)[];
     evalSqlOnFhir(view: import("@medplum/fhirtypes").ViewDefinition, resources: import("@medplum/fhirtypes").Resource[]): MedplumCore.OutputRow[];
-    fetchLatestVersionString(appName: string): Promise<string>;
+    expandSampledData(sample: import("@medplum/fhirtypes").SampledData): number[];
+    expandSampledObservation(obs: import("@medplum/fhirtypes").Observation): import("@medplum/fhirtypes").Observation[];
+    extractAccountReferences(meta: import("@medplum/fhirtypes").Meta | undefined): import("@medplum/fhirtypes").Reference[] | undefined;
+    extractServiceTypeReferences(serviceType: import("@medplum/fhirtypes").CodeableConcept[] | undefined): import("@medplum/fhirtypes").Reference<import("@medplum/fhirtypes").HealthcareService>[];
+    fetchAllVersionStrings(appName: string, params?: Record<string, string>): Promise<MedplumCore.MedplumSemver[]>;
+    fetchLatestVersionString(appName: string): Promise<MedplumCore.MedplumSemver>;
     fetchVersionManifest(appName: string, version?: string, params?: Record<string, string>): Promise<MedplumCore.ReleaseManifest>;
     fhirPathArrayEquals(x: MedplumCore.TypedValue[], y: MedplumCore.TypedValue[]): MedplumCore.TypedValue[];
     fhirPathArrayEquivalent(x: MedplumCore.TypedValue[], y: MedplumCore.TypedValue[]): MedplumCore.TypedValue[];
@@ -81,11 +118,15 @@ declare const Medplum: {
     fhirPathEquivalent(x: MedplumCore.TypedValue, y: MedplumCore.TypedValue): MedplumCore.TypedValue[];
     fhirPathIs(typedValue: MedplumCore.TypedValue, desiredType: string): boolean;
     fhirPathNot(input: MedplumCore.TypedValue[]): MedplumCore.TypedValue[];
+    fhirpathPatchTypedValue(original: MedplumCore.TypedValue, patch: MedplumCore.FhirPathPatch[]): void;
+    findCodeBySystem(categories: import("@medplum/fhirtypes").CodeableConcept[] | undefined, system: string): string | undefined;
     findObservationInterval(definition: import("@medplum/fhirtypes").ObservationDefinition, patient: import("@medplum/fhirtypes").Patient, value: number, category?: "reference" | "critical" | "absolute"): import("@medplum/fhirtypes").ObservationDefinitionQualifiedInterval | undefined;
-    findObservationReferenceRange(definition: import("@medplum/fhirtypes").ObservationDefinition, patient: import("@medplum/fhirtypes").Patient, names: string[]): import("@medplum/fhirtypes").ObservationDefinitionQualifiedInterval | undefined;
+    findObservationReferenceRange(definition: import("@medplum/fhirtypes").ObservationDefinition, patient: import("@medplum/fhirtypes").Patient, names?: string[]): import("@medplum/fhirtypes").ObservationDefinitionQualifiedInterval | undefined;
+    findObservationReferenceRanges(definition: import("@medplum/fhirtypes").ObservationDefinition, patient: import("@medplum/fhirtypes").Patient, names?: string[]): import("@medplum/fhirtypes").ObservationDefinitionQualifiedInterval[];
     findResourceByCode(resources: MedplumCore.ResourceWithCode[], code: import("@medplum/fhirtypes").CodeableConcept | string, system: string): MedplumCore.ResourceWithCode | undefined;
-    flatMapFilter<T, U>(arr: T[] | undefined, fn: (value: T, idx: number) => U | undefined): U[];
-    formatAddress(address: import("@medplum/fhirtypes").Address, options?: MedplumCore.AddressFormatOptions): string;
+    findResourceInBundle<K extends import("@medplum/fhirtypes").ResourceType>(bundle: import("@medplum/fhirtypes").Bundle, resourceType: K, id: string): import("@medplum/fhirtypes").ExtractResource<K>;
+    flatMapFilter<T, U>(arr: T[] | undefined, fn: (value: T, idx: number) => U | U[] | undefined): U[];
+    formatAddress(address: import("@medplum/fhirtypes").Address | undefined, options?: MedplumCore.AddressFormatOptions): string;
     formatCodeableConcept(codeableConcept: import("@medplum/fhirtypes").CodeableConcept | undefined): string;
     formatCoding(coding: import("@medplum/fhirtypes").Coding | undefined, includeCode?: boolean): string;
     formatDate(date: string | undefined, locales?: Intl.LocalesArgument, options?: Intl.DateTimeFormatOptions): string;
@@ -93,7 +134,7 @@ declare const Medplum: {
     formatFamilyName(name: import("@medplum/fhirtypes").HumanName): string;
     formatGivenName(name: import("@medplum/fhirtypes").HumanName): string;
     formatHl7DateTime(isoDate: Date | string): string;
-    formatHumanName(name: import("@medplum/fhirtypes").HumanName, options?: MedplumCore.HumanNameFormatOptions): string;
+    formatHumanName(name: import("@medplum/fhirtypes").HumanName | undefined, options?: MedplumCore.HumanNameFormatOptions): string;
     formatMoney(money: import("@medplum/fhirtypes").Money | undefined): string;
     formatObservationValue(obs: import("@medplum/fhirtypes").Observation | import("@medplum/fhirtypes").ObservationComponent | undefined): string;
     formatPeriod(period: import("@medplum/fhirtypes").Period | undefined, locales?: Intl.LocalesArgument, options?: Intl.DateTimeFormatOptions): string;
@@ -103,23 +144,30 @@ declare const Medplum: {
     formatSearchQuery(definition: MedplumCore.SearchRequest): string;
     formatTime(time: string | undefined, locales?: Intl.LocalesArgument, options?: Intl.DateTimeFormatOptions): string;
     formatTiming(timing: import("@medplum/fhirtypes").Timing | undefined): string;
+    formatWallTime(time: string | undefined, locales?: Intl.LocalesArgument, options?: Intl.DateTimeFormatOptions): string;
     generateId(): string;
     getAllDataTypes(): MedplumCore.DataTypesMap;
     getAllQuestionnaireAnswers(response: import("@medplum/fhirtypes").QuestionnaireResponse): Record<string, import("@medplum/fhirtypes").QuestionnaireResponseItemAnswer[]>;
+    getBuffer(): typeof Buffer | undefined;
     getCodeBySystem(concept: import("@medplum/fhirtypes").CodeableConcept, system: string): string | undefined;
     getDataType(type: string, profileUrl?: string): MedplumCore.InternalTypeSchema;
     getDateProperty(date: string | undefined): Date | undefined;
     getDefaultValuesForNewSliceEntry(key: string, slice: MedplumCore.SliceDefinition, slicing: MedplumCore.SlicingRules, schema: MedplumCore.InternalTypeSchema): import("@medplum/fhirtypes").Resource;
     getDisplayString(resource: import("@medplum/fhirtypes").Resource): string;
     getElementDefinition(typeName: string, propertyName: string, profileUrl?: string): MedplumCore.InternalSchemaElement | undefined;
+    getElementDefinitionForPath(typeName: string, path: string, profileUrl?: string): MedplumCore.InternalSchemaElement | undefined;
     getElementDefinitionFromElements(elements: MedplumCore.InternalTypeSchema["elements"], propertyName: string): MedplumCore.InternalSchemaElement | undefined;
     getElementDefinitionTypeName(elementDefinition: import("@medplum/fhirtypes").ElementDefinition): string;
     getExpressionForResourceType(resourceType: string, expression: string): string | undefined;
     getExpressionsForResourceType(resourceType: string, expression: string): MedplumCore.Atom[];
     getExtension(resource: any, ...urls: string[]): import("@medplum/fhirtypes").Extension | undefined;
+    getExtensions(extensible: MedplumCore.Extensible | undefined, urlOrUrls: string | string[]): import("@medplum/fhirtypes").Extension[];
     getExtensionValue(resource: any, ...urls: string[]): import("@medplum/fhirtypes").ExtensionValue | undefined;
     getIdentifier(resource: import("@medplum/fhirtypes").Resource, system: string): string | undefined;
+    getIdentifierByType(resource: import("@medplum/fhirtypes").Resource, type: import("@medplum/fhirtypes").Coding): string | undefined;
     getImageSrc(resource: import("@medplum/fhirtypes").Resource): string | undefined;
+    getInnerDerivedIdentifierExpression(expression: string): string | undefined;
+    getMedicationOrderIframeUrl(medicationRequest: import("@medplum/fhirtypes").MedicationRequest, ext: MedplumCore.MedicationOrderExtensions): string | undefined;
     getNestedProperty(value: MedplumCore.TypedValueWithPath | undefined, key: string, options: {
         profileUrl?: string;
         withPath: true;
@@ -128,17 +176,31 @@ declare const Medplum: {
         profileUrl?: string;
         withPath?: false;
     }): (MedplumCore.TypedValue | MedplumCore.TypedValue[] | undefined)[];
+    getOutcomeRedirectUrl(outcome: import("@medplum/fhirtypes").OperationOutcome | undefined): string | undefined;
+    getParsedDerivedIdentifierExpression(originalExpression: string, atom: MedplumCore.FhirPathAtom): MedplumCore.FhirPathAtom;
+    getParsedExpressionForResourceType(resourceType: string, expression: string): MedplumCore.FhirPathAtom;
     getPathDifference(parentPath: string, path: string): string | undefined;
     getPathDisplayName(path: string): string;
+    getPendingMedicationOrderId(medicationRequest: import("@medplum/fhirtypes").MedicationRequest, ext: MedplumCore.MedicationOrderExtensions): string | undefined;
+    getPendingMedicationOrderStatus(medicationRequest: import("@medplum/fhirtypes").MedicationRequest, ext: MedplumCore.MedicationOrderExtensions): string | undefined;
+    getPreferredPharmaciesFromPatient(patient: import("@medplum/fhirtypes").Patient, preferenceTypeSystem?: string): MedplumCore.PreferredPharmacy[];
     getPropertyDisplayName(propertyName: string): string;
     getQueryString(query: MedplumCore.QueryTypes): string;
     getQuestionnaireAnswers(response: import("@medplum/fhirtypes").QuestionnaireResponse): Record<string, import("@medplum/fhirtypes").QuestionnaireResponseItemAnswer>;
     getRandomString(): string;
-    getReferenceString(input: import("@medplum/fhirtypes").Reference | import("@medplum/fhirtypes").Resource): string;
+    getRateLimitReset(outcome: import("@medplum/fhirtypes").OperationOutcome): number | undefined;
+    getReferenceString(input: (import("@medplum/fhirtypes").Reference & {
+        reference: string;
+    }) | MedplumCore.WithId<import("@medplum/fhirtypes").Resource>): string;
+    getReferenceString(input: import("@medplum/fhirtypes").Reference | import("@medplum/fhirtypes").Resource): string | undefined;
     getResourceTypes(): import("@medplum/fhirtypes").ResourceType[];
+    getScheduleParameters(schedule: import("@medplum/fhirtypes").Schedule, service: MedplumCore.WithId<import("@medplum/fhirtypes").HealthcareService>, url: string): import("@medplum/fhirtypes").Extension[];
+    getSchedulingTimezone(service: MedplumCore.WithId<import("@medplum/fhirtypes").HealthcareService>, schedule?: import("@medplum/fhirtypes").Schedule, actor?: import("@medplum/fhirtypes").Resource): string | undefined;
     getSearchParameter(resourceType: string, code: string): import("@medplum/fhirtypes").SearchParameter | undefined;
     getSearchParameterDetails(resourceType: string, searchParam: import("@medplum/fhirtypes").SearchParameter): MedplumCore.SearchParameterDetails;
     getSearchParameters(resourceType: string): Record<string, import("@medplum/fhirtypes").SearchParameter> | undefined;
+    getSearchResourceTypes(searchRequest: MedplumCore.SearchRequest): import("@medplum/fhirtypes").ResourceType[];
+    getSmartHealthLinkId(manifestUrl: string): string | undefined;
     getStatus(outcome: import("@medplum/fhirtypes").OperationOutcome): number;
     getTypedPropertyValue(input: MedplumCore.TypedValue, path: string, options?: MedplumCore.GetTypedPropertyValueOptions): MedplumCore.TypedValue[] | MedplumCore.TypedValue | undefined;
     getTypedPropertyValueWithoutSchema(typedValue: MedplumCore.TypedValue, path: string): MedplumCore.TypedValue[] | MedplumCore.TypedValue | undefined;
@@ -146,6 +208,9 @@ declare const Medplum: {
     getTypedPropertyValueWithSchema(typedValue: MedplumCore.TypedValue, path: string, element: MedplumCore.InternalSchemaElement): MedplumCore.TypedValue[] | MedplumCore.TypedValue | undefined;
     getValueSliceName(value: any, slices: MedplumCore.SliceDefinitionWithTypes[], discriminators: MedplumCore.SliceDiscriminator[], profileUrl: string | undefined): string | undefined;
     getWebSocketUrl(baseUrl: URL | string, path: string): string;
+    getWindow(): Window | undefined;
+    hasSchedulingParameters(resource: import("@medplum/fhirtypes").Schedule | import("@medplum/fhirtypes").HealthcareService): boolean;
+    indexConceptMapCodings(params: MedplumCore.ConceptMapTranslateParameters): Record<string, string[]>;
     indexDefaultSearchParameters(bundle: import("@medplum/fhirtypes").StructureDefinition[] | import("@medplum/fhirtypes").Bundle): void;
     indexSearchParameter(searchParam: import("@medplum/fhirtypes").SearchParameter): void;
     indexSearchParameterBundle(bundle: import("@medplum/fhirtypes").Bundle<import("@medplum/fhirtypes").SearchParameter>): void;
@@ -153,7 +218,14 @@ declare const Medplum: {
     inflateBaseSchema(base: MedplumCore.BaseSchema): MedplumCore.DataTypesMap;
     inflateElement(path: string, partial: Partial<MedplumCore.InternalSchemaElement>): MedplumCore.InternalSchemaElement;
     initFhirPathParserBuilder(): MedplumCore.ParserBuilder;
+    intersection(objects: ArrayLike<{
+        [index: string]: any;
+    }>): string[];
+    invalidSearchOperator(operator: MedplumCore.Operator, searchParameterCodeOrId: string): import("@medplum/fhirtypes").OperationOutcome;
     isAccepted(outcome: import("@medplum/fhirtypes").OperationOutcome): boolean;
+    isAckCode(value: string | undefined): value is MedplumCore.AckCode;
+    isAddPharmacyResponse(value: unknown): value is MedplumCore.AddPharmacyResponse;
+    isBrowserEnvironment(): boolean;
     isCodeableConcept(value: unknown): value is import("@medplum/fhirtypes").CodeableConcept & {
         coding: import("@medplum/fhirtypes").Coding[];
     };
@@ -168,72 +240,97 @@ declare const Medplum: {
     isDataTypeLoaded(type: string): boolean;
     isDateString(input: unknown): input is string;
     isDateTimeString(input: unknown): input is string;
+    isDayOfWeek(value: string | undefined): value is MedplumCore.DayOfWeek;
+    isDefined<T>(value: T | undefined | null): value is T;
+    isDestructive({ op }: MedplumCore.Operation): boolean;
     isEmpty(v: unknown): boolean;
+    isError(value: unknown): value is Error;
     isFhircastResourceType(resourceType: MedplumCore.FhircastResourceType): boolean;
     isFhirCriteriaMet(subscription: import("@medplum/fhirtypes").Subscription, currentResource: import("@medplum/fhirtypes").Resource, getPreviousResource: (currentResource: import("@medplum/fhirtypes").Resource) => Promise<import("@medplum/fhirtypes").Resource | undefined>): Promise<boolean>;
     isGone(outcome: import("@medplum/fhirtypes").OperationOutcome): boolean;
     isJwt(token: string): boolean;
     isLowerCase(c: string): boolean;
+    isMedicationArray(value: unknown): value is import("@medplum/fhirtypes").Medication[];
+    isMedicationCartManageResponse(value: unknown): value is MedplumCore.MedicationCartManageResponse;
+    isMedicationCheckoutResponse(value: unknown): value is MedplumCore.MedicationCheckoutResponse;
+    isMedicationOrderResponse(value: unknown): value is MedplumCore.MedicationOrderResponse;
+    isMedicationOrderSetResponse(value: unknown): value is MedplumCore.MedicationOrderSetResponse;
     isMedplumAccessToken(accessToken: string): boolean;
+    isNodeEnvironment(): boolean;
     isNotFound(outcome: import("@medplum/fhirtypes").OperationOutcome): boolean;
     isObject(obj: unknown): obj is Record<string, unknown>;
     isOk(outcome: import("@medplum/fhirtypes").OperationOutcome): boolean;
     isOperationOutcome(value: unknown): value is import("@medplum/fhirtypes").OperationOutcome;
+    isOrganizationArray(value: unknown): value is import("@medplum/fhirtypes").Organization[];
     isPeriod(input: unknown): input is import("@medplum/fhirtypes").Period;
     isPopulated<T extends {
         length: number;
-    } | object>(arg: MedplumCore.CanBePopulated | undefined | null): arg is T;
+    } | Record<string, any>>(arg: MedplumCore.CanBePopulated | undefined | null): arg is T;
     isPrimitiveType(code: string): boolean;
     isProfileLoaded(profileUrl: string): boolean;
     isProfileResource(resource: import("@medplum/fhirtypes").Resource): resource is MedplumCore.ProfileResource;
     isQuantity(input: unknown): input is import("@medplum/fhirtypes").Quantity;
     isQuantityEquivalent(x: import("@medplum/fhirtypes").Quantity, y: import("@medplum/fhirtypes").Quantity): boolean;
     isRedirect(outcome: import("@medplum/fhirtypes").OperationOutcome): boolean;
-    isReference(value: unknown): value is import("@medplum/fhirtypes").Reference & {
+    isReference<T extends import("@medplum/fhirtypes").Resource = import("@medplum/fhirtypes").Resource>(value: unknown, resourceType?: T["resourceType"]): value is import("@medplum/fhirtypes").Reference<T> & {
         reference: string;
     };
-    isResource(value: unknown): value is import("@medplum/fhirtypes").Resource;
-    isResourceType(resourceType: string): boolean;
+    isResource<T extends import("@medplum/fhirtypes").Resource>(value: unknown, resourceType?: T["resourceType"]): value is T;
+    isResourceType(resourceType: string): resourceType is import("@medplum/fhirtypes").ResourceType;
     isResourceTypeSchema(typeSchema: MedplumCore.InternalTypeSchema): boolean;
+    isResourceWithId<T extends import("@medplum/fhirtypes").Resource>(resource: unknown, resourceType?: T["resourceType"]): resource is MedplumCore.WithId<T>;
     isSliceDefinitionWithTypes(slice: MedplumCore.SliceDefinition): slice is MedplumCore.SliceDefinitionWithTypes;
     isString(value: unknown): value is string;
     isStringArray(arr: any[]): arr is string[];
     isTextObject(value: unknown): value is {
         text: string;
     };
+    isTypedValue(value: unknown): value is MedplumCore.TypedValue;
     isUnauthenticated(outcome: import("@medplum/fhirtypes").OperationOutcome): boolean;
     isUUID(input: string): input is string;
     isValidDate(date: Date): boolean;
     isValidHostname(input: string): boolean;
-    isValidMedplumSemver(version: string): boolean;
+    isValidMedplumSemver(version: string): version is MedplumCore.MedplumSemver;
     lazy<T>(fn: () => T): () => T;
     loadDataType(sd: import("@medplum/fhirtypes").StructureDefinition): void;
     mapByIdentifier<T extends import("@medplum/fhirtypes").Resource = import("@medplum/fhirtypes").Resource>(resourceBundle: import("@medplum/fhirtypes").Bundle<T>, identifierSystem: string): Map<string, T>;
     matchDiscriminant(value: MedplumCore.TypedValue | MedplumCore.TypedValue[] | undefined, discriminator: MedplumCore.SliceDiscriminator, slice: MedplumCore.SliceDefinition, elements?: Record<string, MedplumCore.InternalSchemaElement>): boolean;
-    matchesAccessPolicy(accessPolicy: import("@medplum/fhirtypes").AccessPolicy, resource: import("@medplum/fhirtypes").Resource, readonlyMode: boolean): boolean;
     matchesRange(value: number, range: import("@medplum/fhirtypes").Range, precision?: number): boolean;
     matchesSearchRequest(resource: import("@medplum/fhirtypes").Resource, searchRequest: MedplumCore.SearchRequest): boolean;
+    medicationCartClearRequestToParameters(req: MedplumCore.MedicationCartClearRequest): import("@medplum/fhirtypes").Parameters;
+    medicationCartRemoveRequestToParameters(req: MedplumCore.MedicationCartRemoveRequest): import("@medplum/fhirtypes").Parameters;
+    medicationCheckoutRequestToParameters(req: MedplumCore.MedicationCheckoutRequest): import("@medplum/fhirtypes").Parameters;
+    medicationOrderRequestToParameters(req: MedplumCore.MedicationOrderRequest): import("@medplum/fhirtypes").Parameters;
+    medicationOrderSetRequestToParameters(req: MedplumCore.MedicationOrderSetRequest): import("@medplum/fhirtypes").Parameters;
+    medicationSearchParamsToParameters(params: MedplumCore.MedicationSearchParams): import("@medplum/fhirtypes").Parameters;
+    move(object: any, operation: MedplumCore.MoveOperation, _options?: MedplumCore.PatchOptions): MedplumCore.MissingError | null;
     normalizeArrayBufferView(typedArrayOrBuffer: ArrayBufferLike | ArrayBufferView): ArrayBufferLike;
     normalizeCreateBinaryOptions(arg1: MedplumCore.BinarySource | MedplumCore.CreateBinaryOptions, arg2: string | undefined | MedplumCore.MedplumRequestOptions, arg3?: string, arg4?: (e: ProgressEvent) => void): MedplumCore.CreateBinaryOptions;
     normalizeCreatePdfOptions(arg1: TDocumentDefinitions | MedplumCore.CreatePdfOptions, arg2: string | undefined | MedplumCore.MedplumRequestOptions, arg3: Record<string, CustomTableLayout> | undefined, arg4: TFontDictionary | undefined): MedplumCore.CreatePdfOptions;
+    normalizeErrorEvent(event: Event | MedplumCore.ErrorEvent, target: unknown): MedplumCore.ErrorEvent;
     normalizeErrorString(error: unknown): string;
     normalizeOperationOutcome(error: unknown): import("@medplum/fhirtypes").OperationOutcome;
     operationOutcomeIssueToString(issue: import("@medplum/fhirtypes").OperationOutcomeIssue): string;
     operationOutcomeToString(outcome: import("@medplum/fhirtypes").OperationOutcome): string;
-    parseCriteriaAsSearchRequest<T extends import("@medplum/fhirtypes").Resource = import("@medplum/fhirtypes").Resource>(criteria: string): MedplumCore.SearchRequest<T>;
+    parametersToMedicationCartManageResponse(params: import("@medplum/fhirtypes").Parameters): MedplumCore.MedicationCartManageResponse;
+    parametersToMedicationCheckoutResponse(params: import("@medplum/fhirtypes").Parameters): MedplumCore.MedicationCheckoutResponse;
+    parametersToMedicationOrderResponse(params: import("@medplum/fhirtypes").Parameters): MedplumCore.MedicationOrderResponse;
+    parametersToMedicationOrderSetResponse(params: import("@medplum/fhirtypes").Parameters): MedplumCore.MedicationOrderSetResponse;
+    parametersToOrderSetSyncResponse(params: import("@medplum/fhirtypes").Parameters): MedplumCore.OrderSetSyncResponse;
     parseFhirPath(input: string): MedplumCore.FhirPathAtom;
+    parseFhirPathPatchParameters(parameters: import("@medplum/fhirtypes").Parameters): MedplumCore.FhirPathPatch[];
     parseFilterParameter(input: string): MedplumCore.FhirFilterExpression;
     parseHl7DateTime(hl7DateTime: string | undefined, options?: MedplumCore.Hl7DateParseOptions): string | undefined;
-    parseJWTPayload(token: string): Record<string, number | string>;
+    parseJWTPayload(token: string): MedplumCore.JWTPayload;
     parseLogLevel(level: string): MedplumCore.LogLevel;
     parseMappingLanguage(input: string): import("@medplum/fhirtypes").StructureMap;
-    parseParameter(searchParam: import("@medplum/fhirtypes").SearchParameter, modifier: string, value: string): MedplumCore.Filter;
+    parseParameter(searchParam: import("@medplum/fhirtypes").SearchParameter, operator: MedplumCore.Operator, modifier: string, value: string): MedplumCore.Filter;
     parseReference<T extends import("@medplum/fhirtypes").Resource>(reference: import("@medplum/fhirtypes").Reference<T> | undefined): [T["resourceType"], string];
-    parseSearchDefinition<T extends import("@medplum/fhirtypes").Resource = import("@medplum/fhirtypes").Resource>(url: string): MedplumCore.SearchRequest<T>;
-    parseSearchRequest<T extends import("@medplum/fhirtypes").Resource = import("@medplum/fhirtypes").Resource>(url: T["resourceType"] | URL | string, query?: Record<string, string[] | string | undefined>): MedplumCore.SearchRequest<T>;
-    parseSearchUrl<T extends import("@medplum/fhirtypes").Resource = import("@medplum/fhirtypes").Resource>(url: URL): MedplumCore.SearchRequest<T>;
+    parseSearchRequest<T extends import("@medplum/fhirtypes").Resource = import("@medplum/fhirtypes").Resource>(url: URL | string, query?: Record<string, string[] | string | undefined>): MedplumCore.SearchRequest<T>;
+    parseSmartHealthLink(input: string): MedplumCore.SmartHealthLinkPayload;
     parseStructureDefinition(sd: import("@medplum/fhirtypes").StructureDefinition): MedplumCore.InternalTypeSchema;
-    parseXFhirQuery(query: string, variables: Record<string, MedplumCore.TypedValue>): MedplumCore.SearchRequest;
+    parseXFhirQuery(query: string, variables: Record<string, MedplumCore.TypedValue>, context?: MedplumCore.TypedValue[]): MedplumCore.SearchRequest;
+    pathToJSONPointer(path: string): string;
     preciseEquals(a: number, b: number, precision?: number): boolean;
     preciseGreaterThan(a: number, b: number, precision?: number): boolean;
     preciseGreaterThanOrEquals(a: number, b: number, precision?: number): boolean;
@@ -241,19 +338,31 @@ declare const Medplum: {
     preciseLessThanOrEquals(a: number, b: number, precision?: number): boolean;
     preciseRound(a: number, precision: number): number;
     redirect(url: URL): import("@medplum/fhirtypes").OperationOutcome;
+    redirectOk(url: URL): import("@medplum/fhirtypes").OperationOutcome;
+    remove(object: any, operation: MedplumCore.RemoveOperation, _options?: MedplumCore.PatchOptions): MedplumCore.MissingError | null;
     removeDuplicates(arr: MedplumCore.TypedValue[]): MedplumCore.TypedValue[];
+    removePreferredPharmacyFromPatient(patient: import("@medplum/fhirtypes").Patient, orgRef: import("@medplum/fhirtypes").Reference<import("@medplum/fhirtypes").Organization>): import("@medplum/fhirtypes").Patient;
     removeProfileFromResource<T extends import("@medplum/fhirtypes").Resource = import("@medplum/fhirtypes").Resource>(resource: T, profileUrl: string): T;
     reorderBundle(bundle: import("@medplum/fhirtypes").Bundle): import("@medplum/fhirtypes").Bundle;
+    replace(object: any, operation: MedplumCore.ReplaceOperation, _options?: MedplumCore.PatchOptions): MedplumCore.MissingError | null;
+    replaceQueryVariables(user: MedplumCore.CdsUserResource, context: Record<string, unknown>, query: string): string;
     resolveId(input: import("@medplum/fhirtypes").Reference | import("@medplum/fhirtypes").Resource | undefined): string | undefined;
     resourceMatchesSubscriptionCriteria({ resource, subscription, context, getPreviousResource, logger, }: MedplumCore.ResourceMatchesSubscriptionCriteria): Promise<boolean>;
     satisfiedAccessPolicy(resource: import("@medplum/fhirtypes").Resource, interaction: MedplumCore.AccessPolicyInteraction, accessPolicy: import("@medplum/fhirtypes").AccessPolicy | undefined): import("@medplum/fhirtypes").AccessPolicyResource | undefined;
+    schedulingDurationToMinutes(duration: import("@medplum/fhirtypes").Duration | undefined): number | undefined;
+    serializeError(error: Error, depth?: number, maxDepth?: number): Record<string, any>;
     serializeFhircastSubscriptionRequest(subscriptionRequest: MedplumCore.SubscriptionRequest | MedplumCore.PendingSubscriptionRequest): string;
     serverError(err: Error): import("@medplum/fhirtypes").OperationOutcome;
     serverTimeout(msg?: string): import("@medplum/fhirtypes").OperationOutcome;
+    serviceTypeIncludesService(serviceType: import("@medplum/fhirtypes").CodeableConcept[] | undefined, service: MedplumCore.WithId<import("@medplum/fhirtypes").HealthcareService> | (import("@medplum/fhirtypes").Reference<import("@medplum/fhirtypes").HealthcareService> & {
+        reference: string;
+    })): boolean;
     setCodeBySystem(concept: import("@medplum/fhirtypes").CodeableConcept, system: string, code: string): void;
     setIdentifier(resource: import("@medplum/fhirtypes").Resource & {
         identifier?: import("@medplum/fhirtypes").Identifier[];
-    }, system: string, value: string): void;
+    }, system: string, value: string, options?: MedplumCore.SetIdentifierOptions): void;
+    setRateLimitReset(outcome: import("@medplum/fhirtypes").OperationOutcome, msBeforeNext: number): void;
+    setScheduleParameter(schedule: import("@medplum/fhirtypes").Schedule, service: MedplumCore.WithId<import("@medplum/fhirtypes").HealthcareService>, subextension: import("@medplum/fhirtypes").Extension): import("@medplum/fhirtypes").Schedule;
     singleton(collection: MedplumCore.TypedValue[], type?: string): MedplumCore.TypedValue | undefined;
     singularize<T>(value: T | T[] | undefined): T | undefined;
     sortStringArray(array: string[]): string[];
@@ -264,40 +373,71 @@ declare const Medplum: {
     stringifyTypedValue(v: MedplumCore.TypedValue): string;
     structureMapTransform(structureMap: import("@medplum/fhirtypes").StructureMap, input: MedplumCore.TypedValue[], transformMaps?: MedplumCore.TransformMapCollection): MedplumCore.TypedValue[];
     subsetResource<T extends import("@medplum/fhirtypes").Resource>(resource: T | undefined, properties: string[]): T | undefined;
+    subtract(minuend: {
+        [index: string]: any;
+    }, subtrahend: {
+        [index: string]: any;
+    }): string[];
+    sumBy<T>(items: Iterable<T>, fn: (value: T) => number): number;
+    summarizeObservations(observations: import("@medplum/fhirtypes").Observation[] | import("@medplum/fhirtypes").Bundle<import("@medplum/fhirtypes").Observation>, summaryCode: import("@medplum/fhirtypes").CodeableConcept, summarizeFn: MedplumCore.StatsFn): import("@medplum/fhirtypes").Observation;
     toJsBoolean(obj: MedplumCore.TypedValue[]): boolean;
     toPeriod(input: unknown): import("@medplum/fhirtypes").Period | undefined;
+    toServiceTypeCodeableConcepts(service: MedplumCore.WithId<import("@medplum/fhirtypes").HealthcareService>): import("@medplum/fhirtypes").CodeableConcept[];
     toTypedValue(value: unknown): MedplumCore.TypedValue;
+    trimTrailingEmptyElements<T>(arr: T[] | undefined): T[] | undefined;
     tryGetDataType(type: string, profileUrl?: string): MedplumCore.InternalTypeSchema | undefined;
     tryGetJwtExpiration(token: string): number | undefined;
     tryGetProfile(profileUrl: string): MedplumCore.InternalTypeSchema | undefined;
     typedValueToString(typedValue: MedplumCore.TypedValue | undefined): string;
+    unescapeToken(token: string): string;
     validateFhircastSubscriptionRequest(subscriptionRequest: MedplumCore.SubscriptionRequest | MedplumCore.PendingSubscriptionRequest): boolean;
     validateResource(resource: import("@medplum/fhirtypes").Resource, options?: MedplumCore.ValidatorOptions): import("@medplum/fhirtypes").OperationOutcomeIssue[];
     validateResourceType(resourceType: string): void;
     validateTypedValue(typedValue: MedplumCore.TypedValue, options?: MedplumCore.ValidatorOptions): import("@medplum/fhirtypes").OperationOutcomeIssue[];
-    validationError(details: string): import("@medplum/fhirtypes").OperationOutcome;
+    validationError(details: string, expressions?: string[], code?: MedplumCore.IssueType, diagnostics?: string): import("@medplum/fhirtypes").OperationOutcome;
     warnIfNewerVersionAvailable(appName: string, params?: Record<string, string>): Promise<void>;
     wordWrap(text: string, maxLength: number): string[];
-    AccessPolicyInteraction: typeof MedplumCore.AccessPolicyInteraction;
+    AccessPolicyInteraction: {
+        readonly READ: "read";
+        readonly VREAD: "vread";
+        readonly UPDATE: "update";
+        readonly DELETE: "delete";
+        readonly HISTORY: "history";
+        readonly CREATE: "create";
+        readonly SEARCH: "search";
+    };
+    AckCode: {
+        readonly AA: "AA";
+        readonly AE: "AE";
+        readonly AR: "AR";
+        readonly CA: "CA";
+        readonly CE: "CE";
+        readonly CR: "CR";
+    };
     allOk: import("@medplum/fhirtypes").OperationOutcome;
     AndAtom: typeof MedplumCore.AndAtom;
-    ArithemticOperatorAtom: typeof MedplumCore.ArithemticOperatorAtom;
+    ArithmeticOperatorAtom: typeof MedplumCore.ArithmeticOperatorAtom;
     AsAtom: typeof MedplumCore.AsAtom;
-    BooleanInfixOperatorAtom: typeof MedplumCore.BooleanInfixOperatorAtom;
+    assert: typeof MedplumCore.assert;
     ClientStorage: typeof MedplumCore.ClientStorage;
     ConcatAtom: typeof MedplumCore.ConcatAtom;
     ContainsAtom: typeof MedplumCore.ContainsAtom;
     ContentType: {
         readonly CSS: "text/css";
         readonly DICOM: "application/dicom";
+        readonly DICOM_JSON: "application/dicom+json";
+        readonly EVENT_STREAM: "text/event-stream";
         readonly FAVICON: "image/vnd.microsoft.icon";
         readonly FHIR_JSON: "application/fhir+json";
         readonly FORM_URL_ENCODED: "application/x-www-form-urlencoded";
         readonly HL7_V2: "x-application/hl7-v2+er7";
         readonly HTML: "text/html";
         readonly JAVASCRIPT: "text/javascript";
+        readonly JOSE: "application/jose";
         readonly JSON: "application/json";
         readonly JSON_PATCH: "application/json-patch+json";
+        readonly JWT: "application/jwt";
+        readonly MULTIPART_FORM_DATA: "multipart/form-data";
         readonly PNG: "image/png";
         readonly SCIM_JSON: "application/scim+json";
         readonly SVG: "image/svg+xml";
@@ -306,13 +446,17 @@ declare const Medplum: {
         readonly PING: "x-application/ping";
         readonly XML: "text/xml";
         readonly CDA_XML: "application/cda+xml";
+        readonly OCTET_STREAM: "application/octet-stream";
     };
     CPT: "http://www.ama-assn.org/go/cpt";
     created: import("@medplum/fhirtypes").OperationOutcome;
+    DataSampler: typeof MedplumCore.DataSampler;
+    DAYS_OF_WEEK: readonly ["mon", "tue", "wed", "thu", "fri", "sat", "sun"];
     DEFAULT_ACCEPT: string;
     DEFAULT_MAX_SEARCH_COUNT: 1000;
     DEFAULT_SEARCH_COUNT: 20;
     DotAtom: typeof MedplumCore.DotAtom;
+    EMPTY: readonly [];
     EmptySetAtom: typeof MedplumCore.EmptySetAtom;
     EqualsAtom: typeof MedplumCore.EqualsAtom;
     EquivalentAtom: typeof MedplumCore.EquivalentAtom;
@@ -440,8 +584,8 @@ declare const Medplum: {
             };
             readonly select: {
                 readonly resourceType: "*";
-                readonly array: true;
                 readonly reference: true;
+                readonly manyAllowed: true;
             };
         };
         readonly "DiagnosticReport-update": {
@@ -500,6 +644,7 @@ declare const Medplum: {
     FunctionAtom: typeof MedplumCore.FunctionAtom;
     globalSchema: MedplumCore.IndexedStructureDefinition;
     gone: import("@medplum/fhirtypes").OperationOutcome;
+    HL7_V2_0203: "http://terminology.hl7.org/CodeSystem/v2-0203";
     Hl7Context: typeof MedplumCore.Hl7Context;
     Hl7Field: typeof MedplumCore.Hl7Field;
     Hl7Message: typeof MedplumCore.Hl7Message;
@@ -511,30 +656,111 @@ declare const Medplum: {
     InAtom: typeof MedplumCore.InAtom;
     IndexerAtom: typeof MedplumCore.IndexerAtom;
     InfixOperatorAtom: typeof MedplumCore.InfixOperatorAtom;
+    INVALID_MEDICATION_CART_RESPONSE: "Invalid response from cart-management bot";
+    INVALID_MEDICATION_CHECKOUT_RESPONSE: "Invalid response from checkout-medications bot";
+    INVALID_MEDICATION_ORDER_RESPONSE: "Invalid response from order medication bot";
+    INVALID_MEDICATION_ORDER_SET_RESPONSE: "Invalid response from order-set bot";
+    INVALID_MEDICATION_SEARCH_RESPONSE: "Invalid response from medication search bot";
+    InvalidOperationError: typeof MedplumCore.InvalidOperationError;
     IsAtom: typeof MedplumCore.IsAtom;
     LiteralAtom: typeof MedplumCore.LiteralAtom;
+    locationUtils: {
+        assign(url: string): void;
+        reload(): void;
+        getSearch(): string;
+        getPathname(): string;
+        getLocation(): string;
+        getOrigin(): string;
+    };
     Logger: typeof MedplumCore.Logger;
-    LogLevel: typeof MedplumCore.LogLevel;
+    LogLevel: {
+        NONE: number;
+        ERROR: number;
+        WARN: number;
+        INFO: number;
+        DEBUG: number;
+    };
+    LogLevelNames: readonly ["NONE", "ERROR", "WARN", "INFO", "DEBUG"];
     LOINC: "http://loinc.org";
     LRUCache: typeof MedplumCore.LRUCache;
+    MEDICATION_REQUEST_STATUS_REASON_RESPONSE_NOT_RECEIVED: "response-not-received";
+    MEDICATION_REQUEST_STATUS_REASON_SYSTEM: "https://medplum.com/fhir/CodeSystem/medication-request-status-reason";
     MEDPLUM_CLI_CLIENT_ID: "medplum-cli";
     MEDPLUM_RELEASES_URL: "https://meta.medplum.com/releases";
+    MEDPLUM_SEMVER_REGEX: RegExp;
     MEDPLUM_VERSION: string;
     MedplumKeyValueClient: typeof MedplumCore.MedplumKeyValueClient;
     MemoryStorage: typeof MedplumCore.MemoryStorage;
+    MissingError: typeof MedplumCore.MissingError;
     MockAsyncClientStorage: typeof MedplumCore.MockAsyncClientStorage;
+    MRN_IDENTIFIER_TYPE: import("@medplum/fhirtypes").Coding;
     multipleMatches: import("@medplum/fhirtypes").OperationOutcome;
     NDC: "http://hl7.org/fhir/sid/ndc";
+    NOOP: () => void;
     NotEqualsAtom: typeof MedplumCore.NotEqualsAtom;
     NotEquivalentAtom: typeof MedplumCore.NotEquivalentAtom;
     notFound: import("@medplum/fhirtypes").OperationOutcome;
     notModified: import("@medplum/fhirtypes").OperationOutcome;
-    OAuthClientAssertionType: typeof MedplumCore.OAuthClientAssertionType;
-    OAuthGrantType: typeof MedplumCore.OAuthGrantType;
-    OAuthTokenAuthMethod: typeof MedplumCore.OAuthTokenAuthMethod;
-    OAuthTokenType: typeof MedplumCore.OAuthTokenType;
+    OAuthClientAssertionType: {
+        readonly JwtBearer: "urn:ietf:params:oauth:client-assertion-type:jwt-bearer";
+    };
+    OAuthGrantType: {
+        readonly ClientCredentials: "client_credentials";
+        readonly AuthorizationCode: "authorization_code";
+        readonly RefreshToken: "refresh_token";
+        readonly JwtBearer: "urn:ietf:params:oauth:grant-type:jwt-bearer";
+        readonly TokenExchange: "urn:ietf:params:oauth:grant-type:token-exchange";
+        readonly PreAuthorizedCode: "urn:ietf:params:oauth:grant-type:pre-authorized_code";
+    };
+    OAuthSigningAlgorithm: {
+        readonly ES256: "ES256";
+        readonly ES384: "ES384";
+        readonly ES512: "ES512";
+        readonly HS256: "HS256";
+        readonly RS256: "RS256";
+        readonly RS384: "RS384";
+        readonly RS512: "RS512";
+    };
+    OAuthTokenAuthMethod: {
+        readonly ClientSecretBasic: "client_secret_basic";
+        readonly ClientSecretPost: "client_secret_post";
+        readonly ClientSecretJwt: "client_secret_jwt";
+        readonly PrivateKeyJwt: "private_key_jwt";
+        readonly None: "none";
+    };
+    OAuthTokenType: {
+        readonly AccessToken: "urn:ietf:params:oauth:token-type:access_token";
+        readonly RefreshToken: "urn:ietf:params:oauth:token-type:refresh_token";
+        readonly IdToken: "urn:ietf:params:oauth:token-type:id_token";
+        readonly Saml1Token: "urn:ietf:params:oauth:token-type:saml1";
+        readonly Saml2Token: "urn:ietf:params:oauth:token-type:saml2";
+    };
     OperationOutcomeError: typeof MedplumCore.OperationOutcomeError;
-    Operator: typeof MedplumCore.Operator;
+    Operator: {
+        readonly EQUALS: "eq";
+        readonly NOT_EQUALS: "ne";
+        readonly GREATER_THAN: "gt";
+        readonly LESS_THAN: "lt";
+        readonly GREATER_THAN_OR_EQUALS: "ge";
+        readonly LESS_THAN_OR_EQUALS: "le";
+        readonly STARTS_AFTER: "sa";
+        readonly ENDS_BEFORE: "eb";
+        readonly APPROXIMATELY: "ap";
+        readonly CONTAINS: "contains";
+        readonly STARTS_WITH: "sw";
+        readonly EXACT: "exact";
+        readonly TEXT: "text";
+        readonly NOT: "not";
+        readonly ABOVE: "above";
+        readonly BELOW: "below";
+        readonly IN: "in";
+        readonly NOT_IN: "not-in";
+        readonly OF_TYPE: "of-type";
+        readonly MISSING: "missing";
+        readonly PRESENT: "present";
+        readonly IDENTIFIER: "identifier";
+        readonly ITERATE: "iterate";
+    };
     OperatorPrecedence: {
         FunctionCall: number;
         Dot: number;
@@ -571,6 +797,11 @@ declare const Medplum: {
     OrAtom: typeof MedplumCore.OrAtom;
     Parser: typeof MedplumCore.Parser;
     ParserBuilder: typeof MedplumCore.ParserBuilder;
+    PATIENT_PREFERRED_PHARMACY_URL: "http://hl7.org/fhir/StructureDefinition/patient-preferredPharmacy";
+    PHARMACY_PREFERENCE_TYPE_SYSTEM: "https://medplum.com/fhir/CodeSystem/pharmacy-preference-type";
+    PHARMACY_TYPE_PREFERRED: "preferred";
+    PHARMACY_TYPE_PRIMARY: "primary";
+    Pointer: typeof MedplumCore.Pointer;
     preconditionFailed: import("@medplum/fhirtypes").OperationOutcome;
     PrefixOperatorAtom: typeof MedplumCore.PrefixOperatorAtom;
     projectAdminResourceTypes: string[];
@@ -590,6 +821,8 @@ declare const Medplum: {
         readonly Distance: "Distance";
         readonly Dosage: "Dosage";
         readonly Duration: "Duration";
+        readonly Element: "Element";
+        readonly ElementDefinition: "ElementDefinition";
         readonly Expression: "Expression";
         readonly Extension: "Extension";
         readonly HumanName: "HumanName";
@@ -597,6 +830,7 @@ declare const Medplum: {
         readonly MarketingStatus: "MarketingStatus";
         readonly Meta: "Meta";
         readonly Money: "Money";
+        readonly MoneyQuantity: "MoneyQuantity";
         readonly Narrative: "Narrative";
         readonly ParameterDefinition: "ParameterDefinition";
         readonly Period: "Period";
@@ -610,6 +844,7 @@ declare const Medplum: {
         readonly RelatedArtifact: "RelatedArtifact";
         readonly SampledData: "SampledData";
         readonly Signature: "Signature";
+        readonly SimpleQuantity: "SimpleQuantity";
         readonly SubstanceAmount: "SubstanceAmount";
         readonly SystemString: "http://hl7.org/fhirpath/System.String";
         readonly Timing: "Timing";
@@ -634,17 +869,43 @@ declare const Medplum: {
         readonly uri: "uri";
         readonly url: "url";
         readonly uuid: "uuid";
+        readonly xhtml: "xhtml";
     };
     protectedResourceTypes: string[];
+    RATE_LIMIT_RESET_EXTENSION_URL: "https://medplum.com/fhir/StructureDefinition/rate-limit-reset";
     ReadablePromise: typeof MedplumCore.ReadablePromise;
+    readInteractions: MedplumCore.AccessPolicyInteraction[];
     ReconnectingWebSocket: typeof MedplumCore.ReconnectingWebSocket;
+    ReturnAckCategory: {
+        readonly FIRST: "first";
+        readonly APPLICATION: "application";
+    };
     RXNORM: "http://www.nlm.nih.gov/research/umls/rxnorm";
-    SearchParameterType: typeof MedplumCore.SearchParameterType;
-    sleep: (ms: number) => Promise<void>;
+    SchedulingEncounterCodingURI: "https://medplum.com/fhir/StructureDefinition/SchedulingEncounterCoding";
+    SchedulingParametersURI: "https://medplum.com/fhir/StructureDefinition/SchedulingParameters";
+    SchedulingPlanDefinitionURI: "https://medplum.com/fhir/StructureDefinition/SchedulingPlanDefinition";
+    SchedulingScheduleColorURI: "https://medplum.com/fhir/StructureDefinition/SchedulingColor";
+    SearchParameterType: {
+        readonly BOOLEAN: "BOOLEAN";
+        readonly NUMBER: "NUMBER";
+        readonly QUANTITY: "QUANTITY";
+        readonly TEXT: "TEXT";
+        readonly REFERENCE: "REFERENCE";
+        readonly CANONICAL: "CANONICAL";
+        readonly DATE: "DATE";
+        readonly DATETIME: "DATETIME";
+        readonly PERIOD: "PERIOD";
+        readonly UUID: "UUID";
+    };
+    ServiceTypeReferenceURI: "https://medplum.com/fhir/service-type-reference";
+    sleep: (ms: number, options?: MedplumCore.SleepOptions) => Promise<void>;
     SNOMED: "http://snomed.info/sct";
     SubscriptionEmitter: typeof MedplumCore.SubscriptionEmitter;
     SubscriptionManager: typeof MedplumCore.SubscriptionManager;
     SymbolAtom: typeof MedplumCore.SymbolAtom;
+    test: typeof MedplumCore.test;
+    TestError: typeof MedplumCore.TestError;
+    TimezoneExtensionURI: "http://hl7.org/fhir/StructureDefinition/timezone";
     Tokenizer: typeof MedplumCore.Tokenizer;
     tooManyRequests: import("@medplum/fhirtypes").OperationOutcome;
     TransformMapCollection: typeof MedplumCore.TransformMapCollection;
@@ -655,6 +916,7 @@ declare const Medplum: {
     unauthorizedTokenAudience: import("@medplum/fhirtypes").OperationOutcome;
     unauthorizedTokenExpired: import("@medplum/fhirtypes").OperationOutcome;
     UnionAtom: typeof MedplumCore.UnionAtom;
+    unsupportedMediaType: import("@medplum/fhirtypes").OperationOutcome;
     VALID_HOSTNAME_REGEX: RegExp;
     validationRegexes: Record<string, RegExp>;
     XorAtom: typeof MedplumCore.XorAtom;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ovok/core",
-  "version": "0.2.53",
+  "version": "0.2.55",
   "private": false,
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -29,13 +29,9 @@
     "type": "git",
     "url": "git+https://github.com/Actimi/ovok-react-sdk.git"
   },
-  "dependencies": {
-    "@medplum/core": "^3.2.19",
-    "@medplum/react-hooks": "^3.2.19"
-  },
   "devDependencies": {
     "@eslint/js": "^9.15.0",
-    "@medplum/fhirtypes": "^3.2.22",
+    "@medplum/fhirtypes": "^5.1.26",
     "@release-it/conventional-changelog": "^5.0.0",
     "@stylistic/eslint-plugin": "^2.12.1",
     "@types/jest": "^29.5.14",
@@ -53,11 +49,15 @@
     "ts-jest": "^29.2.5",
     "ts-node": "^10.9.2",
     "typescript": "^5.3.3",
-    "typescript-eslint": "^8.15.0"
+    "typescript-eslint": "^8.15.0",
+    "@medplum/core": "^5.1.26",
+    "@medplum/react-hooks": "^5.1.26"
   },
   "peerDependencies": {
-    "@medplum/fhirtypes": "^3.2.22",
-    "react": "*"
+    "@medplum/fhirtypes": ">=3.2.22",
+    "react": "*",
+    "@medplum/core": ">=3.2.19",
+    "@medplum/react-hooks": ">=3.2.19"
   },
   "release-it": {
     "git": {