@icure/be-fhc-api 0.4.0 → 0.4.3

package/x-api/utils/efact-util.d.ts

@@ -0,0 +1,28 @@
+import { HealthcareParty, Invoice, Patient } from "@icure/api";
+import { IccInvoiceXApi, IccMessageXApi, IccInsuranceApi, Insurance } from "@icure/api";
+import { InvoicesBatch, InvoiceItem } from "../../model/models";
+export interface RelatedInvoiceInfo {
+    invoiceId: string;
+    invoiceReference?: string;
+    sendNumber?: string;
+    insuranceCode?: string;
+    invoicingYear?: string;
+    invoicingMonth?: string;
+}
+export interface InvoiceWithPatient {
+    patient: Patient;
+    invoice: Invoice;
+    aggregatedInvoice?: Invoice;
+}
+export declare function getFederaton(invoices: Array<InvoiceWithPatient>, insuranceApi: IccInsuranceApi): Promise<Insurance>;
+export declare function getRelatedInvoicesInfo(invoicesWithPatient: InvoiceWithPatient[], insuranceApi: IccInsuranceApi, invoiceXApi: IccInvoiceXApi, messageXApi: IccMessageXApi): Promise<RelatedInvoiceInfo[]>;
+export declare function toInvoiceBatch(invoicesWithPatient: Array<InvoiceWithPatient>, hcp: HealthcareParty, batchRef: string, batchNumber: number, fileRef: string, insuranceApi: IccInsuranceApi, invoiceXApi: IccInvoiceXApi, messageXApi: IccMessageXApi, flatrateInvoice?: boolean): Promise<InvoicesBatch>;
+export declare function getDerogationMaxNumber(code: number): InvoiceItem.DerogationMaxNumberEnum;
+export declare function toDerogationMaxNumber(derogation: InvoiceItem.DerogationMaxNumberEnum): number;
+export declare function uuidBase36(uuid: string): string;
+/**
+ * This function encodes an uuid in 13 characters in base36, this is
+ * for the fileRef in efact, zone 303
+ */
+export declare function uuidBase36Half(uuid: string): string;
+export declare function decodeBase36Uuid(base36: string): string | null;

package/x-api/utils/efact-util.js

@@ -0,0 +1,316 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decodeBase36Uuid = exports.uuidBase36Half = exports.uuidBase36 = exports.toDerogationMaxNumber = exports.getDerogationMaxNumber = exports.toInvoiceBatch = exports.getRelatedInvoicesInfo = exports.getFederaton = void 0;
+const api_1 = require("@icure/api");
+const models_1 = require("../../model/models");
+const formatting_util_1 = require("./formatting-util");
+const fhc_patient_util_1 = require("./fhc-patient-util");
+const fhc_invoice_sender_util_1 = require("./fhc-invoice-sender-util");
+const insurability_util_1 = require("./insurability-util");
+const _ = require("lodash");
+const moment = require("moment");
+const uuid_encoder_1 = require("./uuid-encoder");
+const base36UUID = new uuid_encoder_1.UuidEncoder();
+function ensureNoFederation(invoices, insurances) {
+    // We will check here for recipient which are federations (except 306).
+    const federations = insurances.filter(i => i.code !== "306" && i.code !== "675" && i.id === i.parent);
+    if (federations.length > 0) {
+        console.error(`Invoices directed to ${federations.map(i => i.code).join()}, invoices ${invoices.map(i => i.invoice.id)}`);
+        throw "Some invoices are directly destinated to federations inside of mutuality office !";
+    }
+}
+function getFederaton(invoices, insuranceApi) {
+    return insuranceApi
+        .getInsurances(new api_1.ListOfIds({
+        ids: _.compact(invoices.map(iwp => iwp.invoice.recipientId))
+    }))
+        .then((insurances) => {
+        ensureNoFederation(invoices, insurances);
+        return insuranceApi
+            .getInsurances(new api_1.ListOfIds({ ids: _.uniq(_.compact(insurances.map(i => i.parent))) }))
+            .then((parents) => {
+            const parentsWithFedCode = parents.filter(i => i.code);
+            if (!parentsWithFedCode.length) {
+                throw "The federation is missing from the recipients of the invoices";
+            }
+            if (parentsWithFedCode.length > 1) {
+                throw "The provided invoices are not addressed to insurances belonging to the same federation";
+            }
+            return parentsWithFedCode[0];
+        });
+    });
+}
+exports.getFederaton = getFederaton;
+function getRelatedInvoicesInfo(invoicesWithPatient, insuranceApi, invoiceXApi, messageXApi) {
+    // Return the id of the related parentInvoice
+    const getRelatedInvoiceId = (iv) => (iv.creditNote && iv.creditNoteRelatedInvoiceId) || iv.correctedInvoiceId;
+    return Promise.resolve(invoicesWithPatient).then(invoicesWithPatient => {
+        const invoices = _(invoicesWithPatient)
+            .map(iwp => iwp.invoice)
+            .filter(piv => !!getRelatedInvoiceId(piv))
+            .value();
+        if (invoices.length === 0) {
+            return Promise.resolve([]);
+        }
+        const relatedInvoiceIds = new api_1.ListOfIds({
+            ids: invoices.map(iv => getRelatedInvoiceId(iv))
+        });
+        return Promise.all([
+            messageXApi.listMessagesByInvoiceIds(relatedInvoiceIds),
+            invoiceXApi.getInvoices(relatedInvoiceIds)
+        ]).then(result => {
+            const messages = result[0];
+            const relatedInvoices = result[1];
+            const insuranceIds = _(relatedInvoices)
+                .map(civ => civ.recipientId)
+                .uniq()
+                .value();
+            return insuranceApi
+                .getInsurances(new api_1.ListOfIds({ ids: insuranceIds }))
+                .then((insurances) => {
+                const relatedInvoicesInfo = [];
+                _.forEach(invoices, invoice => {
+                    const relatedInvoice = _.find(relatedInvoices, riv => !!(riv.id === getRelatedInvoiceId(invoice)));
+                    const message = _.find(messages, m => !!(relatedInvoice && m.invoiceIds.indexOf(relatedInvoice.id) > -1));
+                    const insurance = _.find(insurances, ins => !!(relatedInvoice && ins.id === relatedInvoice.recipientId));
+                    if (!relatedInvoice || !message || !insurance)
+                        return;
+                    relatedInvoicesInfo.push({
+                        invoiceId: invoice.id,
+                        insuranceCode: insurance.code,
+                        invoiceReference: relatedInvoice.invoiceReference,
+                        sendNumber: message.externalRef,
+                        invoicingYear: _.padStart(message.metas.invoiceYear, 4, "0"),
+                        invoicingMonth: _.padStart(message.metas.invoiceMonth, 2, "0")
+                    });
+                });
+                return relatedInvoicesInfo;
+            });
+        });
+    });
+}
+exports.getRelatedInvoicesInfo = getRelatedInvoicesInfo;
+// Here we trust the invoices argument for grouping validity (month, year and patient)
+function toInvoiceBatch(invoicesWithPatient, hcp, batchRef, batchNumber, fileRef, insuranceApi, invoiceXApi, messageXApi, flatrateInvoice = false) {
+    return insuranceApi
+        .getInsurances(new api_1.ListOfIds({
+        ids: _.compact(invoicesWithPatient.map(iwp => iwp.invoice.recipientId))
+    }))
+        .then((insurances) => {
+        ensureNoFederation(invoicesWithPatient, insurances);
+        return insuranceApi
+            .getInsurances(new api_1.ListOfIds({ ids: _.uniq(_.compact(insurances.map(i => i.parent))) }))
+            .then((parents) => {
+            const fedCodes = _.compact(parents.map(i => i.code && i.code.substr(0, 3)));
+            if (!fedCodes.length) {
+                throw "The federation is missing from the recipients of the invoices";
+            }
+            if (fedCodes.length > 1) {
+                throw "The provided invoices are not addressed to insurances belonging to the same federation";
+            }
+            return getRelatedInvoicesInfo(invoicesWithPatient, insuranceApi, invoiceXApi, messageXApi).then((relatedInvoicesInfo) => {
+                const invoicesBatch = new models_1.InvoicesBatch({});
+                invoicesBatch.batchRef = batchRef;
+                invoicesBatch.fileRef = fileRef;
+                invoicesBatch.magneticInvoice = flatrateInvoice; //flatrateInvoice have some different fields
+                if (flatrateInvoice) {
+                    invoicesBatch.invoiceContent = 0;
+                }
+                invoicesBatch.invoices = _.map(invoicesWithPatient, (invWithPat) => {
+                    const invoice = invWithPat.aggregatedInvoice || invWithPat.invoice;
+                    const relatedInvoiceInfo = _.find(relatedInvoicesInfo, rivi => rivi.invoiceId === invoice.id);
+                    const insurance = insurances.find(ins => ins.id === invoice.recipientId);
+                    if (!insurance) {
+                        throw "Insurance is invalid for patient " + invWithPat.patient.id;
+                    }
+                    return toInvoice(hcp.nihii, invoice, invWithPat.patient, insurance, relatedInvoiceInfo, flatrateInvoice);
+                });
+                const now = new Date();
+                const invoiceDate = (0, formatting_util_1.toMoment)(invoicesWithPatient[0].invoice.invoiceDate);
+                const invoicingMonth = invoiceDate.month() + 1;
+                const invoicingYear = invoiceDate.year();
+                // The OA 500, matches the monthYear (zone 300) to check the batch sending number
+                // Use sending year to prevent duplicate sending number in case of invoices made
+                // on the previous year
+                if (now.getFullYear() === invoicingYear) {
+                    invoicesBatch.invoicingMonth = invoicingMonth;
+                    invoicesBatch.invoicingYear = invoicingYear;
+                }
+                else {
+                    invoicesBatch.invoicingMonth = now.getMonth() + 1;
+                    invoicesBatch.invoicingYear = now.getFullYear();
+                }
+                invoicesBatch.ioFederationCode = fedCodes[0];
+                invoicesBatch.numericalRef =
+                    moment().get("year") * 1000000 + Number(fedCodes[0]) * 1000 + batchNumber;
+                invoicesBatch.sender = (0, fhc_invoice_sender_util_1.toInvoiceSender)(hcp, fedCodes[0]);
+                invoicesBatch.uniqueSendNumber = batchNumber;
+                return invoicesBatch;
+            });
+        });
+    });
+}
+exports.toInvoiceBatch = toInvoiceBatch;
+function toInvoice(nihiiHealthcareProvider, invoice, patient, insurance, relatedInvoiceInfo, flatrateInvoice = false) {
+    const efactInvoice = new models_1.Invoice({});
+    const invoiceYear = moment(invoice.created)
+        .year()
+        .toString();
+    efactInvoice.hospitalisedPatient = (0, insurability_util_1.isPatientHospitalized)(patient);
+    // FIXME : coder l'invoice ref
+    efactInvoice.invoiceNumber = Number(invoiceYear + invoice.invoiceReference) || 0;
+    // FIXME : coder l'invoice ref
+    efactInvoice.invoiceRef = uuidBase36(invoice.id);
+    efactInvoice.ioCode = insurance.code.substr(0, 3);
+    efactInvoice.items = _.map(invoice.invoicingCodes, (invoicingCode) => {
+        return toInvoiceItem(invoice.supervisorNihii || nihiiHealthcareProvider, patient, invoice, invoicingCode, flatrateInvoice);
+    });
+    efactInvoice.patient = (0, fhc_patient_util_1.toPatient)(patient);
+    efactInvoice.ignorePrescriptionDate = !!invoice.longDelayJustification;
+    efactInvoice.creditNote = invoice.creditNote;
+    if (relatedInvoiceInfo) {
+        efactInvoice.relatedBatchSendNumber = Number(relatedInvoiceInfo.sendNumber);
+        efactInvoice.relatedBatchYearMonth = Number(relatedInvoiceInfo.invoicingYear + relatedInvoiceInfo.invoicingMonth);
+        efactInvoice.relatedInvoiceNumber = Number(relatedInvoiceInfo.invoicingYear + relatedInvoiceInfo.invoiceReference);
+        efactInvoice.relatedInvoiceIoCode = relatedInvoiceInfo.insuranceCode;
+    }
+    // TODO : fix me later
+    efactInvoice.reason = models_1.Invoice.ReasonEnum.Other;
+    efactInvoice.creditNote = invoice.creditNote;
+    if (flatrateInvoice) {
+        efactInvoice.startOfCoveragePeriod = invoice.invoicingCodes[0].contractDate;
+    }
+    return efactInvoice;
+}
+function toInvoiceItem(nihiiHealthcareProvider, patient, invoice, invoicingCode, flatrateInvoice = false) {
+    const invoiceItem = new models_1.InvoiceItem({});
+    invoiceItem.codeNomenclature = Number(invoicingCode.tarificationId.split("|")[1]);
+    invoiceItem.dateCode = (0, formatting_util_1.dateEncode)((0, formatting_util_1.toMoment)(invoicingCode.dateCode).toDate());
+    invoiceItem.endDateCode =
+        invoiceItem.codeNomenclature === 109594
+            ? (0, formatting_util_1.dateEncode)((0, formatting_util_1.toMoment)(invoicingCode.dateCode).toDate())
+            : (0, formatting_util_1.dateEncode)((0, formatting_util_1.toMoment)(invoicingCode.dateCode)
+                .endOf("month")
+                .toDate());
+    invoiceItem.doctorIdentificationNumber = nihiiHealthcareProvider;
+    invoiceItem.doctorSupplement = Number(((invoicingCode.doctorSupplement || 0) * 100).toFixed(0));
+    if (invoicingCode.eidReadingHour && invoicingCode.eidReadingValue) {
+        invoiceItem.eidItem = new models_1.EIDItem({
+            deviceType: "1",
+            readType: "1",
+            readDate: invoiceItem.dateCode,
+            readHour: invoicingCode.eidReadingHour,
+            readvalue: invoicingCode.eidReadingValue
+        });
+    }
+    invoiceItem.gnotionNihii = invoice.gnotionNihii;
+    invoiceItem.insuranceRef = invoicingCode.contract || undefined; // Must be != ""
+    invoiceItem.insuranceRefDate = invoicingCode.contractDate || invoiceItem.dateCode;
+    invoiceItem.invoiceRef = uuidBase36(invoicingCode.id);
+    invoiceItem.override3rdPayerCode = invoicingCode.override3rdPayerCode;
+    invoiceItem.patientFee = Number(((invoicingCode.patientIntervention || 0) * 100).toFixed(0));
+    invoiceItem.percentNorm = models_1.InvoiceItem.PercentNormEnum.None;
+    invoiceItem.personalInterventionCoveredByThirdPartyCode =
+        invoicingCode.cancelPatientInterventionReason;
+    invoiceItem.prescriberNihii = invoicingCode.prescriberNihii;
+    invoiceItem.prescriberNorm = getPrescriberNorm(invoicingCode.prescriberNorm || 0);
+    invoiceItem.reimbursedAmount = Number(((invoicingCode.reimbursement || 0) * 100).toFixed(0));
+    invoiceItem.relatedCode = Number(invoicingCode.relatedCode || 0);
+    invoiceItem.sideCode = getSideCode(invoicingCode.side || 0);
+    invoiceItem.timeOfDay = getTimeOfDay(invoicingCode.timeOfDay || 0);
+    invoiceItem.units = invoicingCode.units || 1;
+    invoiceItem.derogationMaxNumber = getDerogationMaxNumber(invoicingCode.derogationMaxNumber || 0);
+    invoiceItem.internshipNihii = invoice.internshipNihii;
+    return invoiceItem;
+}
+function getSideCode(code) {
+    return code === 0
+        ? models_1.InvoiceItem.SideCodeEnum.None
+        : code === 1
+            ? models_1.InvoiceItem.SideCodeEnum.Left
+            : code === 2
+                ? models_1.InvoiceItem.SideCodeEnum.Right
+                : models_1.InvoiceItem.SideCodeEnum.None;
+}
+function getTimeOfDay(code) {
+    return code === 0
+        ? models_1.InvoiceItem.TimeOfDayEnum.Other
+        : code === 1
+            ? models_1.InvoiceItem.TimeOfDayEnum.Night
+            : code === 2
+                ? models_1.InvoiceItem.TimeOfDayEnum.Weekend
+                : code === 3
+                    ? models_1.InvoiceItem.TimeOfDayEnum.Bankholiday
+                    : code === 4
+                        ? models_1.InvoiceItem.TimeOfDayEnum.Urgent
+                        : models_1.InvoiceItem.TimeOfDayEnum.Other;
+}
+function getPrescriberNorm(code) {
+    return code === 0
+        ? models_1.InvoiceItem.PrescriberNormEnum.None
+        : code === 1
+            ? models_1.InvoiceItem.PrescriberNormEnum.OnePrescriber
+            : code === 3
+                ? models_1.InvoiceItem.PrescriberNormEnum.SelfPrescriber
+                : code === 4
+                    ? models_1.InvoiceItem.PrescriberNormEnum.AddedCode
+                    : code === 9
+                        ? models_1.InvoiceItem.PrescriberNormEnum.ManyPrescribers
+                        : models_1.InvoiceItem.PrescriberNormEnum.None;
+}
+function getDerogationMaxNumber(code) {
+    return code === 0
+        ? models_1.InvoiceItem.DerogationMaxNumberEnum.Other
+        : code === 1
+            ? models_1.InvoiceItem.DerogationMaxNumberEnum.DerogationMaxNumber
+            : code === 2
+                ? models_1.InvoiceItem.DerogationMaxNumberEnum.OtherPrescription
+                : code === 3
+                    ? models_1.InvoiceItem.DerogationMaxNumberEnum.SecondPrestationOfDay
+                    : models_1.InvoiceItem.DerogationMaxNumberEnum.ThirdAndNextPrestationOfDay;
+}
+exports.getDerogationMaxNumber = getDerogationMaxNumber;
+function toDerogationMaxNumber(derogation) {
+    return derogation === models_1.InvoiceItem.DerogationMaxNumberEnum.Other
+        ? 0
+        : derogation === models_1.InvoiceItem.DerogationMaxNumberEnum.DerogationMaxNumber
+            ? 1
+            : derogation === models_1.InvoiceItem.DerogationMaxNumberEnum.OtherPrescription
+                ? 2
+                : derogation === models_1.InvoiceItem.DerogationMaxNumberEnum.SecondPrestationOfDay
+                    ? 3
+                    : 4;
+}
+exports.toDerogationMaxNumber = toDerogationMaxNumber;
+function uuidBase36(uuid) {
+    return base36UUID.encode(uuid);
+}
+exports.uuidBase36 = uuidBase36;
+/**
+ * This function encodes an uuid in 13 characters in base36, this is
+ * for the fileRef in efact, zone 303
+ */
+function uuidBase36Half(uuid) {
+    const rawEndcode = base36UUID.encode(uuid.substr(0, 18));
+    return _.padStart(rawEndcode, 13, "0");
+}
+exports.uuidBase36Half = uuidBase36Half;
+function decodeBase36Uuid(base36) {
+    try {
+        const decoded = base36UUID.decode(base36);
+        if (base36.length !== 13) {
+            return decoded;
+        }
+        else {
+            const truncated = decoded.substr(19, decoded.length);
+            const raw = truncated.replace(/-/g, "");
+            const formatted = raw.substr(0, 8) + "-" + raw.substring(8, 12) + "-" + raw.substring(12, 16);
+            return formatted;
+        }
+    }
+    catch (e) {
+        console.log("Cannot interpret: " + base36, e);
+    }
+    return null;
+}
+exports.decodeBase36Uuid = decodeBase36Uuid;

package/x-api/utils/fhc-invoice-sender-util.d.ts

@@ -0,0 +1,3 @@
+import { HealthcareParty } from "@icure/api";
+import { InvoiceSender } from "../../model/models";
+export declare function toInvoiceSender(hcp: HealthcareParty, fedCode: string): InvoiceSender;

package/x-api/utils/fhc-invoice-sender-util.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toInvoiceSender = void 0;
+const hcp_util_1 = require("./hcp-util");
+function toInvoiceSender(hcp, fedCode) {
+    const phoneNumber = (0, hcp_util_1.getPhoneNumber)(hcp, 10) || 484082978;
+    if (!phoneNumber) {
+        throw new Error("NO_PHONE_NUMBER_IN_HCP");
+    }
+    const fi = hcp.financialInstitutionInformation &&
+        (hcp.financialInstitutionInformation.find(fii => fii.key === fedCode) ||
+            hcp.financialInstitutionInformation[0]);
+    const bic = hcp.bic || (fi && fi.bic);
+    const iban = hcp.bankAccount || (fi && fi.bankAccount);
+    if (!bic || !iban) {
+        throw new Error("Missing bic or iban for HCP");
+    }
+    const invoiceSender = {
+        bce: Number(hcp.cbe),
+        bic: bic.replace(/ /g, ""),
+        conventionCode: hcp.convention,
+        firstName: hcp.firstName,
+        iban: iban.replace(/ /g, ""),
+        lastName: hcp.lastName,
+        nihii: Number(hcp.nihii),
+        phoneNumber: phoneNumber,
+        ssin: hcp.ssin
+    };
+    return invoiceSender;
+}
+exports.toInvoiceSender = toInvoiceSender;

package/x-api/utils/fhc-patient-util.d.ts

@@ -0,0 +1,3 @@
+import { Patient } from "@icure/api";
+import { Patient as EfactPatient } from "../../model/models";
+export declare function toPatient(patient: Patient): EfactPatient;

package/x-api/utils/fhc-patient-util.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toPatient = void 0;
+const models_1 = require("../../model/models");
+const _ = require("lodash");
+function toPatient(patient) {
+    const efactPatient = new models_1.Patient(patient);
+    _.each(efactPatient.insurabilities, ins => {
+        ins.parameters = _.pick(ins.parameters, [
+            "status",
+            "tc1",
+            "tc2",
+            "preferentialstatus",
+            "chronicaldisease",
+            "paymentapproval"
+        ]);
+    });
+    return efactPatient;
+}
+exports.toPatient = toPatient;

package/x-api/utils/formatting-util.d.ts

@@ -0,0 +1,76 @@
+import { Moment } from "moment";
+export declare function isValidIBAN(iban: string): boolean;
+export declare function ibanValidate(iban: string): boolean;
+export declare function ibanFormat(iban: string): string;
+export declare function nihiiFormat(nihii: string): string;
+export declare function nihiiValidate(nihii: string): boolean;
+export declare function ssinFormat(ssin: string): string;
+export declare function ssinValidate(ssin: string): boolean;
+export declare function phoneNumberValidate(phoneNumber: string): boolean;
+export declare function phoneNumberFormat(phoneNumber: string): string;
+/**
+ * Converts a backend date number (e.g., patient birth date) into a Date object.
+ * @param dateNumber a YYYYMMDD date number from the backend
+ * @return a Date object
+ * @throws Error if it is impossible to create a date from the number, other if dateNumber is negative.
+ * @see #dateEncode
+ * @see #timeDecode
+ */
+export declare function dateDecode(dateNumber: number): Date | undefined;
+/**
+ * Converts a backend time number (e.g., health element openingDate) into a Date object.
+ * @param timeNumber a YYYYMMDD date number from the backend
+ * @return a Date object
+ * @see #timeEncode
+ * @see #dateDecode
+ */
+export declare function timeDecode(timeNumber: number): Date | undefined;
+/**
+ * Encodes a Date object into a backend date number (e.g., patient birth date).
+ * @param date a Date object
+ * @return a YYYYMMDD date number for the backend
+ * @see #dateDecode
+ * @see #timeEncode
+ */
+export declare function dateEncode(date: Date): number | undefined;
+/**
+ * Encodes a Date object into a backend time number (e.g., health element openingDate).
+ * @param date a Date object
+ * @return a YYYYMMDDHHmmss date number for the backend
+ * @see #timeDecode
+ * @see #dateEncode
+ */
+export declare function timeEncode(date: Date): number | undefined;
+/**
+ * Formats a value and a physical unit into text.
+ * @param value the numerical or string value to encode
+ * @param unit the unit represented as a string (an empty string is also supported)
+ */
+export declare function unit(value: number | string, unit: string | null): string;
+/**
+ * 0.1 + 0.2 = 0.30000000000000004. Use this function to be better at maths.
+ * @param a number
+ * @return the rounded number, two after the comma
+ */
+export declare function amount(value: number): number;
+/**
+ * A simple formatter to keep the logic across the app.
+ * Input: 2.1 ; Output: 2.10€
+ */
+export declare function money(value: number): string;
+/**
+ * Transform a dictionary to a url params.
+ * From { key1: value1, key2: value2, ... } returns key1=value1&key2=value2&...=...
+ */
+export declare function toUrlParams(params: {
+    [key: string]: string;
+}): string;
+export declare function personName(person: {
+    firstName?: string;
+    lastName?: string;
+}): string;
+export declare function personNameAbbrev(person: {
+    firstName?: string;
+    lastName?: string;
+}): string;
+export declare function toMoment(epochOrLongCalendar: number): Moment | null;