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";