@kenyaemr/esm-pcs-app 5.4.5-pre.1092

package/src/resources/patient-create.resource.ts

@@ -0,0 +1,296 @@
+import { getSessionLocation, openmrsFetch, restBaseUrl } from '@openmrs/esm-framework';
+import { differenceInYears, parseISO } from 'date-fns';
+import { generateIdentifier, openmrsId, openmrsIdSource, sanitizeName } from './identifiers';
+import { type IdentifierTypeUuids, type PcsDependantDemographics, type PcsHieDependant } from '../types';
+
+interface PatientIdentifier {
+  identifier: string;
+  identifierType: string;
+  location: string;
+  preferred: boolean;
+}
+
+/**
+ * True when the dependant is under 18, or their birth date is unknown or unparseable.
+ *
+ * Load-bearing: minors in the HIE registry are identified by their SHA number, not a national ID.
+ * A national ID present on a minor's record belongs to the household head (parent), so attaching
+ * it to the child would write the parent's identity onto the child's record.
+ */
+const isMinorDependent = (birthDate?: string): boolean => {
+  if (!birthDate || birthDate === 'Unknown') {
+    return true;
+  }
+
+  try {
+    return differenceInYears(new Date(), parseISO(birthDate)) < 18;
+  } catch (error) {
+    return true;
+  }
+};
+
+/**
+ * The identifiers to register a dependant with, taken straight from the flattened HIE contact.
+ *
+ * Express-workflow reaches the same result by building FHIR `identifiers` extensions and then
+ * reading them back out to resolve each code to a type uuid; nothing between those two steps is
+ * observable, so this maps the fields directly.
+ */
+export function buildDependantIdentifiers(
+  dependant: PcsHieDependant,
+  uuids: IdentifierTypeUuids,
+  location: string,
+): Array<PatientIdentifier> {
+  const identifiers: Array<PatientIdentifier> = [];
+  const add = (identifier: string | undefined, identifierType: string | undefined) => {
+    if (identifier && identifierType) {
+      identifiers.push({ identifier, identifierType, location, preferred: false });
+    }
+  };
+
+  // `household-number` is deliberately absent: it holds the parent's own CR number.
+  if (!isMinorDependent(dependant.birthDate)) {
+    add(dependant.nationalId, uuids.nationalIdUUID);
+  }
+  add(dependant.birthCertificate, uuids.birthCertificateUUID);
+  add(dependant.shaNumber, uuids.shaNumberUUID);
+  add(dependant.shaIdNumber, uuids.crIdentificationNumberUUID);
+
+  // The contact's own id IS the dependant's CR number when sha-id-number was not among the
+  // extensions, so it stands in rather than being lost.
+  if (!dependant.shaIdNumber && String(dependant.id ?? '').startsWith('CR')) {
+    add(dependant.id, uuids.crIdentificationNumberUUID);
+  }
+
+  return identifiers;
+}
+
+/** Given/middle/family, preferring the HIE contact's own parts over splitting the display name. */
+function splitDependantName(dependant: PcsHieDependant) {
+  const parts = (dependant.name ?? '').trim().split(' ').filter(Boolean);
+  const given: Array<string> = dependant.contactData?.name?.given ?? parts.slice(0, -1);
+  const family = dependant.contactData?.name?.family || (parts.length > 1 ? parts[parts.length - 1] : '');
+
+  return {
+    givenName: given[0] || parts[0] || '',
+    middleName: given.slice(1).join(' '),
+    familyName: family,
+  };
+}
+
+interface CreatePatientBody {
+  person: {
+    names: Array<{ preferred: boolean; givenName: string; middleName: string; familyName: string }>;
+    gender: string;
+    birthdate: string | null;
+    birthdateEstimated: boolean;
+    attributes: Array<{ attributeType: string; value: string }>;
+    addresses: Array<Record<string, string>>;
+  };
+  identifiers: Array<PatientIdentifier>;
+}
+
+const EMPTY_ADDRESS = { address1: '', cityVillage: '', country: '', postalCode: '', stateProvince: '' };
+
+/** Posts the registration and returns the created patient. */
+async function postPatient(body: CreatePatientBody) {
+  const { data } = await openmrsFetch<{ uuid: string }>(`${restBaseUrl}/patient`, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body,
+  });
+
+  return data;
+}
+
+/**
+ * The OpenMRS ID is minted for every patient and is always the preferred identifier; the HIE
+ * identifiers ride alongside it, and are what let a later search find this record again.
+ */
+async function withOpenmrsId(identifiers: Array<PatientIdentifier>, location: string) {
+  const generated = await generateIdentifier(openmrsIdSource);
+
+  if (!generated?.data?.identifier) {
+    throw new Error('Failed to generate OpenMRS identifier');
+  }
+
+  return [
+    ...identifiers,
+    { identifier: generated.data.identifier, identifierType: openmrsId, location, preferred: true },
+  ];
+}
+
+async function requireSessionLocation() {
+  const location = await getSessionLocation();
+
+  if (!location?.uuid) {
+    throw new Error('Could not determine session location');
+  }
+
+  return location.uuid;
+}
+
+/** Registers a dependant the HIE lists under their parent but who has no record here yet. */
+export async function createDependantPatient(
+  dependant: PcsHieDependant,
+  uuids: IdentifierTypeUuids,
+  parentPhoneNumber?: string,
+) {
+  const location = await requireSessionLocation();
+  const { givenName, middleName, familyName } = splitDependantName(dependant);
+  // `getDependentsFromContacts` reports a missing date as 'Unknown', which must not reach the
+  // payload as a birthdate — it is what makes `birthdateEstimated` true.
+  const birthdate = dependant.birthDate && dependant.birthDate !== 'Unknown' ? dependant.birthDate : null;
+
+  return postPatient({
+    person: {
+      names: [
+        {
+          preferred: true,
+          givenName: sanitizeName(givenName) || 'Unknown',
+          middleName: sanitizeName(middleName) || '',
+          familyName: sanitizeName(familyName) || 'Unknown',
+        },
+      ],
+      gender: dependant.gender?.charAt(0).toUpperCase() || 'U',
+      birthdate,
+      birthdateEstimated: !birthdate,
+      // The parent's number, not the dependant's — a child rarely has one of their own.
+      attributes: parentPhoneNumber ? [{ attributeType: uuids.phoneAttributeTypeUUID, value: parentPhoneNumber }] : [],
+      addresses: [{ ...EMPTY_ADDRESS, country: 'Kenya' }],
+    },
+    identifiers: await withOpenmrsId(buildDependantIdentifiers(dependant, uuids, location), location),
+  });
+}
+
+/**
+ * Registers a patient from plain demographics — a PCS participant's own details, or the
+ * add-dependant form's. There is no HIE contact behind these, so only what was given is written.
+ */
+export async function createPatientFromDemographics(
+  demographics: PcsDependantDemographics,
+  nationalIdUUID: string,
+  phoneAttributeTypeUUID: string,
+) {
+  const location = await requireSessionLocation();
+  const identifiers: Array<PatientIdentifier> = [];
+
+  // Carrying the national ID forward is what lets `findExistingLocalPatient` match this patient
+  // later — and makes OpenMRS reject the create if they are already registered, rather than
+  // silently producing a duplicate.
+  if (demographics.nationalId) {
+    identifiers.push({
+      identifier: demographics.nationalId,
+      identifierType: nationalIdUUID,
+      location,
+      preferred: false,
+    });
+  }
+
+  return postPatient({
+    person: {
+      names: [
+        {
+          preferred: true,
+          givenName: sanitizeName(demographics.firstName) || 'Unknown',
+          middleName: sanitizeName(demographics.middleName ?? '') || '',
+          familyName: sanitizeName(demographics.lastName) || 'Unknown',
+        },
+      ],
+      gender: demographics.sex,
+      birthdate: demographics.dateOfBirth ?? null,
+      birthdateEstimated: !demographics.dateOfBirth,
+      attributes: demographics.phone ? [{ attributeType: phoneAttributeTypeUUID, value: demographics.phone }] : [],
+      addresses: [EMPTY_ADDRESS],
+    },
+    identifiers: await withOpenmrsId(identifiers, location),
+  });
+}
+
+/** The HIE identifier codes, mapped onto the identifier types they are stored as here. */
+function resolveIdentifierType(code: string | undefined, uuids: IdentifierTypeUuids): string | undefined {
+  const map: Record<string, string> = {
+    'sha-number': uuids.shaNumberUUID,
+    'national-id': uuids.nationalIdUUID,
+    'passport-number': uuids.passportUUID,
+    'birth-certificate': uuids.birthCertificateUUID,
+    'sha-id-number': uuids.crIdentificationNumberUUID,
+  };
+
+  return code ? map[code] : undefined;
+}
+
+/** Given/middle/family from a FHIR name, falling back to splitting its display text. */
+function splitHumanName(name?: fhir.HumanName) {
+  const given = name?.given ?? [];
+
+  if (given.length > 0 || name?.family) {
+    return {
+      givenName: given[0] ?? '',
+      middleName: given.slice(1).join(' '),
+      familyName: name?.family ?? '',
+    };
+  }
+
+  const parts = (name?.text ?? '').trim().split(' ').filter(Boolean);
+
+  return {
+    givenName: parts[0] ?? '',
+    middleName: parts.slice(1, -1).join(' '),
+    familyName: parts.length > 1 ? parts[parts.length - 1] : '',
+  };
+}
+
+/**
+ * Registers a patient from their HIE record — the path taken when the authorized patient is being
+ * linked to a participant but has never been seen at this facility.
+ */
+export async function createPatientFromHiePatient(hiePatient: any, uuids: IdentifierTypeUuids) {
+  const location = await requireSessionLocation();
+
+  const identifiers: Array<PatientIdentifier> = (hiePatient?.identifier ?? [])
+    .map((id: any) => ({
+      identifier: id.value,
+      identifierType: resolveIdentifierType(id.type?.coding?.[0]?.code, uuids),
+      location,
+      preferred: false,
+    }))
+    .filter((id: PatientIdentifier) => id.identifier && id.identifierType);
+
+  // The HIE resource id is the patient's CR number.
+  if (hiePatient?.id) {
+    identifiers.push({
+      identifier: hiePatient.id,
+      identifierType: uuids.crIdentificationNumberUUID,
+      location,
+      preferred: false,
+    });
+  }
+
+  const { givenName, middleName, familyName } = splitHumanName(hiePatient?.name?.[0]);
+  const phone = hiePatient?.telecom?.find((contact: any) => contact.system === 'phone')?.value;
+  const addresses = (hiePatient?.address ?? []).map((address: any) => ({
+    ...EMPTY_ADDRESS,
+    cityVillage: address.city || '',
+    country: address.country || '',
+  }));
+
+  return postPatient({
+    person: {
+      names: [
+        {
+          preferred: true,
+          givenName: sanitizeName(givenName) || 'Unknown',
+          middleName: sanitizeName(middleName) || '',
+          familyName: sanitizeName(familyName) || 'Unknown',
+        },
+      ],
+      gender: hiePatient?.gender?.charAt(0).toUpperCase() || 'U',
+      birthdate: hiePatient?.birthDate ?? null,
+      birthdateEstimated: !hiePatient?.birthDate,
+      attributes: phone ? [{ attributeType: uuids.phoneAttributeTypeUUID, value: phone }] : [],
+      addresses: addresses.length > 0 ? addresses : [EMPTY_ADDRESS],
+    },
+    identifiers: await withOpenmrsId(identifiers, location),
+  });
+}

package/src/resources/patient-search.resource.ts

@@ -0,0 +1,106 @@
+import { openmrsFetch, restBaseUrl } from '@openmrs/esm-framework';
+
+const CUSTOM_PATIENT_REPRESENTATION =
+  'custom:(patientId,uuid,identifiers,display,patientIdentifier:(uuid,identifier),person:(gender,age,birthdate,birthdateEstimated,personName,addresses,display,dead,deathDate),attributes:(value,attributeType:(uuid,display)))';
+
+/** National ID first, then SHA, then birth certificate — most to least likely to be on file here. */
+const IDENTIFIER_PRIORITY: Record<string, number> = {
+  'national-id': 1,
+  'sha-number': 2,
+  'birth-certificate': 3,
+};
+
+/**
+ * The identifiers to search a patient by. A dependant carries theirs in `extension` entries
+ * rather than an `identifier` array, which is why the two are read differently.
+ */
+export const extractPatientIdentifiers = (patient: any, isDependent = false) => {
+  const identifiers: Array<{ value: string; type: string }> = [];
+
+  if (isDependent) {
+    const identifierExtensions = patient?.extension?.filter((ext: any) => ext.url === 'identifiers') || [];
+
+    identifierExtensions.forEach((ext: any) => {
+      const code = ext.valueIdentifier?.type?.coding?.[0]?.code;
+      // 'household-number' holds the household head's (parent's) own CR number, not an identifier
+      // unique to this dependent. Searching by it would match the parent's local patient record.
+      if (ext.valueIdentifier?.value && code && code !== 'household-number') {
+        identifiers.push({ value: ext.valueIdentifier.value, type: code });
+      }
+    });
+
+    return identifiers;
+  }
+
+  if (Array.isArray(patient?.identifier)) {
+    patient.identifier.forEach((id: any) => {
+      if (id.value && id.type?.coding?.[0]?.code) {
+        identifiers.push({ value: id.value, type: id.type.coding[0].code });
+      }
+    });
+  }
+
+  return identifiers;
+};
+
+/**
+ * Looks a patient up locally by one identifier. Falls back to a `q=` search when no type is
+ * given, filtering the results down to a real identifier match — `q=` matches on name too.
+ */
+export const searchLocalPatientByIdentifier = async (identifierValue: string, identifierType?: string) => {
+  if (!identifierValue) {
+    return null;
+  }
+
+  try {
+    const byIdentifier = await openmrsFetch(
+      `${restBaseUrl}/patient?identifier=${encodeURIComponent(identifierValue)}&v=${CUSTOM_PATIENT_REPRESENTATION}`,
+    );
+
+    if (byIdentifier?.data?.results?.length > 0) {
+      return byIdentifier.data.results[0];
+    }
+
+    if (!identifierType) {
+      const byQuery = await openmrsFetch(
+        `${restBaseUrl}/patient?q=${encodeURIComponent(identifierValue)}&v=${CUSTOM_PATIENT_REPRESENTATION}`,
+      );
+
+      const matching = (byQuery?.data?.results ?? []).filter((patient: any) =>
+        patient.identifiers?.some(
+          (id: any) => id.identifier === identifierValue || id.display?.includes(identifierValue),
+        ),
+      );
+
+      if (matching.length > 0) {
+        return matching[0];
+      }
+    }
+
+    return null;
+  } catch (error) {
+    return null;
+  }
+};
+
+/** The local record for a patient, or null when none of their identifiers resolve to one. */
+export const findExistingLocalPatient = async (patient: any, isDependent = false) => {
+  const identifiers = extractPatientIdentifiers(patient, isDependent);
+
+  if (identifiers.length === 0) {
+    return null;
+  }
+
+  const prioritized = [...identifiers].sort(
+    (a, b) => (IDENTIFIER_PRIORITY[a.type] || 999) - (IDENTIFIER_PRIORITY[b.type] || 999),
+  );
+
+  for (const identifier of prioritized) {
+    const existing = await searchLocalPatientByIdentifier(identifier.value, identifier.type).catch(() => null);
+    if (existing) {
+      return existing;
+    }
+  }
+
+  return null;
+};

package/src/resources/pcs.resource.test.ts

@@ -0,0 +1,36 @@
+import { describe, expect, it } from 'vitest';
+import { buildParticipantSearchUrl, hasAnyFilter } from './pcs.resource';
+
+const url = (filters: Partial<{ name: string; village: string; phone: string; motherId: string }>, opts = {}) =>
+  buildParticipantSearchUrl({ name: '', village: '', phone: '', ...filters }, opts)!;
+
+/**
+ * Pins the request we send to `pbids-participants`. The module owns the response semantics —
+ * name tiering, phone normalisation, AND-combination, paging — and the cases that covered
+ * those went with the mock that used to stand in for it.
+ */
+describe('pbids participant search request', () => {
+  it('omits blank filters and holds an unfiltered request', () => {
+    // The API rejects an unfiltered request with a 400, so a null URL holds the SWR fetch.
+    expect(hasAnyFilter({ name: '  ', village: '', phone: '' })).toBe(false);
+    expect(buildParticipantSearchUrl({ name: '', village: '', phone: '' })).toBeNull();
+    expect(url({ name: 'Mary Akinyi' })).toContain(
+      '/pbids-participants?name=Mary+Akinyi&limit=50&startIndex=0&fuzzy=true',
+    );
+    expect(url({ name: 'a', village: 'KAMBI' })).toContain('village=KAMBI');
+    expect(url({ name: 'a' })).not.toContain('village=');
+  });
+
+  it('treats motherId as a filter in its own right', () => {
+    expect(hasAnyFilter({ name: '', village: '', phone: '', motherId: '901-1-1-2' })).toBe(true);
+    expect(url({ motherId: '901-1-1-2' })).toContain('motherId=901-1-1-2');
+  });
+
+  it('passes limit, startIndex and fuzzy through', () => {
+    const paged = url({ name: 'ODONGO' }, { limit: 3, startIndex: 6, fuzzy: false });
+
+    expect(paged).toContain('limit=3');
+    expect(paged).toContain('startIndex=6');
+    expect(paged).toContain('fuzzy=false');
+  });
+});

package/src/resources/pcs.resource.ts

@@ -0,0 +1,182 @@
+import useSWR from 'swr';
+import { getPatientName, openmrsFetch, restBaseUrl } from '@openmrs/esm-framework';
+import { getNationalIdFromPatient, getPhoneFromFhirPatient } from './identifiers';
+import {
+  type PcsApiError,
+  type PcsCompound,
+  type PcsMother,
+  type PcsParticipant,
+  type PcsParticipantFilters,
+  type PcsParticipantSearchResponse,
+  type PcsSearchSubject,
+} from '../types';
+
+/** The API's own defaults, restated so the URL we build is explicit about them. */
+const DEFAULT_LIMIT = 50;
+const DEFAULT_START_INDEX = 0;
+
+interface ParticipantSearchOptions {
+  limit?: number;
+  startIndex?: number;
+  fuzzy?: boolean;
+}
+
+/** The default query for a newly authorized patient: their name, plus their phone when on file. */
+export function toPcsParticipantFilters(subject: PcsSearchSubject): PcsParticipantFilters {
+  return {
+    name: subject.name ?? '',
+    village: '',
+    phone: subject.phoneNumber ?? '',
+  };
+}
+
+/** The API rejects an unfiltered request with a 400, so hold it rather than provoke one. */
+export function hasAnyFilter(filters: PcsParticipantFilters | null): boolean {
+  return Boolean(
+    filters && (filters.name.trim() || filters.village.trim() || filters.phone.trim() || filters.motherId?.trim()),
+  );
+}
+
+/**
+ * Builds the participant search URL. Blank filters are omitted — the API AND-combines
+ * whatever it is given. Returns null when nothing is set, which doubles as SWR's
+ * "don't fetch yet" key.
+ */
+export function buildParticipantSearchUrl(
+  filters: PcsParticipantFilters | null,
+  { limit = DEFAULT_LIMIT, startIndex = DEFAULT_START_INDEX, fuzzy = true }: ParticipantSearchOptions = {},
+): string | null {
+  if (!hasAnyFilter(filters)) {
+    return null;
+  }
+
+  const params = new URLSearchParams();
+  (['name', 'village', 'phone', 'motherId'] as const).forEach((filter) => {
+    const value = filters![filter]?.trim();
+    if (value) {
+      params.set(filter, value);
+    }
+  });
+  params.set('limit', String(limit));
+  params.set('startIndex', String(startIndex));
+  params.set('fuzzy', String(fuzzy));
+
+  return `${restBaseUrl}/pbids-participants?${params}`;
+}
+
+async function fetchParticipants(url: string): Promise<PcsParticipantSearchResponse> {
+  const { data } = await openmrsFetch<PcsParticipantSearchResponse>(url);
+  return data;
+}
+
+/** An id PCS does not know returns 404 with an `ApiError` body, which SWR surfaces as an error. */
+async function fetchParticipantById(url: string): Promise<PcsParticipant> {
+  const { data } = await openmrsFetch<PcsParticipant>(url);
+  return data;
+}
+
+/**
+ * Fetches the one participant a patient is already linked to. A single record comes back in
+ * the same shape as one entry of the search results.
+ */
+export function usePcsParticipant(individualId: string | null) {
+  const url = individualId ? `${restBaseUrl}/pbids-participants/${encodeURIComponent(individualId)}` : null;
+
+  const { data, isLoading, error, mutate } = useSWR(url, fetchParticipantById, {
+    revalidateOnFocus: false,
+    revalidateOnReconnect: false,
+    shouldRetryOnError: false,
+  });
+
+  return { participant: data ?? null, isLoading, error, mutate };
+}
+
+/**
+ * The participants whose mother is `motherIndividualId` — a linked client's dependants.
+ * Same endpoint and response shape as the search, just a different filter.
+ */
+export function usePcsDependants(motherIndividualId: string | null) {
+  const url = buildParticipantSearchUrl(
+    motherIndividualId ? { name: '', village: '', phone: '', motherId: motherIndividualId } : null,
+  );
+
+  const { data, isLoading, error, mutate } = useSWR(url, fetchParticipants, {
+    revalidateOnFocus: false,
+    revalidateOnReconnect: false,
+    shouldRetryOnError: false,
+  });
+
+  return { dependants: data?.results ?? [], totalCount: data?.totalCount ?? 0, isLoading, error, mutate };
+}
+
+/**
+ * Searches the PCS registry. The URL is the SWR key, so editing a filter refetches and an
+ * unchanged query dedupes.
+ */
+export function usePcsParticipantSearch(filters: PcsParticipantFilters | null, options?: ParticipantSearchOptions) {
+  const url = buildParticipantSearchUrl(filters, options);
+
+  const { data, isLoading, error } = useSWR(url, fetchParticipants, {
+    revalidateOnFocus: false,
+    revalidateOnReconnect: false,
+    shouldRetryOnError: false,
+  });
+
+  return {
+    participants: data?.results ?? [],
+    totalCount: data?.totalCount ?? 0,
+    isLoading,
+    error,
+  };
+}
+
+/**
+ * Surfaces the API's own wording. `openmrsFetch` attaches the failure body — an `ApiError`
+ * — to the thrown error, and its `message` is more useful than a generic HTTP string.
+ */
+export function getPcsErrorMessage(error: unknown): string | undefined {
+  const apiError = (error as { responseBody?: Partial<PcsApiError> } | undefined)?.responseBody;
+  return apiError?.message || (error as Error | undefined)?.message;
+}
+
+/** A downed VPN to the SQL Server is the common failure, and reads very differently to a bug. */
+export function isPcsUnavailable(error: unknown): boolean {
+  return (error as { responseBody?: Partial<PcsApiError> } | undefined)?.responseBody?.status === 503;
+}
+
+export function formatParticipantName(participant: PcsParticipant): string {
+  return [participant.firstName, participant.middleName, participant.lastName].filter(Boolean).join(' ');
+}
+
+export function formatMotherName(mother: PcsMother): string {
+  return [mother.firstName, mother.middleName, mother.lastName].filter(Boolean).join(' ');
+}
+
+export function formatCompoundHeadName(compound: PcsCompound): string {
+  return [compound.headFirstName, compound.headMiddleName, compound.headLastName].filter(Boolean).join(' ');
+}
+
+/** Contacts are a list; the first one carrying anything identifying is what the tile shows. */
+export function getPrimaryContact(participant: PcsParticipant) {
+  return participant.contacts?.find((contact) => contact.phone || contact.nationalId) ?? participant.contacts?.[0];
+}
+
+/** Normalizes either side of the search results (local or HIE) into a PCS search subject. */
+export function toPcsSearchSubject(
+  patient: fhir.Patient,
+  source: PcsSearchSubject['source'],
+  nationalIdUUID?: string,
+  hiePatient?: fhir.Patient,
+): PcsSearchSubject {
+  return {
+    id: patient.id!,
+    source,
+    patient,
+    hiePatient,
+    name: getPatientName(patient),
+    gender: patient.gender,
+    birthDate: patient.birthDate,
+    nationalId: getNationalIdFromPatient(patient, nationalIdUUID),
+    phoneNumber: getPhoneFromFhirPatient(patient) ?? null,
+  };
+}

package/src/resources/use-identifier-type-uuids.ts

@@ -0,0 +1,38 @@
+import { useMemo } from 'react';
+import { useConfig } from '@openmrs/esm-framework';
+import { type IdentifierTypeUuids } from '../types';
+import { type PcsConfig } from '../config-schema';
+
+/**
+ * The identifier and attribute types a created patient's HIE identifiers are written against,
+ * gathered in one place so every caller passes the same set.
+ */
+export function useIdentifierTypeUuids(): IdentifierTypeUuids {
+  const {
+    nationalIdUUID,
+    shaNumberUUID,
+    passportUUID,
+    birthCertificateUUID,
+    crIdentificationNumberUUID,
+    phoneAttributeTypeUUID,
+  } = useConfig<PcsConfig>();
+
+  return useMemo(
+    () => ({
+      nationalIdUUID,
+      shaNumberUUID,
+      passportUUID,
+      birthCertificateUUID,
+      crIdentificationNumberUUID,
+      phoneAttributeTypeUUID,
+    }),
+    [
+      nationalIdUUID,
+      shaNumberUUID,
+      passportUUID,
+      birthCertificateUUID,
+      crIdentificationNumberUUID,
+      phoneAttributeTypeUUID,
+    ],
+  );
+}