@kenyaemr/esm-patient-registration-app 5.2.2 → 6.0.0

package/src/patient-registration/patient-registration.test.tsx

@@ -1,16 +1,16 @@
 import React from 'react';
 import { BrowserRouter as Router, useParams } from 'react-router-dom';
-import { render, screen, waitFor, within } from '@testing-library/react';
+import { render, screen, within } from '@testing-library/react';
 import userEvent from '@testing-library/user-event';
 import { showSnackbar, useConfig, usePatient } from '@openmrs/esm-framework';
+import type { AddressTemplate, Encounter } from './patient-registration.types';
+import { type RegistrationConfig } from '../config-schema';
 import { FormManager } from './form-manager';
-import { saveEncounter, savePatient } from './patient-registration.resource';
-import type { Encounter } from './patient-registration.types';
-import { Resources, ResourcesContext } from '../offline.resources';
+import { ResourcesContext } from '../offline.resources';
 import { PatientRegistration } from './patient-registration.component';
-import { RegistrationConfig } from '../config-schema';
-import { mockedAddressTemplate } from './field/address/tests/mocks';
-import { mockPatient } from '../../../../tools/test-helpers';
+import { saveEncounter, savePatient } from './patient-registration.resource';
+import { mockedAddressTemplate } from '__mocks__';
+import { mockPatient } from 'tools';
 
 const mockedUseConfig = useConfig as jest.Mock;
 const mockedUsePatient = usePatient as jest.Mock;
@@ -18,7 +18,62 @@ const mockedSaveEncounter = saveEncounter as jest.Mock;
 const mockedSavePatient = savePatient as jest.Mock;
 const mockedShowSnackbar = showSnackbar as jest.Mock;
 
-jest.setTimeout(10000);
+jest.mock('./field/field.resource', () => ({
+  useConcept: jest.fn().mockImplementation((uuid: string) => {
+    let data;
+    if (uuid == 'weight-uuid') {
+      data = {
+        uuid: 'weight-uuid',
+        display: 'Weight (kg)',
+        datatype: { display: 'Numeric', uuid: 'num' },
+        answers: [],
+        setMembers: [],
+      };
+    } else if (uuid == 'chief-complaint-uuid') {
+      data = {
+        uuid: 'chief-complaint-uuid',
+        display: 'Chief Complaint',
+        datatype: { display: 'Text', uuid: 'txt' },
+        answers: [],
+        setMembers: [],
+      };
+    } else if (uuid == 'nationality-uuid') {
+      data = {
+        uuid: 'nationality-uuid',
+        display: 'Nationality',
+        datatype: { display: 'Coded', uuid: 'cdd' },
+        answers: [
+          { display: 'USA', uuid: 'usa' },
+          { display: 'Mexico', uuid: 'mex' },
+        ],
+        setMembers: [],
+      };
+    }
+    return {
+      data: data ?? null,
+      isLoading: !data,
+    };
+  }),
+  useConceptAnswers: jest.fn().mockImplementation((uuid: string) => {
+    if (uuid == 'nationality-uuid') {
+      return {
+        data: [
+          { display: 'USA', uuid: 'usa' },
+          { display: 'Mexico', uuid: 'mex' },
+        ],
+        isLoading: false,
+      };
+    } else if (uuid == 'other-countries-uuid') {
+      return {
+        data: [
+          { display: 'Kenya', uuid: 'ke' },
+          { display: 'Uganda', uuid: 'ug' },
+        ],
+        isLoading: false,
+      };
+    }
+  }),
+}));
 
 jest.mock('@openmrs/esm-framework', () => {
   const originalModule = jest.requireActual('@openmrs/esm-framework');
@@ -29,9 +84,6 @@ jest.mock('@openmrs/esm-framework', () => {
   };
 });
 
-// Mock field.resource using the manual mock (in __mocks__)
-jest.mock('./field/field.resource');
-
 jest.mock('react-router-dom', () => ({
   ...(jest.requireActual('react-router-dom') as any),
   useLocation: () => ({
@@ -62,7 +114,7 @@ jest.mock('@openmrs/esm-framework', () => {
 });
 
 const mockResourcesContextValue = {
-  addressTemplate: mockedAddressTemplate,
+  addressTemplate: mockedAddressTemplate as AddressTemplate,
   currentSession: {
     authenticated: true,
     sessionId: 'JSESSION',
@@ -70,7 +122,7 @@ const mockResourcesContextValue = {
   },
   relationshipTypes: [],
   identifierTypes: [],
-} as Resources;
+};
 
 let mockOpenmrsConfig: RegistrationConfig = {
   sections: ['demographics', 'contact'],
@@ -99,9 +151,8 @@ let mockOpenmrsConfig: RegistrationConfig = {
     },
     gender: [
       {
-        value: 'Male',
+        value: 'male',
         label: 'Male',
-        id: 'male',
       },
     ],
     address: {
@@ -138,6 +189,7 @@ configWithObs.fieldDefinitions = [
     placeholder: '',
     validation: { required: false, matches: null },
     answerConceptSetUuid: null,
+    customConceptAnswers: [],
   },
   {
     id: 'chief complaint',
@@ -147,6 +199,7 @@ configWithObs.fieldDefinitions = [
     placeholder: '',
     validation: { required: false, matches: null },
     answerConceptSetUuid: null,
+    customConceptAnswers: [],
   },
   {
     id: 'nationality',
@@ -156,8 +209,10 @@ configWithObs.fieldDefinitions = [
     placeholder: '',
     validation: { required: false, matches: null },
     answerConceptSetUuid: null,
+    customConceptAnswers: [],
   },
 ];
+
 configWithObs.sectionDefinitions?.push({
   id: 'custom',
   name: 'Custom',
@@ -182,271 +237,235 @@ const fillRequiredFields = async () => {
   user.click(genderInput);
 };
 
-describe('patient registration component', () => {
-  describe('when registering a new patient', () => {
-    beforeEach(() => {
-      mockedUseConfig.mockReturnValue(mockOpenmrsConfig);
-      mockedSavePatient.mockReturnValue({ data: { uuid: 'new-pt-uuid' }, ok: true });
-      mockedSaveEncounter.mockClear();
-      mockedShowSnackbar.mockClear();
-      jest.clearAllMocks();
-    });
+function Wrapper({ children }) {
+  return (
+    <ResourcesContext.Provider value={mockResourcesContextValue}>
+      <Router>{children}</Router>
+    </ResourcesContext.Provider>
+  );
+}
+
+describe('Registering a new patient', () => {
+  beforeEach(() => {
+    mockedUseConfig.mockReturnValue(mockOpenmrsConfig);
+    mockedSavePatient.mockReturnValue({ data: { uuid: 'new-pt-uuid' }, ok: true });
+    mockedSaveEncounter.mockClear();
+    mockedShowSnackbar.mockClear();
+    jest.clearAllMocks();
+  });
 
-    it('renders without crashing', () => {
-      render(
-        <ResourcesContext.Provider value={mockResourcesContextValue}>
-          <Router>
-            <PatientRegistration isOffline={false} savePatientForm={jest.fn()} />
-          </Router>
-          ,
-        </ResourcesContext.Provider>,
-      );
-    });
+  it('renders without crashing', () => {
+    render(<PatientRegistration isOffline={false} savePatientForm={jest.fn()} />, { wrapper: Wrapper });
+  });
 
-    it('has the expected sections', async () => {
-      render(
-        <ResourcesContext.Provider value={mockResourcesContextValue}>
-          <Router>
-            <PatientRegistration isOffline={false} savePatientForm={jest.fn()} />
-          </Router>
-        </ResourcesContext.Provider>,
-      );
-      await waitFor(() => expect(screen.getByLabelText(/Demographics Section/)).not.toBeNull());
-      expect(screen.getByLabelText(/Contact Info Section/)).not.toBeNull();
-    });
+  it('has the expected sections', async () => {
+    render(<PatientRegistration isOffline={false} savePatientForm={jest.fn()} />, { wrapper: Wrapper });
 
-    it('saves the patient without extra info', async () => {
-      const user = userEvent.setup();
-
-      render(
-        <ResourcesContext.Provider value={mockResourcesContextValue}>
-          <Router>
-            <PatientRegistration isOffline={false} savePatientForm={FormManager.savePatientFormOnline} />
-          </Router>
-        </ResourcesContext.Provider>,
-      );
-
-      await fillRequiredFields();
-      await user.click(await screen.findByText('Register Patient'));
-      await waitFor(() => {
-        expect(mockedSavePatient).toHaveBeenCalledWith(
-          expect.objectContaining({
-            identifiers: [], //TODO when the identifer story is finished: { identifier: '', identifierType: '05a29f94-c0ed-11e2-94be-8c13b969e334', location: '' },
-            person: {
-              addresses: expect.arrayContaining([expect.any(Object)]),
-              attributes: [],
-              birthdate: '1993-8-2',
-              birthdateEstimated: false,
-              gender: 'M',
-              names: [{ givenName: 'Paul', middleName: '', familyName: 'Gaihre', preferred: true, uuid: undefined }],
-              dead: false,
-              uuid: expect.anything(),
-            },
-            uuid: expect.anything(),
-          }),
-          undefined,
-        );
-      });
+    expect(screen.getByLabelText(/Demographics Section/)).not.toBeNull();
+    expect(screen.getByLabelText(/Contact Info Section/)).not.toBeNull();
+  });
+
+  it('saves the patient without extra info', async () => {
+    const user = userEvent.setup();
+
+    render(<PatientRegistration isOffline={false} savePatientForm={FormManager.savePatientFormOnline} />, {
+      wrapper: Wrapper,
     });
 
-    it('should not save the patient if validation fails', async () => {
-      const user = userEvent.setup();
+    await fillRequiredFields();
+    await user.click(await screen.findByText('Register Patient'));
+    expect(mockedSavePatient).toHaveBeenCalledWith(
+      expect.objectContaining({
+        identifiers: [], //TODO when the identifer story is finished: { identifier: '', identifierType: '05a29f94-c0ed-11e2-94be-8c13b969e334', location: '' },
+        person: {
+          addresses: expect.arrayContaining([expect.any(Object)]),
+          attributes: [],
+          birthdate: '1993-8-2',
+          birthdateEstimated: false,
+          gender: expect.stringMatching(/^M$/),
+          names: [{ givenName: 'Paul', middleName: '', familyName: 'Gaihre', preferred: true, uuid: undefined }],
+          dead: false,
+          uuid: expect.anything(),
+        },
+        uuid: expect.anything(),
+      }),
+      undefined,
+    );
+  });
 
-      const mockedSavePatientForm = jest.fn();
-      render(
-        <ResourcesContext.Provider value={mockResourcesContextValue}>
-          <Router>
-            <PatientRegistration isOffline={false} savePatientForm={mockedSavePatientForm} />
-          </Router>
-        </ResourcesContext.Provider>,
-      );
+  it('should not save the patient if validation fails', async () => {
+    const user = userEvent.setup();
 
-      const givenNameInput = (await screen.findByLabelText('First Name')) as HTMLInputElement;
+    const mockedSavePatientForm = jest.fn();
+    render(<PatientRegistration isOffline={false} savePatientForm={mockedSavePatientForm} />, { wrapper: Wrapper });
 
-      await user.type(givenNameInput, '5');
-      await user.click(screen.getByText('Register Patient'));
+    const givenNameInput = (await screen.findByLabelText('First Name')) as HTMLInputElement;
 
-      expect(mockedSavePatientForm).not.toHaveBeenCalled();
-    });
+    await user.type(givenNameInput, '5');
+    await user.click(screen.getByText('Register Patient'));
 
-    it('renders and saves registration obs', async () => {
-      const user = userEvent.setup();
+    expect(mockedSavePatientForm).not.toHaveBeenCalled();
+  });
 
-      mockedSaveEncounter.mockResolvedValue({});
-      mockedUseConfig.mockReturnValue(configWithObs);
-
-      render(
-        <ResourcesContext.Provider value={mockResourcesContextValue}>
-          <Router>
-            <PatientRegistration isOffline={false} savePatientForm={FormManager.savePatientFormOnline} />
-          </Router>
-        </ResourcesContext.Provider>,
-      );
-
-      await fillRequiredFields();
-      const customSection = screen.getByLabelText('Custom Section');
-      const weight = within(customSection).getByLabelText('Weight (kg) (optional)');
-      await user.type(weight, '50');
-      const complaint = within(customSection).getByLabelText('Chief Complaint (optional)');
-      await user.type(complaint, 'sad');
-      const nationality = within(customSection).getByLabelText('Nationality');
-      await user.selectOptions(nationality, 'USA');
-
-      await user.click(screen.getByText('Register Patient'));
-
-      await waitFor(() => expect(mockedSavePatient).toHaveBeenCalled());
-      await waitFor(() =>
-        expect(mockedSaveEncounter).toHaveBeenCalledWith(
-          expect.objectContaining<Partial<Encounter>>({
-            encounterType: 'reg-enc-uuid',
-            patient: 'new-pt-uuid',
-            obs: [
-              { concept: 'weight-uuid', value: 50 },
-              { concept: 'chief-complaint-uuid', value: 'sad' },
-              { concept: 'nationality-uuid', value: 'usa' },
-            ],
-          }),
-        ),
-      );
+  it('renders and saves registration obs', async () => {
+    const user = userEvent.setup();
+
+    mockedSaveEncounter.mockResolvedValue({});
+    mockedUseConfig.mockReturnValue(configWithObs);
+
+    render(<PatientRegistration isOffline={false} savePatientForm={FormManager.savePatientFormOnline} />, {
+      wrapper: Wrapper,
     });
 
-    it('retries saving registration obs after a failed attempt', async () => {
-      const user = userEvent.setup();
+    await fillRequiredFields();
+    const customSection = screen.getByLabelText('Custom Section');
+    const weight = within(customSection).getByLabelText('Weight (kg) (optional)');
+    await user.type(weight, '50');
+    const complaint = within(customSection).getByLabelText('Chief Complaint (optional)');
+    await user.type(complaint, 'sad');
+    const nationality = within(customSection).getByLabelText('Nationality');
+    await user.selectOptions(nationality, 'USA');
+
+    await user.click(screen.getByText('Register Patient'));
+
+    expect(mockedSavePatient).toHaveBeenCalled();
+
+    expect(mockedSaveEncounter).toHaveBeenCalledWith(
+      expect.objectContaining<Partial<Encounter>>({
+        encounterType: 'reg-enc-uuid',
+        patient: 'new-pt-uuid',
+        obs: [
+          { concept: 'weight-uuid', value: 50 },
+          { concept: 'chief-complaint-uuid', value: 'sad' },
+          { concept: 'nationality-uuid', value: 'usa' },
+        ],
+      }),
+    );
+  });
+
+  it('retries saving registration obs after a failed attempt', async () => {
+    const user = userEvent.setup();
 
-      mockedUseConfig.mockReturnValue(configWithObs);
+    mockedUseConfig.mockReturnValue(configWithObs);
+
+    render(<PatientRegistration isOffline={false} savePatientForm={FormManager.savePatientFormOnline} />, {
+      wrapper: Wrapper,
+    });
 
-      render(
-        <ResourcesContext.Provider value={mockResourcesContextValue}>
-          <Router>
-            <PatientRegistration isOffline={false} savePatientForm={FormManager.savePatientFormOnline} />
-          </Router>
-        </ResourcesContext.Provider>,
-      );
+    await fillRequiredFields();
+    const customSection = screen.getByLabelText('Custom Section');
+    const weight = within(customSection).getByLabelText('Weight (kg) (optional)');
+    await user.type(weight, '-999');
 
-      await fillRequiredFields();
-      const customSection = screen.getByLabelText('Custom Section');
-      const weight = within(customSection).getByLabelText('Weight (kg) (optional)');
-      await user.type(weight, '-999');
+    mockedSaveEncounter.mockRejectedValue({ status: 400, responseBody: { error: { message: 'an error message' } } });
 
-      mockedSaveEncounter.mockRejectedValue({ status: 400, responseBody: { error: { message: 'an error message' } } });
+    const registerPatientButton = screen.getByText('Register Patient');
 
-      await user.click(screen.getByText('Register Patient'));
+    await user.click(registerPatientButton);
 
-      await waitFor(() => expect(mockedSavePatient).toHaveBeenCalledTimes(1));
-      await waitFor(() => expect(mockedSaveEncounter).toHaveBeenCalledTimes(1));
-      await waitFor(() =>
-        expect(mockedShowSnackbar).toHaveBeenCalledWith(expect.objectContaining({ subtitle: 'an error message' })),
-      );
+    expect(mockedSavePatient).toHaveBeenCalledTimes(1);
+    expect(mockedSaveEncounter).toHaveBeenCalledTimes(1);
 
+    expect(mockedShowSnackbar).toHaveBeenCalledWith(expect.objectContaining({ subtitle: 'an error message' })),
       mockedSaveEncounter.mockResolvedValue({});
 
-      await waitFor(() => user.click(screen.getByText('Register Patient')));
-      await waitFor(() => expect(mockedSavePatient).toHaveBeenCalledTimes(2));
-      await waitFor(() => expect(mockedSaveEncounter).toHaveBeenCalledTimes(2));
-      await waitFor(() =>
-        expect(mockedShowSnackbar).toHaveBeenCalledWith(expect.objectContaining({ kind: 'success' })),
-      );
-    });
+    await user.click(registerPatientButton);
+    expect(mockedSavePatient).toHaveBeenCalledTimes(2);
+    expect(mockedSaveEncounter).toHaveBeenCalledTimes(2);
+
+    expect(mockedShowSnackbar).toHaveBeenCalledWith(expect.objectContaining({ kind: 'success' }));
   });
+});
 
-  describe('when updating an existing patient details', () => {
-    beforeEach(() => {
-      mockedUseConfig.mockReturnValue(mockOpenmrsConfig);
-      mockedSavePatient.mockReturnValue({ data: { uuid: 'new-pt-uuid' }, ok: true });
-      mockedSaveEncounter.mockClear();
-      mockedShowSnackbar.mockClear();
-      jest.clearAllMocks();
-    });
+describe('Updating an existing patient record', () => {
+  beforeEach(() => {
+    mockedUseConfig.mockReturnValue(mockOpenmrsConfig);
+    mockedSavePatient.mockReturnValue({ data: { uuid: 'new-pt-uuid' }, ok: true });
+    mockedSaveEncounter.mockClear();
+    mockedShowSnackbar.mockClear();
+    jest.clearAllMocks();
+  });
 
-    it('edits patient demographics', async () => {
-      const user = userEvent.setup();
+  it('edits patient demographics', async () => {
+    const user = userEvent.setup();
 
-      mockedSavePatient.mockResolvedValue({});
+    mockedSavePatient.mockResolvedValue({});
 
-      const mockedUseParams = useParams as jest.Mock;
+    const mockedUseParams = useParams as jest.Mock;
 
-      mockedUseParams.mockReturnValue({ patientUuid: mockPatient.id });
+    mockedUseParams.mockReturnValue({ patientUuid: mockPatient.id });
 
-      mockedUsePatient.mockReturnValue({
-        isLoading: false,
-        patient: mockPatient,
-        patientUuid: mockPatient.id,
-        error: null,
-      });
-
-      render(
-        <ResourcesContext.Provider value={mockResourcesContextValue}>
-          <Router>
-            <PatientRegistration isOffline={false} savePatientForm={mockedSavePatient} />
-          </Router>
-        </ResourcesContext.Provider>,
-      );
-
-      const givenNameInput: HTMLInputElement = screen.getByLabelText(/First Name/);
-      const familyNameInput: HTMLInputElement = screen.getByLabelText(/Family Name/);
-      const middleNameInput: HTMLInputElement = screen.getByLabelText(/Middle Name/);
-      const dateOfBirthInput: HTMLInputElement = screen.getByLabelText('Date of Birth');
-      const genderInput: HTMLInputElement = screen.getByLabelText(/Male/);
-
-      // assert initial values
-      expect(givenNameInput.value).toBe('John');
-      expect(familyNameInput.value).toBe('Wilson');
-      expect(middleNameInput.value).toBeFalsy();
-      expect(dateOfBirthInput.value).toBe('4/4/1972');
-      expect(genderInput.value).toBe('Male');
-
-      // do some edits
-      await user.clear(givenNameInput);
-      await user.clear(middleNameInput);
-      await user.clear(familyNameInput);
-      await user.type(givenNameInput, 'Eric');
-      await user.type(middleNameInput, 'Johnson');
-      await user.type(familyNameInput, 'Smith');
-      await user.click(screen.getByText('Update Patient'));
-
-      await waitFor(() =>
-        expect(mockedSavePatient).toHaveBeenCalledWith(
-          false,
-          {
-            '0': {
-              oldIdentificationNumber: '100732HE',
-            },
-            '1': {
-              openMrsId: '100GEJ',
-            },
-            addNameInLocalLanguage: undefined,
-            additionalFamilyName: '',
-            additionalGivenName: '',
-            additionalMiddleName: '',
-            address: {},
-            birthdate: new Date('1972-04-04T00:00:00.000Z'),
-            birthdateEstimated: false,
-            deathCause: '',
-            deathDate: '',
-            familyName: 'Smith',
-            gender: 'Male',
-            givenName: 'Eric',
-            identifiers: {},
-            isDead: false,
-            middleName: 'Johnson',
-            monthsEstimated: 0,
-            patientUuid: '8673ee4f-e2ab-4077-ba55-4980f408773e',
-            relationships: [],
-            telephoneNumber: '',
-            unidentifiedPatient: undefined,
-            yearsEstimated: 0,
-          },
-          expect.anything(),
-          expect.anything(),
-          null,
-          undefined,
-          expect.anything(),
-          expect.anything(),
-          expect.anything(),
-          { patientSaved: false },
-          expect.anything(),
-        ),
-      );
+    mockedUsePatient.mockReturnValue({
+      isLoading: false,
+      patient: mockPatient,
+      patientUuid: mockPatient.id,
+      error: null,
     });
+
+    render(<PatientRegistration isOffline={false} savePatientForm={mockedSavePatient} />, { wrapper: Wrapper });
+
+    const givenNameInput: HTMLInputElement = screen.getByLabelText(/First Name/);
+    const familyNameInput: HTMLInputElement = screen.getByLabelText(/Family Name/);
+    const middleNameInput: HTMLInputElement = screen.getByLabelText(/Middle Name/);
+    const dateOfBirthInput: HTMLInputElement = screen.getByLabelText('Date of Birth');
+    const genderInput: HTMLInputElement = screen.getByLabelText(/Male/);
+
+    // assert initial values
+    expect(givenNameInput.value).toBe('John');
+    expect(familyNameInput.value).toBe('Wilson');
+    expect(middleNameInput.value).toBeFalsy();
+    expect(dateOfBirthInput.value).toBe('4/4/1972');
+    expect(genderInput.value).toBe('male');
+
+    // do some edits
+    await user.clear(givenNameInput);
+    await user.clear(middleNameInput);
+    await user.clear(familyNameInput);
+    await user.type(givenNameInput, 'Eric');
+    await user.type(middleNameInput, 'Johnson');
+    await user.type(familyNameInput, 'Smith');
+    await user.click(screen.getByText('Update Patient'));
+
+    expect(mockedSavePatient).toHaveBeenCalledWith(
+      false,
+      {
+        '0': {
+          oldIdentificationNumber: '100732HE',
+        },
+        '1': {
+          openMrsId: '100GEJ',
+        },
+        addNameInLocalLanguage: undefined,
+        additionalFamilyName: '',
+        additionalGivenName: '',
+        additionalMiddleName: '',
+        address: {},
+        birthdate: new Date('1972-04-04T00:00:00.000Z'),
+        birthdateEstimated: false,
+        deathCause: '',
+        deathDate: '',
+        familyName: 'Smith',
+        gender: expect.stringMatching(/male/i),
+        givenName: 'Eric',
+        identifiers: {},
+        isDead: false,
+        middleName: 'Johnson',
+        monthsEstimated: 0,
+        patientUuid: '8673ee4f-e2ab-4077-ba55-4980f408773e',
+        relationships: [],
+        telephoneNumber: '',
+        unidentifiedPatient: undefined,
+        yearsEstimated: 0,
+      },
+      expect.anything(),
+      expect.anything(),
+      null,
+      undefined,
+      expect.anything(),
+      expect.anything(),
+      expect.anything(),
+      { patientSaved: false },
+      expect.anything(),
+    );
   });
 });

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

@@ -1,6 +1,6 @@
-import { OpenmrsResource, Session } from '@openmrs/esm-framework';
-import { RegistrationConfig } from '../config-schema';
-import { SavePatientTransactionManager } from './form-manager';
+import { type OpenmrsResource, type Session } from '@openmrs/esm-framework';
+import { type RegistrationConfig } from '../config-schema';
+import { type SavePatientTransactionManager } from './form-manager';
 
 interface NameValue {
   uuid: string;
@@ -310,6 +310,15 @@ export interface AddressTemplate {
   elementRegexFormats: ExtensibleAddressProperties;
   requiredElements: Array<AddressProperties> | null;
 }
+
+// https://rest.openmrs.org/#address-template
+export interface RestAddressTemplate {
+  uuid: string;
+  description: string;
+  property: string;
+  display: string;
+  value: string;
+}
 export interface ObsResponse {
   results: Array<{ obs: Array<{ uuid: string; display: string; value: OpenmrsResource; concept: OpenmrsResource }> }>;
 }