@ovok/core 0.2.47

package/dist/index.d.ts

@@ -0,0 +1,666 @@
+import * as MedplumCore from "@medplum/core";
+export * from "./types";
+declare const Medplum: {
+    accepted(location: string): import("@medplum/fhirtypes").OperationOutcome;
+    addProfileToResource<T extends import("@medplum/fhirtypes").Resource = import("@medplum/fhirtypes").Resource>(resource: T, profileUrl: string): T;
+    append<T>(array: T[] | undefined, value: T): T[];
+    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;
+    arrayBufferToBase64(arrayBuffer: ArrayBufferLike | ArrayBufferView): string;
+    arrayBufferToHex(arrayBuffer: ArrayBufferLike | ArrayBufferView): string;
+    arrayify<T>(value: T | T[] | undefined): T[] | undefined;
+    assert(condition: unknown, msg?: string): asserts condition;
+    assertContextVersionOptional(event: string): asserts event is MedplumCore.FhircastEventVersionOptional;
+    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;
+    booleanToTypedValue(value: boolean): [MedplumCore.TypedValue];
+    buildElementsContext({ parentContext, path, elements, profileUrl, debugMode, accessPolicyResource, }: {
+        parentContext: MedplumCore.ElementsContextType | undefined;
+        path: string;
+        elements: Record<string, MedplumCore.InternalSchemaElement>;
+        profileUrl?: string;
+        debugMode?: boolean;
+        accessPolicyResource?: import("@medplum/fhirtypes").AccessPolicyResource;
+    }): MedplumCore.ElementsContextType | undefined;
+    buildTypeName(components: string[]): string;
+    calculateAge(birthDateStr: string, endDateStr?: string): {
+        years: number;
+        months: number;
+        days: number;
+    };
+    calculateAgeString(birthDateStr: string, endDateStr?: string): string | undefined;
+    canReadResourceType(accessPolicy: import("@medplum/fhirtypes").AccessPolicy, resourceType: import("@medplum/fhirtypes").ResourceType): boolean;
+    canWriteResource(accessPolicy: import("@medplum/fhirtypes").AccessPolicy, resource: import("@medplum/fhirtypes").Resource): boolean;
+    canWriteResourceType(accessPolicy: import("@medplum/fhirtypes").AccessPolicy, resourceType: import("@medplum/fhirtypes").ResourceType): boolean;
+    capitalize(word: string): string;
+    checkForNull(value: unknown, path: string, issues: import("@medplum/fhirtypes").OperationOutcomeIssue[]): void;
+    checkIfValidMedplumVersion(appName: string, version: string): Promise<boolean>;
+    clearReleaseCache(): void;
+    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;
+    convertContainedResourcesToBundle(resource: import("@medplum/fhirtypes").Resource & {
+        contained?: import("@medplum/fhirtypes").Resource[];
+    }): import("@medplum/fhirtypes").Bundle;
+    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>;
+    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>;
+    createOperationOutcomeIssue(severity: MedplumCore.IssueSeverity, code: MedplumCore.IssueType, message: string, path: string, data?: Record<string, any>): import("@medplum/fhirtypes").OperationOutcomeIssue;
+    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;
+    decodeBase64(data: string): string;
+    deepClone<T>(input: T): T;
+    deepEquals(object1: unknown, object2: unknown, path?: string): boolean;
+    deepIncludes(value: any, pattern: any): boolean;
+    encodeBase64(data: string): 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[];
+    evalSqlOnFhir(view: import("@medplum/fhirtypes").ViewDefinition, resources: import("@medplum/fhirtypes").Resource[]): MedplumCore.OutputRow[];
+    fetchLatestVersionString(appName: string): Promise<string>;
+    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[];
+    fhirPathArrayNotEquals(x: MedplumCore.TypedValue[], y: MedplumCore.TypedValue[]): MedplumCore.TypedValue[];
+    fhirPathEquals(x: MedplumCore.TypedValue, y: MedplumCore.TypedValue): MedplumCore.TypedValue[];
+    fhirPathEquivalent(x: MedplumCore.TypedValue, y: MedplumCore.TypedValue): MedplumCore.TypedValue[];
+    fhirPathIs(typedValue: MedplumCore.TypedValue, desiredType: string): boolean;
+    fhirPathNot(input: MedplumCore.TypedValue[]): MedplumCore.TypedValue[];
+    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;
+    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;
+    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;
+    formatDateTime(dateTime: string | undefined, locales?: Intl.LocalesArgument, options?: Intl.DateTimeFormatOptions): string;
+    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;
+    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;
+    formatQuantity(quantity: import("@medplum/fhirtypes").Quantity | undefined, precision?: number): string;
+    formatRange(range: import("@medplum/fhirtypes").Range | undefined, precision?: number, exclusive?: boolean): string;
+    formatReferenceString(value: import("@medplum/fhirtypes").Reference | undefined): string;
+    formatSearchQuery(definition: MedplumCore.SearchRequest): string;
+    formatTime(time: string | undefined, locales?: Intl.LocalesArgument, options?: Intl.DateTimeFormatOptions): string;
+    formatTiming(timing: import("@medplum/fhirtypes").Timing | undefined): string;
+    generateId(): string;
+    getAllDataTypes(): MedplumCore.DataTypesMap;
+    getAllQuestionnaireAnswers(response: import("@medplum/fhirtypes").QuestionnaireResponse): Record<string, import("@medplum/fhirtypes").QuestionnaireResponseItemAnswer[]>;
+    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;
+    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;
+    getExtensionValue(resource: any, ...urls: string[]): import("@medplum/fhirtypes").ExtensionValue | undefined;
+    getIdentifier(resource: import("@medplum/fhirtypes").Resource, system: string): string | undefined;
+    getImageSrc(resource: import("@medplum/fhirtypes").Resource): string | undefined;
+    getNestedProperty(value: MedplumCore.TypedValueWithPath | undefined, key: string, options: {
+        profileUrl?: string;
+        withPath: true;
+    }): (MedplumCore.TypedValueWithPath | MedplumCore.TypedValueWithPath[])[];
+    getNestedProperty(value: MedplumCore.TypedValue | undefined, key: string, options?: {
+        profileUrl?: string;
+        withPath?: false;
+    }): (MedplumCore.TypedValue | MedplumCore.TypedValue[] | undefined)[];
+    getPathDifference(parentPath: string, path: string): string | undefined;
+    getPathDisplayName(path: string): string;
+    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;
+    getResourceTypes(): import("@medplum/fhirtypes").ResourceType[];
+    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;
+    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;
+    getTypedPropertyValueWithPath(input: MedplumCore.TypedValue | MedplumCore.TypedValueWithPath, path: string, options?: MedplumCore.GetTypedPropertyValueOptions): MedplumCore.TypedValueWithPath[] | MedplumCore.TypedValueWithPath;
+    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;
+    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;
+    indexStructureDefinitionBundle(bundle: import("@medplum/fhirtypes").StructureDefinition[] | import("@medplum/fhirtypes").Bundle): void;
+    inflateBaseSchema(base: MedplumCore.BaseSchema): MedplumCore.DataTypesMap;
+    inflateElement(path: string, partial: Partial<MedplumCore.InternalSchemaElement>): MedplumCore.InternalSchemaElement;
+    initFhirPathParserBuilder(): MedplumCore.ParserBuilder;
+    isAccepted(outcome: import("@medplum/fhirtypes").OperationOutcome): boolean;
+    isCodeableConcept(value: unknown): value is import("@medplum/fhirtypes").CodeableConcept & {
+        coding: import("@medplum/fhirtypes").Coding[];
+    };
+    isCoding(value: unknown): value is import("@medplum/fhirtypes").Coding & {
+        code: string;
+    };
+    isCompletedSubscriptionRequest(subscriptionRequest: MedplumCore.SubscriptionRequest | MedplumCore.PendingSubscriptionRequest): subscriptionRequest is MedplumCore.SubscriptionRequest;
+    isComplexTypeCode(code: string): boolean;
+    isConflict(outcome: import("@medplum/fhirtypes").OperationOutcome): boolean;
+    isContextVersionRequired(event: string): event is MedplumCore.FhircastEventVersionRequired;
+    isCreated(outcome: import("@medplum/fhirtypes").OperationOutcome): boolean;
+    isDataTypeLoaded(type: string): boolean;
+    isDateString(input: unknown): input is string;
+    isDateTimeString(input: unknown): input is string;
+    isEmpty(v: unknown): boolean;
+    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;
+    isMedplumAccessToken(accessToken: string): 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;
+    isPeriod(input: unknown): input is import("@medplum/fhirtypes").Period;
+    isPopulated<T extends {
+        length: number;
+    } | object>(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 & {
+        reference: string;
+    };
+    isResource(value: unknown): value is import("@medplum/fhirtypes").Resource;
+    isResourceType(resourceType: string): boolean;
+    isResourceTypeSchema(typeSchema: MedplumCore.InternalTypeSchema): boolean;
+    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;
+    };
+    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;
+    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;
+    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;
+    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>;
+    parseFhirPath(input: string): MedplumCore.FhirPathAtom;
+    parseFilterParameter(input: string): MedplumCore.FhirFilterExpression;
+    parseHl7DateTime(hl7DateTime: string | undefined, options?: MedplumCore.Hl7DateParseOptions): string | undefined;
+    parseJWTPayload(token: string): Record<string, number | string>;
+    parseLogLevel(level: string): MedplumCore.LogLevel;
+    parseMappingLanguage(input: string): import("@medplum/fhirtypes").StructureMap;
+    parseParameter(searchParam: import("@medplum/fhirtypes").SearchParameter, 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>;
+    parseStructureDefinition(sd: import("@medplum/fhirtypes").StructureDefinition): MedplumCore.InternalTypeSchema;
+    parseXFhirQuery(query: string, variables: Record<string, MedplumCore.TypedValue>): MedplumCore.SearchRequest;
+    preciseEquals(a: number, b: number, precision?: number): boolean;
+    preciseGreaterThan(a: number, b: number, precision?: number): boolean;
+    preciseGreaterThanOrEquals(a: number, b: number, precision?: number): boolean;
+    preciseLessThan(a: number, b: number, precision?: number): boolean;
+    preciseLessThanOrEquals(a: number, b: number, precision?: number): boolean;
+    preciseRound(a: number, precision: number): number;
+    redirect(url: URL): import("@medplum/fhirtypes").OperationOutcome;
+    removeDuplicates(arr: MedplumCore.TypedValue[]): MedplumCore.TypedValue[];
+    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;
+    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;
+    serializeFhircastSubscriptionRequest(subscriptionRequest: MedplumCore.SubscriptionRequest | MedplumCore.PendingSubscriptionRequest): string;
+    serverError(err: Error): import("@medplum/fhirtypes").OperationOutcome;
+    serverTimeout(msg?: string): import("@medplum/fhirtypes").OperationOutcome;
+    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;
+    singleton(collection: MedplumCore.TypedValue[], type?: string): MedplumCore.TypedValue | undefined;
+    singularize<T>(value: T | T[] | undefined): T | undefined;
+    sortStringArray(array: string[]): string[];
+    splitN(str: string, delim: string, n: number): string[];
+    splitSearchOnComma(input: string): string[];
+    streamToBuffer(stream: import("stream").Readable): Promise<Buffer>;
+    stringify(value: any, pretty?: boolean): string;
+    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;
+    toJsBoolean(obj: MedplumCore.TypedValue[]): boolean;
+    toPeriod(input: unknown): import("@medplum/fhirtypes").Period | undefined;
+    toTypedValue(value: unknown): MedplumCore.TypedValue;
+    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;
+    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;
+    warnIfNewerVersionAvailable(appName: string, params?: Record<string, string>): Promise<void>;
+    wordWrap(text: string, maxLength: number): string[];
+    AccessPolicyInteraction: typeof MedplumCore.AccessPolicyInteraction;
+    allOk: import("@medplum/fhirtypes").OperationOutcome;
+    AndAtom: typeof MedplumCore.AndAtom;
+    ArithemticOperatorAtom: typeof MedplumCore.ArithemticOperatorAtom;
+    AsAtom: typeof MedplumCore.AsAtom;
+    BooleanInfixOperatorAtom: typeof MedplumCore.BooleanInfixOperatorAtom;
+    ClientStorage: typeof MedplumCore.ClientStorage;
+    ConcatAtom: typeof MedplumCore.ConcatAtom;
+    ContainsAtom: typeof MedplumCore.ContainsAtom;
+    ContentType: {
+        readonly CSS: "text/css";
+        readonly DICOM: "application/dicom";
+        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 JSON: "application/json";
+        readonly JSON_PATCH: "application/json-patch+json";
+        readonly PNG: "image/png";
+        readonly SCIM_JSON: "application/scim+json";
+        readonly SVG: "image/svg+xml";
+        readonly TEXT: "text/plain";
+        readonly TYPESCRIPT: "text/typescript";
+        readonly PING: "x-application/ping";
+        readonly XML: "text/xml";
+        readonly CDA_XML: "application/cda+xml";
+    };
+    CPT: "http://www.ama-assn.org/go/cpt";
+    created: import("@medplum/fhirtypes").OperationOutcome;
+    DEFAULT_ACCEPT: string;
+    DEFAULT_MAX_SEARCH_COUNT: 1000;
+    DEFAULT_SEARCH_COUNT: 20;
+    DotAtom: typeof MedplumCore.DotAtom;
+    EmptySetAtom: typeof MedplumCore.EmptySetAtom;
+    EqualsAtom: typeof MedplumCore.EqualsAtom;
+    EquivalentAtom: typeof MedplumCore.EquivalentAtom;
+    EventTarget: typeof MedplumCore.EventTarget;
+    ExternalSecretSystems: {
+        readonly aws_ssm_parameter_store: "aws_ssm_parameter_store";
+    };
+    FHIRCAST_EVENT_NAMES: {
+        readonly "Patient-open": "Patient-open";
+        readonly "Patient-close": "Patient-close";
+        readonly "ImagingStudy-open": "ImagingStudy-open";
+        readonly "ImagingStudy-close": "ImagingStudy-close";
+        readonly "Encounter-open": "Encounter-open";
+        readonly "Encounter-close": "Encounter-close";
+        readonly "DiagnosticReport-open": "DiagnosticReport-open";
+        readonly "DiagnosticReport-close": "DiagnosticReport-close";
+        readonly "DiagnosticReport-select": "DiagnosticReport-select";
+        readonly "DiagnosticReport-update": "DiagnosticReport-update";
+        readonly syncerror: "syncerror";
+    };
+    FHIRCAST_EVENT_RESOURCES: {
+        readonly "Patient-open": {
+            readonly patient: {
+                readonly resourceType: "Patient";
+            };
+            readonly encounter: {
+                readonly resourceType: "Encounter";
+                readonly optional: true;
+            };
+        };
+        readonly "Patient-close": {
+            readonly patient: {
+                readonly resourceType: "Patient";
+            };
+            readonly encounter: {
+                readonly resourceType: "Encounter";
+                readonly optional: true;
+            };
+        };
+        readonly "ImagingStudy-open": {
+            readonly study: {
+                readonly resourceType: "ImagingStudy";
+            };
+            readonly encounter: {
+                readonly resourceType: "Encounter";
+                readonly optional: true;
+            };
+            readonly patient: {
+                readonly resourceType: "Patient";
+                readonly optional: true;
+            };
+        };
+        readonly "ImagingStudy-close": {
+            readonly study: {
+                readonly resourceType: "ImagingStudy";
+            };
+            readonly encounter: {
+                readonly resourceType: "Encounter";
+                readonly optional: true;
+            };
+            readonly patient: {
+                readonly resourceType: "Patient";
+                readonly optional: true;
+            };
+        };
+        readonly "Encounter-open": {
+            readonly encounter: {
+                readonly resourceType: "Encounter";
+            };
+            readonly patient: {
+                readonly resourceType: "Patient";
+            };
+        };
+        readonly "Encounter-close": {
+            readonly encounter: {
+                readonly resourceType: "Encounter";
+            };
+            readonly patient: {
+                readonly resourceType: "Patient";
+            };
+        };
+        readonly "DiagnosticReport-open": {
+            readonly report: {
+                readonly resourceType: "DiagnosticReport";
+            };
+            readonly encounter: {
+                readonly resourceType: "Encounter";
+                readonly optional: true;
+            };
+            readonly study: {
+                readonly resourceType: "ImagingStudy";
+                readonly optional: true;
+                readonly manyAllowed: true;
+            };
+            readonly patient: {
+                readonly resourceType: "Patient";
+            };
+        };
+        readonly "DiagnosticReport-close": {
+            readonly report: {
+                readonly resourceType: "DiagnosticReport";
+            };
+            readonly encounter: {
+                readonly resourceType: "Encounter";
+                readonly optional: true;
+            };
+            readonly study: {
+                readonly resourceType: "ImagingStudy";
+                readonly optional: true;
+                readonly manyAllowed: true;
+            };
+            readonly patient: {
+                readonly resourceType: "Patient";
+            };
+        };
+        readonly "DiagnosticReport-select": {
+            readonly report: {
+                readonly resourceType: "DiagnosticReport";
+                readonly reference: true;
+            };
+            readonly patient: {
+                readonly resourceType: "Patient";
+                readonly optional: true;
+                readonly reference: true;
+            };
+            readonly select: {
+                readonly resourceType: "*";
+                readonly array: true;
+                readonly reference: true;
+            };
+        };
+        readonly "DiagnosticReport-update": {
+            readonly report: {
+                readonly resourceType: "DiagnosticReport";
+                readonly reference: true;
+            };
+            readonly patient: {
+                readonly resourceType: "Patient";
+                readonly optional: true;
+                readonly reference: true;
+            };
+            readonly updates: {
+                readonly resourceType: "Bundle";
+            };
+        };
+        readonly syncerror: {
+            readonly operationoutcome: {
+                readonly resourceType: "OperationOutcome";
+            };
+        };
+    };
+    FHIRCAST_EVENT_VERSION_REQUIRED: readonly ["DiagnosticReport-update"];
+    FHIRCAST_RESOURCE_TYPES: readonly ["Patient", "Encounter", "ImagingStudy", "DiagnosticReport", "OperationOutcome", "Bundle"];
+    FhircastConnection: typeof MedplumCore.FhircastConnection;
+    FhirFilterComparison: typeof MedplumCore.FhirFilterComparison;
+    FhirFilterConnective: typeof MedplumCore.FhirFilterConnective;
+    FhirFilterNegation: typeof MedplumCore.FhirFilterNegation;
+    FhirPathAtom: typeof MedplumCore.FhirPathAtom;
+    fhirTypeToJsType: {
+        readonly base64Binary: "string";
+        readonly boolean: "boolean";
+        readonly canonical: "string";
+        readonly code: "string";
+        readonly date: "string";
+        readonly dateTime: "string";
+        readonly decimal: "number";
+        readonly id: "string";
+        readonly instant: "string";
+        readonly integer: "number";
+        readonly integer64: "string";
+        readonly markdown: "string";
+        readonly oid: "string";
+        readonly positiveInt: "number";
+        readonly string: "string";
+        readonly time: "string";
+        readonly unsignedInt: "number";
+        readonly uri: "string";
+        readonly url: "string";
+        readonly uuid: "string";
+        readonly xhtml: "string";
+        readonly "http://hl7.org/fhirpath/System.String": "string";
+    };
+    FileBuilder: typeof MedplumCore.FileBuilder;
+    forbidden: import("@medplum/fhirtypes").OperationOutcome;
+    FunctionAtom: typeof MedplumCore.FunctionAtom;
+    globalSchema: MedplumCore.IndexedStructureDefinition;
+    gone: import("@medplum/fhirtypes").OperationOutcome;
+    Hl7Context: typeof MedplumCore.Hl7Context;
+    Hl7Field: typeof MedplumCore.Hl7Field;
+    Hl7Message: typeof MedplumCore.Hl7Message;
+    Hl7Segment: typeof MedplumCore.Hl7Segment;
+    HTTP_HL7_ORG: "http://hl7.org";
+    HTTP_TERMINOLOGY_HL7_ORG: "http://terminology.hl7.org";
+    ICD10: "http://hl7.org/fhir/sid/icd-10";
+    ImpliesAtom: typeof MedplumCore.ImpliesAtom;
+    InAtom: typeof MedplumCore.InAtom;
+    IndexerAtom: typeof MedplumCore.IndexerAtom;
+    InfixOperatorAtom: typeof MedplumCore.InfixOperatorAtom;
+    IsAtom: typeof MedplumCore.IsAtom;
+    LiteralAtom: typeof MedplumCore.LiteralAtom;
+    Logger: typeof MedplumCore.Logger;
+    LogLevel: typeof MedplumCore.LogLevel;
+    LOINC: "http://loinc.org";
+    LRUCache: typeof MedplumCore.LRUCache;
+    MEDPLUM_CLI_CLIENT_ID: "medplum-cli";
+    MEDPLUM_RELEASES_URL: "https://meta.medplum.com/releases";
+    MEDPLUM_VERSION: string;
+    MedplumKeyValueClient: typeof MedplumCore.MedplumKeyValueClient;
+    MemoryStorage: typeof MedplumCore.MemoryStorage;
+    MockAsyncClientStorage: typeof MedplumCore.MockAsyncClientStorage;
+    multipleMatches: import("@medplum/fhirtypes").OperationOutcome;
+    NDC: "http://hl7.org/fhir/sid/ndc";
+    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;
+    OperationOutcomeError: typeof MedplumCore.OperationOutcomeError;
+    Operator: typeof MedplumCore.Operator;
+    OperatorPrecedence: {
+        FunctionCall: number;
+        Dot: number;
+        Indexer: number;
+        UnaryAdd: number;
+        UnarySubtract: number;
+        Multiply: number;
+        Divide: number;
+        IntegerDivide: number;
+        Modulo: number;
+        Add: number;
+        Subtract: number;
+        Ampersand: number;
+        Is: number;
+        As: number;
+        Union: number;
+        GreaterThan: number;
+        GreaterThanOrEquals: number;
+        LessThan: number;
+        LessThanOrEquals: number;
+        Equals: number;
+        Equivalent: number;
+        NotEquals: number;
+        NotEquivalent: number;
+        In: number;
+        Contains: number;
+        And: number;
+        Xor: number;
+        Or: number;
+        Implies: number;
+        Arrow: number;
+        Semicolon: number;
+    };
+    OrAtom: typeof MedplumCore.OrAtom;
+    Parser: typeof MedplumCore.Parser;
+    ParserBuilder: typeof MedplumCore.ParserBuilder;
+    preconditionFailed: import("@medplum/fhirtypes").OperationOutcome;
+    PrefixOperatorAtom: typeof MedplumCore.PrefixOperatorAtom;
+    projectAdminResourceTypes: string[];
+    PropertyType: {
+        readonly Address: "Address";
+        readonly Age: "Age";
+        readonly Annotation: "Annotation";
+        readonly Attachment: "Attachment";
+        readonly BackboneElement: "BackboneElement";
+        readonly CodeableConcept: "CodeableConcept";
+        readonly Coding: "Coding";
+        readonly ContactDetail: "ContactDetail";
+        readonly ContactPoint: "ContactPoint";
+        readonly Contributor: "Contributor";
+        readonly Count: "Count";
+        readonly DataRequirement: "DataRequirement";
+        readonly Distance: "Distance";
+        readonly Dosage: "Dosage";
+        readonly Duration: "Duration";
+        readonly Expression: "Expression";
+        readonly Extension: "Extension";
+        readonly HumanName: "HumanName";
+        readonly Identifier: "Identifier";
+        readonly MarketingStatus: "MarketingStatus";
+        readonly Meta: "Meta";
+        readonly Money: "Money";
+        readonly Narrative: "Narrative";
+        readonly ParameterDefinition: "ParameterDefinition";
+        readonly Period: "Period";
+        readonly Population: "Population";
+        readonly ProdCharacteristic: "ProdCharacteristic";
+        readonly ProductShelfLife: "ProductShelfLife";
+        readonly Quantity: "Quantity";
+        readonly Range: "Range";
+        readonly Ratio: "Ratio";
+        readonly Reference: "Reference";
+        readonly RelatedArtifact: "RelatedArtifact";
+        readonly SampledData: "SampledData";
+        readonly Signature: "Signature";
+        readonly SubstanceAmount: "SubstanceAmount";
+        readonly SystemString: "http://hl7.org/fhirpath/System.String";
+        readonly Timing: "Timing";
+        readonly TriggerDefinition: "TriggerDefinition";
+        readonly UsageContext: "UsageContext";
+        readonly base64Binary: "base64Binary";
+        readonly boolean: "boolean";
+        readonly canonical: "canonical";
+        readonly code: "code";
+        readonly date: "date";
+        readonly dateTime: "dateTime";
+        readonly decimal: "decimal";
+        readonly id: "id";
+        readonly instant: "instant";
+        readonly integer: "integer";
+        readonly markdown: "markdown";
+        readonly oid: "oid";
+        readonly positiveInt: "positiveInt";
+        readonly string: "string";
+        readonly time: "time";
+        readonly unsignedInt: "unsignedInt";
+        readonly uri: "uri";
+        readonly url: "url";
+        readonly uuid: "uuid";
+    };
+    protectedResourceTypes: string[];
+    ReadablePromise: typeof MedplumCore.ReadablePromise;
+    ReconnectingWebSocket: typeof MedplumCore.ReconnectingWebSocket;
+    RXNORM: "http://www.nlm.nih.gov/research/umls/rxnorm";
+    SearchParameterType: typeof MedplumCore.SearchParameterType;
+    sleep: (ms: number) => Promise<void>;
+    SNOMED: "http://snomed.info/sct";
+    SubscriptionEmitter: typeof MedplumCore.SubscriptionEmitter;
+    SubscriptionManager: typeof MedplumCore.SubscriptionManager;
+    SymbolAtom: typeof MedplumCore.SymbolAtom;
+    Tokenizer: typeof MedplumCore.Tokenizer;
+    tooManyRequests: import("@medplum/fhirtypes").OperationOutcome;
+    TransformMapCollection: typeof MedplumCore.TransformMapCollection;
+    TypedEventTarget: typeof MedplumCore.TypedEventTarget;
+    UCUM: "http://unitsofmeasure.org";
+    UnaryOperatorAtom: typeof MedplumCore.UnaryOperatorAtom;
+    unauthorized: import("@medplum/fhirtypes").OperationOutcome;
+    unauthorizedTokenAudience: import("@medplum/fhirtypes").OperationOutcome;
+    unauthorizedTokenExpired: import("@medplum/fhirtypes").OperationOutcome;
+    UnionAtom: typeof MedplumCore.UnionAtom;
+    VALID_HOSTNAME_REGEX: RegExp;
+    validationRegexes: Record<string, RegExp>;
+    XorAtom: typeof MedplumCore.XorAtom;
+};
+export { Medplum };
+export { OvokClient } from "./client/ovok-client";
+export * from "./hooks";
+export * from "./utils";
+export * from "./client/observation/services";