@kenyaemr/esm-patient-registration-app 8.1.1-pre.111 → 8.1.1-pre.116

package/src/patient-registration/section/death-info/death-info-section.test.tsx

@@ -1,10 +1,10 @@
 import React from 'react';
 import { render, screen } from '@testing-library/react';
-import { Formik, Form } from 'formik';
+import { Form, Formik } from 'formik';
 import { initialFormValues } from '../../patient-registration.component';
-import { DeathInfoSection } from './death-info-section.component';
 import { type FormValues } from '../../patient-registration.types';
 import { PatientRegistrationContext } from '../../patient-registration-context';
+import { DeathInfoSection } from './death-info-section.component';
 
 const initialContextValues = {
   currentPhoto: 'data:image/png;base64,1234567890',
@@ -29,7 +29,7 @@ describe('Death info section', () => {
       <PatientRegistrationContext.Provider value={initialContextValues}>
         <Formik initialValues={initialFormValues} onSubmit={jest.fn()}>
           <Form>
-            <DeathInfoSection />
+            <DeathInfoSection fields={[]} />
           </Form>
         </Formik>
       </PatientRegistrationContext.Provider>,
@@ -40,16 +40,6 @@ describe('Death info section', () => {
     renderDeathInfoSection(true);
 
     expect(screen.getByRole('region', { name: /death info section/i })).toBeInTheDocument();
-    expect(screen.getByRole('heading', { name: /death info/i })).toBeInTheDocument();
-    expect(screen.getByRole('textbox', { name: /is dead \(optional\)/i })).toBeInTheDocument();
-    expect(screen.getByRole('textbox', { name: /date of death \(optional\)/i })).toBeInTheDocument();
-    expect(screen.getByRole('combobox', { name: /cause of death \(optional\)/i })).toBeInTheDocument();
-  });
-
-  it('has the correct number of inputs if is dead is not checked', async () => {
-    renderDeathInfoSection(false);
-
-    expect(screen.queryByRole('textbox', { name: /date of death \(optional\)/i })).not.toBeInTheDocument();
-    expect(screen.queryByRole('combobox', { name: /cause of death \(optional\)/i })).not.toBeInTheDocument();
+    expect(screen.getByRole('checkbox', { name: /is dead/i })).toBeInTheDocument();
   });
 });

package/src/patient-registration/section/section.component.tsx

@@ -14,7 +14,7 @@ export function Section({ sectionDefinition }: SectionProps) {
     case 'demographics':
       return <DemographicsSection fields={sectionDefinition.fields} />;
     case 'death':
-      return <DeathInfoSection />;
+      return <DeathInfoSection fields={sectionDefinition.fields} />;
     case 'relationships':
       return <RelationshipsSection />;
     default: // includes 'contact'

package/src/patient-registration/section/section.scss

@@ -1,3 +1,4 @@
+@use '@carbon/colors';
 @use '@carbon/layout';
 @use '@carbon/type';
 @use '@openmrs/esm-styleguide/src/vars' as *;
@@ -14,3 +15,7 @@
   color: $ui-04;
   cursor: pointer;
 }
+
+.isDeadFieldContainer {
+  margin-bottom: layout.$spacing-05;
+}

package/src/patient-registration/validation/{patient-registration-validation.test.tsx → patient-registration-validation.test.ts}

@@ -1,6 +1,7 @@
 import { getConfig } from '@openmrs/esm-framework';
 import { type RegistrationConfig } from '../../config-schema';
 import { getValidationSchema } from './patient-registration-validation';
+import dayjs from 'dayjs';
 
 const mockGetConfig = jest.mocked(getConfig);
 
@@ -35,6 +36,8 @@ describe('Patient registration validation', () => {
     additionalGivenName: '',
     birthdate: new Date('1990-01-01'),
     birthdateEstimated: false,
+    isDead: false,
+    causeOfDeath: null,
     deathDate: null,
     email: 'john.doe@example.com',
     familyName: 'Doe',
@@ -142,7 +145,7 @@ describe('Patient registration validation', () => {
     expect(validationError).toBeFalsy();
   });
 
-  it('should throw error when date of birth is a future date', async () => {
+  it('should throw an error when date of birth is a future date', async () => {
     const invalidFormValues = {
       ...validFormValues,
       birthdate: new Date('2100-01-01'),
@@ -151,6 +154,15 @@ describe('Patient registration validation', () => {
     expect(validationError.errors).toContain('birthdayNotInTheFuture');
   });
 
+  it('should throw an error when date of birth is more than 140 years ago', async () => {
+    const invalidFormValues = {
+      ...validFormValues,
+      birthdate: dayjs().subtract(141, 'years').toDate(),
+    };
+    const validationError = await validateFormValues(invalidFormValues);
+    expect(validationError.errors).toContain('birthdayNotOver140YearsAgo');
+  });
+
   it('should require yearsEstimated when birthdateEstimated is true', async () => {
     const invalidFormValues = {
       ...validFormValues,
@@ -160,7 +172,7 @@ describe('Patient registration validation', () => {
     expect(validationError.errors).toContain('yearsEstimateRequired');
   });
 
-  it('should throw error when monthEstimated is negative', async () => {
+  it('should throw an error when monthEstimated is negative', async () => {
     const invalidFormValues = {
       ...validFormValues,
       birthdateEstimated: true,
@@ -171,12 +183,22 @@ describe('Patient registration validation', () => {
     expect(validationError.errors).toContain('negativeMonths');
   });
 
-  it('should throw error when deathDate is in future', async () => {
+  it('should throw an error when yearsEstimated is more than 140', async () => {
+    const invalidFormValues = {
+      ...validFormValues,
+      birthdateEstimated: true,
+      yearsEstimated: 141,
+    };
+    const validationError = await validateFormValues(invalidFormValues);
+    expect(validationError.errors).toContain('nonsensicalYears');
+  });
+
+  it('should throw an error when deathDate is in future', async () => {
     const invalidFormValues = {
       ...validFormValues,
       deathDate: new Date('2100-01-01'),
     };
     const validationError = await validateFormValues(invalidFormValues);
-    expect(validationError.errors).toContain('deathdayNotInTheFuture');
+    expect(validationError.errors).toContain('deathDateInFuture');
   });
 });

package/src/patient-registration/validation/patient-registration-validation.ts

@@ -0,0 +1,126 @@
+import dayjs from 'dayjs';
+import * as Yup from 'yup';
+import mapValues from 'lodash/mapValues';
+import { translateFrom } from '@openmrs/esm-framework';
+import { type RegistrationConfig } from '../../config-schema';
+import { type FormValues } from '../patient-registration.types';
+import { getDatetime } from '../patient-registration.resource';
+
+const t = (key: string, value: string) => translateFrom('@openmrs/esm-framework', key, value);
+
+export function getValidationSchema(config: RegistrationConfig) {
+  return Yup.object({
+    givenName: Yup.string().required(t('givenNameRequired', 'Given name is required')),
+    familyName: Yup.string().required(t('familyNameRequired', 'Family name is required')),
+    additionalGivenName: Yup.string().when('addNameInLocalLanguage', {
+      is: true,
+      then: Yup.string().required(t('givenNameRequired', 'Given name is required')),
+      otherwise: Yup.string().notRequired(),
+    }),
+    additionalFamilyName: Yup.string().when('addNameInLocalLanguage', {
+      is: true,
+      then: Yup.string().required(t('familyNameRequired', 'Family name is required')),
+      otherwise: Yup.string().notRequired(),
+    }),
+    gender: Yup.string()
+      .oneOf(
+        config.fieldConfigurations.gender.map((g) => g.value),
+        t('genderUnspecified', 'Gender unspecified'),
+      )
+      .required(t('genderRequired', 'Gender is required')),
+    birthdate: Yup.date().when('birthdateEstimated', {
+      is: false,
+      then: Yup.date()
+        .required(t('birthdayRequired', 'Birthday is required'))
+        .max(Date(), t('birthdayNotInTheFuture', 'Birthday cannot be in future'))
+        .min(
+          dayjs().subtract(140, 'years').toDate(),
+          t('birthdayNotOver140YearsAgo', 'Birthday cannot be more than 140 years ago'),
+        )
+        .nullable(),
+      otherwise: Yup.date().nullable(),
+    }),
+    yearsEstimated: Yup.number().when('birthdateEstimated', {
+      is: true,
+      then: Yup.number()
+        .required(t('yearsEstimateRequired', 'Estimated years required'))
+        .min(0, t('negativeYears', 'Estimated years cannot be negative'))
+        .max(140, t('nonsensicalYears', 'Estimated years cannot be more than 140')),
+      otherwise: Yup.number().nullable(),
+    }),
+    monthsEstimated: Yup.number().min(0, t('negativeMonths', 'Estimated months cannot be negative')),
+    isDead: Yup.boolean(),
+    deathDate: Yup.date()
+      .when('isDead', {
+        is: true,
+        then: Yup.date().required(t('deathDateRequired', 'Death date is required')),
+        otherwise: Yup.date().nullable(),
+      })
+      .max(new Date(), 'deathDateInFuture')
+      .test(
+        'deathDate-after-birthdate',
+        t('deathdayInvalidDate', 'Death date and time cannot be before the birthday'),
+        function (value) {
+          const { birthdate } = this.parent;
+          if (birthdate && value) {
+            return dayjs(value).isAfter(birthdate);
+          }
+          return true;
+        },
+      )
+      .test('deathDate-before-today', t('deathDateInFuture', 'Death date cannot be in future'), function (value) {
+        const { deathTime, deathTimeFormat } = this.parent;
+        if (value && deathTime && deathTimeFormat && /^(1[0-2]|0?[1-9]):([0-5]?[0-9])$/.test(deathTime)) {
+          return dayjs(getDatetime(value, deathTime, deathTimeFormat)).isBefore(dayjs());
+        }
+        return true;
+      }),
+    deathTime: Yup.string()
+      .when('isDead', {
+        is: true,
+        then: Yup.string().required(t('deathTimeRequired', 'Death time is required')),
+        otherwise: Yup.string().nullable(),
+      })
+      .matches(/^(1[0-2]|0?[1-9]):([0-5]?[0-9])$/, t('deathTimeInvalid', "Time doesn't match the format 'hh:mm'")),
+
+    deathTimeFormat: Yup.string()
+      .when('isDead', {
+        is: true,
+        then: Yup.string().required(t('deathTimeFormatRequired', 'Time format is required')),
+        otherwise: Yup.string().nullable(),
+      })
+      .oneOf(['AM', 'PM'], t('deathTimeFormatInvalid', 'Time format is invalid')),
+
+    deathCause: Yup.string().when('isDead', {
+      is: true,
+      then: Yup.string().required(t('deathCauseRequired', 'Cause of death is required')),
+      otherwise: Yup.string().nullable(),
+    }),
+    nonCodedCauseOfDeath: Yup.string().when(['isDead', 'deathCause'], {
+      is: (isDead, deathCause) => isDead && deathCause === config.freeTextFieldConceptUuid,
+      then: Yup.string().required(t('nonCodedCauseOfDeathRequired', 'Cause of death is required')),
+      otherwise: Yup.string().nullable(),
+    }),
+    email: Yup.string().optional().email(t('invalidEmail', 'Invalid email')),
+    identifiers: Yup.lazy((obj: FormValues['identifiers']) =>
+      Yup.object(
+        mapValues(obj, () =>
+          Yup.object({
+            required: Yup.bool(),
+            identifierValue: Yup.string().when('required', {
+              is: true,
+              then: Yup.string().required(t('identifierValueRequired', 'Identifier value is required')),
+              otherwise: Yup.string().notRequired(),
+            }),
+          }),
+        ),
+      ),
+    ),
+    relationships: Yup.array().of(
+      Yup.object().shape({
+        relatedPersonUuid: Yup.string().required(),
+        relationshipType: Yup.string().required(),
+      }),
+    ),
+  });
+}

package/src/routes.json

@@ -25,12 +25,6 @@
       "online": true,
       "offline": true
     },
-    {
-      "component": "cancelPatientEditModal",
-      "name": "cancel-patient-edit-modal",
-      "online": true,
-      "offline": true
-    },
     {
       "component": "patientPhotoExtension",
       "name": "patient-photo-widget",
@@ -51,27 +45,25 @@
       "slot": "patient-search-actions-slot",
       "online": true,
       "offline": true
+    }
+  ],
+  "modals": [
+    {
+      "name": "cancel-patient-edit-modal",
+      "component": "cancelPatientEditModal"
     },
     {
-      "component": "deleteIdentifierConfirmationModal",
       "name": "delete-identifier-confirmation-modal",
-      "online": true,
-      "offline": true
+      "component": "deleteIdentifierConfirmationModal"
     },
     {
       "component": "emptyClientRegistryModal",
-      "name": "empty-client-registry-modal",
-      "online": true,
-      "offline": true
+      "name": "empty-client-registry-modal"
     },
     {
       "component": "confirmClientRegistryModal",
-      "name": "confirm-client-registry-modal",
-      "online": true,
-      "offline": true
-    }
-  ],
-  "modals": [
+      "name": "confirm-client-registry-modal"
+    },
     {
       "component": "hieConfirmationModal",
       "name": "hie-confirmation-modal"

package/src/widgets/cancel-patient-edit.modal.tsx

@@ -0,0 +1,33 @@
+import React from 'react';
+import { useTranslation } from 'react-i18next';
+import { Button, ModalBody, ModalFooter, ModalHeader } from '@carbon/react';
+
+interface CancelPatientEditPropsModal {
+  close(): void;
+  onConfirm(): void;
+}
+
+const CancelPatientEditModal: React.FC<CancelPatientEditPropsModal> = ({ close, onConfirm }) => {
+  const { t } = useTranslation();
+  return (
+    <>
+      <ModalHeader
+        closeModal={close}
+        title={t('confirmDiscardChangesTitle', 'Are you sure you want to discard these changes?')}
+      />
+      <ModalBody>
+        <p>{t('confirmDiscardChangesBody', 'Your unsaved changes will be lost if you proceed to discard the form')}.</p>
+      </ModalBody>
+      <ModalFooter>
+        <Button kind="secondary" onClick={close}>
+          {t('cancel', 'Cancel')}
+        </Button>
+        <Button kind="danger" onClick={onConfirm}>
+          {t('discard', 'Discard')}
+        </Button>
+      </ModalFooter>
+    </>
+  );
+};
+
+export default CancelPatientEditModal;

package/src/widgets/cancel-patient-edit.test.tsx

@@ -1,15 +1,14 @@
 import React from 'react';
 import userEvent from '@testing-library/user-event';
 import { screen, render } from '@testing-library/react';
-import CancelPatientEdit from './cancel-patient-edit.component';
+import CancelPatientEdit from './cancel-patient-edit.modal';
 
-describe('CancelPatientEdit component', () => {
+describe('CancelPatientEdit modal', () => {
   const mockClose = jest.fn();
   const mockOnConfirm = jest.fn();
 
   it('renders the modal and triggers close and onConfirm functions', async () => {
     const user = userEvent.setup();
-
     render(<CancelPatientEdit close={mockClose} onConfirm={mockOnConfirm} />);
 
     const cancelButton = screen.getByRole('button', { name: /Cancel/i });

package/src/widgets/delete-identifier-confirmation.modal.tsx

@@ -1,15 +1,16 @@
 import React from 'react';
 import { useTranslation } from 'react-i18next';
-import { Button } from '@carbon/react';
-import styles from './delete-identifier-confirmation.scss';
+import { Button, ModalBody, ModalHeader, ModalFooter } from '@carbon/react';
 
 interface DeleteIdentifierConfirmationModalProps {
+  closeModal: () => void;
   deleteIdentifier: (x: boolean) => void;
   identifierName: string;
   identifierValue: string;
 }
 
 const DeleteIdentifierConfirmationModal: React.FC<DeleteIdentifierConfirmationModalProps> = ({
+  closeModal,
   deleteIdentifier,
   identifierName,
   identifierValue,
@@ -17,24 +18,30 @@ const DeleteIdentifierConfirmationModal: React.FC<DeleteIdentifierConfirmationMo
   const { t } = useTranslation();
 
   return (
-    <div className={styles.modalContent}>
-      <h1 className={styles.productiveHeading}>{t('deleteIdentifierModalHeading', 'Remove identifier?')}</h1>
-      <h3 className={styles.modalSubtitle}>
-        {identifierName}
-        {t('deleteIdentifierModalText', ' has a value of ')} {identifierValue}
-      </h3>
-      <p className={styles.modalBody}>
-        {t('confirmIdentifierDeletionText', 'Are you sure you want to remove this identifier?')}
-      </p>
-      <div className={styles.buttonSet}>
+    <>
+      <ModalHeader
+        closeModal={closeModal}
+        title={t('deleteIdentifierModalHeading', 'Delete identifier?')}></ModalHeader>
+      <ModalBody>
+        <p>
+          {identifierName && identifierValue && (
+            <span>
+              <strong>{identifierName}</strong>
+              {t('deleteIdentifierModalText', ' has a value of ')} <strong>{identifierValue}</strong>.{' '}
+            </span>
+          )}
+          {t('confirmIdentifierDeletionText', 'Are you sure you want to delete this identifier?')}
+        </p>
+      </ModalBody>
+      <ModalFooter>
         <Button kind="secondary" size="lg" onClick={() => deleteIdentifier(false)}>
           {t('cancel', 'Cancel')}
         </Button>
         <Button kind="danger" size="lg" onClick={() => deleteIdentifier(true)}>
-          {t('removeIdentifierButton', 'Remove Identifier')}
+          {t('removeIdentifierButton', 'Remove identifier')}
         </Button>
-      </div>
-    </div>
+      </ModalFooter>
+    </>
   );
 };
 

package/src/widgets/delete-identifier-confirmation.test.tsx

@@ -3,7 +3,7 @@ import userEvent from '@testing-library/user-event';
 import { render, screen } from '@testing-library/react';
 import DeleteIdentifierConfirmationModal from './delete-identifier-confirmation.modal';
 
-describe('DeleteIdentifierConfirmationModal component', () => {
+describe('DeleteIdentifierConfirmationModal', () => {
   const mockDeleteIdentifier = jest.fn();
   const mockIdentifierName = 'Identifier Name';
   const mockIdentifierValue = 'Identifier Value';
@@ -13,6 +13,7 @@ describe('DeleteIdentifierConfirmationModal component', () => {
 
     render(
       <DeleteIdentifierConfirmationModal
+        closeModal={jest.fn()}
         deleteIdentifier={mockDeleteIdentifier}
         identifierName={mockIdentifierName}
         identifierValue={mockIdentifierValue}

package/translations/am.json

@@ -4,68 +4,78 @@
   "age": "Age",
   "allFieldsRequiredText": "All fields are required unless marked optional",
   "autoGeneratedPlaceholderText": "Auto-generated",
-  "birthdayNotInTheFuture": "Birthday cannot be in the future",
+  "birthdayNotInTheFuture": "Birthday cannot be in future",
+  "birthdayNotOver140YearsAgo": "Birthday cannot be more than 140 years ago",
   "birthdayRequired": "Birthday is required",
   "birthFieldLabelText": "Birth",
   "cancel": "Cancel",
-  "causeOfDeathInputLabel": "Cause of Death",
-  "clientRegistryEmpty": "Create & Post Patient",
-  "clientVerificationWithClientRegistry": "Client verification with client registry",
+  "causeOfDeathInputLabel": "Cause of death",
   "closeOverlay": "Close overlay",
   "codedPersonAttributeAnswerSetEmpty": "The coded person attribute field '{{codedPersonAttributeFieldId}}' has been defined with an answer concept set UUID '{{answerConceptSetUuid}}' that does not have any concept answers.",
   "codedPersonAttributeAnswerSetInvalid": "The coded person attribute field '{{codedPersonAttributeFieldId}}' has been defined with an invalid answer concept set UUID '{{answerConceptSetUuid}}'.",
   "codedPersonAttributeNoAnswerSet": "The person attribute field '{{codedPersonAttributeFieldId}}' is of type 'coded' but has been defined without an answer concept set UUID. The 'answerConceptSetUuid' key is required.",
   "configure": "Configure",
   "configureIdentifiers": "Configure identifiers",
+  "confirmDiscardChangesBody": "Your unsaved changes will be lost if you proceed to discard the form",
+  "confirmDiscardChangesTitle": "Are you sure you want to discard these changes?",
   "confirmIdentifierDeletionText": "Are you sure you want to remove this identifier?",
   "contactSection": "Contact Details",
   "createNewPatient": "Create new patient",
-  "continue": "Continue to registration",
-  "createNew": "Create New",
-  "dateOfBirth": "Date of birth",
-  "dateOfBirthLabelText": "Date of Birth",
-  "deathDateInputLabel": "Date of Death",
-  "deathdayNotInTheFuture": "Death day cannot be in the future",
+  "dateOfBirthLabelText": "Date of birth",
+  "deathCauseRequired": "Cause of death is required",
+  "deathDateInFuture": "Death date cannot be in future",
+  "deathDateInputLabel": "Date of death",
+  "deathDateRequired": "Death date is required",
+  "deathdayInvalidDate": "Death date and time cannot be before the birthday",
+  "deathdayIsRequired": "Death date is required when the patient is marked as deceased.",
+  "deathdayNotInTheFuture": "",
   "deathSection": "Death Info",
+  "deathTimeFormatInvalid": "Time format is invalid",
+  "deathTimeFormatRequired": "Time format is required",
+  "deathTimeInvalid": "Time doesn't match the format 'hh:mm'",
+  "deathTimeRequired": "Death time is required",
   "deleteIdentifierModalHeading": "Remove identifier?",
   "deleteIdentifierModalText": " has a value of ",
   "deleteIdentifierTooltip": "Delete",
   "deleteRelationshipTooltipText": "Delete",
   "demographicsSection": "Basic Info",
   "discard": "Discard",
-  "discardModalBody": "The changes you made to this patient's details have not been saved. Discard changes?",
-  "discardModalHeader": "Confirm Discard Changes",
   "dobToggleLabelText": "Date of Birth Known?",
   "editIdentifierTooltip": "Edit",
   "editPatientDetails": "Edit patient details",
   "editPatientDetailsBreadcrumb": "Edit patient details",
+  "enterNonCodedCauseOfDeath": "Enter non-coded cause of death",
   "error": "Error",
+  "errorFetchingCodedCausesOfDeath": "Error fetching coded causes of death",
   "errorFetchingOrderedFields": "Error occured fetching ordered fields for address hierarchy",
   "estimatedAgeInMonthsLabelText": "Estimated age in months",
   "estimatedAgeInYearsLabelText": "Estimated age in years",
   "familyNameLabelText": "Family Name",
   "familyNameRequired": "Family name is required",
   "female": "Female",
+  "fieldsWithErrors": "The following fields have errors: ",
   "fullNameLabelText": "Full Name",
   "gender": "Gender",
   "genderLabelText": "Sex",
   "genderRequired": "Gender is required",
-  "genderUnspecified": "Gender is not specified",
+  "genderUnspecified": "Gender unspecified",
   "givenNameLabelText": "First Name",
   "givenNameRequired": "Given name is required",
   "identifierValueRequired": "Identifier value is required",
   "idFieldLabelText": "Identifiers",
   "IDInstructions": "Select the identifiers you'd like to add for this patient:",
-  "incompleteForm": "Incomplete form",
-  "invalidEmail": "A valid email has to be given",
+  "invalidEmail": "Invalid email",
   "invalidInput": "Invalid Input",
-  "isDeadInputLabel": "Is Dead",
+  "isDeadInputLabel": "Is dead",
   "jumpTo": "Jump to",
   "male": "Male",
   "middleNameLabelText": "Middle Name",
-  "negativeMonths": "Negative months",
-  "negativeYears": "Negative years",
+  "negativeMonths": "Estimated months cannot be negative",
+  "negativeYears": "Estimated years cannot be negative",
   "no": "No",
+  "nonCodedCauseOfDeath": "Non-coded cause of death",
+  "nonCodedCauseOfDeathRequired": "Cause of death is required",
+  "nonsensicalYears": "Estimated years cannot be more than 140",
   "numberInNameDubious": "Number in name is dubious",
   "obsFieldUnknownDatatype": "Concept for obs field '{{fieldDefinitionId}}' has unknown datatype '{{datatypeName}}'",
   "optional": "optional",
@@ -78,8 +88,8 @@
   "patientNameKnown": "Patient's Name is Known?",
   "patientNotFound": "The patient records could not be found in Client registry, do you want to continue to create and post patient to registry",
   "patientRegistrationBreadcrumb": "Patient Registration",
-  "postToRegistry": "Post to registry",
-  "registerPatient": "Register Patient",
+  "refreshOrContactAdmin": "Try refreshing the page or contact your system administrator",
+  "registerPatient": "Register patient",
   "registerPatientSuccessSnackbarSubtitle": "The patient can now be found by searching for them using their name or ID number",
   "registerPatientSuccessSnackbarTitle": "New Patient Created",
   "registrationErrorSnackbarTitle": "Patient Registration Failed",
@@ -89,9 +99,9 @@
   "relationshipRemovedText": "Relationship removed",
   "relationshipsSection": "Relationships",
   "relationshipToPatient": "Relationship to patient",
-  "relativeFullNameLabelText": "Related person",
+  "relativeFullNameLabelText": "Full name",
   "relativeNamePlaceholder": "Firstname Familyname",
-  "removeIdentifierButton": "Remove Identifier",
+  "removeIdentifierButton": "Remove identifier",
   "resetIdentifierTooltip": "Reset",
   "restoreRelationshipActionButton": "Undo",
   "searchAddress": "Search address",
@@ -101,15 +111,16 @@
   "selectIdentifierType": "Select identifier type",
   "sexFieldLabelText": "Sex",
   "source": "Source",
-  "stroke": "Stroke",
   "submitting": "Submitting",
+  "timeFormat": "Time Format",
+  "timeOfDeathInputLabel": "Time of death (hh:mm)",
   "unableToFetch": "Unable to fetch person attribute type - {{personattributetype}}",
   "unknown": "Unknown",
   "unknownPatientAttributeType": "Patient attribute type has unknown format {{personAttributeTypeFormat}}",
-  "updatePatient": "Update Patient",
+  "updatePatient": "Update patient",
   "updatePatientErrorSnackbarTitle": "Patient Details Update Failed",
   "updatePatientSuccessSnackbarSubtitle": "The patient's information has been successfully updated",
   "updatePatientSuccessSnackbarTitle": "Patient Details Updated",
-  "yearsEstimateRequired": "Years estimate required",
+  "yearsEstimateRequired": "Estimated years required",
   "yes": "Yes"
 }