@medplum/core 0.9.28 → 0.9.31

package/dist/cjs/jwt.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Parses the JWT payload.
+ * @param token JWT token
+ */
+export declare function parseJWTPayload(token: string): Record<string, number | string>;

package/dist/cjs/outcomes.d.ts

@@ -0,0 +1,30 @@
+import { OperationOutcome } from '@medplum/fhirtypes';
+export declare const allOk: OperationOutcome;
+export declare const created: OperationOutcome;
+export declare const notModified: OperationOutcome;
+export declare const notFound: OperationOutcome;
+export declare const unauthorized: OperationOutcome;
+export declare const forbidden: OperationOutcome;
+export declare const gone: OperationOutcome;
+export declare const tooManyRequests: OperationOutcome;
+export declare function badRequest(details: string, expression?: string): OperationOutcome;
+export declare function isOk(outcome: OperationOutcome): boolean;
+export declare function isNotFound(outcome: OperationOutcome): boolean;
+export declare function isGone(outcome: OperationOutcome): boolean;
+export declare function getStatus(outcome: OperationOutcome): number;
+/**
+ * Asserts that the operation completed successfully and that the resource is defined.
+ * @param outcome The operation outcome.
+ * @param resource The resource that may or may not have been returned.
+ */
+export declare function assertOk<T>(outcome: OperationOutcome, resource: T | undefined): asserts resource is T;
+export declare class OperationOutcomeError extends Error {
+    readonly outcome: OperationOutcome;
+    constructor(outcome: OperationOutcome);
+}
+/**
+ * Normalizes an error object into a displayable error string.
+ * @param error The error value which could be a string, Error, OperationOutcome, or other unknown type.
+ * @returns A display string for the error.
+ */
+export declare function normalizeErrorString(error: unknown): string;

package/dist/cjs/readablepromise.d.ts

@@ -0,0 +1,48 @@
+/**
+ * The ReadablePromise class wraps a request promise suitable for React Suspense.
+ * See: https://blog.logrocket.com/react-suspense-data-fetching/#wrappromise-js
+ * See: https://github.com/ovieokeh/suspense-data-fetching/blob/master/lib/api/wrapPromise.js
+ */
+export declare class ReadablePromise<T> implements Promise<T> {
+    #private;
+    readonly [Symbol.toStringTag]: string;
+    constructor(requestPromise: Promise<T>);
+    /**
+     * Returns true if the promise is pending.
+     * @returns True if the Promise is pending.
+     */
+    isPending(): boolean;
+    /**
+     * Returns true if the promise resolved successfully.
+     * @returns True if the Promise resolved successfully.
+     */
+    isOk(): boolean;
+    /**
+     * Attempts to read the value of the promise.
+     * If the promise is pending, this method will throw a promise.
+     * If the promise rejected, this method will throw the rejection reason.
+     * If the promise resolved, this method will return the resolved value.
+     * @returns The resolved value of the Promise.
+     */
+    read(): T;
+    /**
+     * Attaches callbacks for the resolution and/or rejection of the Promise.
+     * @param onfulfilled The callback to execute when the Promise is resolved.
+     * @param onrejected The callback to execute when the Promise is rejected.
+     * @returns A Promise for the completion of which ever callback is executed.
+     */
+    then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): Promise<TResult1 | TResult2>;
+    /**
+     * Attaches a callback for only the rejection of the Promise.
+     * @param onrejected The callback to execute when the Promise is rejected.
+     * @returns A Promise for the completion of the callback.
+     */
+    catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | undefined | null): Promise<T | TResult>;
+    /**
+     * Attaches a callback that is invoked when the Promise is settled (fulfilled or rejected). The
+     * resolved value cannot be modified from the callback.
+     * @param onfinally The callback to execute when the Promise is settled (fulfilled or rejected).
+     * @returns A Promise for the completion of the callback.
+     */
+    finally(onfinally?: (() => void) | undefined | null): Promise<T>;
+}

package/dist/cjs/search.d.ts

@@ -0,0 +1,64 @@
+export declare const DEFAULT_SEARCH_COUNT = 20;
+export interface SearchRequest {
+    readonly resourceType: string;
+    filters?: Filter[];
+    sortRules?: SortRule[];
+    offset?: number;
+    count?: number;
+    fields?: string[];
+    name?: string;
+    total?: 'none' | 'estimate' | 'accurate';
+}
+export interface Filter {
+    code: string;
+    operator: Operator;
+    value: string;
+    unitSystem?: string;
+    unitCode?: string;
+}
+export interface SortRule {
+    code: string;
+    descending?: boolean;
+}
+/**
+ * Search operators.
+ * These operators represent "modifiers" and "prefixes" in FHIR search.
+ * See: https://www.hl7.org/fhir/search.html
+ */
+export declare enum Operator {
+    EQUALS = "eq",
+    NOT_EQUALS = "ne",
+    GREATER_THAN = "gt",
+    LESS_THAN = "lt",
+    GREATER_THAN_OR_EQUALS = "ge",
+    LESS_THAN_OR_EQUALS = "le",
+    STARTS_AFTER = "sa",
+    ENDS_BEFORE = "eb",
+    APPROXIMATELY = "ap",
+    CONTAINS = "contains",
+    EXACT = "exact",
+    TEXT = "text",
+    NOT = "not",
+    ABOVE = "above",
+    BELOW = "below",
+    IN = "in",
+    NOT_IN = "not-in",
+    OF_TYPE = "of-type",
+    MISSING = "missing"
+}
+/**
+ * Parses a URL into a SearchRequest.
+ *
+ * See the FHIR search spec: http://hl7.org/fhir/r4/search.html
+ *
+ * @param url The URL to parse.
+ * @returns Parsed search definition.
+ */
+export declare function parseSearchDefinition(url: string): SearchRequest;
+/**
+ * Formats a search definition object into a query string.
+ * Note: The return value does not include the resource type.
+ * @param {!SearchRequest} definition The search definition.
+ * @returns Formatted URL.
+ */
+export declare function formatSearchQuery(definition: SearchRequest): string;

package/dist/cjs/searchparams.d.ts

@@ -0,0 +1,35 @@
+import { ElementDefinition, SearchParameter } from '@medplum/fhirtypes';
+import { IndexedStructureDefinition } from './types';
+export declare enum SearchParameterType {
+    BOOLEAN = "BOOLEAN",
+    NUMBER = "NUMBER",
+    QUANTITY = "QUANTITY",
+    TEXT = "TEXT",
+    REFERENCE = "REFERENCE",
+    DATE = "DATE",
+    DATETIME = "DATETIME",
+    PERIOD = "PERIOD"
+}
+export interface SearchParameterDetails {
+    readonly columnName: string;
+    readonly type: SearchParameterType;
+    readonly elementDefinition?: ElementDefinition;
+    readonly array?: boolean;
+}
+/**
+ * Returns the type details of a SearchParameter.
+ *
+ * The SearchParameter resource has a "type" parameter, but that is missing some critical information.
+ *
+ * For example:
+ *   1) The "date" type includes "date", "datetime", and "period".
+ *   2) The "token" type includes enums and booleans.
+ *   3) Arrays/multiple values are not reflected at all.
+ *
+ * @param structureDefinitions Collection of StructureDefinition resources indexed by name.
+ * @param resourceType The root resource type.
+ * @param searchParam The search parameter.
+ * @returns The search parameter type details.
+ */
+export declare function getSearchParameterDetails(structureDefinitions: IndexedStructureDefinition, resourceType: string, searchParam: SearchParameter): SearchParameterDetails;
+export declare function getExpressionForResourceType(resourceType: string, expression: string): string | undefined;

package/dist/cjs/storage.d.ts

@@ -0,0 +1,47 @@
+/**
+ * The ClientStorage class is a utility class for storing strings and objects.
+ *
+ * When using MedplumClient in the browser, it will be backed by browser localStorage.
+ *
+ * When Using MedplumClient in the server, it will be backed by the MemoryStorage class.
+ */
+export declare class ClientStorage {
+    #private;
+    constructor();
+    clear(): void;
+    getString(key: string): string | undefined;
+    setString(key: string, value: string | undefined): void;
+    getObject<T>(key: string): T | undefined;
+    setObject<T>(key: string, value: T): void;
+}
+/**
+ * The MemoryStorage class is a minimal in-memory implementation of the Storage interface.
+ */
+export declare class MemoryStorage implements Storage {
+    #private;
+    constructor();
+    /**
+     * Returns the number of key/value pairs.
+     */
+    get length(): number;
+    /**
+     * Removes all key/value pairs, if there are any.
+     */
+    clear(): void;
+    /**
+     * Returns the current value associated with the given key, or null if the given key does not exist.
+     */
+    getItem(key: string): string | null;
+    /**
+     * Sets the value of the pair identified by key to value, creating a new key/value pair if none existed for key previously.
+     */
+    setItem(key: string, value: string | null): void;
+    /**
+     * Removes the key/value pair with the given key, if a key/value pair with the given key exists.
+     */
+    removeItem(key: string): void;
+    /**
+     * Returns the name of the nth key, or null if n is greater than or equal to the number of key/value pairs.
+     */
+    key(index: number): string | null;
+}

package/dist/cjs/types.d.ts

@@ -0,0 +1,148 @@
+import { Bundle, ElementDefinition, SearchParameter, StructureDefinition } from '@medplum/fhirtypes';
+/**
+ * List of property types.
+ * http://www.hl7.org/fhir/valueset-defined-types.html
+ * The list here includes additions found from StructureDefinition resources.
+ */
+export declare enum PropertyType {
+    Address = "Address",
+    Age = "Age",
+    Annotation = "Annotation",
+    Attachment = "Attachment",
+    BackboneElement = "BackboneElement",
+    CodeableConcept = "CodeableConcept",
+    Coding = "Coding",
+    ContactDetail = "ContactDetail",
+    ContactPoint = "ContactPoint",
+    Contributor = "Contributor",
+    Count = "Count",
+    DataRequirement = "DataRequirement",
+    Distance = "Distance",
+    Dosage = "Dosage",
+    Duration = "Duration",
+    Expression = "Expression",
+    Extension = "Extension",
+    HumanName = "HumanName",
+    Identifier = "Identifier",
+    MarketingStatus = "MarketingStatus",
+    Meta = "Meta",
+    Money = "Money",
+    Narrative = "Narrative",
+    ParameterDefinition = "ParameterDefinition",
+    Period = "Period",
+    Population = "Population",
+    ProdCharacteristic = "ProdCharacteristic",
+    ProductShelfLife = "ProductShelfLife",
+    Quantity = "Quantity",
+    Range = "Range",
+    Ratio = "Ratio",
+    Reference = "Reference",
+    RelatedArtifact = "RelatedArtifact",
+    SampledData = "SampledData",
+    Signature = "Signature",
+    SubstanceAmount = "SubstanceAmount",
+    SystemString = "http://hl7.org/fhirpath/System.String",
+    Timing = "Timing",
+    TriggerDefinition = "TriggerDefinition",
+    UsageContext = "UsageContext",
+    base64Binary = "base64Binary",
+    boolean = "boolean",
+    canonical = "canonical",
+    code = "code",
+    date = "date",
+    dateTime = "dateTime",
+    decimal = "decimal",
+    id = "id",
+    instant = "instant",
+    integer = "integer",
+    markdown = "markdown",
+    oid = "oid",
+    positiveInt = "positiveInt",
+    string = "string",
+    time = "time",
+    unsignedInt = "unsignedInt",
+    uri = "uri",
+    url = "url",
+    uuid = "uuid"
+}
+/**
+ * An IndexedStructureDefinition is a lookup-optimized version of a StructureDefinition.
+ *
+ * StructureDefinition resources contain schema information for other resource types.
+ * These schemas can be used to automatically generate user interface elements for
+ * resources.
+ *
+ * However, a StructureDefinition resource is not optimized for realtime lookups.  All
+ * resource types, sub types, and property definitions are stored in a flat array of
+ * ElementDefinition objects.  Therefore, to lookup the schema for a property (i.e., "Patient.name")
+ * requires a linear scan of all ElementDefinition objects
+ *
+ * A StructureDefinition resource contains information about one or more types.
+ * For example, the "Patient" StructureDefinition includes "Patient", "Patient_Contact",
+ * "Patient_Communication", and "Patient_Link".  This is inefficient.
+ *
+ * Instead, we create an indexed version of the StructureDefinition, called IndexedStructureDefinition.
+ * In an IndexedStructureDefinition, retrieving a property definition is a hashtable lookup.
+ *
+ * The hierarchy is:
+ *   IndexedStructureDefinition - top level for one resource type
+ *   TypeSchema - one per resource type and all contained BackboneElements
+ *   PropertySchema - one per property/field
+ */
+export interface IndexedStructureDefinition {
+    types: {
+        [resourceType: string]: TypeSchema;
+    };
+}
+/**
+ * An indexed TypeSchema.
+ *
+ * Example:  The IndexedStructureDefinition for "Patient" would include the following TypeSchemas:
+ *   1) Patient
+ *   2) Patient_Contact
+ *   3) Patient_Communication
+ *   4) Patient_Link
+ */
+export interface TypeSchema {
+    display: string;
+    properties: {
+        [name: string]: ElementDefinition;
+    };
+    searchParams?: {
+        [code: string]: SearchParameter;
+    };
+    description?: string;
+    parentType?: string;
+}
+/**
+ * Creates a new empty IndexedStructureDefinition.
+ * @returns The empty IndexedStructureDefinition.
+ * @deprecated Use globalSchema
+ */
+export declare function createSchema(): IndexedStructureDefinition;
+export declare function createTypeSchema(typeName: string, description: string | undefined): TypeSchema;
+/**
+ * Indexes a bundle of StructureDefinitions for faster lookup.
+ * @param bundle A FHIR bundle StructureDefinition resources.
+ */
+export declare function indexStructureDefinitionBundle(bundle: Bundle): void;
+/**
+ * Indexes a StructureDefinition for fast lookup.
+ * See comments on IndexedStructureDefinition for more details.
+ * @param schema The output IndexedStructureDefinition.
+ * @param structureDefinition The original StructureDefinition.
+ */
+export declare function indexStructureDefinition(schema: IndexedStructureDefinition, structureDefinition: StructureDefinition): void;
+/**
+ * Indexes a SearchParameter resource for fast lookup.
+ * Indexes by SearchParameter.code, which is the query string parameter name.
+ * @param schema The output IndexedStructureDefinition.
+ * @param searchParam The SearchParameter resource.
+ */
+export declare function indexSearchParameter(schema: IndexedStructureDefinition, searchParam: SearchParameter): void;
+export declare function buildTypeName(components: string[]): string;
+export declare function getPropertyDisplayName(path: string): string;
+/**
+ * Global schema singleton.
+ */
+export declare const globalSchema: IndexedStructureDefinition;

package/dist/cjs/utils.d.ts

@@ -0,0 +1,245 @@
+import { CodeableConcept, ObservationDefinition, ObservationDefinitionQualifiedInterval, Patient, Practitioner, QuestionnaireResponse, QuestionnaireResponseItemAnswer, Range, Reference, RelatedPerson, Resource } from '@medplum/fhirtypes';
+/**
+ * @internal
+ */
+export declare type ProfileResource = Patient | Practitioner | RelatedPerson;
+/**
+ * Creates a reference resource.
+ * @param resource The FHIR reesource.
+ * @returns A reference resource.
+ */
+export declare function createReference<T extends Resource>(resource: T): Reference<T>;
+/**
+ * Returns a reference string for a resource.
+ * @param resource The FHIR resource.
+ * @returns A reference string of the form resourceType/id.
+ */
+export declare function getReferenceString(resource: Resource): string;
+/**
+ * Returns the ID portion of a reference.
+ * @param reference A FHIR reference.
+ * @returns The ID portion of a reference.
+ */
+export declare function resolveId(reference: Reference | undefined): string | undefined;
+/**
+ * Returns true if the resource is a "ProfileResource".
+ * @param resource The FHIR resource.
+ * @returns True if the resource is a "ProfileResource".
+ */
+export declare function isProfileResource(resource: Resource): boolean;
+/**
+ * Returns a display string for the resource.
+ * @param resource The input resource.
+ * @return Human friendly display string.
+ */
+export declare function getDisplayString(resource: Resource): string;
+/**
+ * Returns an image URL for the resource, if one is available.
+ * @param resource The input resource.
+ * @returns The image URL for the resource or undefined.
+ */
+export declare function getImageSrc(resource: Resource): string | undefined;
+/**
+ * Returns a Date property as a Date.
+ * When working with JSON objects, Dates are often serialized as ISO-8601 strings.
+ * When that happens, we need to safely convert to a proper Date object.
+ * @param date The date property value, which could be a string or a Date object.
+ * @returns A Date object.
+ */
+export declare function getDateProperty(date: string | undefined): Date | undefined;
+/**
+ * Calculates the age in years from the birth date.
+ * @param birthDateStr The birth date or start date in ISO-8601 format YYYY-MM-DD.
+ * @param endDateStr Optional end date in ISO-8601 format YYYY-MM-DD. Default value is today.
+ * @returns The age in years, months, and days.
+ */
+export declare function calculateAge(birthDateStr: string, endDateStr?: string): {
+    years: number;
+    months: number;
+    days: number;
+};
+/**
+ * Calculates the age string for display using the age appropriate units.
+ * If the age is greater than or equal to 2 years, then the age is displayed in years.
+ * If the age is greater than or equal to 1 month, then the age is displayed in months.
+ * Otherwise, the age is displayed in days.
+ * @param birthDateStr The birth date or start date in ISO-8601 format YYYY-MM-DD.
+ * @param endDateStr Optional end date in ISO-8601 format YYYY-MM-DD. Default value is today.
+ * @returns The age string.
+ */
+export declare function calculateAgeString(birthDateStr: string, endDateStr?: string): string | undefined;
+/**
+ * Returns all questionnaire answers as a map by link ID.
+ * @param response The questionnaire response resource.
+ * @returns Questionnaire answers mapped by link ID.
+ */
+export declare function getQuestionnaireAnswers(response: QuestionnaireResponse): Record<string, QuestionnaireResponseItemAnswer>;
+/**
+ * Returns the resource identifier for the given system.
+ *
+ * If multiple identifiers exist with the same system, the first one is returned.
+ *
+ * If the system is not found, then returns undefined.
+ *
+ * @param resource The resource to check.
+ * @param system The identifier system.
+ * @returns The identifier value if found; otherwise undefined.
+ */
+export declare function getIdentifier(resource: Resource, system: string): string | undefined;
+/**
+ * Returns an extension value by extension URLs.
+ * @param resource The base resource.
+ * @param urls Array of extension URLs.  Each entry represents a nested extension.
+ * @returns The extension value if found; undefined otherwise.
+ */
+export declare function getExtensionValue(resource: Resource, ...urls: string[]): string | undefined;
+/**
+ * FHIR JSON stringify.
+ * Removes properties with empty string values.
+ * Removes objects with zero properties.
+ * See: https://www.hl7.org/fhir/json.html
+ * @param value The input value.
+ * @param pretty Optional flag to pretty-print the JSON.
+ * @returns The resulting JSON string.
+ */
+export declare function stringify(value: any, pretty?: boolean): string;
+/**
+ * Returns true if the value is empty (null, undefined, empty string, or empty object).
+ * @param v Any value.
+ * @returns True if the value is an empty string or an empty object.
+ */
+export declare function isEmpty(v: any): boolean;
+/**
+ * Resource equality.
+ * Ignores meta.versionId and meta.lastUpdated.
+ * @param object1 The first object.
+ * @param object2 The second object.
+ * @returns True if the objects are equal.
+ */
+export declare function deepEquals(object1: unknown, object2: unknown, path?: string): boolean;
+/**
+ * Creates a deep clone of the input value.
+ *
+ * Limitations:
+ *  - Only supports JSON primitives and arrays.
+ *  - Does not support Functions, lambdas, etc.
+ *  - Does not support circular references.
+ *
+ * See: https://web.dev/structured-clone/
+ * See: https://stackoverflow.com/questions/40488190/how-is-structured-clone-algorithm-different-from-deep-copy
+ *
+ * @param input The input to clone.
+ * @returns A deep clone of the input.
+ */
+export declare function deepClone<T>(input: T): T;
+/**
+ * Returns true if the input string is a UUID.
+ * @param input The input string.
+ * @returns True if the input string matches the UUID format.
+ */
+export declare function isUUID(input: string): boolean;
+/**
+ * Returns true if the input is an object.
+ * @param object The candidate object.
+ * @returns True if the input is a non-null non-undefined object.
+ */
+export declare function isObject(obj: unknown): obj is Record<string, unknown>;
+/**
+ * Returns true if the input array is an array of strings.
+ * @param arr Input array.
+ * @returns True if the input array is an array of strings.
+ */
+export declare function isStringArray(arr: any[]): arr is string[];
+/**
+ * Converts an ArrayBuffer to hex string.
+ * See: https://stackoverflow.com/a/55200387
+ * @param arrayBuffer The input array buffer.
+ * @returns The resulting hex string.
+ */
+export declare function arrayBufferToHex(arrayBuffer: ArrayBuffer): string;
+/**
+ * Converts an ArrayBuffer to a base-64 encoded string.
+ * @param arrayBuffer The input array buffer.
+ * @returns The base-64 encoded string.
+ */
+export declare function arrayBufferToBase64(arrayBuffer: ArrayBuffer): string;
+export declare function capitalize(word: string): string;
+export declare function isLowerCase(c: string): boolean;
+/**
+ * Tries to find a code string for a given system within a given codeable concept.
+ * @param concept The codeable concept.
+ * @param system The system string.
+ * @returns The code if found; otherwise undefined.
+ */
+export declare function getCodeBySystem(concept: CodeableConcept, system: string): string | undefined;
+/**
+ * Sets a code for a given system within a given codeable concept.
+ * @param concept The codeable concept.
+ * @param system The system string.
+ * @param code The code value.
+ */
+export declare function setCodeBySystem(concept: CodeableConcept, system: string, code: string): void;
+/**
+ * Tries to find an observation interval for the given patient and value.
+ * @param definition The observation definition.
+ * @param patient The patient.
+ * @param value The observation value.
+ * @returns The observation interval if found; otherwise undefined.
+ */
+export declare function findObservationInterval(definition: ObservationDefinition, patient: Patient, value: number, category?: 'reference' | 'critical' | 'absolute'): ObservationDefinitionQualifiedInterval | undefined;
+/**
+ * Tries to find an observation reference range for the given patient and condition names.
+ * @param definition The observation definition.
+ * @param patient The patient.
+ * @param names The condition names.
+ * @returns The observation interval if found; otherwise undefined.
+ */
+export declare function findObservationReferenceRange(definition: ObservationDefinition, patient: Patient, names: string[]): ObservationDefinitionQualifiedInterval | undefined;
+/**
+ * Returns true if the value is in the range accounting for precision.
+ * @param value The numeric value.
+ * @param range The numeric range.
+ * @param precision Optional precision in number of digits.
+ * @returns True if the value is within the range.
+ */
+export declare function matchesRange(value: number, range: Range, precision?: number): boolean;
+/**
+ * Returns true if the two numbers are equal to the given precision.
+ * @param a The first number.
+ * @param b The second number.
+ * @param precision Optional precision in number of digits.
+ * @returns True if the two numbers are equal to the given precision.
+ */
+export declare function preciseEquals(a: number, b: number, precision?: number): boolean;
+/**
+ * Returns true if the first number is less than the second number to the given precision.
+ * @param a The first number.
+ * @param b The second number.
+ * @param precision Optional precision in number of digits.
+ * @returns True if the first number is less than the second number to the given precision.
+ */
+export declare function preciseLessThan(a: number, b: number, precision?: number): boolean;
+/**
+ * Returns true if the first number is greater than the second number to the given precision.
+ * @param a The first number.
+ * @param b The second number.
+ * @param precision Optional precision in number of digits.
+ * @returns True if the first number is greater than the second number to the given precision.
+ */
+export declare function preciseGreaterThan(a: number, b: number, precision?: number): boolean;
+/**
+ * Returns true if the first number is less than or equal to the second number to the given precision.
+ * @param a The first number.
+ * @param b The second number.
+ * @param precision Optional precision in number of digits.
+ * @returns True if the first number is less than or equal to the second number to the given precision.
+ */
+export declare function preciseLessThanOrEquals(a: number, b: number, precision?: number): boolean;
+/**
+ * Returns true if the first number is greater than or equal to the second number to the given precision.
+ * @param a The first number.
+ * @param b The second number.
+ * @param precision Optional precision in number of digits.
+ * @returns True if the first number is greater than or equal to the second number to the given precision.
+ */
+export declare function preciseGreaterThanOrEquals(a: number, b: number, precision?: number): boolean;