@kenyaemr/esm-ward-app 8.5.1-pre.41 → 8.5.1-pre.46

package/src/discharge-printouts/discharge-printout.resource.ts

@@ -1,19 +1,25 @@
 import {
+  type Encounter,
   type FetchResponse,
-  fhirBaseUrl,
+  type Obs,
   openmrsFetch,
+  type OpenmrsResource,
   restBaseUrl,
   useConfig,
   type Visit,
 } from '@openmrs/esm-framework';
+import { type Order } from '@openmrs/esm-patient-common-lib';
 import { useMemo } from 'react';
 import useSWR from 'swr';
-import { useEncounterDetails } from '../hooks/useIpdDischargeEncounter';
 import { type WardConfigObject } from '../config-schema';
-import { type Order } from '@openmrs/esm-patient-common-lib';
+import { useEncounterDetails } from '../hooks/useIpdDischargeEncounter';
 export const DATE_FORMART = 'DD/MM/YYYY';
 export const TIME_FORMART = 'hh:mm A';
 
+const labConceptRepresentation =
+  'custom:(uuid,display,name,datatype,set,answers,hiNormal,hiAbsolute,hiCritical,lowNormal,lowAbsolute,lowCritical,units,allowDecimal,' +
+  'setMembers:(uuid,display,answers,datatype,hiNormal,hiAbsolute,hiCritical,lowNormal,lowAbsolute,lowCritical,units,allowDecimal,set,setMembers:(uuid)))';
+
 export const usePatientDiagnosis = (encounterUuid: string) => {
   const customRepresentation =
     'custom:(uuid,display,visit:(uuid,encounters:(uuid,diagnoses:(uuid,display,certainty,diagnosis:(coded:(uuid,display))))))';
@@ -34,7 +40,11 @@ export const usePatientDiagnosis = (encounterUuid: string) => {
     );
   }, [data]);
   const display = useMemo(() => {
-    if (diagnoses?.length) return diagnoses.map((d) => d.text).join(', ');
+    if (diagnoses?.length)
+      return diagnoses
+        .map((d) => d.text)
+        .join(', ')
+        ?.toLowerCase();
     return null;
   }, [diagnoses]);
 
@@ -46,150 +56,39 @@ export const usePatientDiagnosis = (encounterUuid: string) => {
   };
 };
 
-export interface AllergyIntoleranceResponse {
-  resourceType: string;
-  id: string;
-  meta: {
-    lastUpdated: string;
-  };
-  type: string;
-  total: number;
-  entry: Array<{
-    resource: AllergyIntolerance;
-  }>;
-}
-
-export interface AllergyIntolerance {
-  resourceType: string;
-  id: string;
-  meta: {
-    lastUpdated: string;
-  };
-  clinicalStatus: {
-    coding: [
-      {
-        system: string;
-        code: string;
-        display: string;
-      },
-    ];
-    text: string;
-  };
-  verificationStatus: {
-    coding: [
-      {
-        system: string;
-        code: string;
-        display: string;
-      },
-    ];
-    text: string;
-  };
-  type: string;
-  category: Array<string>;
-  criticality: string;
-  code: {
-    coding: [
-      {
-        code: string;
-        display: string;
-      },
-    ];
-    text: string;
-  };
-  patient: {
-    reference: string;
-    type: string;
-    display: string;
-  };
-  recordedDate: string;
-  recorder: {
-    reference: string;
-    type: string;
-    display: string;
-  };
-  reaction: [
-    {
-      substance: {
-        coding: [
-          {
-            code: string;
-            display: string;
-          },
-        ];
-        text: string;
-      };
-      manifestation: [
-        {
-          coding: [
-            {
-              code: string;
-              display: string;
-            },
-          ];
-          text: string;
-        },
-      ];
-      severity: string;
-    },
-  ];
-}
-
-export interface Coding {
-  system?: string;
-  code: string;
-  display?: string;
-}
-
-export function getConceptCoding(codings: Coding[]): Coding {
-  return codings ? codings.find((c) => !('system' in c) || c.system === undefined) : null;
-}
-
-export function getConceptCodingDisplay(codings: Coding[]): string {
-  return getConceptCoding(codings)?.display;
-}
-
-export function usePatientAllergies(patientUuid: string) {
-  const { data, error, isLoading } = useSWR<{ data: AllergyIntoleranceResponse }, Error>(
-    `${fhirBaseUrl}/AllergyIntolerance?patient=${patientUuid}`,
-    openmrsFetch,
-  );
-  const allergies: Array<AllergyIntolerance> = useMemo(() => {
-    const _allergies: Array<AllergyIntolerance> = [];
-    if (data) {
-      const entries = data?.data.entry;
-      entries?.map((allergy) => {
-        return _allergies.push(allergy.resource);
-      });
-    }
-    return _allergies;
-  }, [data]);
-
-  const display = useMemo(() => {
-    if (allergies?.length) return allergies.map((allergy) => getConceptCodingDisplay(allergy.code.coding)).join(', ');
-    return null;
-  }, [allergies]);
-
-  return {
-    allergies,
-    totalAllergies: data?.data.total,
-    error,
-    isLoading,
-    display,
-  };
-}
-
 export function usePatientOrders(dischargeEncounterUuId: string) {
   const rep =
     'custom:(uuid,display,location:(display),encounterDatetime,visit:(uuid,display,encounters:(uuid,display,encounterType:(uuid,display),encounterDatetime,orders,obs)))';
   const { encounter, error, isLoading } = useEncounterDetails(dischargeEncounterUuId, rep);
-  const { drugOrderEncounterType } = useConfig<WardConfigObject>();
+  const {
+    drugOrderEncounterType,
+    clinicalConsultationEncounterType,
+    ipdDischargeEncounterTypeUuid,
+    doctorsNoteEncounterType,
+    conceptUuidForWardAdmission: concepts,
+  } = useConfig<WardConfigObject>();
+
   const orderEncounters = useMemo(() => {
     const encounters = (encounter?.visit?.encounters ?? []).filter(
       (enc) => enc.encounterType.uuid === drugOrderEncounterType,
     );
     return encounters;
   }, [encounter, drugOrderEncounterType]);
+
+  const clinicalConsultationEncounters = useMemo(() => {
+    const encounters = (encounter?.visit?.encounters ?? []).filter(
+      (enc) => enc.encounterType.uuid === clinicalConsultationEncounterType,
+    );
+    return encounters;
+  }, [encounter, clinicalConsultationEncounterType]);
+
+  const doctorsNoteEncounters = useMemo(() => {
+    const encounters = (encounter?.visit?.encounters ?? []).filter(
+      (enc) => enc.encounterType.uuid === doctorsNoteEncounterType,
+    );
+    return encounters;
+  }, [encounter, doctorsNoteEncounterType]);
+
   const { drugorder, testorder } = useMemo<{ drugorder: Array<Order>; testorder: Array<Order> }>(
     () =>
       orderEncounters.reduce(
@@ -205,11 +104,232 @@ export function usePatientOrders(dischargeEncounterUuId: string) {
     [orderEncounters],
   );
 
+  const complaints = useMemo(() => {
+    const obs = getComplaintsObs(doctorsNoteEncounters, concepts.complaint, concepts.chiefComplaint);
+    if (obs.length) return obs.map((o) => getObservationDisplayValue(o.value, null)).join(', ');
+    return null;
+  }, [doctorsNoteEncounters, concepts]);
+
+  const drugReactions = useMemo(() => {
+    const obs = getDrugReactions(clinicalConsultationEncounters, concepts.drugReaction, concepts.reactingDrug);
+    if (obs.length)
+      return obs
+        .map((o) => getObservationDisplayValue(o.value, null))
+        .join(', ')
+        .toLowerCase();
+    return null;
+  }, [clinicalConsultationEncounters, concepts]);
+
+  const ipdDischargeEncounter = useMemo<Encounter>(() => {
+    const encounters = (encounter?.visit?.encounters ?? []).find(
+      (enc) => enc.encounterType.uuid === ipdDischargeEncounterTypeUuid,
+    );
+    return encounters;
+  }, [encounter, ipdDischargeEncounterTypeUuid]);
+
+  const physicalExaminations = useMemo(() => {
+    const obs = doctorsNoteEncounters.reduce<Array<Obs>>((prev, cur) => {
+      if (cur.obs?.length) {
+        const obs = cur.obs.filter((o) => o.concept.uuid === concepts.physicalExamination);
+        prev.push(...obs);
+      }
+      return prev;
+    }, []);
+    return obs?.map((ob) => getObservationDisplayValue(ob.value, null)?.toLowerCase());
+  }, [doctorsNoteEncounters, concepts.physicalExamination]);
+
+  const dischargeinstructions = useMemo(() => {
+    const instructionObsValue = ipdDischargeEncounter?.obs?.find(
+      (o) => o.concept.uuid === concepts.dischargeInstruction,
+    )?.value;
+    return getObservationDisplayValue(instructionObsValue, null);
+  }, [ipdDischargeEncounter, concepts.dischargeInstruction]);
+
   return {
     isLoading,
     error,
     drugOrders: drugorder,
     testOrders: testorder,
     orderEncounters,
+    clinicalConsultationEncounters,
+    complaints,
+    drugReactions,
+    dischargeinstructions,
+    ipdDischargeEncounter,
+    physicalExaminations,
   };
 }
+
+function getComplaintsObs(
+  encounters: Array<Encounter>,
+  complaintsConceptUuid: string,
+  chiefComplainConceptUuid: string,
+) {
+  return encounters.reduce<Array<Obs>>((prev, curr) => {
+    if (curr.obs.length) {
+      const complaintObs = curr.obs
+        .filter((o) => o.concept.uuid === complaintsConceptUuid && o.groupMembers)
+        .flatMap((o) => o.groupMembers)
+        .filter((o) => o.concept.uuid === chiefComplainConceptUuid);
+      prev.push(...complaintObs);
+    }
+    return prev;
+  }, []);
+}
+
+function getDrugReactions(encounters: Array<Encounter>, drugReactionsConceptUuid: string, drugConceptUuid: string) {
+  return encounters.reduce<Array<Obs>>((prev, curr) => {
+    if (curr.obs.length) {
+      const complaintObs = curr.obs
+        .filter((o) => o.concept.uuid === drugReactionsConceptUuid && o.groupMembers)
+        .flatMap((o) => o.groupMembers)
+        .filter((o) => o.concept.uuid === drugConceptUuid);
+      prev.push(...complaintObs);
+    }
+    return prev;
+  }, []);
+}
+type NullableNumber = number | null | undefined;
+export type ObservationValue =
+  | OpenmrsResource // coded
+  | number // numeric
+  | string // text or misc
+  | boolean
+  | null;
+
+export interface LabOrderConcept {
+  uuid: string;
+  display: string;
+  name?: ConceptName;
+  datatype: LabOrderConceptDatatype;
+  set: boolean;
+  version: string;
+  retired: boolean;
+  descriptions: Array<LabOrderConceptDescription>;
+  mappings?: Array<LabOrderConceptMapping>;
+  answers?: Array<OpenmrsResource>;
+  setMembers?: Array<LabOrderConcept>;
+  hiNormal?: NullableNumber;
+  hiAbsolute?: NullableNumber;
+  hiCritical?: NullableNumber;
+  lowNormal?: NullableNumber;
+  lowAbsolute?: NullableNumber;
+  lowCritical?: NullableNumber;
+  allowDecimal?: boolean | null;
+  units?: string;
+}
+
+export interface ConceptName {
+  display: string;
+  uuid: string;
+  name: string;
+  locale: string;
+  localePreferred: boolean;
+  conceptNameType: string;
+}
+
+export interface LabOrderConceptDatatype {
+  uuid: string;
+  display: string;
+  name: string;
+  description: string;
+  hl7Abbreviation: string;
+  retired: boolean;
+  resourceVersion: string;
+}
+
+export interface LabOrderConceptDescription {
+  display: string;
+  uuid: string;
+  description: string;
+  locale: string;
+  resourceVersion: string;
+}
+
+export interface LabOrderConceptMapping {
+  display: string;
+  uuid: string;
+  conceptReferenceTerm: OpenmrsResource;
+  conceptMapType: OpenmrsResource;
+  resourceVersion: string;
+}
+export function useOrderConceptByUuid(uuid: string) {
+  const apiUrl = `${restBaseUrl}/concept/${uuid}?v=${labConceptRepresentation}`;
+
+  const { data, error, isLoading, isValidating, mutate } = useSWR<LabOrderConcept, Error>(uuid, fetchAllSetMembers);
+  /**
+   * We are fetching 2 levels of set members at one go.
+   */
+
+  const results = useMemo(
+    () => ({
+      concept: data,
+      isLoading,
+      error,
+      isValidating,
+      mutate,
+    }),
+    [data, error, isLoading, isValidating, mutate],
+  );
+
+  return results;
+}
+
+/**
+ * This function fetches all the different levels of set members for a concept,
+ * while fetching 2 levels of set members at one go.
+ * @param conceptUuid - The UUID of the concept to fetch.
+ * @returns The concept with all its set members and their set members.
+ */
+async function fetchAllSetMembers(conceptUuid: string): Promise<LabOrderConcept> {
+  const conceptResponse = await openmrsFetch<LabOrderConcept>(getUrlForConcept(conceptUuid));
+  let concept = conceptResponse.data;
+  const secondLevelSetMembers = concept.set
+    ? concept.setMembers
+        .map((member) => (member.set ? member.setMembers.map((lowerMember) => lowerMember.uuid) : []))
+        .flat()
+    : [];
+  if (secondLevelSetMembers.length > 0) {
+    const concepts = await Promise.all(secondLevelSetMembers.map((uuid) => fetchAllSetMembers(uuid)));
+    const uuidMap = concepts.reduce(
+      (acc, c) => {
+        acc[c.uuid] = c;
+        return acc;
+      },
+      {} as Record<string, LabOrderConcept>,
+    );
+    concept.setMembers = concept.setMembers.map((member) => {
+      if (member.set) {
+        member.setMembers = member.setMembers.map((lowerMember) => uuidMap[lowerMember.uuid]);
+      }
+      return member;
+    });
+  }
+
+  return concept;
+}
+
+function getUrlForConcept(conceptUuid: string) {
+  return `${restBaseUrl}/concept/${conceptUuid}?v=${labConceptRepresentation}`;
+}
+
+export const getObservationDisplayValue = (value: ObservationValue, defaultValue: string | null = '--'): string => {
+  if (value == null) return defaultValue;
+
+  switch (typeof value) {
+    case 'string':
+      return value.trim() || defaultValue;
+    case 'number':
+      return String(value);
+    case 'object':
+      if ('display' in value && typeof value.display === 'string') {
+        return value.display.trim() || defaultValue;
+      }
+      break;
+  }
+
+  return defaultValue;
+};
+export const getTreatmentDisplayText = (order: Order): string => {
+  return `${order.drug?.display} ${order.frequency.display} for ${order.duration} ${order.durationUnits.display}`;
+};

package/src/discharge-printouts/discharge-summary.tsx

@@ -1,18 +1,19 @@
+import { InlineLoading, InlineNotification } from '@carbon/react';
+import { useEmrConfiguration, usePatient, useSession } from '@openmrs/esm-framework';
+import dayjs from 'dayjs';
 import React, { type FC, useMemo } from 'react';
-import styles from './discharge-printouts.scss';
-import FieldInput from './field-input';
 import { useTranslation } from 'react-i18next';
-import { useEmrConfiguration, usePatient, useSession } from '@openmrs/esm-framework';
 import { useEncounterDetails } from '../hooks/useIpdDischargeEncounter';
-import { InlineLoading, InlineNotification } from '@carbon/react';
-import dayjs from 'dayjs';
+import { useProvider } from '../ward-workspace/admit-patient-form-workspace/patient-admission.resources';
 import {
   DATE_FORMART,
-  usePatientAllergies,
+  getTreatmentDisplayText,
   usePatientDiagnosis,
   usePatientOrders,
 } from './discharge-printout.resource';
-import { useProvider } from '../ward-workspace/admit-patient-form-workspace/patient-admission.resources';
+import styles from './discharge-printouts.scss';
+import FieldInput from './field-input';
+import LabResults from './lab-results';
 
 type DischargeSummaryProps = {
   dischargeEncounterUuid: string;
@@ -32,11 +33,6 @@ const DischargeSummary: FC<DischargeSummaryProps> = ({ dischargeEncounterUuid, p
     error: diagnosisError,
     display: diagnoses,
   } = usePatientDiagnosis(dischargeEncounterUuid);
-  const {
-    display: allergies,
-    error: allergiesError,
-    isLoading: isLoadingAllergies,
-  } = usePatientAllergies(_patient.uuid);
   const session = useSession();
   const { error: errorProvider, isLoading: isLoadingProvider, provider } = useProvider(session.currentProvider.uuid);
   const { emrConfiguration, isLoadingEmrConfiguration, errorFetchingEmrConfiguration } = useEmrConfiguration();
@@ -45,6 +41,11 @@ const DischargeSummary: FC<DischargeSummaryProps> = ({ dischargeEncounterUuid, p
     error: orderserror,
     drugOrders,
     testOrders,
+    complaints,
+    drugReactions,
+    orderEncounters,
+    dischargeinstructions,
+    physicalExaminations,
   } = usePatientOrders(dischargeEncounterUuid);
   const admissionDate = useMemo(() => {
     const admisionEncounter = encounter?.visit?.encounters?.find(
@@ -60,19 +61,10 @@ const DischargeSummary: FC<DischargeSummaryProps> = ({ dischargeEncounterUuid, p
     isLoadingEmrConfiguration ||
     isLoadingDiagnosis ||
     isLoadingProvider ||
-    isLoadingAllergies ||
     isLoadingOders
   )
     return <InlineLoading />;
-  if (
-    error ||
-    patientError ||
-    errorFetchingEmrConfiguration ||
-    diagnosisError ||
-    errorProvider ||
-    allergiesError ||
-    orderserror
-  )
+  if (error || patientError || errorFetchingEmrConfiguration || diagnosisError || errorProvider || orderserror)
     return (
       <InlineNotification
         kind="error"
@@ -82,7 +74,6 @@ const DischargeSummary: FC<DischargeSummaryProps> = ({ dischargeEncounterUuid, p
           errorFetchingEmrConfiguration?.message ??
           diagnosisError?.message ??
           errorProvider?.message ??
-          allergiesError?.message ??
           orderserror?.message
         }
       />
@@ -116,31 +107,39 @@ const DischargeSummary: FC<DischargeSummaryProps> = ({ dischargeEncounterUuid, p
 
       <div>
         <strong className={styles.txtUpper}>{t('diagnosis', 'Diagnosis')}</strong>
-        <p className={styles.txtTitle}>{diagnoses?.toLowerCase() ?? t('noDiagnoses', 'No Diagnoses')}</p>
+        <p className={styles.txtTitle}>{diagnoses ?? t('noDiagnoses', 'No Diagnoses')}</p>
       </div>
       <div>
         <strong className={styles.txtUpper}>{t('history', 'History')}</strong>
         <p>
-          {`${_patient.name}, a ${Math.abs(dayjs(patient.birthDate).diff(dayjs(), 'years'))} year ${
-            patient.gender
-          } presented with .${
-            allergies
-              ? t('knownAlergies', 'Known Alergies') + ': ' + allergies
-              : t('noKnownAlergies', 'No known alergies')
+          {`${complaints ? 'Presented with ' + complaints + '.' : ''}${
+            drugReactions
+              ? t('knownDrugAllergies', 'Known drug allergies') + ': ' + drugReactions
+              : t('noKnownDrugAllergies', 'No known drug allergies')
           }`}
         </p>
       </div>
       <div>
         <strong className={styles.txtUpper}>{t('physicalExamination', 'Physical Examination')}</strong>
-        <p></p>
+        {physicalExaminations?.length ? (
+          physicalExaminations?.map((examination, i) => (
+            <p key={i} className={styles.txtTitle}>
+              {examination}
+            </p>
+          ))
+        ) : (
+          <p>{t('noExaminations', 'No Examinations')}</p>
+        )}
       </div>
       <div>
         <strong className={styles.txtUpper}>{t('investigation', 'Investigation')}</strong>
         <p>
           {testOrders.map((order) => (
-            <p key={order.uuid} className={styles.txtTitle}>
-              {order.display?.toLowerCase()}
-            </p>
+            <LabResults
+              order={order}
+              key={order.uuid}
+              labEncounter={orderEncounters.find((e) => e.uuid === order.encounter.uuid)}
+            />
           ))}
         </p>
       </div>
@@ -148,13 +147,13 @@ const DischargeSummary: FC<DischargeSummaryProps> = ({ dischargeEncounterUuid, p
         <strong className={styles.txtUpper}>{t('treatment', 'Treatment')}</strong>
         <div>
           {drugOrders.map((order) => (
-            <p key={order.uuid}>{order.display}</p>
+            <p key={order.uuid}>{getTreatmentDisplayText(order)}</p>
           ))}
         </div>
       </div>
       <div>
         <strong className={styles.txtUpper}>{t('dischargeInstructions', 'Discharge Instructions')}</strong>
-        <p></p>
+        <p>{dischargeinstructions ?? t('noInstructions', 'No instructions')}</p>
       </div>
       <div className={styles.cols2}>
         <FieldInput name={t('name', 'Name')} value={provider?.display?.split('-')?.at(-1)} />

package/src/discharge-printouts/lab-results.tsx

@@ -0,0 +1,96 @@
+import { InlineLoading, InlineNotification } from '@carbon/react';
+import { type Encounter } from '@openmrs/esm-framework';
+import type { Order } from '@openmrs/esm-patient-common-lib';
+import React, { type FC, useMemo } from 'react';
+import { useTranslation } from 'react-i18next';
+import { getObservationDisplayValue, useOrderConceptByUuid } from './discharge-printout.resource';
+import styles from './discharge-printouts.scss';
+type LabResultsProps = {
+  order: Order;
+  labEncounter?: Encounter;
+};
+
+const LabResults: FC<LabResultsProps> = ({ order, labEncounter: encounter }) => {
+  const { concept, isLoading: isLoadingTestConcepts, error } = useOrderConceptByUuid(order?.concept?.uuid);
+  const testResultObs = useMemo(() => {
+    if (!encounter || !concept) return null;
+    return encounter.obs?.find((obs) => obs.concept.uuid === concept.uuid);
+  }, [concept, encounter]);
+  const { t } = useTranslation();
+  const EMPTY_TEXT = t('noResults', 'No results');
+
+  const testResults = useMemo(() => {
+    if (!concept) return [];
+
+    // For panel tests (with set members)
+    if (concept.setMembers && concept.setMembers.length > 0) {
+      return concept.setMembers.map((memberConcept) => {
+        const memberObs = testResultObs?.groupMembers?.find((obs) => obs.concept.uuid === memberConcept.uuid);
+        let resultValue: string;
+        if (memberObs) {
+          resultValue = getObservationDisplayValue(memberObs.value ?? (memberObs as any));
+        } else {
+          resultValue = EMPTY_TEXT;
+        }
+
+        return {
+          id: memberConcept.uuid,
+          testType: memberConcept.display || EMPTY_TEXT,
+          result: resultValue,
+          normalRange:
+            memberConcept.hiNormal && memberConcept.lowNormal
+              ? `${memberConcept.lowNormal} - ${memberConcept.hiNormal}`
+              : 'N/A',
+        };
+      });
+    }
+
+    // For single tests (no set members)
+    let resultValue: string;
+    if (testResultObs) {
+      resultValue = getObservationDisplayValue(testResultObs.value ?? (testResultObs as any));
+    } else {
+      resultValue = EMPTY_TEXT;
+    }
+
+    return [
+      {
+        id: concept.uuid,
+        testType: concept.display || EMPTY_TEXT,
+        result: resultValue,
+        normalRange: concept.hiNormal && concept.lowNormal ? `${concept.lowNormal} - ${concept.hiNormal}` : 'N/A',
+      },
+    ];
+  }, [concept, testResultObs, EMPTY_TEXT]);
+
+  if (isLoadingTestConcepts)
+    return (
+      <InlineLoading
+        status="active"
+        iconDescription="Loading"
+        description={t('loadinglabresults', 'Loading lab results') + '...'}
+      />
+    );
+
+  if (error)
+    return (
+      <InlineNotification
+        kind="error"
+        title={t('labResultError', 'Error loading lab results')}
+        subtitle={error?.message}
+      />
+    );
+
+  return (
+    <div key={order.uuid} className={styles.txtTitle}>
+      {testResults.map((res) => (
+        <p key={res.id}>
+          <strong>{res.testType.toLowerCase()}: </strong>
+          <span>{res.result}</span>
+        </p>
+      ))}
+    </div>
+  );
+};
+
+export default LabResults;

package/src/index.ts

@@ -18,7 +18,10 @@ const options = {
 
 export const root = getAsyncLifecycle(() => import('./root.component'), options);
 
-export const wardDashboardLink = getSyncLifecycle(createDashboardLink({ name: 'ward', title: 'wards' }), options);
+export const wardDashboardLink = getSyncLifecycle(
+  createDashboardLink({ name: 'ward', title: 'Admissions', icon: 'omrs-icon-hospital-bed' }),
+  options,
+);
 
 export const wardView = getAsyncLifecycle(() => import('./ward-view/ward-view.component'), options);