pha-hermes 1.15.0 → 1.16.0

package/dist/api/liphe_legacy/assignment/assignmentClient.d.ts

@@ -0,0 +1,28 @@
+import { AxiosInstance } from 'axios';
+export interface LipheAssignment {
+    id: number;
+    request_id: number;
+    dates_start: Date;
+    dates_end: Date;
+    shift: 'morning' | 'afternoon' | 'evening' | 'night';
+    time_start: Date;
+    time_end: Date;
+    status: 'draft' | 'inprogress' | 'approved' | 'rejected';
+    selected_client: Record<string, any>;
+    approver: string;
+    cost_covered: number | null;
+    travel: number | null;
+    lodging: number | null;
+    meal: number | null;
+    others: number | null;
+    modified_by: string | null;
+    created_at: Date;
+    updated_at: Date;
+}
+export declare class AssignmentClient {
+    private axiosInstance;
+    constructor(axiosInstance: AxiosInstance);
+    fetchAllAssignments(agencyId?: number, from?: Date, to?: Date, assignedPractitionerId?: string, page?: number, page_size?: number): Promise<LipheAssignment[]>;
+    fetchAssignment(assignmentId: string): Promise<LipheAssignment>;
+    createAssignment(assignment: LipheAssignment): Promise<LipheAssignment>;
+}

package/dist/api/{liphe1.0 → liphe_legacy}/auth/authClient.d.ts

@@ -7,7 +7,7 @@ export declare class LipheAuthenticator {
     private email;
     private password;
     private type;
-    constructor(authenticatedAxiosInstance: AxiosInstance, baseUrl: string, email: string, password: string, type?: string);
+    constructor(authenticatedAxiosInstance: AxiosInstance, baseUrl: string, email: string, password: string, type?: 'user' | 'client');
     initializeAuth(): Promise<void>;
     private login;
 }

package/dist/api/liphe_legacy/contract_request/contractRequestClient.d.ts

@@ -0,0 +1,80 @@
+import { AxiosInstance } from 'axios';
+import { Workorder } from '../../../models';
+export interface LipheContractRequest {
+    id: number;
+    name: string;
+    po_number: string | null;
+    level: string;
+    deadline: string;
+    from: string;
+    by: string;
+    by_value: string;
+    date: Date;
+    email_request: string;
+    type_of_request: string;
+    status: string;
+    is_deleted: number;
+    created_at: Date;
+    updated_at: Date;
+    created_by: string;
+    updated_by: string;
+    community_id: number;
+    agency_id: number;
+    contract_id: number;
+    job_id: number;
+    start_date: Date;
+    end_date: Date;
+    department_id: number | null;
+    job: LipheJob;
+    community: LipheCommunity;
+}
+interface LipheJob {
+    id: number;
+    code_nethris: number;
+    translations: LipheJobTranslation[];
+}
+interface LipheJobTranslation {
+    id: number;
+    translatable_type: string;
+    translatable_id: number;
+    column: string;
+    content: string;
+    locale: string;
+    created_at: Date;
+    updated_at: Date;
+}
+interface LipheCommunity {
+    id: number;
+    name: string;
+    region: LipheRegion;
+    contact: LipheContact;
+}
+interface LipheRegion {
+    id: number;
+    translations: LipheRegionTranslation[];
+}
+interface LipheRegionTranslation {
+    id: number;
+    translatable_type: string;
+    translatable_id: number;
+    column: string;
+    content: string;
+    locale: string;
+    created_at: Date;
+    updated_at: Date;
+}
+interface LipheContact {
+    id: number;
+    address: string;
+    address_city: string;
+    address_zip: string;
+    address_country: string;
+    address_state: string;
+    phone: string;
+}
+export declare class ContractRequestClient {
+    private axiosInstance;
+    constructor(axiosInstance: AxiosInstance);
+    fetchAllContractRequests(agencyId: number, from?: Date, to?: Date, page?: number, page_size?: number): Promise<Workorder[]>;
+}
+export {};

package/dist/api/liphe_legacy/contract_request_period/contractRequestPeriodClient.d.ts

@@ -0,0 +1,47 @@
+import { AxiosInstance } from 'axios';
+import { Agency, Period, Workorder } from '../../../models';
+import { LipheContractRequest } from '../contract_request/contractRequestClient';
+import { LipheAssignment } from '../assignment/assignmentClient';
+interface LipheContractRequestPeriodData {
+    id: number;
+    contract_request_id: number;
+    start_date: Date;
+    end_date: Date;
+    shift: 'morning' | 'afternoon' | 'evening' | 'night';
+    start_time: Date;
+    end_time: Date;
+    departement_id: number;
+    note: string;
+    assignment_id: number;
+    assignment_parent_id: number | null;
+    created_at: Date;
+    updated_at: Date;
+    contract_request: LipheContractRequest;
+    department: string | null;
+    assignment: LipheAssignment;
+    assigned_employee_details: UserDetails;
+    assignment_employee: any;
+}
+interface UserDetails {
+    id: number;
+    name: string;
+    email: string | null;
+}
+export declare class ContractRequestPeriodClient {
+    private axiosInstance;
+    constructor(axiosInstance: AxiosInstance);
+    fetchAllContractRequestPeriods(agencyId: Agency, from?: Date, to?: Date, page?: number, activeAssignationsOnly?: boolean, assignedPractitionerId?: string): Promise<Workorder[]>;
+    fetchContractRequestPeriod(workorderId: string): Promise<LipheContractRequestPeriodData>;
+    getPayPeriodDatesForPayPeriodId(payPeriodId: string): Promise<Period[]>;
+    private getRole;
+    /**
+     * Calculates the pay period day of week that comes before the start date
+     * @param firstPayPeriodDate The first pay period date from the agency
+     * @param startDate The start date to find the pay period before
+     * @returns The day of week (0-6, where 0 is Sunday) of the pay period before start_date
+     */
+    private getPayPeriodDayBeforeStartDate;
+    private getLastDayOfPayPeriod;
+    private calculateWeeksBetween;
+}
+export {};

package/dist/api/{lipheApiClient.d.ts → liphe_legacy/lipheApiClient.d.ts}

@@ -1,11 +1,13 @@
 import { AxiosInstance } from 'axios';
-import { LiphePractitionerClient } from './liphe1.0/practitioner/practitionerClient';
+import { LiphePractitionerClient } from './practitioner/practitionerClient';
+import { ContractRequestPeriodClient } from './contract_request_period/contractRequestPeriodClient';
 export declare class LipheApiClient {
     private instance;
     private axiosInstance;
     private authenticator;
     practitionerClient: LiphePractitionerClient;
-    constructor(baseUrl: string, email: string, password: string, type?: string);
+    contractRequestPeriodClient: ContractRequestPeriodClient;
+    constructor(baseUrl: string, email: string, password: string, type?: 'user' | 'client');
     init(): Promise<void>;
     setInstance(instance: LipheApiClient): void;
     getInstance(): LipheApiClient;

package/dist/api/liphe_legacy/practitioner/practitionerClient.d.ts

@@ -0,0 +1,7 @@
+import type { AxiosInstance } from 'axios';
+import { Practitioner } from '../../../models';
+export declare class LiphePractitionerClient {
+    private axios;
+    constructor(axiosInstance: AxiosInstance);
+    fetchAllPractitioners(agencyId?: number): Promise<Practitioner[]>;
+}

package/dist/api/{apiClient.d.ts → salesforce/apiClient.d.ts}

@@ -1,9 +1,9 @@
 import { SFTimesheetClient } from './timesheet/timesheetClient';
 import { SFPractitionerClient } from './practitioner/practitionerClient';
-import { Role } from '../models';
+import { Role } from '../../models';
 import { SFWorkorderClient } from './workorder/workorderClient';
 import { SFPayPeriodClient } from './payperiod/payperiodClient';
-import { SFExpenseClient } from './expenses/expenseClient';
+import { SFExpenseClient } from '../expenses/expenseClient';
 export declare const SF_API_VERSION: string;
 export declare class SFApiClient {
     private instance;

package/dist/api/{payperiod → salesforce/payperiod}/payperiodClient.d.ts

@@ -1,11 +1,5 @@
 import { AxiosInstance } from 'axios';
-export interface Period {
-    payPeriodId: string;
-    startDate: Date;
-    endDate: Date;
-    timesheetId?: string;
-    workorderId?: string;
-}
+import { Period } from '../../../models';
 export declare class SFPayPeriodClient {
     private axiosInstance;
     constructor(axiosInstance: AxiosInstance);

package/dist/api/{practitioner → salesforce/practitioner}/practitionerClient.d.ts

@@ -1,5 +1,5 @@
 import { AxiosInstance } from 'axios';
-import { Practitioner } from '../../models';
+import { Practitioner } from '../../../models';
 export declare class SFPractitionerClient {
     private axiosInstance;
     constructor(axiosInstance: AxiosInstance);

package/dist/api/{timesheet → salesforce/timesheet}/timesheetClient.d.ts

@@ -1,6 +1,6 @@
 /// <reference types="node" />
 import { AxiosInstance } from 'axios';
-import { TimesheetDayEntry } from '../../models';
+import { TimesheetDayEntry } from '../../../models';
 interface SFTimesheetHourField {
     Id: string;
     Date__c: Date;

package/dist/api/{workorder → salesforce/workorder}/workorderClient.d.ts

@@ -1,5 +1,5 @@
 import { AxiosInstance } from 'axios';
-import { Workorder } from '../../models';
+import { Workorder } from '../../../models';
 export declare class SFWorkorderClient {
     private axiosInstance;
     constructor(axiosInstance: AxiosInstance);

package/dist/index.d.ts

@@ -1,9 +1,9 @@
-export { SFApiClient } from './api/apiClient';
-export { SFPractitionerClient } from './api/practitioner/practitionerClient';
-export { SFTimesheetClient } from './api/timesheet/timesheetClient';
-export { SFAuthenticator } from './api/auth/auth';
-export { Practitioner, Role, TimesheetDayEntry, Workorder } from './models';
-export { LipheApiClient } from './api/lipheApiClient';
-export { LipheAuthenticator } from './api/liphe1.0/auth/authClient';
-export { LiphePractitionerClient } from './api/liphe1.0/practitioner/practitionerClient';
+export { SFApiClient } from './api/salesforce/apiClient';
+export { SFPractitionerClient } from './api/salesforce/practitioner/practitionerClient';
+export { SFTimesheetClient } from './api/salesforce/timesheet/timesheetClient';
+export { SFAuthenticator } from './api/salesforce/auth/auth';
+export { LipheApiClient } from './api/liphe_legacy/lipheApiClient';
+export { LipheAuthenticator } from './api/liphe_legacy/auth/authClient';
+export { LiphePractitionerClient } from './api/liphe_legacy/practitioner/practitionerClient';
 export { SFExpenseClient } from './api/expenses/expenseClient';
+export { Practitioner, Role, TimesheetDayEntry, Workorder, Agency, Period } from './models';

package/dist/models/index.d.ts

@@ -1,19 +1,15 @@
-export interface Role {
-    label: string;
-    value: string;
-}
-export interface Workorder {
-    id: string;
-    name: string;
-    region: string;
-    establishmentName: string;
-    establishmentId: string;
-    role: string;
-    practitionerId: string;
-    startDate: Date;
-    endDate: Date;
-    createdAt: Date;
-    updatedAt: Date;
+export declare enum Agency {
+    CHCA = "7",
+    CodeBleu = "5",
+    NordikOntario = "6",
+    PHA = "8",
+    PremierSoin = "1",
+    PremierSoinNordik = "3",
+    SolutionNursing = "4",
+    SolutionsStaffing = "9",
+    Transport = "2",
+    SSI = "99"
 }
 export * from './timesheet';
-export * from './practitioner';
+export * from './user';
+export * from './workorder';

package/dist/models/{practitioner.d.ts → user.d.ts}

@@ -5,3 +5,7 @@ export interface Practitioner {
     email: string;
     staffId: string;
 }
+export interface Role {
+    label: string;
+    value: string;
+}

package/dist/models/workorder.d.ts

@@ -0,0 +1,20 @@
+export interface Period {
+    payPeriodId: string;
+    startDate: Date;
+    endDate: Date;
+    timesheetId?: string;
+    workorderId?: string;
+}
+export interface Workorder {
+    id: string;
+    name: string;
+    region: string;
+    establishmentName: string;
+    establishmentId: string;
+    role: string;
+    practitionerId?: string;
+    startDate: Date;
+    endDate: Date;
+    createdAt?: Date;
+    updatedAt?: Date;
+}

package/dist/pha-hermes.cjs.development.js

@@ -6,6 +6,7 @@ function _interopDefault (ex) { return (ex && (typeof ex === 'object') && 'defau
 
 var axios = _interopDefault(require('axios'));
 var FormData = _interopDefault(require('form-data'));
+var axiosRetry = _interopDefault(require('axios-retry'));
 
 function _arrayLikeToArray(r, a) {
   (null == a || a > r.length) && (a = r.length);
@@ -1292,6 +1293,12 @@ var LipheAuthenticator = /*#__PURE__*/function () {
     this.token = undefined;
     this.tokenRefreshPromise = null;
     this.authenticatedAxiosInstance = authenticatedAxiosInstance;
+    axiosRetry(this.axiosTokenInstance, {
+      retries: 10,
+      retryDelay: function retryDelay(retryCount) {
+        return Math.min(1000 * Math.pow(2, retryCount - 1), 30000);
+      }
+    });
     this.email = email;
     this.password = password;
     this.type = type;
@@ -1380,7 +1387,7 @@ var LipheAuthenticator = /*#__PURE__*/function () {
             form.append('password', this.password);
             form.append('type', this.type);
             _context3.next = 6;
-            return this.axiosTokenInstance.post('/v2/signin', form, {
+            return this.axiosTokenInstance.post('v2/signin', form, {
               headers: form.getHeaders()
             });
           case 6:
@@ -1431,7 +1438,7 @@ var LiphePractitionerClient = /*#__PURE__*/function () {
               break;
             }
             _context.next = 7;
-            return this.axios.get('/v2/employees', {
+            return this.axios.get('v2/employees', {
               params: {
                 agency_id: agencyId,
                 page: page
@@ -1461,7 +1468,15 @@ var LiphePractitionerClient = /*#__PURE__*/function () {
             _context.next = 4;
             break;
           case 17:
-            return _context.abrupt("return", practitioners);
+            return _context.abrupt("return", practitioners.map(function (p) {
+              return {
+                id: String(p.id),
+                firstName: p.firstname,
+                lastName: p.lastname,
+                email: p.email,
+                staffId: String(p.id)
+              };
+            }));
           case 18:
           case "end":
             return _context.stop();
@@ -1476,6 +1491,200 @@ var LiphePractitionerClient = /*#__PURE__*/function () {
   return LiphePractitionerClient;
 }();
 
+var ContractRequestPeriodClient = /*#__PURE__*/function () {
+  function ContractRequestPeriodClient(axiosInstance) {
+    this.axiosInstance = axiosInstance;
+  }
+  var _proto = ContractRequestPeriodClient.prototype;
+  _proto.fetchAllContractRequestPeriods = /*#__PURE__*/function () {
+    var _fetchAllContractRequestPeriods = /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee(agencyId, from, to, page, activeAssignationsOnly, assignedPractitionerId) {
+      var url, params, periods, nextPage, response, _iterator, _step, period;
+      return _regeneratorRuntime().wrap(function _callee$(_context) {
+        while (1) switch (_context.prev = _context.next) {
+          case 0:
+            if (page === void 0) {
+              page = 1;
+            }
+            if (activeAssignationsOnly === void 0) {
+              activeAssignationsOnly = true;
+            }
+            url = "v2/contract-request-periods/agency/" + agencyId;
+            params = new URLSearchParams();
+            periods = [];
+            nextPage = true;
+            if (from) {
+              params.append('from', from.toISOString().split('T')[0] + ' 00:00:00');
+            }
+            if (to) {
+              params.append('to', to.toISOString().split('T')[0] + ' 23:59:59');
+            }
+            if (page) {
+              params.append('page', page.toString());
+            }
+            if (activeAssignationsOnly) {
+              params.append('active_assignations_only', activeAssignationsOnly ? '1' : '0');
+            }
+            if (assignedPractitionerId) {
+              params.append('assigned_employee_id', assignedPractitionerId);
+            }
+          case 11:
+            if (!nextPage) {
+              _context.next = 21;
+              break;
+            }
+            params.set('page', page.toString());
+            _context.next = 15;
+            return this.axiosInstance.get(url, {
+              params: params
+            });
+          case 15:
+            response = _context.sent;
+            for (_iterator = _createForOfIteratorHelperLoose(response.data.data); !(_step = _iterator()).done;) {
+              period = _step.value;
+              periods.push({
+                id: period.id.toString(),
+                name: period.id.toString(),
+                establishmentId: period.contract_request.community.id.toString(),
+                region: period.contract_request.community.contact.address_state,
+                establishmentName: period.contract_request.community.name,
+                role: this.getRole(period),
+                practitionerId: period.assignment.selected_client.id,
+                startDate: new Date(period.start_date),
+                endDate: new Date(period.end_date),
+                createdAt: new Date(period.created_at),
+                updatedAt: new Date(period.updated_at)
+              });
+            }
+            nextPage = page < response.data.meta.last_page;
+            page++;
+            _context.next = 11;
+            break;
+          case 21:
+            return _context.abrupt("return", periods);
+          case 22:
+          case "end":
+            return _context.stop();
+        }
+      }, _callee, this);
+    }));
+    function fetchAllContractRequestPeriods(_x, _x2, _x3, _x4, _x5, _x6) {
+      return _fetchAllContractRequestPeriods.apply(this, arguments);
+    }
+    return fetchAllContractRequestPeriods;
+  }();
+  _proto.fetchContractRequestPeriod = /*#__PURE__*/function () {
+    var _fetchContractRequestPeriod = /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee2(workorderId) {
+      var url, params, response;
+      return _regeneratorRuntime().wrap(function _callee2$(_context2) {
+        while (1) switch (_context2.prev = _context2.next) {
+          case 0:
+            url = "v2/contract-request-periods/" + workorderId;
+            params = new URLSearchParams();
+            _context2.next = 4;
+            return this.axiosInstance.get(url, {
+              params: params
+            });
+          case 4:
+            response = _context2.sent;
+            return _context2.abrupt("return", response.data.data);
+          case 6:
+          case "end":
+            return _context2.stop();
+        }
+      }, _callee2, this);
+    }));
+    function fetchContractRequestPeriod(_x7) {
+      return _fetchContractRequestPeriod.apply(this, arguments);
+    }
+    return fetchContractRequestPeriod;
+  }();
+  _proto.getPayPeriodDatesForPayPeriodId = /*#__PURE__*/function () {
+    var _getPayPeriodDatesForPayPeriodId = /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee3(payPeriodId) {
+      var period, payPeriods, firstPayPeriodDate, lastPayPeriodDate, weeksBetween, i, tempDate, startDate, endDate;
+      return _regeneratorRuntime().wrap(function _callee3$(_context3) {
+        while (1) switch (_context3.prev = _context3.next) {
+          case 0:
+            _context3.next = 2;
+            return this.fetchContractRequestPeriod(payPeriodId);
+          case 2:
+            period = _context3.sent;
+            payPeriods = [];
+            firstPayPeriodDate = this.getPayPeriodDayBeforeStartDate(new Date(period.assignment.selected_client.agency.date_first_periode_paie), new Date(period.start_date));
+            lastPayPeriodDate = this.getLastDayOfPayPeriod(new Date(firstPayPeriodDate), new Date(period.end_date)); // Calculate the number of weeks between lastPayPeriodDate and firstPayPeriodDate
+            weeksBetween = this.calculateWeeksBetween(firstPayPeriodDate, lastPayPeriodDate);
+            for (i = 0; i < weeksBetween; i++) {
+              tempDate = new Date(firstPayPeriodDate);
+              startDate = new Date(tempDate.setDate(tempDate.getDate() + 7 * i));
+              endDate = new Date(tempDate.setDate(tempDate.getDate() + 6));
+              payPeriods.push({
+                payPeriodId: '',
+                startDate: startDate.toISOString().split('T')[0],
+                endDate: endDate.toISOString().split('T')[0],
+                workorderId: payPeriodId
+              });
+            }
+            return _context3.abrupt("return", payPeriods);
+          case 9:
+          case "end":
+            return _context3.stop();
+        }
+      }, _callee3, this);
+    }));
+    function getPayPeriodDatesForPayPeriodId(_x8) {
+      return _getPayPeriodDatesForPayPeriodId.apply(this, arguments);
+    }
+    return getPayPeriodDatesForPayPeriodId;
+  }();
+  _proto.getRole = function getRole(period) {
+    if (period.contract_request.job.translations.length === 0) {
+      return '';
+    }
+    if (period.contract_request.job.translations.length > 1) {
+      var roleTranslation = period.contract_request.job.translations.find(function (translation) {
+        return translation.locale === 'en';
+      });
+      return roleTranslation == null ? void 0 : roleTranslation.content;
+    } else {
+      return period.contract_request.job.translations[0].content;
+    }
+  }
+  /**
+   * Calculates the pay period day of week that comes before the start date
+   * @param firstPayPeriodDate The first pay period date from the agency
+   * @param startDate The start date to find the pay period before
+   * @returns The day of week (0-6, where 0 is Sunday) of the pay period before start_date
+   */;
+  _proto.getPayPeriodDayBeforeStartDate = function getPayPeriodDayBeforeStartDate(firstPayPeriodDate, startDate) {
+    var payPeriodDayOfWeek = firstPayPeriodDate.getDay();
+    // Calculate the most recent pay period date that falls before start_date
+    var tempDate = new Date(startDate);
+    // Go back one week at a time until we find a date that matches the pay period day of week
+    while (tempDate.getDay() !== payPeriodDayOfWeek) {
+      tempDate.setDate(tempDate.getDate() - 1);
+    }
+    // If the calculated date is not before start_date, go back another week
+    if (tempDate >= startDate) {
+      tempDate.setDate(tempDate.getDate() - 7);
+    }
+    return tempDate;
+  };
+  _proto.getLastDayOfPayPeriod = function getLastDayOfPayPeriod(firstPayPeriodDate, endDate) {
+    var tempDate = new Date(firstPayPeriodDate);
+    // Go back one week at a time until we find a date that matches the pay period day of week
+    while (endDate > tempDate) {
+      tempDate.setDate(tempDate.getDate() + 7);
+    }
+    return tempDate;
+  };
+  _proto.calculateWeeksBetween = function calculateWeeksBetween(startDate, endDate) {
+    var diffTime = Math.abs(endDate.getTime() - startDate.getTime());
+    var diffDays = Math.ceil(diffTime / (1000 * 60 * 60 * 24));
+    var weeks = Math.floor(diffDays / 7);
+    return weeks;
+  };
+  return ContractRequestPeriodClient;
+}();
+
 var LipheApiClient = /*#__PURE__*/function () {
   function LipheApiClient(baseUrl, email, password, type) {
     if (type === void 0) {
@@ -1485,7 +1694,17 @@ var LipheApiClient = /*#__PURE__*/function () {
     this.axiosInstance = axios.create();
     this.axiosInstance.defaults.baseURL = baseUrl;
     this.authenticator = new LipheAuthenticator(this.axiosInstance, baseUrl, email, password, type);
+    axiosRetry(this.axiosInstance, {
+      retries: 10,
+      retryDelay: function retryDelay(retryCount) {
+        return Math.min(1000 * Math.pow(2, retryCount - 1), 30000);
+      },
+      onRetry: function onRetry(retryCount, error) {
+        console.log("Retry attempt " + retryCount + " failed: " + error.message);
+      }
+    });
     this.practitionerClient = new LiphePractitionerClient(this.axiosInstance);
+    this.contractRequestPeriodClient = new ContractRequestPeriodClient(this.axiosInstance);
   }
   var _proto = LipheApiClient.prototype;
   _proto.init = /*#__PURE__*/function () {
@@ -1518,6 +1737,19 @@ var LipheApiClient = /*#__PURE__*/function () {
   return LipheApiClient;
 }();
 
+(function (Agency) {
+  Agency["CHCA"] = "7";
+  Agency["CodeBleu"] = "5";
+  Agency["NordikOntario"] = "6";
+  Agency["PHA"] = "8";
+  Agency["PremierSoin"] = "1";
+  Agency["PremierSoinNordik"] = "3";
+  Agency["SolutionNursing"] = "4";
+  Agency["SolutionsStaffing"] = "9";
+  Agency["Transport"] = "2";
+  Agency["SSI"] = "99";
+})(exports.Agency || (exports.Agency = {}));
+
 exports.LipheApiClient = LipheApiClient;
 exports.LipheAuthenticator = LipheAuthenticator;
 exports.LiphePractitionerClient = LiphePractitionerClient;