gdc-sdk-front-ts 0.6.2 → 0.6.6

package/dist/gdc-common-utils-ts/src/constants/healthcare.js

@@ -0,0 +1,274 @@
+import { LOINC_SYSTEM_URL, loincI18nKey } from '../models/clinical-sections';
+import { clinicalDocTypes, clinicalSectionAdditional, clinicalSectionsBase, } from '../models/clinical-sections.en';
+import { HL7_CODING_SYSTEM_PERSONAL_RELATIONSHIP, HL7_CODING_SYSTEM_V3_ROLE_CODE, HL7_PERSONAL_RELATIONSHIP_ROLES, HL7_V3_ROLE_CODE_LEGAL_REPRESENTATIVE, } from './hl7-roles';
+import { DataspaceSectors } from './sectors';
+export const ISCO08_CODING_SYSTEM = 'org.ilo.isco';
+export const ISCO08_I18N_NAMESPACE = 'org.ilo.isco-08';
+export const HealthcareRoleFamilies = Object.freeze({
+    ProfessionalOccupationIsco08: 'professionalOccupationIsco08',
+    PersonalRelationshipHl7: 'personalRelationshipHl7',
+    LegalRepresentativeHl7: 'legalRepresentativeHl7',
+});
+function defineSection(code, titleEn) {
+    return Object.freeze({
+        system: LOINC_SYSTEM_URL,
+        code,
+        claim: `LOINC|${code}`,
+        i18nKey: loincI18nKey(code),
+        titleEn,
+    });
+}
+export const HealthcareSectionFamilies = Object.freeze({
+    Summary: 'summary',
+    Management: 'management',
+    SubjectMatterDomain: 'subjectMatterDomain',
+});
+function buildSectionCatalogByCode(source) {
+    return Object.freeze(Object.fromEntries(Object.entries(source).map(([code, titleEn]) => [code, defineSection(code, titleEn)])));
+}
+export const HealthcareBasicSections = Object.freeze({
+    PatientSummaryDocument: defineSection('60591-5'),
+    AllergiesAndIntolerances: defineSection('48765-2'),
+    HistoryOfMedicationUse: defineSection('10160-0'),
+    ProblemList: defineSection('11450-4'),
+    Results: defineSection('30954-2'),
+    Procedures: defineSection('47519-4'),
+    Immunizations: defineSection('11369-6'),
+    MedicalDevices: defineSection('46264-8'),
+    FunctionalStatus: defineSection('47420-5'),
+    PlanOfCare: defineSection('18776-5'),
+    SocialHistory: defineSection('29762-2'),
+    VitalSigns: defineSection('8716-3'),
+});
+export const HealthcareAdditionalSections = Object.freeze({
+    AdvanceDirectives: defineSection('42348-3'),
+    DiagnosticImaging: defineSection('18726-0'),
+    HistoryOfPastIllness: defineSection('11348-0'),
+    ReasonForReferral: defineSection('42349-1'),
+    ChiefComplaint: defineSection('10154-3'),
+    HealthcareGeneral: defineSection('56796-6'),
+});
+export const HealthcareAllSections = Object.freeze({
+    ...HealthcareBasicSections,
+    ...HealthcareAdditionalSections,
+});
+/**
+ * Full section families sourced from the existing section catalogs in
+ * `models/clinical-sections.en.ts`.
+ *
+ * Family mapping used by SDK/business layers:
+ * - `summary`: IPS/base summary sections.
+ * - `management`: kind-of-document and type-of-service oriented sections.
+ * - `subjectMatterDomain`: additional service-domain sections.
+ */
+export const HealthcareSectionsByFamily = Object.freeze({
+    [HealthcareSectionFamilies.Summary]: buildSectionCatalogByCode(clinicalSectionsBase),
+    [HealthcareSectionFamilies.Management]: buildSectionCatalogByCode(clinicalDocTypes),
+    [HealthcareSectionFamilies.SubjectMatterDomain]: buildSectionCatalogByCode(clinicalSectionAdditional),
+});
+export const HealthcareAllSectionsByCode = Object.freeze({
+    ...HealthcareSectionsByFamily[HealthcareSectionFamilies.Summary],
+    ...HealthcareSectionsByFamily[HealthcareSectionFamilies.Management],
+    ...HealthcareSectionsByFamily[HealthcareSectionFamilies.SubjectMatterDomain],
+});
+export function getHealthcareSectionByCode(code) {
+    return HealthcareAllSectionsByCode[String(code || '').trim()];
+}
+export function getHealthcareSectionsByFamily(family) {
+    return HealthcareSectionsByFamily[family];
+}
+export const HealthcareConsentPurposes = Object.freeze({
+    Treatment: 'TREAT',
+    EmergencyTreatment: 'ETREAT',
+    CareManagement: 'CAREMGT',
+    Operations: 'HOPERAT',
+    PatientAdministration: 'PATADMIN',
+    RecordsManagement: 'RECORDMGT',
+});
+export const HealthcareActorRoles = Object.freeze({
+    Controller: 'ISCO-08|1120',
+    Physician: 'ISCO-08|2211',
+    NursingProfessional: 'ISCO-08|2221',
+    Paramedic: 'ISCO-08|2240',
+    Veterinarian: 'ISCO-08|2250',
+});
+export const HealthcareActorRoleCodes = Object.freeze({
+    Controller: '1120',
+    Physician: '2211',
+    PhysicianBroad: '221',
+    NursingProfessional: '2221',
+    Paramedic: '2240',
+    Veterinarian: '2250',
+});
+function buildProfessionalIscoRoles() {
+    const entries = [
+        [
+            HealthcareActorRoleCodes.Controller,
+            Object.freeze({
+                family: HealthcareRoleFamilies.ProfessionalOccupationIsco08,
+                codingSystem: ISCO08_CODING_SYSTEM,
+                code: HealthcareActorRoleCodes.Controller,
+                claim: HealthcareActorRoles.Controller,
+                i18nKey: `${ISCO08_I18N_NAMESPACE}.${HealthcareActorRoleCodes.Controller}`,
+                titleEn: 'Controller',
+            }),
+        ],
+        [
+            HealthcareActorRoleCodes.Physician,
+            Object.freeze({
+                family: HealthcareRoleFamilies.ProfessionalOccupationIsco08,
+                codingSystem: ISCO08_CODING_SYSTEM,
+                code: HealthcareActorRoleCodes.Physician,
+                claim: HealthcareActorRoles.Physician,
+                i18nKey: `${ISCO08_I18N_NAMESPACE}.${HealthcareActorRoleCodes.Physician}`,
+                titleEn: 'Physician',
+            }),
+        ],
+        [
+            HealthcareActorRoleCodes.NursingProfessional,
+            Object.freeze({
+                family: HealthcareRoleFamilies.ProfessionalOccupationIsco08,
+                codingSystem: ISCO08_CODING_SYSTEM,
+                code: HealthcareActorRoleCodes.NursingProfessional,
+                claim: HealthcareActorRoles.NursingProfessional,
+                i18nKey: `${ISCO08_I18N_NAMESPACE}.${HealthcareActorRoleCodes.NursingProfessional}`,
+                titleEn: 'Nursing professional',
+            }),
+        ],
+        [
+            HealthcareActorRoleCodes.Paramedic,
+            Object.freeze({
+                family: HealthcareRoleFamilies.ProfessionalOccupationIsco08,
+                codingSystem: ISCO08_CODING_SYSTEM,
+                code: HealthcareActorRoleCodes.Paramedic,
+                claim: HealthcareActorRoles.Paramedic,
+                i18nKey: `${ISCO08_I18N_NAMESPACE}.${HealthcareActorRoleCodes.Paramedic}`,
+                titleEn: 'Paramedic',
+            }),
+        ],
+        [
+            HealthcareActorRoleCodes.Veterinarian,
+            Object.freeze({
+                family: HealthcareRoleFamilies.ProfessionalOccupationIsco08,
+                codingSystem: ISCO08_CODING_SYSTEM,
+                code: HealthcareActorRoleCodes.Veterinarian,
+                claim: HealthcareActorRoles.Veterinarian,
+                i18nKey: `${ISCO08_I18N_NAMESPACE}.${HealthcareActorRoleCodes.Veterinarian}`,
+                titleEn: 'Veterinarian',
+            }),
+        ],
+    ];
+    return Object.freeze(Object.fromEntries(entries));
+}
+function buildPersonalRelationshipRoles() {
+    return Object.freeze(Object.fromEntries(HL7_PERSONAL_RELATIONSHIP_ROLES.map((item) => [
+        item.code,
+        Object.freeze({
+            family: HealthcareRoleFamilies.PersonalRelationshipHl7,
+            codingSystem: HL7_CODING_SYSTEM_PERSONAL_RELATIONSHIP,
+            code: item.code,
+            claim: `v3-PersonalRelationshipRoleType|${item.code}`,
+            i18nKey: `org.hl7.v3.personalRelationship.${item.code}`,
+            titleEn: item.display,
+            definition: item.definition,
+        }),
+    ])));
+}
+function buildLegalRepresentativeRoles() {
+    return Object.freeze(Object.fromEntries(HL7_V3_ROLE_CODE_LEGAL_REPRESENTATIVE.map((item) => [
+        item.code,
+        Object.freeze({
+            family: HealthcareRoleFamilies.LegalRepresentativeHl7,
+            codingSystem: HL7_CODING_SYSTEM_V3_ROLE_CODE,
+            code: item.code,
+            claim: `v3-RoleCode|${item.code}`,
+            i18nKey: `org.hl7.v3.roleCode.${item.code}`,
+            titleEn: item.display,
+            definition: item.definition,
+        }),
+    ])));
+}
+export const HealthcareRolesByFamily = Object.freeze({
+    [HealthcareRoleFamilies.ProfessionalOccupationIsco08]: buildProfessionalIscoRoles(),
+    [HealthcareRoleFamilies.PersonalRelationshipHl7]: buildPersonalRelationshipRoles(),
+    [HealthcareRoleFamilies.LegalRepresentativeHl7]: buildLegalRepresentativeRoles(),
+});
+export const HealthcareAllRolesByClaim = Object.freeze(Object.fromEntries(Object.values(HealthcareRolesByFamily)
+    .flatMap((catalog) => Object.values(catalog))
+    .map((descriptor) => [descriptor.claim, descriptor])));
+function pickRoleCatalogByCodes(catalog, codes) {
+    return Object.freeze(Object.fromEntries(codes
+        .map((code) => [code, catalog[code]])
+        .filter((entry) => Boolean(entry[1]))));
+}
+export const HealthcareProfessionalRoleCodesBySector = Object.freeze({
+    [DataspaceSectors.HealthCare]: Object.freeze([
+        HealthcareActorRoleCodes.Controller,
+        HealthcareActorRoleCodes.Physician,
+        HealthcareActorRoleCodes.NursingProfessional,
+        HealthcareActorRoleCodes.Paramedic,
+    ]),
+    [DataspaceSectors.HealthResearch]: Object.freeze([
+        HealthcareActorRoleCodes.Controller,
+        HealthcareActorRoleCodes.Physician,
+    ]),
+    [DataspaceSectors.HealthTech]: Object.freeze([HealthcareActorRoleCodes.Controller]),
+    [DataspaceSectors.HealthInsurance]: Object.freeze([HealthcareActorRoleCodes.Controller]),
+    [DataspaceSectors.AnimalCare]: Object.freeze([
+        HealthcareActorRoleCodes.Controller,
+        HealthcareActorRoleCodes.Veterinarian,
+    ]),
+    [DataspaceSectors.AnimalResearch]: Object.freeze([
+        HealthcareActorRoleCodes.Controller,
+        HealthcareActorRoleCodes.Veterinarian,
+    ]),
+    [DataspaceSectors.AnimalInsurance]: Object.freeze([HealthcareActorRoleCodes.Controller]),
+    [DataspaceSectors.AnimalTech]: Object.freeze([HealthcareActorRoleCodes.Controller]),
+    [DataspaceSectors.OneHealthResearch]: Object.freeze([
+        HealthcareActorRoleCodes.Controller,
+        HealthcareActorRoleCodes.Physician,
+        HealthcareActorRoleCodes.Veterinarian,
+    ]),
+    [DataspaceSectors.OneHealthTech]: Object.freeze([HealthcareActorRoleCodes.Controller]),
+});
+export const HealthcareProfessionalRolesBySector = Object.freeze({
+    [DataspaceSectors.HealthCare]: pickRoleCatalogByCodes(HealthcareRolesByFamily[HealthcareRoleFamilies.ProfessionalOccupationIsco08], HealthcareProfessionalRoleCodesBySector[DataspaceSectors.HealthCare]),
+    [DataspaceSectors.HealthResearch]: pickRoleCatalogByCodes(HealthcareRolesByFamily[HealthcareRoleFamilies.ProfessionalOccupationIsco08], HealthcareProfessionalRoleCodesBySector[DataspaceSectors.HealthResearch]),
+    [DataspaceSectors.HealthTech]: pickRoleCatalogByCodes(HealthcareRolesByFamily[HealthcareRoleFamilies.ProfessionalOccupationIsco08], HealthcareProfessionalRoleCodesBySector[DataspaceSectors.HealthTech]),
+    [DataspaceSectors.HealthInsurance]: pickRoleCatalogByCodes(HealthcareRolesByFamily[HealthcareRoleFamilies.ProfessionalOccupationIsco08], HealthcareProfessionalRoleCodesBySector[DataspaceSectors.HealthInsurance]),
+    [DataspaceSectors.AnimalCare]: pickRoleCatalogByCodes(HealthcareRolesByFamily[HealthcareRoleFamilies.ProfessionalOccupationIsco08], HealthcareProfessionalRoleCodesBySector[DataspaceSectors.AnimalCare]),
+    [DataspaceSectors.AnimalResearch]: pickRoleCatalogByCodes(HealthcareRolesByFamily[HealthcareRoleFamilies.ProfessionalOccupationIsco08], HealthcareProfessionalRoleCodesBySector[DataspaceSectors.AnimalResearch]),
+    [DataspaceSectors.AnimalInsurance]: pickRoleCatalogByCodes(HealthcareRolesByFamily[HealthcareRoleFamilies.ProfessionalOccupationIsco08], HealthcareProfessionalRoleCodesBySector[DataspaceSectors.AnimalInsurance]),
+    [DataspaceSectors.AnimalTech]: pickRoleCatalogByCodes(HealthcareRolesByFamily[HealthcareRoleFamilies.ProfessionalOccupationIsco08], HealthcareProfessionalRoleCodesBySector[DataspaceSectors.AnimalTech]),
+    [DataspaceSectors.OneHealthResearch]: pickRoleCatalogByCodes(HealthcareRolesByFamily[HealthcareRoleFamilies.ProfessionalOccupationIsco08], HealthcareProfessionalRoleCodesBySector[DataspaceSectors.OneHealthResearch]),
+    [DataspaceSectors.OneHealthTech]: pickRoleCatalogByCodes(HealthcareRolesByFamily[HealthcareRoleFamilies.ProfessionalOccupationIsco08], HealthcareProfessionalRoleCodesBySector[DataspaceSectors.OneHealthTech]),
+});
+export const HealthcareRolesBySector = Object.freeze(Object.fromEntries(Object.values(DataspaceSectors).map((sector) => [
+    sector,
+    Object.freeze({
+        [HealthcareRoleFamilies.ProfessionalOccupationIsco08]: HealthcareProfessionalRolesBySector[sector] || {},
+        [HealthcareRoleFamilies.PersonalRelationshipHl7]: HealthcareRolesByFamily[HealthcareRoleFamilies.PersonalRelationshipHl7],
+        [HealthcareRoleFamilies.LegalRepresentativeHl7]: HealthcareRolesByFamily[HealthcareRoleFamilies.LegalRepresentativeHl7],
+    }),
+])));
+export function getHealthcareRolesByFamily(family) {
+    return HealthcareRolesByFamily[family];
+}
+export function getHealthcareRoleByClaim(claim) {
+    return HealthcareAllRolesByClaim[String(claim || '').trim()];
+}
+export function getHealthcareProfessionalRolesBySector(sector) {
+    return HealthcareProfessionalRolesBySector[sector] || {};
+}
+export function getHealthcareRolesBySector(sector, family) {
+    return HealthcareRolesBySector[sector]?.[family] || {};
+}
+export const HealthcareConsentActions = Object.freeze({
+    PatientSummaryDocument: HealthcareBasicSections.PatientSummaryDocument.claim,
+    AllergiesAndIntolerances: HealthcareBasicSections.AllergiesAndIntolerances.claim,
+    HistoryOfMedicationUse: HealthcareBasicSections.HistoryOfMedicationUse.claim,
+    ProblemList: HealthcareBasicSections.ProblemList.claim,
+    Results: HealthcareBasicSections.Results.claim,
+    Procedures: HealthcareBasicSections.Procedures.claim,
+    Immunizations: HealthcareBasicSections.Immunizations.claim,
+});

package/dist/gdc-common-utils-ts/src/constants/hl7-roles.d.ts

@@ -0,0 +1,44 @@
+/**
+ * HL7 role constants shared across GDC projects.
+ *
+ * Two distinct value sets are provided:
+ *
+ * 1. v3-PersonalRelationshipRoleType
+ *    "Who are you in relation to the subject?" (family / social relationship)
+ *    Source: http://terminology.hl7.org/ValueSet/v3-PersonalRelationshipRoleType
+ *
+ * 2. v3-RoleCode — legal / functional representative subset
+ *    "What legal role do you exercise over the subject?" (guardian, attorney…)
+ *    Source: http://terminology.hl7.org/ValueSet/v3-RoleCode
+ *    Used as default for non-human subjects (e.g. animal-care sector).
+ *    Default for animal-care: RESPRSN (Responsible party).
+ */
+export type Hl7RoleEntry = {
+    code: string;
+    display: string;
+    definition: string;
+};
+export declare const HL7_CODING_SYSTEM_PERSONAL_RELATIONSHIP = "http://terminology.hl7.org/CodeSystem/v3-PersonalRelationshipRoleType";
+/** Canonical OID alias used in GDC claims (org.hl7.v3.RoleCode covers both sets). */
+export declare const HL7_CLAIMS_CODING_SYSTEM = "org.hl7.v3.RoleCode";
+/**
+ * Full ordered list of HL7 v3-PersonalRelationshipRoleType entries.
+ * Suitable for relationship pickers in health-sector family registration.
+ * Default role: `ONESELF` (patient represents themselves).
+ */
+export declare const HL7_PERSONAL_RELATIONSHIP_ROLES: Hl7RoleEntry[];
+export declare const HL7_CODING_SYSTEM_V3_ROLE_CODE = "http://terminology.hl7.org/CodeSystem/v3-RoleCode";
+/**
+ * Legal representative / guardian roles from HL7 v3-RoleCode.
+ *
+ * Used when the owner of an individual record exercises a legal function
+ * rather than a personal relationship (e.g. animal-care sector, minors
+ * with court-appointed guardian, power of attorney).
+ *
+ * Default for animal-care sector: `RESPRSN` (Responsible party).
+ */
+export declare const HL7_V3_ROLE_CODE_LEGAL_REPRESENTATIVE: Hl7RoleEntry[];
+/** Default role code for animal-care and non-human subjects. */
+export declare const HL7_DEFAULT_ROLE_ANIMAL_CARE = "RESPRSN";
+/** Default role code for health sector (patient self-represents). */
+export declare const HL7_DEFAULT_ROLE_HEALTH = "ONESELF";

package/dist/gdc-common-utils-ts/src/constants/hl7-roles.js

@@ -0,0 +1,208 @@
+/**
+ * HL7 role constants shared across GDC projects.
+ *
+ * Two distinct value sets are provided:
+ *
+ * 1. v3-PersonalRelationshipRoleType
+ *    "Who are you in relation to the subject?" (family / social relationship)
+ *    Source: http://terminology.hl7.org/ValueSet/v3-PersonalRelationshipRoleType
+ *
+ * 2. v3-RoleCode — legal / functional representative subset
+ *    "What legal role do you exercise over the subject?" (guardian, attorney…)
+ *    Source: http://terminology.hl7.org/ValueSet/v3-RoleCode
+ *    Used as default for non-human subjects (e.g. animal-care sector).
+ *    Default for animal-care: RESPRSN (Responsible party).
+ */
+// ---------------------------------------------------------------------------
+// 1. v3-PersonalRelationshipRoleType
+// ---------------------------------------------------------------------------
+export const HL7_CODING_SYSTEM_PERSONAL_RELATIONSHIP = 'http://terminology.hl7.org/CodeSystem/v3-PersonalRelationshipRoleType';
+/** Canonical OID alias used in GDC claims (org.hl7.v3.RoleCode covers both sets). */
+export const HL7_CLAIMS_CODING_SYSTEM = 'org.hl7.v3.RoleCode';
+const PERSONAL_RELATIONSHIP_LIST = [
+    { code: 'ONESELF', display: 'self', definition: 'The relationship that a person has with himself or herself.' },
+    { code: 'CHILD', display: 'child', definition: 'The player of the role is a child of the scoping entity.' },
+    { code: 'CHLDADOPT', display: 'adopted child', definition: 'The player of the role is a child taken into a family through legal means and raised by the scoping person as his or her own child.' },
+    { code: 'DAUADOPT', display: 'adopted daughter', definition: 'The player of the role is a female child taken into a family through legal means and raised by the scoping person as his or her own child.' },
+    { code: 'SONADOPT', display: 'adopted son', definition: 'The player of the role is a male child taken into a family through legal means and raised by the scoping person as his or her own child.' },
+    { code: 'CHLDFOST', display: 'foster child', definition: 'The player of the role is a child receiving parental care and nurture from the scoping person but not related through legal or blood ties.' },
+    { code: 'DAUFOST', display: 'foster daughter', definition: 'The player of the role is a female child receiving parental care and nurture from the scoping person but not related through legal or blood ties.' },
+    { code: 'SONFOST', display: 'foster son', definition: 'The player of the role is a male child receiving parental care and nurture from the scoping person but not related through legal or blood ties.' },
+    { code: 'DAUC', display: 'daughter', definition: 'The player of the role is a female child (of any type) of the scoping entity.' },
+    { code: 'DAU', display: 'natural daughter', definition: 'The player of the role is a female offspring of the scoping entity.' },
+    { code: 'STPDAU', display: 'stepdaughter', definition: "The player of the role is a daughter of the scoping person's spouse by a previous union." },
+    { code: 'NCHILD', display: 'natural child', definition: 'The player of the role is an offspring of the scoping entity as determined by birth.' },
+    { code: 'SON', display: 'natural son', definition: 'The player of the role is a male offspring of the scoping entity.' },
+    { code: 'SONC', display: 'son', definition: 'The player of the role is a male child (of any type) of the scoping entity.' },
+    { code: 'STPSON', display: 'stepson', definition: "The player of the role is a son of the scoping person's spouse by a previous union." },
+    { code: 'STPCHLD', display: 'step child', definition: "The player of the role is a child of the scoping person's spouse by a previous union." },
+    { code: 'AUNT', display: 'aunt', definition: "The player of the role is a sister of the scoping person's mother or father." },
+    { code: 'MAUNT', display: 'maternal aunt', definition: "The player of the role is a biological sister of the scoping person's biological mother." },
+    { code: 'PAUNT', display: 'paternal aunt', definition: "The player of the role is a biological sister of the scoping person's biological father." },
+    { code: 'COUSN', display: 'cousin', definition: 'The player of the role is a relative of the scoping person descended from a common ancestor, such as a grandparent, by two or more steps in a diverging line.' },
+    { code: 'MCOUSN', display: 'maternal cousin', definition: "The player of the role is a biological relative of the scoping person descended from a common ancestor on the player's mother's side." },
+    { code: 'PCOUSN', display: 'paternal cousin', definition: "The player of the role is a biological relative of the scoping person descended from a common ancestor on the player's father's side." },
+    { code: 'GGRPRN', display: 'great grandparent', definition: "The player of the role is a parent of the scoping person's grandparent." },
+    { code: 'GGRFTH', display: 'great grandfather', definition: "The player of the role is the father of the scoping person's grandparent." },
+    { code: 'MGGRFTH', display: 'maternal great-grandfather', definition: "The player of the role is the biological father of the scoping person's biological mother's parent." },
+    { code: 'PGGRFTH', display: 'paternal great-grandfather', definition: "The player of the role is the biological father of the scoping person's biological father's parent." },
+    { code: 'GGRMTH', display: 'great grandmother', definition: "The player of the role is the mother of the scoping person's grandparent." },
+    { code: 'MGGRMTH', display: 'maternal great-grandmother', definition: "The player of the role is the biological mother of the scoping person's biological mother's parent." },
+    { code: 'PGGRMTH', display: 'paternal great-grandmother', definition: "The player of the role is the biological mother of the scoping person's biological father's parent." },
+    { code: 'MGGRPRN', display: 'maternal great-grandparent', definition: "The player of the role is a biological parent of the scoping person's biological mother's parent." },
+    { code: 'PGGRPRN', display: 'paternal great-grandparent', definition: "The player of the role is a biological parent of the scoping person's biological father's parent." },
+    { code: 'GRNDCHILD', display: 'grandchild', definition: "The player of the role is a child of the scoping person's son or daughter." },
+    { code: 'GRNDDAU', display: 'granddaughter', definition: "The player of the role is a daughter of the scoping person's son or daughter." },
+    { code: 'GRNDSON', display: 'grandson', definition: "The player of the role is a son of the scoping person's son or daughter." },
+    { code: 'GRPRN', display: 'grandparent', definition: "The player of the role is a parent of the scoping person's mother or father." },
+    { code: 'GRFTH', display: 'grandfather', definition: "The player of the role is the father of the scoping person's mother or father." },
+    { code: 'MGRFTH', display: 'maternal grandfather', definition: "The player of the role is the biological father of the scoping person's biological mother." },
+    { code: 'PGRFTH', display: 'paternal grandfather', definition: "The player of the role is the biological father of the scoping person's biological father." },
+    { code: 'GRMTH', display: 'grandmother', definition: "The player of the role is the mother of the scoping person's mother or father." },
+    { code: 'MGRMTH', display: 'maternal grandmother', definition: "The player of the role is the biological mother of the scoping person's biological mother." },
+    { code: 'PGRMTH', display: 'paternal grandmother', definition: "The player of the role is the biological mother of the scoping person's biological father." },
+    { code: 'MGRPRN', display: 'maternal grandparent', definition: "The player of the role is the biological parent of the scoping person's biological mother." },
+    { code: 'PGRPRN', display: 'paternal grandparent', definition: "The player of the role is the biological parent of the scoping person's biological father." },
+    { code: 'CHLDINLAW', display: 'child-in-law', definition: "The player of the role is the spouse of the scoping person's child." },
+    { code: 'DAUINLAW', display: 'daughter in-law', definition: "The player of the role is the wife of the scoping person's son." },
+    { code: 'SONINLAW', display: 'son in-law', definition: "The player of the role is the husband of the scoping person's daughter." },
+    { code: 'PRNINLAW', display: 'parent in-law', definition: "The player of the role is the parent of the scoping person's husband or wife." },
+    { code: 'FTHINLAW', display: 'father-in-law', definition: "The player of the role is the father of the scoping person's husband or wife." },
+    { code: 'MTHINLAW', display: 'mother-in-law', definition: "The player of the role is the mother of the scoping person's husband or wife." },
+    { code: 'SIBINLAW', display: 'sibling in-law', definition: "The player of the role is a sibling of the scoping person's spouse, or the spouse of the scoping person's sibling, or the spouse of a sibling of the scoping person's spouse." },
+    { code: 'BROINLAW', display: 'brother-in-law', definition: "The player of the role is a brother of the scoping person's spouse, or the husband of the scoping person's sister, or the husband of a sister of the scoping person's spouse." },
+    { code: 'SISINLAW', display: 'sister-in-law', definition: "The player of the role is a sister of the scoping person's spouse, or the wife of the scoping person's brother, or the wife of a brother of the scoping person's spouse." },
+    { code: 'NIENEPH', display: 'niece/nephew', definition: "The player of the role is a child of the scoping person's brother or sister or of the brother or sister of the scoping person's spouse." },
+    { code: 'NEPHEW', display: 'nephew', definition: "The player of the role is a son of the scoping person's brother or sister or of the brother or sister of the scoping person's spouse." },
+    { code: 'NIECE', display: 'niece', definition: "The player of the role is a daughter of the scoping person's brother or sister or of the brother or sister of the scoping person's spouse." },
+    { code: 'UNCLE', display: 'uncle', definition: "The player of the role is a brother of the scoping person's mother or father." },
+    { code: 'MUNCLE', display: 'maternal uncle', definition: "The player of the role is a biological brother of the scoping person's biological mother." },
+    { code: 'PUNCLE', display: 'paternal uncle', definition: "The player of the role is a biological brother of the scoping person's biological father." },
+    { code: 'PRN', display: 'parent', definition: 'The player of the role is one who begets, gives birth to, or nurtures and raises the scoping entity.' },
+    { code: 'ADOPTP', display: 'adoptive parent', definition: 'The player of the role has taken the scoper into their family through legal means and raises them as their own child.' },
+    { code: 'ADOPTF', display: 'adoptive father', definition: 'The player of the role is a male who has taken the scoper into their family through legal means and raises them as his own child.' },
+    { code: 'ADOPTM', display: 'adoptive mother', definition: 'The player of the role is a female who has taken the scoper into their family through legal means and raises them as her own child.' },
+    { code: 'FTH', display: 'father', definition: 'The player of the role is a male who begets or raises or nurtures the scoping entity.' },
+    { code: 'FTHFOST', display: 'foster father', definition: 'The player of the role is a male state-certified caregiver responsible for the child placed in their care.' },
+    { code: 'NFTH', display: 'natural father', definition: 'The player of the role is a male who begets the scoping entity.' },
+    { code: 'NFTHF', display: 'natural father of fetus', definition: 'Indicates the biologic male parent of a fetus.' },
+    { code: 'STPFTH', display: 'stepfather', definition: "The player of the role is the husband of the scoping person's mother and not the scoping person's natural father." },
+    { code: 'MTH', display: 'mother', definition: 'The player of the role is a female who conceives, gives birth to, or raises and nurtures the scoping entity.' },
+    { code: 'GESTM', display: 'gestational mother', definition: 'The player is a female whose womb carries the fetus of the scoper.' },
+    { code: 'MTHFOST', display: 'foster mother', definition: 'The player of the role is a female state-certified caregiver responsible for the child placed in their care.' },
+    { code: 'NMTH', display: 'natural mother', definition: 'The player of the role is a female who conceives or gives birth to the scoping entity.' },
+    { code: 'NMTHF', display: 'natural mother of fetus', definition: 'The player is the biologic female parent of the scoping fetus.' },
+    { code: 'STPMTH', display: 'stepmother', definition: "The player of the role is the wife of the scoping person's father and not the scoping person's natural mother." },
+    { code: 'NPRN', display: 'natural parent', definition: 'The player of the role is a natural parent.' },
+    { code: 'PRNFOST', display: 'foster parent', definition: 'The player of the role is a state-certified caregiver responsible for the child placed in their care.' },
+    { code: 'STPPRN', display: 'step parent', definition: "The player of the role is the spouse of the scoping person's parent and not the scoping person's natural parent." },
+    { code: 'SIB', display: 'sibling', definition: 'The player of the role shares one or both parents in common with the scoping entity.' },
+    { code: 'BRO', display: 'brother', definition: 'The player of the role is a male sharing one or both parents in common with the scoping entity.' },
+    { code: 'HBRO', display: 'half-brother', definition: 'The player of the role is a male related to the scoping entity by sharing only one biological parent.' },
+    { code: 'NBRO', display: 'natural brother', definition: 'The player of the role is a male having the same biological parents as the scoping entity.' },
+    { code: 'TWINBRO', display: 'twin brother', definition: 'The scoper was carried in the same womb as the male player and shares common biological parents.' },
+    { code: 'FTWINBRO', display: 'fraternal twin brother', definition: 'The scoper was carried in the same womb as the male player and shares common biological parents but is the product of distinct egg/sperm pairs.' },
+    { code: 'ITWINBRO', display: 'identical twin brother', definition: 'The male scoper is an offspring of the same egg-sperm pair as the male player.' },
+    { code: 'STPBRO', display: 'stepbrother', definition: "The player of the role is a son of the scoping person's stepparent." },
+    { code: 'HSIB', display: 'half-sibling', definition: 'The player of the role is related to the scoping entity by sharing only one biological parent.' },
+    { code: 'HSIS', display: 'half-sister', definition: 'The player of the role is a female related to the scoping entity by sharing only one biological parent.' },
+    { code: 'NSIB', display: 'natural sibling', definition: 'The player of the role has both biological parents in common with the scoping entity.' },
+    { code: 'NSIS', display: 'natural sister', definition: 'The player of the role is a female having the same biological parents as the scoping entity.' },
+    { code: 'TWINSIS', display: 'twin sister', definition: 'The scoper was carried in the same womb as the female player and shares common biological parents.' },
+    { code: 'FTWINSIS', display: 'fraternal twin sister', definition: 'The scoper was carried in the same womb as the female player and shares common biological parents but is the product of distinct egg/sperm pairs.' },
+    { code: 'ITWINSIS', display: 'identical twin sister', definition: 'The female scoper is an offspring of the same egg-sperm pair as the female player.' },
+    { code: 'TWIN', display: 'twin', definition: 'The scoper and player were carried in the same womb and shared common biological parents.' },
+    { code: 'FTWIN', display: 'fraternal twin', definition: 'The scoper and player were carried in the same womb and share common biological parents but are the product of distinct egg/sperm pairs.' },
+    { code: 'ITWIN', display: 'identical twin', definition: 'The scoper and player are offspring of the same egg-sperm pair.' },
+    { code: 'SIS', display: 'sister', definition: 'The player of the role is a female sharing one or both parents in common with the scoping entity.' },
+    { code: 'STPSIS', display: 'stepsister', definition: "The player of the role is a daughter of the scoping person's stepparent." },
+    { code: 'STPSIB', display: 'step sibling', definition: "The player of the role is a child of the scoping person's stepparent." },
+    { code: 'SIGOTHR', display: 'significant other', definition: "A person who is important to one's well being; especially a spouse or one in a similar relationship." },
+    { code: 'DOMPART', display: 'domestic partner', definition: "The player of the role cohabits with the scoping person but is not the scoping person's spouse." },
+    { code: 'FMRSPS', display: 'former spouse', definition: 'Player of the role was previously joined to the scoping person in marriage and this marriage is now dissolved and inactive.' },
+    { code: 'SPS', display: 'spouse', definition: 'The player of the role is a marriage partner of the scoping person.' },
+    { code: 'HUSB', display: 'husband', definition: 'The player of the role is a man joined to a woman in marriage.' },
+    { code: 'WIFE', display: 'wife', definition: 'The player of the role is a woman joined to a man in marriage.' },
+    { code: 'FRND', display: 'unrelated friend', definition: 'The player of the role is a person who is known, liked, and trusted by the scoping person.' },
+    { code: 'NBOR', display: 'neighbor', definition: 'The player of the role lives near or next to the scoping person.' },
+    { code: 'ROOM', display: 'roommate', definition: 'One who shares living quarters with the subject.' },
+];
+const PERSONAL_PREFERRED_ORDER = [
+    'ONESELF', 'SPS', 'HUSB', 'WIFE', 'SIGOTHR', 'DOMPART', 'FMRSPS', 'ROOM',
+    'CHILD', 'SON', 'DAU', 'SONC', 'DAUC', 'NCHILD',
+    'CHLDADOPT', 'SONADOPT', 'DAUADOPT', 'CHLDFOST', 'SONFOST', 'DAUFOST',
+    'STPCHLD', 'STPSON', 'STPDAU',
+    'PRN', 'FTH', 'MTH', 'NFTH', 'NMTH',
+    'ADOPTP', 'ADOPTF', 'ADOPTM', 'FTHFOST', 'MTHFOST', 'PRNFOST',
+    'STPFTH', 'STPMTH', 'STPPRN', 'NPRN',
+    'SIB', 'BRO', 'SIS', 'NBRO', 'NSIS', 'NSIB', 'HBRO', 'HSIS', 'HSIB',
+    'TWIN', 'TWINBRO', 'TWINSIS', 'FTWIN', 'FTWINBRO', 'FTWINSIS',
+    'ITWIN', 'ITWINBRO', 'ITWINSIS',
+    'GRPRN', 'GRFTH', 'GRMTH', 'MGRPRN', 'PGRPRN', 'MGRFTH', 'PGRFTH', 'MGRMTH', 'PGRMTH',
+    'GGRPRN', 'GGRFTH', 'GGRMTH', 'MGGRPRN', 'PGGRPRN', 'MGGRFTH', 'PGGRFTH', 'MGGRMTH', 'PGGRMTH',
+    'GRNDCHILD', 'GRNDSON', 'GRNDDAU',
+    'CHLDINLAW', 'SONINLAW', 'DAUINLAW', 'PRNINLAW', 'FTHINLAW', 'MTHINLAW',
+    'SIBINLAW', 'BROINLAW', 'SISINLAW',
+    'UNCLE', 'AUNT', 'MUNCLE', 'PAUNT',
+    'NIENEPH', 'NEPHEW', 'NIECE',
+    'COUSN', 'MCOUSN', 'PCOUSN',
+    'FRND', 'NBOR',
+];
+const _personalByCode = new Map(PERSONAL_RELATIONSHIP_LIST.map((r) => [r.code, r]));
+const _personalPreferred = PERSONAL_PREFERRED_ORDER
+    .map((code) => _personalByCode.get(code))
+    .filter(Boolean);
+const _personalRemaining = PERSONAL_RELATIONSHIP_LIST.filter((r) => !PERSONAL_PREFERRED_ORDER.includes(r.code));
+/**
+ * Full ordered list of HL7 v3-PersonalRelationshipRoleType entries.
+ * Suitable for relationship pickers in health-sector family registration.
+ * Default role: `ONESELF` (patient represents themselves).
+ */
+export const HL7_PERSONAL_RELATIONSHIP_ROLES = [
+    ..._personalPreferred,
+    ..._personalRemaining,
+];
+// ---------------------------------------------------------------------------
+// 2. v3-RoleCode — legal / functional representative subset
+// ---------------------------------------------------------------------------
+export const HL7_CODING_SYSTEM_V3_ROLE_CODE = 'http://terminology.hl7.org/CodeSystem/v3-RoleCode';
+/**
+ * Legal representative / guardian roles from HL7 v3-RoleCode.
+ *
+ * Used when the owner of an individual record exercises a legal function
+ * rather than a personal relationship (e.g. animal-care sector, minors
+ * with court-appointed guardian, power of attorney).
+ *
+ * Default for animal-care sector: `RESPRSN` (Responsible party).
+ */
+export const HL7_V3_ROLE_CODE_LEGAL_REPRESENTATIVE = [
+    {
+        code: 'RESPRSN',
+        display: 'Responsible party',
+        definition: 'The role played by a party who has legal responsibility for another party.',
+    },
+    {
+        code: 'GUARD',
+        display: 'Guardian',
+        definition: 'The role played by a person or institution legally empowered with responsibility for the care of a ward.',
+    },
+    {
+        code: 'GUADLTM',
+        display: 'Guardian ad lidem',
+        definition: 'The role played by a person appointed by the court to represent the best interests of a child or incompetent in a legal proceeding.',
+    },
+    {
+        code: 'POWATT',
+        display: 'Power of attorney',
+        definition: 'A relationship between two people in which one person acts on behalf of another in legal or financial matters.',
+    },
+    {
+        code: 'DPOWATT',
+        display: 'Durable power of attorney',
+        definition: 'A relationship between two people in which one person acts on behalf of another even if the grantor becomes incapacitated.',
+    },
+];
+/** Default role code for animal-care and non-human subjects. */
+export const HL7_DEFAULT_ROLE_ANIMAL_CARE = 'RESPRSN';
+/** Default role code for health sector (patient self-represents). */
+export const HL7_DEFAULT_ROLE_HEALTH = 'ONESELF';

package/dist/gdc-common-utils-ts/src/constants/index.d.ts

@@ -0,0 +1,21 @@
+export * from './actor-session';
+export * from './communication';
+export * from './cryptography';
+export * from './dataspace-discovery';
+export * from './dataspace-protocol';
+export * from './device';
+export * from './did-services';
+export * from './eu-countries';
+export * from './fhir-code-systems';
+export * from './fhir-resource-types';
+export * from './fhir-versions';
+export * from './schemaorg';
+export * from './hl7-roles';
+export * from './healthcare';
+export * from './vital-signs';
+export * from './network';
+export * from './sectors';
+export * from './smart';
+export * from './service-capabilities';
+export * from './urn';
+export * from './verifiable-credentials';

package/dist/gdc-common-utils-ts/src/constants/index.js

@@ -0,0 +1,21 @@
+export * from './actor-session';
+export * from './communication';
+export * from './cryptography';
+export * from './dataspace-discovery';
+export * from './dataspace-protocol';
+export * from './device';
+export * from './did-services';
+export * from './eu-countries';
+export * from './fhir-code-systems';
+export * from './fhir-resource-types';
+export * from './fhir-versions';
+export * from './schemaorg';
+export * from './hl7-roles';
+export * from './healthcare';
+export * from './vital-signs';
+export * from './network';
+export * from './sectors';
+export * from './smart';
+export * from './service-capabilities';
+export * from './urn';
+export * from './verifiable-credentials';

package/dist/gdc-common-utils-ts/src/constants/network.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Canonical network/environment labels used to identify host networks during
+ * discovery/bootstrap flows.
+ *
+ * These labels do not replace the business route `sector`. They describe the
+ * host environment itself.
+ */
+export declare const HostNetworkTypes: Readonly<{
+    readonly Test: "test";
+    readonly TestNetwork: "test-network";
+    readonly Network: "network";
+}>;
+export type HostNetworkType = typeof HostNetworkTypes[keyof typeof HostNetworkTypes];
+/**
+ * @deprecated Use `HostNetworkTypes`.
+ */
+export declare const NodeOperatorNetworkTypes: Readonly<{
+    readonly Test: "test";
+    readonly TestNetwork: "test-network";
+    readonly Network: "network";
+}>;
+/**
+ * @deprecated Use `HostNetworkType`.
+ */
+export type NodeOperatorNetworkType = HostNetworkType;

package/dist/gdc-common-utils-ts/src/constants/network.js

@@ -0,0 +1,17 @@
+// Copyright 2025 Antifraud Services Inc. under the Apache License, Version 2.0.
+/**
+ * Canonical network/environment labels used to identify host networks during
+ * discovery/bootstrap flows.
+ *
+ * These labels do not replace the business route `sector`. They describe the
+ * host environment itself.
+ */
+export const HostNetworkTypes = Object.freeze({
+    Test: 'test',
+    TestNetwork: 'test-network',
+    Network: 'network',
+});
+/**
+ * @deprecated Use `HostNetworkTypes`.
+ */
+export const NodeOperatorNetworkTypes = HostNetworkTypes;