@digihmis/esm-billing-app 1.0.0 → 1.0.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@digihmis/esm-billing-app",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "description": "Billing microfrontend for the OpenMRS SPA",
   "browser": "dist/digihmis-esm-billing-app.js",
   "main": "src/index.ts",
@@ -37,6 +37,7 @@
     "url": "https://github.com/its-kios09/DigiHMIS-apps/issues"
   },
   "dependencies": {
+    "@digihmis/esm-commons-lib": "1.0.0",
     "lodash-es": "^4.17.15",
     "react-to-print": "2.14.13"
   },

package/src/billing-checkin-form/billing-checkin-form.extension.tsx

@@ -1,16 +1,22 @@
 import { FilterableMultiSelect, InlineLoading, InlineNotification, Tag } from '@carbon/react';
 import { zodResolver } from '@hookform/resolvers/zod';
-import { showSnackbar, useConfig, useFeatureFlag } from '@openmrs/esm-framework';
-import React, { useCallback, useEffect, useState, useMemo } from 'react';
+import { showSnackbar, useConfig } from '@openmrs/esm-framework';
+import React, { useEffect, useMemo, useState } from 'react';
 import { FormProvider, useForm } from 'react-hook-form';
 import { useTranslation } from 'react-i18next';
 import { BillingConfig } from '../config-schema';
 import styles from './billing-checkin-form.scss';
 import VisitAttributesForm from './visit-attributes/visit-attributes-form.component';
-import { createPatientBill, useBillableItems, useCashPoint } from './billing-checkin-form.resource';
+import {
+  addBillLinesForVisit,
+  priceForMode,
+  useBillableItems,
+  usePatientType,
+  type BillableItem,
+  type SelectedService,
+} from './billing-checkin-form.resource';
 import { visitAttributesFormSchema, VisitAttributesFormValue } from './billing-checkin-form-schema';
 import { hasPatientBeenExempted } from './helper';
-import { EXEMPTED_PAYMENT_STATUS, PENDING_PAYMENT_STATUS } from '../constants';
 import { useCurrencyFormatting } from '../utils';
 
 type BillingCheckInFormProps = {
@@ -21,12 +27,12 @@ type BillingCheckInFormProps = {
 const BillingCheckInForm: React.FC<BillingCheckInFormProps> = ({ patientUuid, setExtraVisitInfo }) => {
   const { t } = useTranslation();
   const {
-    visitAttributeTypes: { isPatientExempted },
+    visitAttributeTypes: { isPatientExempted, patientType: patientTypeAttrUuid },
   } = useConfig<BillingConfig>();
-  const { cashPoints, isLoading: isLoadingCashPoints, error: cashError } = useCashPoint();
   const { lineItems, isLoading: isLoadingLineItems, error: lineError } = useBillableItems();
+  const { patientType } = usePatientType(patientUuid);
   const [attributes, setAttributes] = useState([]);
-  const [selectedServices, setSelectedServices] = useState([]);
+  const [selectedServices, setSelectedServices] = useState<Array<SelectedService>>([]);
   const { formatSimple } = useCurrencyFormatting();
 
   const formMethods = useForm<VisitAttributesFormValue>({
@@ -41,70 +47,78 @@ const BillingCheckInForm: React.FC<BillingCheckInFormProps> = ({ patientUuid, se
     resolver: zodResolver(visitAttributesFormSchema),
   });
 
-  const isPatientExemptedValue = formMethods.watch('isPatientExempted');
   const paymentMethod = formMethods.watch('paymentMethods');
 
-  const handleCreateBill = useCallback((createBillPayload) => {
-    createPatientBill(createBillPayload).then(
-      () => {
-        showSnackbar({ title: 'Patient Bill', subtitle: 'Patient has been billed successfully', kind: 'success' });
-      },
-      (error) => {
-        const errorMessage = JSON.stringify(error?.responseBody?.error?.message?.replace(/\[/g, '').replace(/\]/g, ''));
-        showSnackbar({
-          title: 'Patient Bill Error',
-          subtitle: `An error has occurred while creating patient bill, Contact system administrator quoting this error ${errorMessage}`,
-          kind: 'error',
-          isLowContrast: true,
-        });
-      },
-    );
-  }, []);
-
-  const handleBillingService = (selectedItems) => {
-    setSelectedServices(selectedItems);
-
-    const cashPointUuid = cashPoints?.[0]?.uuid ?? '';
-    const billStatus = hasPatientBeenExempted(attributes, isPatientExempted)
-      ? EXEMPTED_PAYMENT_STATUS
-      : PENDING_PAYMENT_STATUS;
-
-    const lineItems = selectedItems.map((item, index) => {
-      const priceForPaymentMode =
-        item.servicePrices.find((p) => p.paymentMode?.uuid === paymentMethod) || item?.servicePrices[0];
-      return {
-        billableService: item?.uuid ?? '',
-        quantity: 1,
-        price: priceForPaymentMode ? priceForPaymentMode.price : '0.000',
-        priceName: 'Default',
-        priceUuid: priceForPaymentMode ? priceForPaymentMode.uuid : '',
-        lineItemOrder: index,
-        paymentStatus: billStatus,
-      };
-    });
+  // Only offer services actually priced for the chosen payment mode. A service with no price for this
+  // mode is not billable under it (it must not quote another mode's price), so it is left out entirely.
+  const availableItems = useMemo(
+    () => lineItems.filter((item) => priceForMode(item, paymentMethod) != null),
+    [lineItems, paymentMethod],
+  );
 
-    const billPayload = {
-      lineItems: lineItems,
-      cashPoint: cashPointUuid,
-      patient: patientUuid,
-      status: billStatus,
-      payments: [],
-    };
+  // The price is per mode, so a service picked under one mode can't carry over to another. Clear the
+  // selection whenever the payment mode changes -- the clerk re-picks against the new mode's prices.
+  useEffect(() => {
+    setSelectedServices([]);
+  }, [paymentMethod]);
 
-    setExtraVisitInfo({
-      handleCreateExtraVisitInfo: () => handleCreateBill(billPayload),
-      attributes,
-    });
-  };
+  const formatPrice = (price: number | string | undefined) =>
+    formatSimple(parseFloat(String(price ?? 0)), { minimumFractionDigits: 2, maximumFractionDigits: 2 });
 
+  // Hand the visit form a callback it runs *after* the visit is saved: DigiHMIS bills are
+  // visit-scoped, so the selected services can only be charged once the visit uuid exists. An
+  // exempted patient (or no selection) is a no-op. The captured payment/insurance/exemption details
+  // still ride along as visit attributes.
   useEffect(() => {
+    const exempt = hasPatientBeenExempted(attributes, isPatientExempted);
+    // New vs revisit is derived from the patient's visit history, not asked on the form.
+    const attributesWithType = patientTypeAttrUuid
+      ? [...attributes, { attributeType: patientTypeAttrUuid, value: patientType }]
+      : attributes;
     setExtraVisitInfo({
-      handleCreateExtraVisitInfo: () => {},
-      attributes,
+      handleCreateExtraVisitInfo: (visitUuid?: string) => {
+        if (exempt || !visitUuid || selectedServices.length === 0) {
+          return Promise.resolve();
+        }
+        return addBillLinesForVisit(visitUuid, selectedServices, paymentMethod).then(
+          () =>
+            showSnackbar({
+              title: t('patientBill', 'Patient bill'),
+              subtitle: t('patientBilledSuccessfully', 'Patient has been billed successfully'),
+              kind: 'success',
+            }),
+          (error) =>
+            showSnackbar({
+              title: t('patientBillError', 'Patient bill error'),
+              subtitle:
+                error?.responseBody?.error?.message ??
+                error?.message ??
+                t('billErrorGeneric', 'An error occurred while billing the patient'),
+              kind: 'error',
+              isLowContrast: true,
+            }),
+        );
+      },
+      attributes: attributesWithType,
     });
-  }, [attributes, setExtraVisitInfo]);
+  }, [
+    attributes,
+    isPatientExempted,
+    patientType,
+    patientTypeAttrUuid,
+    paymentMethod,
+    selectedServices,
+    setExtraVisitInfo,
+    t,
+  ]);
+
+  const handleBillingService = (selectedItems: Array<BillableItem>) => {
+    setSelectedServices(
+      selectedItems.map((item) => ({ uuid: item.uuid, name: item.name, price: item.price, prices: item.prices })),
+    );
+  };
 
-  if (isLoadingLineItems || isLoadingCashPoints) {
+  if (isLoadingLineItems) {
     return (
       <InlineLoading
         status="active"
@@ -114,7 +128,7 @@ const BillingCheckInForm: React.FC<BillingCheckInFormProps> = ({ patientUuid, se
     );
   }
 
-  if (cashError || lineError) {
+  if (lineError) {
     return (
       <InlineNotification
         kind="error"
@@ -131,34 +145,19 @@ const BillingCheckInForm: React.FC<BillingCheckInFormProps> = ({ patientUuid, se
       {paymentMethod && (
         <section className={styles.sectionContainer}>
           <div className={styles.sectionField}>
-            {lineItems && lineItems.length > 0 ? (
+            {availableItems && availableItems.length > 0 ? (
               <>
-                {selectedServices.map((item, index) => {
-                  const priceForPaymentMode =
-                    item.servicePrices.find((p) => p.paymentMode?.uuid === paymentMethod) || item?.servicePrices[0];
-                  const price = priceForPaymentMode ? parseFloat(priceForPaymentMode.price) : 0;
-                  return (
-                    <Tag key={index} type="cyan" className={styles.selectedServicesTag}>
-                      {item.name} - {formatSimple(price, { minimumFractionDigits: 2, maximumFractionDigits: 2 })}
-                    </Tag>
-                  );
-                })}
+                {selectedServices.map((item, index) => (
+                  <Tag key={index} type="cyan" className={styles.selectedServicesTag}>
+                    {item.name} - {formatPrice(priceForMode(item, paymentMethod))}
+                  </Tag>
+                ))}
                 <FilterableMultiSelect
-                  key={isPatientExemptedValue}
                   id="billing-service"
                   titleText={t('searchServices', 'Search services')}
-                  items={lineItems}
-                  itemToString={(item) => {
-                    if (!item) {
-                      return '';
-                    }
-                    const priceForPaymentMode =
-                      item.servicePrices.find((p) => p.paymentMode?.uuid === paymentMethod) || item?.servicePrices[0];
-                    const price = priceForPaymentMode ? parseFloat(priceForPaymentMode.price) : 0;
-                    return `${item.name} - ${formatSimple(price, { minimumFractionDigits: 2, maximumFractionDigits: 2 })}`;
-                  }}
-                  onChange={({ selectedItems }) => handleBillingService(selectedItems)}
-                  disabled={isPatientExemptedValue === ''}
+                  items={availableItems}
+                  itemToString={(item) => (item ? `${item.name} - ${formatPrice(priceForMode(item, paymentMethod))}` : '')}
+                  onChange={({ selectedItems }) => handleBillingService(selectedItems as Array<BillableItem>)}
                 />
               </>
             ) : (
@@ -166,7 +165,10 @@ const BillingCheckInForm: React.FC<BillingCheckInFormProps> = ({ patientUuid, se
                 kind="info"
                 lowContrast
                 title={t('noBillableServices', 'No billable services')}
-                subtitle={t('noBillableServicesDescription', 'Please configure billable services to continue.')}
+                subtitle={t(
+                  'noServicesPricedForMode',
+                  'No services are priced for the selected payment method. Configure a price for this payment method to bill it here.',
+                )}
               />
             )}
           </div>

package/src/billing-checkin-form/billing-checkin-form.resource.ts

@@ -1,42 +1,107 @@
-import { openmrsFetch, type OpenmrsResource, restBaseUrl, useConfig } from '@openmrs/esm-framework';
+import { openmrsFetch, restBaseUrl, useConfig } from '@openmrs/esm-framework';
 import { useMemo, useState } from 'react';
 import useSWR from 'swr';
-import { BillingConfig } from '../config-schema';
+import { type BillingConfig } from '../config-schema';
 
-export const useCashPoint = () => {
-  const url = `${restBaseUrl}/cashier/cashPoint`;
-  const { data, isLoading, error } = useSWR<{ data: { results: Array<OpenmrsResource> } }>(url, openmrsFetch);
+export interface BillableItemPrice {
+  paymentMode: string;
+  price: number | string;
+}
 
-  return { isLoading, error, cashPoints: data?.data?.results ?? [] };
-};
-export const createPatientBill = (payload) => {
-  const postUrl = `${restBaseUrl}/cashier/bill`;
-  return openmrsFetch(postUrl, { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: payload });
+export interface BillableItem {
+  uuid: string;
+  name: string;
+  price: number | string;
+  prices?: Array<BillableItemPrice>;
+  concept?: { uuid: string; display: string };
+  serviceType?: { uuid: string; display: string };
+  description?: string;
+  retired?: boolean;
+}
+
+export interface SelectedService {
+  uuid?: string;
+  name: string;
+  price: number | string;
+  prices?: Array<BillableItemPrice>;
+}
+
+/**
+ * The price to charge for a payment mode.
+ *
+ * Per-mode pricing is strict: once a service has any per-mode prices, it is only offered at the price
+ * set for the *selected* mode. A mode with no price of its own is not priced for that service -- it
+ * must never borrow another mode's price (that is what made a cash-only service quote the cash price
+ * under Mobile Money). Returns undefined in that case so the caller can hide/skip it. Only a service
+ * with no per-mode prices at all falls back to its single flat price.
+ */
+export const priceForMode = (
+  item: { price: number | string; prices?: Array<BillableItemPrice> },
+  mode?: string,
+): number | string | undefined => {
+  const overrides = item.prices ?? [];
+  if (overrides.length > 0) {
+    const match = mode ? overrides.find((entry) => entry.paymentMode === mode) : undefined;
+    return match?.price;
+  }
+  return item.price;
 };
 
+/**
+ * The facility's billable items (concept + price) from the DigiHMIS billing module.
+ */
 export const useBillableItems = () => {
   const { registrationServiceType } = useConfig<BillingConfig>();
-  const url = `${restBaseUrl}/cashier/billableService?v=custom:(uuid,name,shortName,serviceStatus,serviceType:(uuid,display),servicePrices:(uuid,name,price,paymentMode))`;
-  const { data, isLoading, error } = useSWR<{ data: { results: Array<OpenmrsResource> } }>(url, openmrsFetch);
+  const url = `${restBaseUrl}/digihmisbilling/billableitem`;
+  const { data, isLoading, error } = useSWR<{ data: { results: Array<BillableItem> } }>(url, openmrsFetch);
   const [searchTerm, setSearchTerm] = useState('');
 
-  const filteredItems = useMemo(() => {
-    if (!data?.data?.results) {
-      return [];
+  const lineItems = useMemo(() => {
+    let items = (data?.data?.results ?? []).filter((item) => !item.retired);
+    // Check-in only offers the registration service(s) -- items in the configured registration
+    // service type. If none is configured, fall back to showing all so nothing silently disappears.
+    if (registrationServiceType) {
+      items = items.filter((item) => item.serviceType?.uuid === registrationServiceType);
     }
+    const query = searchTerm.trim().toLowerCase();
+    return query ? items.filter((item) => item.name?.toLowerCase().includes(query)) : items;
+  }, [data?.data?.results, searchTerm, registrationServiceType]);
 
-    const lowerSearchTerm = searchTerm.toLowerCase();
+  return { lineItems, isLoading, error, searchTerm, setSearchTerm };
+};
 
-    return data.data.results.filter(
-      (item) => item.serviceType?.uuid === registrationServiceType && item.name.toLowerCase().includes(lowerSearchTerm),
-    );
-  }, [data?.data?.results, searchTerm, registrationServiceType]);
+/**
+ * New vs revisit is derived, never asked -- a manual choice only confuses the clerk. Checked at
+ * check-in before the new visit is saved: a patient with any existing visit is a REVISIT, otherwise
+ * NEW. The value is written to the patient-type visit attribute alongside the payment details.
+ */
+export const usePatientType = (patientUuid: string) => {
+  const url = patientUuid
+    ? `${restBaseUrl}/visit?patient=${patientUuid}&includeInactive=true&limit=1&v=custom:(uuid)`
+    : null;
+  const { data, isLoading } = useSWR<{ data: { results: Array<{ uuid: string }> } }>(url, openmrsFetch);
+  const patientType = (data?.data?.results?.length ?? 0) > 0 ? 'REVISIT' : 'NEW';
+  return { patientType, isLoading };
+};
 
-  return {
-    lineItems: filteredItems,
-    isLoading,
-    error,
-    searchTerm,
-    setSearchTerm,
-  };
+/**
+ * Charge the selected services to the visit's bill. DigiHMIS bills are visit-scoped, so this runs
+ * once the visit has been saved and its uuid is known; each service becomes a bill line.
+ */
+export const addBillLinesForVisit = (
+  visitUuid: string,
+  services: Array<SelectedService>,
+  paymentMode?: string,
+) => {
+  return Promise.all(
+    services.map((service) => {
+      const params = new URLSearchParams({
+        visit: visitUuid,
+        description: service.name ?? '',
+        unitPrice: String(priceForMode(service, paymentMode) ?? '0'),
+        quantity: '1',
+      });
+      return openmrsFetch(`${restBaseUrl}/digihmisbilling/bill/line?${params.toString()}`, { method: 'POST' });
+    }),
+  );
 };

package/src/billing-checkin-form/visit-attributes/visit-attributes-form.resource.ts

@@ -1,23 +1,35 @@
-import { openmrsFetch, restBaseUrl, useConfig } from '@openmrs/esm-framework';
+import { useConfig } from '@openmrs/esm-framework';
 import { BillingConfig } from '../../config-schema';
-import { PaymentMethod } from '../type';
-import useSWR from 'swr';
+
+export interface PaymentModeOption {
+  uuid: string;
+  name: string;
+  description?: string;
+}
+
+/**
+ * DigiHMIS models the payment mode as a fixed enum
+ * (org.openmrs.module.digihmisbilling.model.PaymentMode), not a REST-listed entity, so the check-in
+ * payment-method options come from that closed set. The `uuid` carries the enum name, which is what
+ * the visit attribute stores and what the payment endpoint expects.
+ */
+const PAYMENT_MODES: Array<PaymentModeOption> = [
+  { uuid: 'CASH', name: 'Cash', description: 'Physical cash at the till' },
+  { uuid: 'MOBILE_MONEY', name: 'Mobile money', description: 'M-Pesa and the like' },
+  { uuid: 'CARD', name: 'Card', description: 'Card payment' },
+  { uuid: 'INSURANCE', name: 'Insurance', description: 'Settled by an insurer or scheme' },
+  { uuid: 'WAIVER', name: 'Waiver', description: 'Written off (waiver / exemption)' },
+];
 
 export const usePaymentModes = (excludeWaiver: boolean = true) => {
   const { excludedPaymentMode } = useConfig<BillingConfig>();
-  const url = `${restBaseUrl}/cashier/paymentMode?v=full`;
-  const { data, isLoading, error, mutate } = useSWR<{ data: { results: Array<PaymentMethod> } }>(url, openmrsFetch, {
-    errorRetryCount: 2,
-  });
-  const allowedPaymentModes =
-    excludedPaymentMode?.length > 0
-      ? (data?.data?.results.filter((mode) => !excludedPaymentMode.some((excluded) => excluded.uuid === mode.uuid)) ??
-        [])
-      : (data?.data?.results ?? []);
+  const excluded = new Set((excludedPaymentMode ?? []).map((mode) => mode.uuid));
+  const allowedPaymentModes = PAYMENT_MODES.filter((mode) => !excluded.has(mode.uuid));
+
   return {
-    paymentModes: excludeWaiver ? allowedPaymentModes : data?.data?.results,
-    isLoading,
-    mutate,
-    error,
+    paymentModes: excludeWaiver ? allowedPaymentModes.filter((mode) => mode.uuid !== 'WAIVER') : allowedPaymentModes,
+    isLoading: false,
+    error: undefined,
+    mutate: () => {},
   };
 };

package/src/billing-dashboard/billing-dashboard.resource.ts

@@ -6,15 +6,24 @@ import { CashPoint, Timesheet } from './type';
  * Hook to get the current cashier's active timesheet (clocked-in session)
  */
 export const useCurrentTimesheet = () => {
-  const session = useSession();
-  const providerUuid = session?.currentProvider?.uuid;
-
-  const { data, error, isLoading, mutate } = useSWR<{ data: { results: Array<Timesheet> } }>(
-    providerUuid ? `${restBaseUrl}/cashier/timesheet?cashier=${providerUuid}&getProviderOpenTimesheet=true` : null,
+  // The DigiHMIS shift is scoped to the logged-in user server-side; /shift/active returns it or {}.
+  const { data, error, isLoading, mutate } = useSWR<{ data: any }>(
+    `${restBaseUrl}/digihmisbilling/shift/active`,
     openmrsFetch,
   );
 
-  const activeTimesheet = data?.data?.results?.[0] || null;
+  const shift = data?.data && data.data.uuid ? data.data : null;
+  const activeTimesheet = shift
+    ? {
+        uuid: shift.uuid,
+        cashPoint: { uuid: shift.paymentPoint?.uuid, name: shift.paymentPoint?.display },
+        cashier: shift.cashier,
+        clockIn: shift.clockIn,
+        clockOut: shift.clockOut ?? null,
+        totalCollected: shift.totalCollected,
+        collectedByMode: shift.collectedByMode,
+      }
+    : null;
   const isClockedIn = activeTimesheet !== null && activeTimesheet.clockOut === null;
 
   return {
@@ -69,7 +78,7 @@ export const useTimesheets = (
  * Hook to fetch all available cash points
  */
 export const useCashPoints = () => {
-  const url = `${restBaseUrl}/cashier/cashPoint?v=default`;
+  const url = `${restBaseUrl}/digihmisbilling/paymentpoint`;
 
   const { data, error, isLoading, mutate } = useSWR<{ data: { results: Array<CashPoint> } }>(url, openmrsFetch);
 

package/src/billing-header/page-header/page-icon/icon-wrapper.extension.tsx

@@ -1,17 +1,2 @@
-import React from 'react';
-
-interface IconWrapperProps {
-  src: string;
-  alt?: string;
-  className?: string;
-  style?: React.CSSProperties;
-}
-
-export const IconWrapper: React.FC<IconWrapperProps> = ({
-  src,
-  alt = 'Icon',
-  className,
-  style = { width: '100px', height: '148px' },
-}) => {
-  return <img src={src} alt={alt} className={className} style={style} />;
-};
+// Moved to the shared library so every app uses one implementation.
+export { IconWrapper, type IconWrapperProps } from '@digihmis/esm-commons-lib';

package/src/billing-timesheet-modal/billing-timesheet-modal.tsx

@@ -59,7 +59,7 @@ export const BillingTimesheetModal: React.FC<BillingTimesheetModalProps> = ({
     setIsSubmitting(true);
 
     try {
-      const response = await clockIn(providerUuid, selectedCashPoint);
+      const response = await clockIn(selectedCashPoint);
       await mutateTimesheet();
 
       showSnackbar({
@@ -114,7 +114,7 @@ export const BillingTimesheetModal: React.FC<BillingTimesheetModalProps> = ({
       await clockOut(activeTimesheet.uuid);
 
       // Clock in to new cash point
-      const response = await clockIn(providerUuid, selectedCashPoint);
+      const response = await clockIn(selectedCashPoint);
       await mutateTimesheet();
 
       showSnackbar({
@@ -181,6 +181,8 @@ export const BillingTimesheetModal: React.FC<BillingTimesheetModalProps> = ({
               {t('currentlyActiveAt', 'Currently active at {{location}}', {
                 location: activeTimesheet.cashPoint?.name || t('unknown', 'Unknown'),
               })}
+              {' · '}
+              {t('collectedThisShift', 'Collected: {{amount}}', { amount: activeTimesheet.totalCollected ?? 0 })}
             </span>
           )}
         </div>

package/src/billing-timesheet-modal/billing-timesheet-resource-modal.ts

@@ -1,37 +1,16 @@
 import { openmrsFetch, restBaseUrl } from '@openmrs/esm-framework';
 
 /**
- * Clock in a cashier to a cash point
+ * Open a cashier shift at a payment point. The cashier is the logged-in user, resolved server-side,
+ * so only the payment point is passed.
  */
-export const clockIn = async (cashierUuid: string, cashPointUuid: string) => {
-  const url = `${restBaseUrl}/cashier/timesheet`;
-
-  return openmrsFetch(url, {
+export const clockIn = async (paymentPointUuid: string) => {
+  return openmrsFetch(`${restBaseUrl}/digihmisbilling/shift/clockin?paymentPoint=${paymentPointUuid}`, {
     method: 'POST',
-    headers: {
-      'Content-Type': 'application/json',
-    },
-    body: {
-      cashier: cashierUuid,
-      cashPoint: cashPointUuid,
-      clockIn: new Date().toISOString(),
-    },
   });
 };
 
-/**
- * Clock out the current cashier (close the timesheet)
- */
-export const clockOut = async (timesheetUuid: string) => {
-  const url = `${restBaseUrl}/cashier/timesheet/${timesheetUuid}`;
-
-  return openmrsFetch(url, {
-    method: 'POST',
-    headers: {
-      'Content-Type': 'application/json',
-    },
-    body: {
-      clockOut: new Date().toISOString(),
-    },
-  });
+/** Close an open shift. */
+export const clockOut = async (shiftUuid: string) => {
+  return openmrsFetch(`${restBaseUrl}/digihmisbilling/shift/${shiftUuid}/clockout`, { method: 'POST' });
 };

package/src/config-schema.ts

@@ -8,6 +8,7 @@ export interface BillingConfig {
     exemptionCategory: string;
     billPaymentStatus: string;
     shaBenefitPackagesAndInterventions: string;
+    patientType: string;
   };
   insurancePaymentMethod: string;
   patientExemptionCategories: Array<{ value: string; label: string }>;
@@ -62,11 +63,16 @@ export const configSchema: ConfigSchema = {
       _description: 'The bill payment status visit attribute uuid',
       _default: '919b51c9-8e2e-468f-8354-181bf3e55786',
     },
+    patientType: {
+      _type: Type.String,
+      _description: 'The patient type (new vs revisit) visit attribute uuid',
+      _default: '6b9e1f7a-2c3d-4e5f-8a1b-9c0d1e2f3a4b',
+    },
   },
   insurancePaymentMethod: {
     _type: Type.String,
-    _description: 'Insurance Payment method UUID',
-    _default: 'beac329b-f1dc-4a33-9e7c-d95821a137a6',
+    _description: 'The payment-method value that reveals the insurance fields (DigiHMIS PaymentMode enum)',
+    _default: 'INSURANCE',
   },
   patientExemptionCategories: {
     _type: Type.Array,