gdc-common-utils-ts 2.3.16 → 2.3.18

package/dist/convert/convert-care-plan.js

@@ -4,13 +4,22 @@ import { CarePlanClaim } from '../models/interoperable-claims/care-plan-claims.j
 import { codingFromValue, codingToValue, referenceListToCsv, referenceToValue } from './convert-shared.js';
 export function carePlanFlatToFhirR4(claims) {
     const subject = claims[CarePlanClaim.Subject] ?? claims[CarePlanClaim.Patient];
+    const categoryCoding = codingFromValue(claims[CarePlanClaim.Category])?.map((coding) => ({
+        ...coding,
+        ...(claims[CarePlanClaim.CategoryDisplay] ? { display: claims[CarePlanClaim.CategoryDisplay] } : {}),
+    }));
     return {
         resourceType: 'CarePlan',
         identifier: claims[CarePlanClaim.Identifier] ? [{ value: claims[CarePlanClaim.Identifier] }] : undefined,
         status: claims[CarePlanClaim.Status],
         intent: claims[CarePlanClaim.Intent],
         subject: subject ? { reference: subject } : undefined,
-        category: claims[CarePlanClaim.Category] ? [{ coding: codingFromValue(claims[CarePlanClaim.Category]) }] : undefined,
+        category: claims[CarePlanClaim.Category] || claims[CarePlanClaim.CategoryText] || claims[CarePlanClaim.CategoryDisplay]
+            ? [{
+                    ...(categoryCoding ? { coding: categoryCoding } : {}),
+                    ...(claims[CarePlanClaim.CategoryText] ? { text: claims[CarePlanClaim.CategoryText] } : {}),
+                }]
+            : undefined,
         created: claims[CarePlanClaim.Date],
         note: claims[CarePlanClaim.Note] ? [{ text: claims[CarePlanClaim.Note] }] : undefined,
         basedOn: claims[CarePlanClaim.BasedOn] ? claims[CarePlanClaim.BasedOn].split(',').map((reference) => ({ reference: reference.trim() })) : undefined,
@@ -41,6 +50,8 @@ export function carePlanFhirR4ToFlat(resource) {
         [CarePlanClaim.BasedOn]: referenceListToCsv(resource.basedOn),
         [CarePlanClaim.CareTeam]: referenceListToCsv(resource.careTeam),
         [CarePlanClaim.Category]: codingToValue(resource.category?.[0]?.coding?.[0]),
+        [CarePlanClaim.CategoryText]: resource.category?.[0]?.text,
+        [CarePlanClaim.CategoryDisplay]: resource.category?.[0]?.coding?.[0]?.display,
         [CarePlanClaim.Condition]: referenceListToCsv(resource.addresses),
         [CarePlanClaim.Date]: resource.created || period?.start,
         [CarePlanClaim.Encounter]: referenceToValue(resource.encounter),

package/dist/convert/convert-consent.d.ts

@@ -0,0 +1,3 @@
+import type { FhirResource, FlatClaims } from './convert-shared';
+export declare function consentFhirR4ToFlat(resource: FhirResource, context?: string): FlatClaims;
+export declare function consentFlatToFhirR4(claims: FlatClaims): FhirResource;

package/dist/convert/convert-consent.js

@@ -0,0 +1,32 @@
+// Copyright 2026 Conéctate Soluciones y Aplicaciones SL under the Apache License, Version 2.0.
+import { ClaimConsent } from '../models/consent-rule.js';
+import { codingFromValue, codingToValue, fhirResourceToFlatClaims, flatClaimsToFhirResource, } from './convert-shared.js';
+export function consentFhirR4ToFlat(resource, context = 'org.hl7.fhir.r4') {
+    const concept = resource.category?.[0];
+    return {
+        ...fhirResourceToFlatClaims(resource, context),
+        [ClaimConsent.category]: codingToValue(concept?.coding?.[0]),
+        [ClaimConsent.categoryText]: concept?.text,
+        [ClaimConsent.categoryDisplay]: concept?.coding?.[0]?.display,
+    };
+}
+export function consentFlatToFhirR4(claims) {
+    const structuralClaims = { ...claims };
+    delete structuralClaims[ClaimConsent.category];
+    delete structuralClaims[ClaimConsent.categoryText];
+    delete structuralClaims[ClaimConsent.categoryDisplay];
+    const resource = flatClaimsToFhirResource(structuralClaims);
+    const coding = codingFromValue(claims[ClaimConsent.category])?.map((item) => ({
+        ...item,
+        ...(claims[ClaimConsent.categoryDisplay]
+            ? { display: claims[ClaimConsent.categoryDisplay] }
+            : {}),
+    }));
+    if (coding || claims[ClaimConsent.categoryText]) {
+        resource.category = [{
+                ...(coding ? { coding } : {}),
+                ...(claims[ClaimConsent.categoryText] ? { text: claims[ClaimConsent.categoryText] } : {}),
+            }];
+    }
+    return resource;
+}

package/dist/convert/convert-device.js

@@ -3,6 +3,10 @@
 import { DeviceClaim } from '../models/interoperable-claims/device-claims.js';
 import { codingFromValue, codingToValue, referenceToValue } from './convert-shared.js';
 export function deviceFlatToFhirR4(claims) {
+    const typeCoding = codingFromValue(claims[DeviceClaim.Type])?.map((coding) => ({
+        ...coding,
+        ...(claims[DeviceClaim.TypeDisplay] ? { display: claims[DeviceClaim.TypeDisplay] } : {}),
+    }));
     return {
         resourceType: 'Device',
         identifier: claims[DeviceClaim.Identifier] ? [{ value: claims[DeviceClaim.Identifier] }] : undefined,
@@ -14,7 +18,12 @@ export function deviceFlatToFhirR4(claims) {
         patient: claims[DeviceClaim.Patient] ? { reference: claims[DeviceClaim.Patient] } : undefined,
         serialNumber: claims[DeviceClaim.SerialNumber],
         status: claims[DeviceClaim.Status],
-        type: claims[DeviceClaim.Type] ? { coding: codingFromValue(claims[DeviceClaim.Type]) } : undefined,
+        type: claims[DeviceClaim.Type] || claims[DeviceClaim.TypeText] || claims[DeviceClaim.TypeDisplay]
+            ? {
+                ...(typeCoding ? { coding: typeCoding } : {}),
+                ...(claims[DeviceClaim.TypeText] ? { text: claims[DeviceClaim.TypeText] } : {}),
+            }
+            : undefined,
         udiCarrier: claims[DeviceClaim.UdiCarrier] ? [{ carrierHRF: claims[DeviceClaim.UdiCarrier] }] : undefined,
         url: claims[DeviceClaim.Url],
     };
@@ -31,6 +40,8 @@ export function deviceFhirR4ToFlat(resource) {
         [DeviceClaim.SerialNumber]: resource.serialNumber,
         [DeviceClaim.Status]: resource.status,
         [DeviceClaim.Type]: codingToValue(resource.type?.coding?.[0]),
+        [DeviceClaim.TypeText]: resource.type?.text,
+        [DeviceClaim.TypeDisplay]: resource.type?.coding?.[0]?.display,
         [DeviceClaim.UdiCarrier]: resource.udiCarrier?.[0]?.carrierHRF,
         [DeviceClaim.Url]: resource.url,
     };

package/dist/convert/convert-document-reference.js

@@ -1,14 +1,29 @@
 // Copyright 2026 Conéctate Soluciones y Aplicaciones SL under the Apache License, Version 2.0.
 // File: src/utils/convert-document-reference.ts
 import { DocumentReferenceClaim } from '../models/interoperable-claims/document-reference-claims.js';
-import { requireClaim } from './convert-shared.js';
+import { codingFromValue, codingToValue, requireClaim } from './convert-shared.js';
 export function documentReferenceFlatToFhirR4(claims) {
     const subject = requireClaim(claims, DocumentReferenceClaim.Subject);
+    const typeCoding = codingFromValue(claims[DocumentReferenceClaim.Type])?.map((coding) => ({
+        ...coding,
+        ...(claims[DocumentReferenceClaim.TypeDisplay] ? { display: claims[DocumentReferenceClaim.TypeDisplay] } : {}),
+    }));
     return {
         resourceType: 'DocumentReference',
         identifier: claims[DocumentReferenceClaim.Identifier] ? [{ value: claims[DocumentReferenceClaim.Identifier] }] : undefined,
         subject: { reference: subject },
         description: claims[DocumentReferenceClaim.Description],
+        category: claims[DocumentReferenceClaim.Category]
+            ? [{ coding: codingFromValue(claims[DocumentReferenceClaim.Category]) }]
+            : undefined,
+        type: claims[DocumentReferenceClaim.Type]
+            || claims[DocumentReferenceClaim.TypeText]
+            || claims[DocumentReferenceClaim.TypeDisplay]
+            ? {
+                ...(typeCoding ? { coding: typeCoding } : {}),
+                ...(claims[DocumentReferenceClaim.TypeText] ? { text: claims[DocumentReferenceClaim.TypeText] } : {}),
+            }
+            : undefined,
         date: claims[DocumentReferenceClaim.Date],
         content: [{ attachment: {
                     contentType: claims[DocumentReferenceClaim.ContentType],
@@ -25,6 +40,10 @@ export function documentReferenceFhirR4ToFlat(resource) {
         [DocumentReferenceClaim.Identifier]: resource.identifier?.[0]?.value,
         [DocumentReferenceClaim.Subject]: resource.subject?.reference,
         [DocumentReferenceClaim.Description]: resource.description,
+        [DocumentReferenceClaim.Category]: codingToValue(resource.category?.[0]?.coding?.[0]),
+        [DocumentReferenceClaim.Type]: codingToValue(resource.type?.coding?.[0]),
+        [DocumentReferenceClaim.TypeText]: resource.type?.text,
+        [DocumentReferenceClaim.TypeDisplay]: resource.type?.coding?.[0]?.display,
         [DocumentReferenceClaim.Date]: resource.date,
         [DocumentReferenceClaim.ContentType]: attachment?.contentType,
         [DocumentReferenceClaim.ContentData]: attachment?.data,

package/dist/convert/convert-observation.js

@@ -23,6 +23,16 @@ export function observationFromFlatToFhirR4(claims) {
             code: claims[ObservationClaim.ValueConceptValue],
         });
     const valueQuantityCoding = codingFromValue(claims[ObservationClaim.ValueQuantityUnit])?.[0];
+    const codeCoding = codingFromValue(codeToken)?.map((coding) => ({
+        ...coding,
+        ...(claims[ObservationClaim.CodeDisplay] ? { display: claims[ObservationClaim.CodeDisplay] } : {}),
+    }));
+    const valueConceptCoding = codingFromValue(valueConceptToken)?.map((coding) => ({
+        ...coding,
+        ...(claims[ObservationClaim.ValueConceptDisplay]
+            ? { display: claims[ObservationClaim.ValueConceptDisplay] }
+            : {}),
+    }));
     return {
         resourceType: 'Observation',
         identifier: claims[ObservationClaim.Identifier] ? [{ value: claims[ObservationClaim.Identifier] }] : undefined,
@@ -30,10 +40,8 @@ export function observationFromFlatToFhirR4(claims) {
         category: claims[ObservationClaim.Category] ? claims[ObservationClaim.Category].split(',').map((value) => ({ coding: codingFromValue(value.trim()) })) : undefined,
         code: codeToken
             ? {
-                coding: codingFromValue(codeToken),
-                ...(claims[ObservationClaim.CodeText] || claims[ObservationClaim.CodeDisplay]
-                    ? { text: claims[ObservationClaim.CodeText] ?? claims[ObservationClaim.CodeDisplay] }
-                    : {}),
+                coding: codeCoding,
+                ...(claims[ObservationClaim.CodeText] ? { text: claims[ObservationClaim.CodeText] } : {}),
             }
             : undefined,
         subject: subject ? { reference: subject } : undefined,
@@ -42,9 +50,9 @@ export function observationFromFlatToFhirR4(claims) {
         performer: claims[ObservationClaim.Performer] ? claims[ObservationClaim.Performer].split(',').map((reference) => ({ reference: reference.trim() })) : undefined,
         valueCodeableConcept: valueConceptToken
             ? {
-                coding: codingFromValue(valueConceptToken),
-                ...(claims[ObservationClaim.ValueConceptText] || claims[ObservationClaim.ValueConceptDisplay]
-                    ? { text: claims[ObservationClaim.ValueConceptText] ?? claims[ObservationClaim.ValueConceptDisplay] }
+                coding: valueConceptCoding,
+                ...(claims[ObservationClaim.ValueConceptText]
+                    ? { text: claims[ObservationClaim.ValueConceptText] }
                     : {}),
             }
             : undefined,

package/dist/convert/convert-practitioner-role.d.ts

@@ -0,0 +1,3 @@
+import type { FhirResource, FlatClaims } from './convert-shared';
+export declare function practitionerRoleFhirR4ToFlat(resource: FhirResource, context?: string): FlatClaims;
+export declare function practitionerRoleFlatToFhirR4(claims: FlatClaims): FhirResource;

package/dist/convert/convert-practitioner-role.js

@@ -0,0 +1,34 @@
+// Copyright 2026 Conéctate Soluciones y Aplicaciones SL under the Apache License, Version 2.0.
+import { PractitionerRoleClaim } from '../models/interoperable-claims/practitioner-role-claims.js';
+import { codingFromValue, codingToValue, fhirResourceToFlatClaims, flatClaimsToFhirResource, } from './convert-shared.js';
+export function practitionerRoleFhirR4ToFlat(resource, context = 'org.hl7.fhir.r4') {
+    const concept = resource.code?.[0];
+    return {
+        ...fhirResourceToFlatClaims(resource, context),
+        [PractitionerRoleClaim.Code]: codingToValue(concept?.coding?.[0]),
+        [PractitionerRoleClaim.CodeText]: concept?.text,
+        [PractitionerRoleClaim.CodeDisplay]: concept?.coding?.[0]?.display,
+    };
+}
+export function practitionerRoleFlatToFhirR4(claims) {
+    const structuralClaims = { ...claims };
+    delete structuralClaims[PractitionerRoleClaim.Code];
+    delete structuralClaims[PractitionerRoleClaim.CodeText];
+    delete structuralClaims[PractitionerRoleClaim.CodeDisplay];
+    const resource = flatClaimsToFhirResource(structuralClaims);
+    const coding = codingFromValue(claims[PractitionerRoleClaim.Code])?.map((item) => ({
+        ...item,
+        ...(claims[PractitionerRoleClaim.CodeDisplay]
+            ? { display: claims[PractitionerRoleClaim.CodeDisplay] }
+            : {}),
+    }));
+    if (coding || claims[PractitionerRoleClaim.CodeText]) {
+        resource.code = [{
+                ...(coding ? { coding } : {}),
+                ...(claims[PractitionerRoleClaim.CodeText]
+                    ? { text: claims[PractitionerRoleClaim.CodeText] }
+                    : {}),
+            }];
+    }
+    return resource;
+}

package/dist/convert/index.d.ts

@@ -20,4 +20,6 @@ export * from './convert-encounter';
 export * from './convert-related-person';
 export * from './convert-coverage';
 export * from './convert-clinical-impression';
+export * from './convert-consent';
+export * from './convert-practitioner-role';
 export * from './schemaorg-to-gaia-x';

package/dist/convert/index.js

@@ -20,4 +20,6 @@ export * from './convert-encounter.js';
 export * from './convert-related-person.js';
 export * from './convert-coverage.js';
 export * from './convert-clinical-impression.js';
+export * from './convert-consent.js';
+export * from './convert-practitioner-role.js';
 export * from './schemaorg-to-gaia-x.js';

package/dist/models/consent-rule.d.ts

@@ -2,6 +2,8 @@ export declare enum ClaimConsent {
     'decision' = "Consent.decision",
     'action' = "Consent.action",
     'category' = "Consent.category",
+    'categoryText' = "Consent.category-text",
+    'categoryDisplay' = "Consent.category-display",
     'resourceType' = "Consent.resourceType",
     'subject' = "Consent.subject",
     'actorIdentifier' = "Consent.actor-identifier",

package/dist/models/consent-rule.js

@@ -4,6 +4,8 @@ export var ClaimConsent;
     ClaimConsent["decision"] = "Consent.decision";
     ClaimConsent["action"] = "Consent.action";
     ClaimConsent["category"] = "Consent.category";
+    ClaimConsent["categoryText"] = "Consent.category-text";
+    ClaimConsent["categoryDisplay"] = "Consent.category-display";
     ClaimConsent["resourceType"] = "Consent.resourceType";
     ClaimConsent["subject"] = "Consent.subject";
     ClaimConsent["actorIdentifier"] = "Consent.actor-identifier";

package/dist/models/index.d.ts

@@ -49,6 +49,7 @@ export * from './relationship-access';
 export * from './response';
 export * from './subject-identifier-ledger';
 export * from './subject-identity-binding';
+export * from './terminology';
 export * from './urlPath';
 export * from './verifiable-credential';
 export * from './wallet';

package/dist/models/index.js

@@ -49,6 +49,7 @@ export * from './relationship-access.js';
 export * from './response.js';
 export * from './subject-identifier-ledger.js';
 export * from './subject-identity-binding.js';
+export * from './terminology.js';
 export * from './urlPath.js';
 export * from './verifiable-credential.js';
 export * from './wallet.js';

package/dist/models/interoperable-claims/care-plan-claims.d.ts

@@ -6,6 +6,8 @@ export declare const CarePlanClaim: {
     readonly BasedOn: "CarePlan.based-on";
     readonly CareTeam: "CarePlan.care-team";
     readonly Category: "CarePlan.category";
+    readonly CategoryText: "CarePlan.category-text";
+    readonly CategoryDisplay: "CarePlan.category-display";
     readonly Condition: "CarePlan.condition";
     readonly Date: "CarePlan.date";
     readonly Encounter: "CarePlan.encounter";

package/dist/models/interoperable-claims/care-plan-claims.js

@@ -7,6 +7,8 @@ export const CarePlanClaim = {
     BasedOn: 'CarePlan.based-on',
     CareTeam: 'CarePlan.care-team',
     Category: 'CarePlan.category',
+    CategoryText: 'CarePlan.category-text',
+    CategoryDisplay: 'CarePlan.category-display',
     Condition: 'CarePlan.condition',
     Date: 'CarePlan.date',
     Encounter: 'CarePlan.encounter',
@@ -28,6 +30,8 @@ export const CarePlanClaimSpecs = [
     { key: CarePlanClaim.BasedOn, meaning: 'Based-on reference.', example: 'CarePlan/plan-parent' },
     { key: CarePlanClaim.CareTeam, meaning: 'Care team references (CSV).', example: 'CareTeam/team-1' },
     { key: CarePlanClaim.Category, meaning: 'Care plan category token.', example: 'http://snomed.info/sct|736373009' },
+    { key: CarePlanClaim.CategoryText, meaning: 'Local-language care plan category label.', example: 'Plan de control de peso' },
+    { key: CarePlanClaim.CategoryDisplay, meaning: 'Canonical/international care plan category display.', example: 'Weight management plan' },
     { key: CarePlanClaim.Condition, meaning: 'Condition references (CSV).', example: 'Condition/cond-1' },
     { key: CarePlanClaim.Date, meaning: 'Care plan creation or period date.', example: '2026-06-01T10:00:00Z' },
     { key: CarePlanClaim.Encounter, meaning: 'Encounter reference.', example: 'Encounter/enc-1' },

package/dist/models/interoperable-claims/device-claims.d.ts

@@ -10,6 +10,8 @@ export declare const DeviceClaim: {
     readonly SerialNumber: "Device.serial-number";
     readonly Status: "Device.status";
     readonly Type: "Device.type";
+    readonly TypeText: "Device.type-text";
+    readonly TypeDisplay: "Device.type-display";
     readonly UdiCarrier: "Device.udi-carrier";
     readonly Url: "Device.url";
     readonly Note: "Device.note";

package/dist/models/interoperable-claims/device-claims.js

@@ -11,6 +11,8 @@ export const DeviceClaim = {
     SerialNumber: 'Device.serial-number',
     Status: 'Device.status',
     Type: 'Device.type',
+    TypeText: 'Device.type-text',
+    TypeDisplay: 'Device.type-display',
     UdiCarrier: 'Device.udi-carrier',
     Url: 'Device.url',
     Note: 'Device.note',
@@ -26,6 +28,8 @@ export const DeviceClaimSpecs = [
     { key: DeviceClaim.SerialNumber, meaning: 'Serial number.', example: 'SN-12345' },
     { key: DeviceClaim.Status, meaning: 'Device status.', example: 'active' },
     { key: DeviceClaim.Type, meaning: 'Device type token.', example: 'http://snomed.info/sct|706172005' },
+    { key: DeviceClaim.TypeText, meaning: 'Local-language device type label.', example: 'Bomba de insulina' },
+    { key: DeviceClaim.TypeDisplay, meaning: 'Canonical/international device type display.', example: 'Insulin pump' },
     { key: DeviceClaim.UdiCarrier, meaning: 'UDI carrier string.', example: '(01)09504000059118(17)220101(10)ABCD1234' },
     { key: DeviceClaim.Url, meaning: 'Canonical URL.', example: 'https://device.example.org/catalogue/123' },
     { key: DeviceClaim.Note, meaning: 'Clinical note text.', example: 'Patient-owned continuous glucose monitor.' },

package/dist/models/interoperable-claims/document-reference-claims.d.ts

@@ -22,6 +22,8 @@ export declare const DocumentReferenceClaim: {
     readonly Relation: "DocumentReference.relation";
     readonly Subject: "DocumentReference.subject";
     readonly Type: "DocumentReference.type";
+    readonly TypeText: "DocumentReference.type-text";
+    readonly TypeDisplay: "DocumentReference.type-display";
     readonly UserSelected: "DocumentReference.user-selected";
 };
 export type DocumentReferenceClaimKey = typeof DocumentReferenceClaim[keyof typeof DocumentReferenceClaim];

package/dist/models/interoperable-claims/document-reference-claims.js

@@ -24,6 +24,8 @@ export const DocumentReferenceClaim = {
     Relation: 'DocumentReference.relation',
     Subject: 'DocumentReference.subject',
     Type: 'DocumentReference.type',
+    TypeText: 'DocumentReference.type-text',
+    TypeDisplay: 'DocumentReference.type-display',
     UserSelected: 'DocumentReference.user-selected',
 };
 /**
@@ -53,6 +55,8 @@ export const DocumentReferenceClaimSpecs = [
     { key: DocumentReferenceClaim.Relation, meaning: 'Relation type to related document.', example: 'appends' },
     { key: DocumentReferenceClaim.Subject, meaning: 'URN for the section in the individual index.', example: 'urn:uhix:section:vitals' },
     { key: DocumentReferenceClaim.Type, meaning: 'Lower-level, sector-specific type.', example: 'http://hl7.org/fhir/ValueSet/c80-doc-typecodes|34133-9' },
+    { key: DocumentReferenceClaim.TypeText, meaning: 'Local-language document type label.', example: 'Resumen clínico' },
+    { key: DocumentReferenceClaim.TypeDisplay, meaning: 'Canonical/international document type display.', example: 'Patient summary Document' },
     { key: DocumentReferenceClaim.UserSelected, meaning: 'Custom provenance flag telling whether the document was explicitly created or selected by the end user/controller.', example: 'true' },
 ];
 /**

package/dist/models/interoperable-claims/index.d.ts

@@ -13,6 +13,7 @@ export * from './device-claims';
 export * from './observation-claims';
 export * from './immunization-claims';
 export * from './procedure-claims';
+export * from './practitioner-role-claims';
 export * from './care-plan-claims';
 export * from './flag-claims';
 export * from './appointment-claims';

package/dist/models/interoperable-claims/index.js

@@ -15,6 +15,7 @@ export * from './device-claims.js';
 export * from './observation-claims.js';
 export * from './immunization-claims.js';
 export * from './procedure-claims.js';
+export * from './practitioner-role-claims.js';
 export * from './care-plan-claims.js';
 export * from './flag-claims.js';
 export * from './appointment-claims.js';

package/dist/models/interoperable-claims/practitioner-role-claims.d.ts

@@ -0,0 +1,9 @@
+import type { ClaimSpec } from './types';
+/** Canonical claims used to preserve the primary coded PractitionerRole label. */
+export declare const PractitionerRoleClaim: {
+    readonly Code: "PractitionerRole.code";
+    readonly CodeText: "PractitionerRole.code-text";
+    readonly CodeDisplay: "PractitionerRole.code-display";
+};
+export type PractitionerRoleClaimKey = typeof PractitionerRoleClaim[keyof typeof PractitionerRoleClaim];
+export declare const PractitionerRoleClaimSpecs: ClaimSpec[];

package/dist/models/interoperable-claims/practitioner-role-claims.js

@@ -0,0 +1,24 @@
+// Copyright 2026 Conéctate Soluciones y Aplicaciones SL under the Apache License, Version 2.0.
+/** Canonical claims used to preserve the primary coded PractitionerRole label. */
+export const PractitionerRoleClaim = {
+    Code: 'PractitionerRole.code',
+    CodeText: 'PractitionerRole.code-text',
+    CodeDisplay: 'PractitionerRole.code-display',
+};
+export const PractitionerRoleClaimSpecs = [
+    {
+        key: PractitionerRoleClaim.Code,
+        meaning: 'Primary practitioner role code token.',
+        example: 'http://snomed.info/sct|158965000',
+    },
+    {
+        key: PractitionerRoleClaim.CodeText,
+        meaning: 'Local-language practitioner role label.',
+        example: 'Médico',
+    },
+    {
+        key: PractitionerRoleClaim.CodeDisplay,
+        meaning: 'Canonical/international practitioner role display.',
+        example: 'Doctor',
+    },
+];

package/dist/models/terminology.d.ts

@@ -0,0 +1,59 @@
+/**
+ * One terminology block in the legacy JSON catalog format.
+ *
+ * `id` is normally the canonical coding-system URI. The compatibility alias
+ * `ips` is accepted for the SNOMED IPS catalog used by
+ * the predecessor FHIR utility package.
+ */
+export type TerminologyCatalogResource = Readonly<{
+    id: string;
+    language?: string;
+    attributes: Readonly<Record<string, string>>;
+    meta?: Readonly<Record<string, unknown>>;
+}>;
+/**
+ * Loadable local terminology document compatible with the historic
+ * `data[].attributes[code] = display` JSON shape.
+ */
+export type TerminologyCatalogDocument = Readonly<{
+    id?: string;
+    name?: string;
+    language?: string;
+    system?: string;
+    version?: string;
+    jurisdiction?: string;
+    data: readonly TerminologyCatalogResource[];
+    meta?: Readonly<Record<string, unknown>>;
+}>;
+/** Input for a synchronous local terminology label lookup. */
+export type TerminologyLookupInput = Readonly<{
+    system: string;
+    code: string;
+    language: string;
+    jurisdiction?: string;
+}>;
+/** Input for an offline/local terminology text search. */
+export type TerminologySearchInput = Readonly<{
+    text: string;
+    language: string;
+    jurisdiction?: string;
+    systems?: readonly string[];
+    limit?: number;
+}>;
+/** One terminology option suitable for a coded clinical form control. */
+export type TerminologySearchResult = Readonly<{
+    system: string;
+    code: string;
+    display: string;
+    language: string;
+}>;
+/**
+ * Synchronous terminology contract used by cached and offline applications.
+ *
+ * A future remote terminology client should populate a local implementation
+ * of this contract before synchronous clinical-card rendering.
+ */
+export interface TerminologyProvider {
+    lookup(input: TerminologyLookupInput): string | undefined;
+    search(input: TerminologySearchInput): readonly TerminologySearchResult[];
+}

package/dist/models/terminology.js

@@ -0,0 +1 @@
+export {};

package/dist/utils/bundle-document-builder.js

@@ -5,7 +5,7 @@ import { ConditionClaim } from '../models/interoperable-claims/condition-claims.
 import { DiagnosticReportClaim } from '../models/interoperable-claims/diagnostic-report-claims.js';
 import { MedicationStatementClaim } from '../models/interoperable-claims/medication-statement-claims.js';
 import { ClaimConsent } from '../models/consent-rule.js';
-import { allergyIntoleranceFlatToFhirR4, appointmentFlatToFhirR4, carePlanFlatToFhirR4, clinicalImpressionFlatToFhirR4, compositionFlatToFhirR4, conditionFlatToFhirR4, convertFhirResourceToClaims, coverageFlatToFhirR4, deviceFlatToFhirR4, documentReferenceFlatToFhirR4, diagnosticReportFlatToFhirR4, encounterFlatToFhirR4, flagFlatToFhirR4, flatClaimsToFhirResource, immunizationFlatToFhirR4, locationFlatToFhirR4, medicationStatementFlatToFhirR4, observationFromFlatToFhirR4, organizationFlatToFhirR4, procedureFlatToFhirR4, relatedPersonFlatToFhirR4, } from './clinical-resource-converters.js';
+import { allergyIntoleranceFlatToFhirR4, appointmentFlatToFhirR4, carePlanFlatToFhirR4, clinicalImpressionFlatToFhirR4, compositionFlatToFhirR4, conditionFlatToFhirR4, consentFlatToFhirR4, convertFhirResourceToClaims, coverageFlatToFhirR4, deviceFlatToFhirR4, documentReferenceFlatToFhirR4, diagnosticReportFlatToFhirR4, encounterFlatToFhirR4, flagFlatToFhirR4, flatClaimsToFhirResource, immunizationFlatToFhirR4, locationFlatToFhirR4, medicationStatementFlatToFhirR4, observationFromFlatToFhirR4, organizationFlatToFhirR4, procedureFlatToFhirR4, practitionerRoleFlatToFhirR4, relatedPersonFlatToFhirR4, } from './clinical-resource-converters.js';
 function asTrimmedString(value) {
     if (value === undefined || value === null)
         return '';
@@ -378,6 +378,10 @@ function convertClaimsToFhirResourceByType(flatClaims, resourceType) {
             return coverageFlatToFhirR4(flatClaims);
         case 'ClinicalImpression':
             return clinicalImpressionFlatToFhirR4(flatClaims);
+        case ResourceTypesFhirR4.Consent:
+            return consentFlatToFhirR4(flatClaims);
+        case ResourceTypesFhirR4.PractitionerRole:
+            return practitionerRoleFlatToFhirR4(flatClaims);
         default:
             return flatClaimsToFhirResource(flatClaims);
     }

package/dist/utils/clinical-resource-converters.d.ts

@@ -21,6 +21,8 @@ export { encounterFlatToFhirR4, encounterFhirR4ToFlat, } from '../convert/conver
 export { relatedPersonFlatToFhirR4, relatedPersonFhirR4ToFlat, } from '../convert/convert-related-person';
 export { coverageFlatToFhirR4, coverageFhirR4ToFlat, } from '../convert/convert-coverage';
 export { clinicalImpressionFlatToFhirR4, clinicalImpressionFhirR4ToFlat, } from '../convert/convert-clinical-impression';
+export { consentFlatToFhirR4, consentFhirR4ToFlat, } from '../convert/convert-consent';
+export { practitionerRoleFlatToFhirR4, practitionerRoleFhirR4ToFlat, } from '../convert/convert-practitioner-role';
 import type { FhirResource, FlatClaims } from '../convert/convert-shared';
 import { medicationStatementFhirR4ToFlat, medicationStatementFlatToFhirR4 } from '../convert/convert-medication-statement';
 import { allergyIntoleranceFhirR4ToFlat, allergyIntoleranceFlatToFhirR4 } from '../convert/convert-allergy-intolerance';
@@ -43,6 +45,8 @@ import { encounterFhirR4ToFlat, encounterFlatToFhirR4 } from '../convert/convert
 import { relatedPersonFhirR4ToFlat, relatedPersonFlatToFhirR4 } from '../convert/convert-related-person';
 import { coverageFhirR4ToFlat, coverageFlatToFhirR4 } from '../convert/convert-coverage';
 import { clinicalImpressionFhirR4ToFlat, clinicalImpressionFlatToFhirR4 } from '../convert/convert-clinical-impression';
+import { consentFhirR4ToFlat, consentFlatToFhirR4 } from '../convert/convert-consent';
+import { practitionerRoleFhirR4ToFlat, practitionerRoleFlatToFhirR4 } from '../convert/convert-practitioner-role';
 export declare const medicationStatementFlatToFhir: typeof medicationStatementFlatToFhirR4;
 export declare const medicationStatementFhirToFlat: typeof medicationStatementFhirR4ToFlat;
 export declare const allergyIntoleranceFlatToFhir: typeof allergyIntoleranceFlatToFhirR4;
@@ -85,6 +89,10 @@ export declare const coverageFlatToFhir: typeof coverageFlatToFhirR4;
 export declare const coverageFhirToFlat: typeof coverageFhirR4ToFlat;
 export declare const clinicalImpressionFlatToFhir: typeof clinicalImpressionFlatToFhirR4;
 export declare const clinicalImpressionFhirToFlat: typeof clinicalImpressionFhirR4ToFlat;
+export declare const consentFlatToFhir: typeof consentFlatToFhirR4;
+export declare const consentFhirToFlat: typeof consentFhirR4ToFlat;
+export declare const practitionerRoleFlatToFhir: typeof practitionerRoleFlatToFhirR4;
+export declare const practitionerRoleFhirToFlat: typeof practitionerRoleFhirR4ToFlat;
 /**
  * Converts a FHIR resource to the semantic flat-claims contract when a
  * resource-specific converter exists. Unsupported resources fall back to the

package/dist/utils/clinical-resource-converters.js

@@ -22,6 +22,8 @@ export { encounterFlatToFhirR4, encounterFhirR4ToFlat, } from '../convert/conver
 export { relatedPersonFlatToFhirR4, relatedPersonFhirR4ToFlat, } from '../convert/convert-related-person.js';
 export { coverageFlatToFhirR4, coverageFhirR4ToFlat, } from '../convert/convert-coverage.js';
 export { clinicalImpressionFlatToFhirR4, clinicalImpressionFhirR4ToFlat, } from '../convert/convert-clinical-impression.js';
+export { consentFlatToFhirR4, consentFhirR4ToFlat, } from '../convert/convert-consent.js';
+export { practitionerRoleFlatToFhirR4, practitionerRoleFhirR4ToFlat, } from '../convert/convert-practitioner-role.js';
 import { fhirResourceToFlatClaims } from '../convert/convert-shared.js';
 import { medicationStatementFhirR4ToFlat, medicationStatementFlatToFhirR4 } from '../convert/convert-medication-statement.js';
 import { allergyIntoleranceFhirR4ToFlat, allergyIntoleranceFlatToFhirR4 } from '../convert/convert-allergy-intolerance.js';
@@ -44,6 +46,8 @@ import { encounterFhirR4ToFlat, encounterFlatToFhirR4 } from '../convert/convert
 import { relatedPersonFhirR4ToFlat, relatedPersonFlatToFhirR4 } from '../convert/convert-related-person.js';
 import { coverageFhirR4ToFlat, coverageFlatToFhirR4 } from '../convert/convert-coverage.js';
 import { clinicalImpressionFhirR4ToFlat, clinicalImpressionFlatToFhirR4 } from '../convert/convert-clinical-impression.js';
+import { consentFhirR4ToFlat, consentFlatToFhirR4 } from '../convert/convert-consent.js';
+import { practitionerRoleFhirR4ToFlat, practitionerRoleFlatToFhirR4 } from '../convert/convert-practitioner-role.js';
 export const medicationStatementFlatToFhir = medicationStatementFlatToFhirR4;
 export const medicationStatementFhirToFlat = medicationStatementFhirR4ToFlat;
 export const allergyIntoleranceFlatToFhir = allergyIntoleranceFlatToFhirR4;
@@ -86,6 +90,10 @@ export const coverageFlatToFhir = coverageFlatToFhirR4;
 export const coverageFhirToFlat = coverageFhirR4ToFlat;
 export const clinicalImpressionFlatToFhir = clinicalImpressionFlatToFhirR4;
 export const clinicalImpressionFhirToFlat = clinicalImpressionFhirR4ToFlat;
+export const consentFlatToFhir = consentFlatToFhirR4;
+export const consentFhirToFlat = consentFhirR4ToFlat;
+export const practitionerRoleFlatToFhir = practitionerRoleFlatToFhirR4;
+export const practitionerRoleFhirToFlat = practitionerRoleFhirR4ToFlat;
 /**
  * Converts a FHIR resource to the semantic flat-claims contract when a
  * resource-specific converter exists. Unsupported resources fall back to the
@@ -142,6 +150,10 @@ function convertFhirResourceToClaimsByType(resource, context) {
             return coverageFhirR4ToFlat(resource);
         case 'ClinicalImpression':
             return clinicalImpressionFhirR4ToFlat(resource);
+        case 'Consent':
+            return consentFhirR4ToFlat(resource, context);
+        case 'PractitionerRole':
+            return practitionerRoleFhirR4ToFlat(resource, context);
         default:
             return fhirResourceToFlatClaims(resource, context);
     }

package/dist/utils/clinical-resource-view.d.ts

@@ -37,11 +37,17 @@ export type ClinicalResourceDisplayOptions = Readonly<{
     /**
      * Product terminology lookup keyed by canonical `system|code`.
      *
-     * The token is resolved claims-first, so translations remain available when
-     * a `$summary` readback keeps `Coding.display` but omits native coding fields.
+     * The token is resolved claims-first from the resource-specific primary
+     * coded claim (for example `Observation.code`, `Immunization.vaccine-code`
+     * or `Device.type`). Other coded claims on the resource are never guessed.
+     * This keeps translations available when a `$summary` readback retains
+     * `Coding.display` but omits native coding identity fields.
      *
      * Return `undefined` when the product has no translation so the shared
      * reader can fall back to the international `Coding.display`.
+     * `createClinicalCodeTranslator(new LocalTerminologyProvider(catalogs))`
+     * provides the synchronous MVP/offline implementation. Remote terminology
+     * results must be fetched and cached before this render callback runs.
      */
     translateCode?: (input: ClinicalTerminologyTranslationInput) => string | undefined;
 }>;

package/dist/utils/clinical-resource-view.js

@@ -3,10 +3,17 @@ import { ResourceTypesFhirR4 } from '../constants/fhir-resource-types.js';
 import { ClaimConsent } from '../models/consent-rule.js';
 import { AllergyIntoleranceClaim, AllergyIntoleranceClaimsFhirApi, } from '../models/interoperable-claims/allergy-intolerance-claims.js';
 import { CommunicationClaim } from '../models/interoperable-claims/communication-claims.js';
+import { CarePlanClaim } from '../models/interoperable-claims/care-plan-claims.js';
 import { ConditionClaim, ConditionClaimsFhirApi, } from '../models/interoperable-claims/condition-claims.js';
+import { DeviceClaim } from '../models/interoperable-claims/device-claims.js';
+import { DiagnosticReportClaim } from '../models/interoperable-claims/diagnostic-report-claims.js';
+import { DocumentReferenceClaim } from '../models/interoperable-claims/document-reference-claims.js';
+import { FlagClaim } from '../models/interoperable-claims/flag-claims.js';
 import { ImmunizationClaim } from '../models/interoperable-claims/immunization-claims.js';
 import { MedicationStatementClaim, MedicationStatementClaimsFhirApi, MedicationStatementClaimsFhirApiExtended, } from '../models/interoperable-claims/medication-statement-claims.js';
 import { ObservationClaim } from '../models/interoperable-claims/observation-claims.js';
+import { PractitionerRoleClaim } from '../models/interoperable-claims/practitioner-role-claims.js';
+import { ProcedureClaim } from '../models/interoperable-claims/procedure-claims.js';
 const CONSENT_ACTOR_REFERENCE_CLAIM = 'Consent.actor-reference';
 const GENERIC_CREATOR_CLAIM_SUFFIX = '.creator';
 const GENERIC_PERFORMER_CLAIM_SUFFIX = '.performer';
@@ -615,31 +622,40 @@ function findFirstClaimBySuffixes(claims, suffixes) {
     return firstDefinedText(suffixes.map((suffix) => findBySuffix(claims, suffix)));
 }
 function resolvePrimaryClaimCodeToken(resourceType, claims) {
-    const suffixes = resourceType === ResourceTypesFhirR4.Immunization
-        || resourceType === ResourceTypesFhirR4.ImmunizationRecommendation
-        ? ['vaccine-code', 'code']
-        : resourceType === ResourceTypesFhirR4.Device
-            || resourceType === ResourceTypesFhirR4.DocumentReference
-            || resourceType === ResourceTypesFhirR4.Specimen
-            ? ['type', 'code']
-            : resourceType === ResourceTypesFhirR4.ImagingStudy
-                ? ['procedure-code', 'code']
-                : resourceType === ResourceTypesFhirR4.CarePlan
-                    ? ['category', 'code']
-                    : ['code'];
-    const normalizedResourceType = resourceType.toLowerCase();
-    for (const suffix of suffixes) {
-        const token = findBySuffix(claims, `${normalizedResourceType}.${suffix}`);
-        const firstToken = splitCsv(token)[0];
-        if (firstToken)
-            return firstToken;
-    }
-    const system = findBySuffix(claims, `${normalizedResourceType}.code-system`);
-    const code = findBySuffix(claims, `${normalizedResourceType}.code-value`);
-    if (code)
-        return system ? `${system}|${code}` : code;
+    const claimKey = resourceType === ResourceTypesFhirR4.Observation
+        ? ObservationClaim.Code
+        : resourceType === ResourceTypesFhirR4.Flag
+            ? FlagClaim.Code
+            : resourceType === ResourceTypesFhirR4.Immunization
+                ? ImmunizationClaim.VaccineCode
+                : resourceType === ResourceTypesFhirR4.Procedure
+                    ? ProcedureClaim.Code
+                    : resourceType === ResourceTypesFhirR4.DiagnosticReport
+                        ? DiagnosticReportClaim.Code
+                        : resourceType === ResourceTypesFhirR4.Device
+                            ? DeviceClaim.Type
+                            : resourceType === ResourceTypesFhirR4.DocumentReference
+                                ? DocumentReferenceClaim.Type
+                                : resourceType === ResourceTypesFhirR4.CarePlan
+                                    ? CarePlanClaim.Category
+                                    : resourceType === ResourceTypesFhirR4.PractitionerRole
+                                        ? PractitionerRoleClaim.Code
+                                        : undefined;
+    const token = claimKey ? readCanonicalClaimValue(claims, claimKey) : undefined;
+    if (token)
+        return splitCsv(token)[0];
+    if (resourceType === ResourceTypesFhirR4.Observation) {
+        const system = readCanonicalClaimValue(claims, ObservationClaim.CodeSystem);
+        const code = readCanonicalClaimValue(claims, ObservationClaim.CodeValue);
+        if (code)
+            return system ? `${system}|${code}` : code;
+    }
     return undefined;
 }
+function readCanonicalClaimValue(claims, claimKey) {
+    return trimValue(claims[claimKey])
+        || findBySuffix(claims, `.${claimKey.toLowerCase()}`);
+}
 function resolveResourceCodeText(resource) {
     return trimValue(asRecord(resource?.code).text) || undefined;
 }

package/dist/utils/index.d.ts

@@ -81,6 +81,7 @@ export * from './jwt-signer';
 export * from './jwk-thumbprint';
 export * from './legal-organization-onboarding';
 export * from './legal-organization-verification-transaction';
+export * from './local-terminology-provider';
 export * from './license';
 export * from './license-commercial-search';
 export * from './license-list-search';

package/dist/utils/index.js

@@ -81,6 +81,7 @@ export * from './jwt-signer.js';
 export * from './jwk-thumbprint.js';
 export * from './legal-organization-onboarding.js';
 export * from './legal-organization-verification-transaction.js';
+export * from './local-terminology-provider.js';
 export * from './license.js';
 export * from './license-commercial-search.js';
 export * from './license-list-search.js';

package/dist/utils/local-terminology-provider.d.ts

@@ -0,0 +1,27 @@
+import type { TerminologyCatalogDocument, TerminologyLookupInput, TerminologyProvider, TerminologySearchInput, TerminologySearchResult } from '../models/terminology.js';
+import type { ClinicalTerminologyTranslationInput } from './clinical-resource-view.js';
+/**
+ * In-memory terminology provider compatible with the historic JSON
+ * catalogs. It performs no network requests and keeps catalog loading under
+ * application control.
+ */
+export declare class LocalTerminologyProvider implements TerminologyProvider {
+    private readonly terms;
+    private readonly byIdentity;
+    private readonly byScopedIdentity;
+    constructor(catalogs: readonly TerminologyCatalogDocument[]);
+    /** Returns the best local label for one canonical coding identity. */
+    lookup(input: TerminologyLookupInput): string | undefined;
+    /**
+     * Searches local labels and codes, optionally constrained to coding systems.
+     * Results are deterministic and contain at most 100 entries.
+     */
+    search(input: TerminologySearchInput): readonly TerminologySearchResult[];
+    private identityKey;
+    private scopedIdentityKey;
+}
+/**
+ * Adapts a synchronous local terminology provider to
+ * `ClinicalResourceDisplayOptions.translateCode`.
+ */
+export declare function createClinicalCodeTranslator(provider: Pick<TerminologyProvider, 'lookup'>): (input: ClinicalTerminologyTranslationInput) => string | undefined;

package/dist/utils/local-terminology-provider.js

@@ -0,0 +1,154 @@
+const SNOMED_SYSTEM = 'http://snomed.info/sct';
+const DEFAULT_LANGUAGE = 'en';
+const DEFAULT_LIMIT = 20;
+const MAX_LIMIT = 100;
+function normalizedString(value) {
+    return typeof value === 'string' ? value.trim() : '';
+}
+function normalizeSystem(value) {
+    const system = normalizedString(value);
+    return system.toLowerCase() === 'ips' ? SNOMED_SYSTEM : system;
+}
+function normalizeLanguage(value) {
+    return normalizedString(value).replace(/_/g, '-').toLowerCase();
+}
+function normalizeJurisdiction(value) {
+    return normalizedString(value).toUpperCase();
+}
+function languageCandidates(language) {
+    const normalized = normalizeLanguage(language);
+    const base = normalized.split('-')[0];
+    return [...new Set([normalized, base, DEFAULT_LANGUAGE].filter(Boolean))];
+}
+function searchableText(value) {
+    return value
+        .normalize('NFD')
+        .replace(/[\u0300-\u036f]/g, '')
+        .toLocaleLowerCase();
+}
+function normalizedLimit(value) {
+    if (!Number.isFinite(value))
+        return DEFAULT_LIMIT;
+    return Math.max(1, Math.min(MAX_LIMIT, Math.trunc(value)));
+}
+/**
+ * In-memory terminology provider compatible with the historic JSON
+ * catalogs. It performs no network requests and keeps catalog loading under
+ * application control.
+ */
+export class LocalTerminologyProvider {
+    terms;
+    byIdentity;
+    byScopedIdentity;
+    constructor(catalogs) {
+        const terms = [];
+        const byIdentity = new Map();
+        const byScopedIdentity = new Map();
+        for (const catalog of catalogs) {
+            const catalogLanguage = normalizeLanguage(catalog.language) || DEFAULT_LANGUAGE;
+            const jurisdiction = normalizeJurisdiction(catalog.jurisdiction) || undefined;
+            for (const resource of catalog.data || []) {
+                const system = normalizeSystem(resource.id || catalog.system);
+                const language = normalizeLanguage(resource.language) || catalogLanguage;
+                if (!system || !language || !resource.attributes)
+                    continue;
+                for (const [rawCode, rawDisplay] of Object.entries(resource.attributes)) {
+                    const code = normalizedString(rawCode);
+                    const display = normalizedString(rawDisplay);
+                    if (!code || !display)
+                        continue;
+                    const term = { system, code, display, language, jurisdiction };
+                    terms.push(term);
+                    byIdentity.set(this.identityKey(language, system, code), display);
+                    byScopedIdentity.set(this.scopedIdentityKey(language, jurisdiction, system, code), display);
+                }
+            }
+        }
+        this.terms = terms;
+        this.byIdentity = byIdentity;
+        this.byScopedIdentity = byScopedIdentity;
+    }
+    /** Returns the best local label for one canonical coding identity. */
+    lookup(input) {
+        const system = normalizeSystem(input.system);
+        const code = normalizedString(input.code);
+        const jurisdiction = normalizeJurisdiction(input.jurisdiction) || undefined;
+        if (!system || !code)
+            return undefined;
+        for (const language of languageCandidates(input.language)) {
+            if (jurisdiction) {
+                const scopedDisplay = this.byScopedIdentity.get(this.scopedIdentityKey(language, jurisdiction, system, code)) || this.byScopedIdentity.get(this.scopedIdentityKey(language, undefined, system, code));
+                if (scopedDisplay)
+                    return scopedDisplay;
+                continue;
+            }
+            const display = this.byIdentity.get(this.identityKey(language, system, code));
+            if (display)
+                return display;
+        }
+        return undefined;
+    }
+    /**
+     * Searches local labels and codes, optionally constrained to coding systems.
+     * Results are deterministic and contain at most 100 entries.
+     */
+    search(input) {
+        const query = searchableText(normalizedString(input.text));
+        if (!query)
+            return [];
+        const allowedSystems = new Set((input.systems || []).map(normalizeSystem).filter(Boolean));
+        const jurisdiction = normalizeJurisdiction(input.jurisdiction);
+        const languages = languageCandidates(input.language);
+        const languageRank = new Map(languages.map((language, index) => [language, index]));
+        const selected = new Map();
+        for (const term of this.terms) {
+            if (allowedSystems.size > 0 && !allowedSystems.has(term.system))
+                continue;
+            if (jurisdiction && term.jurisdiction && term.jurisdiction !== jurisdiction)
+                continue;
+            const rank = languageRank.get(term.language);
+            if (rank === undefined)
+                continue;
+            if (!searchableText(term.code).includes(query)
+                && !searchableText(term.display).includes(query)) {
+                continue;
+            }
+            const identity = `${term.system}\u0000${term.code}`;
+            const current = selected.get(identity);
+            if (!current || rank < current.rank)
+                selected.set(identity, { term, rank });
+        }
+        return [...selected.values()]
+            .sort((left, right) => (left.rank - right.rank
+            || left.term.display.localeCompare(right.term.display)
+            || left.term.code.localeCompare(right.term.code)))
+            .slice(0, normalizedLimit(input.limit))
+            .map(({ term }) => ({
+            system: term.system,
+            code: term.code,
+            display: term.display,
+            language: term.language,
+        }));
+    }
+    identityKey(language, system, code) {
+        return `${language}\u0000${system}\u0000${code}`;
+    }
+    scopedIdentityKey(language, jurisdiction, system, code) {
+        return `${language}\u0000${jurisdiction || ''}\u0000${system}\u0000${code}`;
+    }
+}
+/**
+ * Adapts a synchronous local terminology provider to
+ * `ClinicalResourceDisplayOptions.translateCode`.
+ */
+export function createClinicalCodeTranslator(provider) {
+    return (input) => {
+        if (!input.system)
+            return undefined;
+        return provider.lookup({
+            system: input.system,
+            code: input.code,
+            language: input.locale,
+        });
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gdc-common-utils-ts",
-  "version": "2.3.16",
+  "version": "2.3.18",
   "publishConfig": {
     "access": "public"
   },