gdc-common-utils-ts 2.0.12 → 2.0.13

package/dist/utils/convert-flag.js

@@ -1,34 +0,0 @@
-// Copyright 2026 Conéctate Soluciones y Aplicaciones SL under the Apache License, Version 2.0.
-// File: src/utils/convert-flag.ts
-import { FlagClaim } from '../models/interoperable-claims/flag-claims.js';
-import { codingFromValue, codingToValue, referenceToValue } from './convert-shared.js';
-export function flagFlatToFhirR4(claims) {
-    const subject = claims[FlagClaim.Subject] ?? claims[FlagClaim.Patient];
-    return {
-        resourceType: 'Flag',
-        identifier: claims[FlagClaim.Identifier] ? [{ value: claims[FlagClaim.Identifier] }] : undefined,
-        status: claims[FlagClaim.Status],
-        category: claims[FlagClaim.Category] ? { coding: codingFromValue(claims[FlagClaim.Category]) } : undefined,
-        code: claims[FlagClaim.Code] ? { coding: codingFromValue(claims[FlagClaim.Code]) } : undefined,
-        subject: subject ? { reference: subject } : undefined,
-        author: claims[FlagClaim.Author] ? { reference: claims[FlagClaim.Author] } : undefined,
-        encounter: claims[FlagClaim.Encounter] ? { reference: claims[FlagClaim.Encounter] } : undefined,
-        period: (claims[FlagClaim.PeriodStart] || claims[FlagClaim.PeriodEnd]) ? { start: claims[FlagClaim.PeriodStart], end: claims[FlagClaim.PeriodEnd] } : undefined,
-    };
-}
-export function flagFhirR4ToFlat(resource) {
-    const period = resource.period;
-    return {
-        [FlagClaim.Author]: referenceToValue(resource.author),
-        [FlagClaim.Date]: undefined,
-        [FlagClaim.Encounter]: referenceToValue(resource.encounter),
-        [FlagClaim.Identifier]: resource.identifier?.[0]?.value,
-        [FlagClaim.Patient]: referenceToValue(resource.subject),
-        [FlagClaim.Subject]: referenceToValue(resource.subject),
-        [FlagClaim.Status]: resource.status,
-        [FlagClaim.Category]: codingToValue(resource.category?.coding?.[0]),
-        [FlagClaim.Code]: codingToValue(resource.code?.coding?.[0]),
-        [FlagClaim.PeriodStart]: period?.start,
-        [FlagClaim.PeriodEnd]: period?.end,
-    };
-}

package/dist/utils/convert-immunization.d.ts

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

package/dist/utils/convert-immunization.js

@@ -1,56 +0,0 @@
-// Copyright 2026 Conéctate Soluciones y Aplicaciones SL under the Apache License, Version 2.0.
-// File: src/utils/convert-immunization.ts
-import { ImmunizationClaim } from '../models/interoperable-claims/immunization-claims.js';
-import { codingFromValue, codingToValue, referenceToValue } from './convert-shared.js';
-export function immunizationFlatToFhirR4(claims) {
-    const subject = claims[ImmunizationClaim.Subject] ?? claims[ImmunizationClaim.Patient];
-    return {
-        resourceType: 'Immunization',
-        identifier: claims[ImmunizationClaim.Identifier] ? [{ value: claims[ImmunizationClaim.Identifier] }] : undefined,
-        status: claims[ImmunizationClaim.Status],
-        vaccineCode: claims[ImmunizationClaim.VaccineCode] ? { coding: codingFromValue(claims[ImmunizationClaim.VaccineCode]) } : undefined,
-        patient: subject ? { reference: subject } : undefined,
-        occurrenceDateTime: claims[ImmunizationClaim.Date],
-        location: claims[ImmunizationClaim.Location] ? { reference: claims[ImmunizationClaim.Location] } : undefined,
-        manufacturer: claims[ImmunizationClaim.Manufacturer] ? { reference: claims[ImmunizationClaim.Manufacturer] } : undefined,
-        lotNumber: claims[ImmunizationClaim.LotNumber],
-        performer: claims[ImmunizationClaim.Performer] ? claims[ImmunizationClaim.Performer].split(',').map((reference) => ({ actor: { reference: reference.trim() } })) : undefined,
-        reasonCode: claims[ImmunizationClaim.ReasonCode] ? [{ coding: codingFromValue(claims[ImmunizationClaim.ReasonCode]) }] : undefined,
-        reasonReference: claims[ImmunizationClaim.ReasonReference] ? [{ reference: claims[ImmunizationClaim.ReasonReference] }] : undefined,
-        statusReason: claims[ImmunizationClaim.StatusReason] ? { coding: codingFromValue(claims[ImmunizationClaim.StatusReason]) } : undefined,
-        note: claims[ImmunizationClaim.Note] ? [{ text: claims[ImmunizationClaim.Note] }] : undefined,
-        protocolApplied: (claims[ImmunizationClaim.Series] || claims[ImmunizationClaim.TargetDisease] || claims[ImmunizationClaim.DoseSequence]) ? [{
-                series: claims[ImmunizationClaim.Series],
-                targetDisease: claims[ImmunizationClaim.TargetDisease] ? [{ coding: codingFromValue(claims[ImmunizationClaim.TargetDisease]) }] : undefined,
-                doseNumberString: claims[ImmunizationClaim.DoseSequence],
-            }] : undefined,
-        reaction: claims[ImmunizationClaim.ReactionDate] ? [{ date: claims[ImmunizationClaim.ReactionDate] }] : undefined,
-    };
-}
-export function immunizationFhirR4ToFlat(resource) {
-    const reaction = Array.isArray(resource.reaction) ? resource.reaction[0] : undefined;
-    const protocolApplied = Array.isArray(resource.protocolApplied) ? resource.protocolApplied[0] : undefined;
-    const performer = Array.isArray(resource.performer)
-        ? resource.performer.map((item) => referenceToValue(item?.actor)).filter((item) => Boolean(item))
-        : [];
-    return {
-        [ImmunizationClaim.Identifier]: resource.identifier?.[0]?.value,
-        [ImmunizationClaim.Date]: resource.occurrenceDateTime,
-        [ImmunizationClaim.Location]: referenceToValue(resource.location),
-        [ImmunizationClaim.LotNumber]: resource.lotNumber,
-        [ImmunizationClaim.Manufacturer]: referenceToValue(resource.manufacturer),
-        [ImmunizationClaim.Patient]: referenceToValue(resource.patient),
-        [ImmunizationClaim.Performer]: performer.length ? performer.join(',') : undefined,
-        [ImmunizationClaim.ReactionDate]: reaction?.date,
-        [ImmunizationClaim.ReasonCode]: codingToValue(resource.reasonCode?.[0]?.coding?.[0]),
-        [ImmunizationClaim.ReasonReference]: referenceToValue(resource.reasonReference?.[0]),
-        [ImmunizationClaim.Series]: protocolApplied?.series,
-        [ImmunizationClaim.Status]: resource.status,
-        [ImmunizationClaim.StatusReason]: codingToValue(resource.statusReason?.coding?.[0]),
-        [ImmunizationClaim.TargetDisease]: codingToValue(protocolApplied?.targetDisease?.[0]?.coding?.[0]),
-        [ImmunizationClaim.VaccineCode]: codingToValue(resource.vaccineCode?.coding?.[0]),
-        [ImmunizationClaim.DoseSequence]: protocolApplied?.doseNumberString,
-        [ImmunizationClaim.Subject]: referenceToValue(resource.patient),
-        [ImmunizationClaim.Note]: resource.note?.[0]?.text,
-    };
-}

package/dist/utils/convert-medication-statement.d.ts

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

package/dist/utils/convert-medication-statement.js

@@ -1,64 +0,0 @@
-// Copyright 2026 Conéctate Soluciones y Aplicaciones SL under the Apache License, Version 2.0.
-// File: src/utils/convert-medication-statement.ts
-import { MedicationStatementClaim } from '../models/interoperable-claims/medication-statement-claims.js';
-import { codingFromValue, codingToValue, requireClaim } from './convert-shared.js';
-export function medicationStatementFlatToFhirR4(claims) {
-    const subject = requireClaim(claims, MedicationStatementClaim.Subject);
-    const status = requireClaim(claims, MedicationStatementClaim.Status);
-    const effectiveDateTime = claims[MedicationStatementClaim.Effective];
-    const medicationText = claims[MedicationStatementClaim.MedicationText];
-    const medicationIdentifier = claims[MedicationStatementClaim.MedicationIdentifier];
-    const medicationSerialNumber = claims[MedicationStatementClaim.MedicationSerialNumber];
-    const medicationExpirationDate = claims[MedicationStatementClaim.MedicationExpirationDate];
-    const hasContainedMedication = Boolean(medicationIdentifier) || Boolean(medicationSerialNumber) || Boolean(medicationExpirationDate) || Boolean(medicationText);
-    const containedMedicationId = 'medication-contained-1';
-    const containedMedication = hasContainedMedication ? {
-        resourceType: 'Medication',
-        id: containedMedicationId,
-        identifier: medicationIdentifier ? [{ value: medicationIdentifier }] : undefined,
-        code: medicationText ? { text: medicationText } : undefined,
-        batch: medicationSerialNumber || medicationExpirationDate ? {
-            lotNumber: medicationSerialNumber,
-            expirationDate: medicationExpirationDate,
-        } : undefined,
-    } : undefined;
-    return {
-        resourceType: 'MedicationStatement',
-        identifier: claims[MedicationStatementClaim.Identifier] ? [{ value: claims[MedicationStatementClaim.Identifier] }] : undefined,
-        status,
-        subject: { reference: subject },
-        effectiveDateTime,
-        medicationCodeableConcept: claims[MedicationStatementClaim.Code]
-            ? { coding: codingFromValue(claims[MedicationStatementClaim.Code]) }
-            : (!hasContainedMedication && medicationText ? { text: medicationText } : undefined),
-        medicationReference: hasContainedMedication ? { reference: `#${containedMedicationId}` } : undefined,
-        contained: containedMedication ? [containedMedication] : undefined,
-        dosage: claims[MedicationStatementClaim.DosageInstruction] ? [{ text: claims[MedicationStatementClaim.DosageInstruction] }] : undefined,
-        note: claims[MedicationStatementClaim.Note] ? [{ text: claims[MedicationStatementClaim.Note] }] : undefined,
-    };
-}
-export function medicationStatementFhirR4ToFlat(resource) {
-    const medicationReference = resource.medicationReference?.reference;
-    const containedResources = Array.isArray(resource.contained) ? resource.contained : [];
-    const containedMedication = medicationReference?.startsWith('#')
-        ? containedResources.find((item) => item?.resourceType === 'Medication' && String(item?.id || '') === medicationReference.slice(1))
-        : containedResources.find((item) => item?.resourceType === 'Medication');
-    const containedMedicationIdentifier = containedMedication?.identifier?.[0]?.value;
-    const containedMedicationText = containedMedication?.code?.text;
-    const batch = containedMedication?.batch;
-    const medicationCode = codingToValue(resource.medicationCodeableConcept?.coding?.[0]);
-    const medicationText = containedMedicationText || resource.medicationCodeableConcept?.text || undefined;
-    return {
-        [MedicationStatementClaim.Identifier]: resource.identifier?.[0]?.value,
-        [MedicationStatementClaim.Subject]: resource.subject?.reference,
-        [MedicationStatementClaim.Status]: resource.status,
-        [MedicationStatementClaim.Effective]: resource.effectiveDateTime,
-        [MedicationStatementClaim.Code]: medicationCode,
-        [MedicationStatementClaim.MedicationText]: medicationText,
-        [MedicationStatementClaim.Note]: resource.note?.[0]?.text,
-        [MedicationStatementClaim.DosageInstruction]: resource.dosage?.[0]?.text,
-        [MedicationStatementClaim.MedicationIdentifier]: containedMedicationIdentifier,
-        [MedicationStatementClaim.MedicationSerialNumber]: batch?.lotNumber,
-        [MedicationStatementClaim.MedicationExpirationDate]: batch?.expirationDate,
-    };
-}

package/dist/utils/convert-observation.d.ts

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

package/dist/utils/convert-observation.js

@@ -1,57 +0,0 @@
-// Copyright 2026 Conéctate Soluciones y Aplicaciones SL under the Apache License, Version 2.0.
-// File: src/utils/convert-observation.ts
-import { ObservationClaim } from '../models/interoperable-claims/observation-claims.js';
-import { codingFromValue, codingListToCsv, codingToValue, referenceListToCsv, referenceToValue } from './convert-shared.js';
-export function observationFlatToFhirR4(claims) {
-    const subject = claims[ObservationClaim.Subject] ?? claims[ObservationClaim.Patient];
-    return {
-        resourceType: 'Observation',
-        identifier: claims[ObservationClaim.Identifier] ? [{ value: claims[ObservationClaim.Identifier] }] : undefined,
-        status: claims[ObservationClaim.Status],
-        category: claims[ObservationClaim.Category] ? claims[ObservationClaim.Category].split(',').map((value) => ({ coding: codingFromValue(value.trim()) })) : undefined,
-        code: claims[ObservationClaim.Code] ? { coding: codingFromValue(claims[ObservationClaim.Code]) } : undefined,
-        subject: subject ? { reference: subject } : undefined,
-        effectiveDateTime: claims[ObservationClaim.EffectiveDateTime] ?? claims[ObservationClaim.Date],
-        issued: claims[ObservationClaim.EffectiveDateTime] ? undefined : claims[ObservationClaim.Date],
-        performer: claims[ObservationClaim.Performer] ? claims[ObservationClaim.Performer].split(',').map((reference) => ({ reference: reference.trim() })) : undefined,
-        valueCodeableConcept: claims[ObservationClaim.ValueConcept] ? { coding: codingFromValue(claims[ObservationClaim.ValueConcept]) } : undefined,
-        valueDateTime: claims[ObservationClaim.ValueDate],
-        valueString: claims[ObservationClaim.ValueString],
-        note: claims[ObservationClaim.Note] ? [{ text: claims[ObservationClaim.Note] }] : undefined,
-        basedOn: claims[ObservationClaim.BasedOn] ? claims[ObservationClaim.BasedOn].split(',').map((reference) => ({ reference: reference.trim() })) : undefined,
-        device: claims[ObservationClaim.Device] ? { reference: claims[ObservationClaim.Device] } : undefined,
-        encounter: claims[ObservationClaim.Encounter] ? { reference: claims[ObservationClaim.Encounter] } : undefined,
-        focus: claims[ObservationClaim.Focus] ? claims[ObservationClaim.Focus].split(',').map((reference) => ({ reference: reference.trim() })) : undefined,
-        hasMember: claims[ObservationClaim.HasMember] ? claims[ObservationClaim.HasMember].split(',').map((reference) => ({ reference: reference.trim() })) : undefined,
-        method: claims[ObservationClaim.Method] ? { coding: codingFromValue(claims[ObservationClaim.Method]) } : undefined,
-        specimen: claims[ObservationClaim.Specimen] ? { reference: claims[ObservationClaim.Specimen] } : undefined,
-        component: claims[ObservationClaim.ComponentCode] ? [{ code: { coding: codingFromValue(claims[ObservationClaim.ComponentCode]) } }] : undefined,
-    };
-}
-export function observationFhirR4ToFlat(resource) {
-    const valueCodeableConcept = resource.valueCodeableConcept;
-    const component = Array.isArray(resource.component) ? resource.component[0] : undefined;
-    return {
-        [ObservationClaim.BasedOn]: referenceListToCsv(resource.basedOn),
-        [ObservationClaim.Category]: codingListToCsv(resource.category?.flatMap((item) => item.coding || [])),
-        [ObservationClaim.Code]: codingToValue(resource.code?.coding?.[0]),
-        [ObservationClaim.Date]: resource.effectiveDateTime || resource.issued,
-        [ObservationClaim.Device]: referenceToValue(resource.device),
-        [ObservationClaim.Encounter]: referenceToValue(resource.encounter),
-        [ObservationClaim.Focus]: referenceListToCsv(resource.focus),
-        [ObservationClaim.HasMember]: referenceListToCsv(resource.hasMember),
-        [ObservationClaim.Identifier]: resource.identifier?.[0]?.value,
-        [ObservationClaim.Method]: codingToValue(resource.method?.coding?.[0]),
-        [ObservationClaim.Patient]: referenceToValue(resource.subject),
-        [ObservationClaim.Performer]: referenceListToCsv(resource.performer),
-        [ObservationClaim.Specimen]: referenceToValue(resource.specimen),
-        [ObservationClaim.Status]: resource.status,
-        [ObservationClaim.Subject]: referenceToValue(resource.subject),
-        [ObservationClaim.ValueConcept]: codingToValue(valueCodeableConcept?.coding?.[0]),
-        [ObservationClaim.ValueDate]: resource.valueDateTime,
-        [ObservationClaim.ValueString]: resource.valueString,
-        [ObservationClaim.ComponentCode]: codingToValue(component?.code?.coding?.[0]),
-        [ObservationClaim.Note]: resource.note?.[0]?.text,
-        [ObservationClaim.EffectiveDateTime]: resource.effectiveDateTime,
-    };
-}

package/dist/utils/convert-procedure.d.ts

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

package/dist/utils/convert-procedure.js

@@ -1,50 +0,0 @@
-// Copyright 2026 Conéctate Soluciones y Aplicaciones SL under the Apache License, Version 2.0.
-// File: src/utils/convert-procedure.ts
-import { ProcedureClaim } from '../models/interoperable-claims/procedure-claims.js';
-import { codingFromValue, codingToValue, referenceListToCsv, referenceToValue } from './convert-shared.js';
-export function procedureFlatToFhirR4(claims) {
-    const subject = claims[ProcedureClaim.Subject] ?? claims[ProcedureClaim.Patient];
-    return {
-        resourceType: 'Procedure',
-        identifier: claims[ProcedureClaim.Identifier] ? [{ value: claims[ProcedureClaim.Identifier] }] : undefined,
-        status: claims[ProcedureClaim.Status],
-        subject: subject ? { reference: subject } : undefined,
-        code: claims[ProcedureClaim.Code] ? { coding: codingFromValue(claims[ProcedureClaim.Code]) } : undefined,
-        performedDateTime: claims[ProcedureClaim.Date],
-        note: claims[ProcedureClaim.Note] ? [{ text: claims[ProcedureClaim.Note] }] : undefined,
-        basedOn: claims[ProcedureClaim.BasedOn] ? claims[ProcedureClaim.BasedOn].split(',').map((reference) => ({ reference: reference.trim() })) : undefined,
-        bodySite: claims[ProcedureClaim.BodySite] ? [{ coding: codingFromValue(claims[ProcedureClaim.BodySite]) }] : undefined,
-        encounter: claims[ProcedureClaim.Encounter] ? { reference: claims[ProcedureClaim.Encounter] } : undefined,
-        instantiatesCanonical: claims[ProcedureClaim.InstantiatesCanonical] ? [claims[ProcedureClaim.InstantiatesCanonical]] : undefined,
-        instantiatesUri: claims[ProcedureClaim.InstantiatesUri] ? [claims[ProcedureClaim.InstantiatesUri]] : undefined,
-        location: claims[ProcedureClaim.Location] ? { reference: claims[ProcedureClaim.Location] } : undefined,
-        partOf: claims[ProcedureClaim.PartOf] ? claims[ProcedureClaim.PartOf].split(',').map((reference) => ({ reference: reference.trim() })) : undefined,
-        performer: claims[ProcedureClaim.Performer] ? claims[ProcedureClaim.Performer].split(',').map((reference) => ({ actor: { reference: reference.trim() } })) : undefined,
-        reasonCode: claims[ProcedureClaim.ReasonCode] ? [{ coding: codingFromValue(claims[ProcedureClaim.ReasonCode]) }] : undefined,
-        reasonReference: claims[ProcedureClaim.ReasonReference] ? claims[ProcedureClaim.ReasonReference].split(',').map((reference) => ({ reference: reference.trim() })) : undefined,
-    };
-}
-export function procedureFhirR4ToFlat(resource) {
-    const performer = Array.isArray(resource.performer)
-        ? resource.performer.map((item) => referenceToValue(item?.actor)).filter((item) => Boolean(item))
-        : [];
-    return {
-        [ProcedureClaim.BasedOn]: referenceListToCsv(resource.basedOn),
-        [ProcedureClaim.BodySite]: codingToValue(resource.bodySite?.[0]?.coding?.[0]),
-        [ProcedureClaim.Code]: codingToValue(resource.code?.coding?.[0]),
-        [ProcedureClaim.Date]: resource.performedDateTime || resource.performedPeriod?.start,
-        [ProcedureClaim.Encounter]: referenceToValue(resource.encounter),
-        [ProcedureClaim.Identifier]: resource.identifier?.[0]?.value,
-        [ProcedureClaim.InstantiatesCanonical]: Array.isArray(resource.instantiatesCanonical) ? resource.instantiatesCanonical[0] : undefined,
-        [ProcedureClaim.InstantiatesUri]: Array.isArray(resource.instantiatesUri) ? resource.instantiatesUri[0] : undefined,
-        [ProcedureClaim.Location]: referenceToValue(resource.location),
-        [ProcedureClaim.PartOf]: referenceListToCsv(resource.partOf),
-        [ProcedureClaim.Patient]: referenceToValue(resource.subject),
-        [ProcedureClaim.Performer]: performer.length ? performer.join(',') : undefined,
-        [ProcedureClaim.ReasonCode]: codingToValue(resource.reasonCode?.[0]?.coding?.[0]),
-        [ProcedureClaim.ReasonReference]: referenceListToCsv(resource.reasonReference),
-        [ProcedureClaim.Status]: resource.status,
-        [ProcedureClaim.Subject]: referenceToValue(resource.subject),
-        [ProcedureClaim.Note]: resource.note?.[0]?.text,
-    };
-}

package/dist/utils/convert-related-person.d.ts

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

package/dist/utils/convert-related-person.js

@@ -1,31 +0,0 @@
-// Copyright 2026 Conéctate Soluciones y Aplicaciones SL under the Apache License, Version 2.0.
-// File: src/utils/convert-related-person.ts
-import { RelatedPersonClaim } from '../models/interoperable-claims/related-person-claims.js';
-import { codingFromValue, codingToValue, referenceToValue } from './convert-shared.js';
-export function relatedPersonFlatToFhirR4(claims) {
-    return {
-        resourceType: 'RelatedPerson',
-        identifier: claims[RelatedPersonClaim.Identifier] ? [{ value: claims[RelatedPersonClaim.Identifier] }] : undefined,
-        active: claims[RelatedPersonClaim.Active] === undefined ? undefined : claims[RelatedPersonClaim.Active] === 'true',
-        patient: claims[RelatedPersonClaim.Patient] ? { reference: claims[RelatedPersonClaim.Patient] } : undefined,
-        relationship: claims[RelatedPersonClaim.Relationship] ? [{ coding: codingFromValue(claims[RelatedPersonClaim.Relationship]) }] : undefined,
-        name: claims[RelatedPersonClaim.Name] ? [{ text: claims[RelatedPersonClaim.Name] }] : undefined,
-        telecom: claims[RelatedPersonClaim.Telecom] ? [{ value: claims[RelatedPersonClaim.Telecom] }] : undefined,
-        gender: claims[RelatedPersonClaim.Gender],
-        birthDate: claims[RelatedPersonClaim.BirthDate],
-        address: claims[RelatedPersonClaim.Address] ? [{ text: claims[RelatedPersonClaim.Address] }] : undefined,
-    };
-}
-export function relatedPersonFhirR4ToFlat(resource) {
-    return {
-        [RelatedPersonClaim.Identifier]: resource.identifier?.[0]?.value,
-        [RelatedPersonClaim.Active]: resource.active === undefined ? undefined : String(resource.active),
-        [RelatedPersonClaim.Patient]: referenceToValue(resource.patient),
-        [RelatedPersonClaim.Relationship]: codingToValue(resource.relationship?.[0]?.coding?.[0]),
-        [RelatedPersonClaim.Name]: resource.name?.[0]?.text,
-        [RelatedPersonClaim.Telecom]: resource.telecom?.[0]?.value,
-        [RelatedPersonClaim.Gender]: resource.gender,
-        [RelatedPersonClaim.BirthDate]: resource.birthDate,
-        [RelatedPersonClaim.Address]: resource.address?.[0]?.text,
-    };
-}

package/dist/utils/convert-shared.d.ts

@@ -1,34 +0,0 @@
-export type FlatClaims = Record<string, string | undefined>;
-export type FhirResource = Record<string, unknown> & {
-    resourceType: string;
-};
-export declare function isPlainObject(value: unknown): value is Record<string, unknown>;
-export declare function codingFromValue(value?: string): Array<{
-    system?: string;
-    code: string;
-}> | undefined;
-export declare function codingToValue(coding?: {
-    system?: string;
-    code?: string;
-}): string | undefined;
-export declare function referenceToValue(reference?: {
-    reference?: string;
-}): string | undefined;
-export declare function referenceListToCsv(references?: Array<{
-    reference?: string;
-}>): string | undefined;
-export declare function codingListToCsv(codings?: Array<{
-    system?: string;
-    code?: string;
-}>): string | undefined;
-export declare function requireClaim(claims: FlatClaims, key: string): string;
-export declare function requireSubjectIdentifier(value: string, key: string): void;
-export declare function requireDidWeb(value: string, key: string): void;
-/**
- * Generic structural fallback for unsupported resources.
- */
-export declare function fhirResourceToFlatClaims(resource: FhirResource, context?: string): FlatClaims;
-/**
- * Generic structural regeneration for unsupported resources.
- */
-export declare function flatClaimsToFhirResource(claims: FlatClaims): FhirResource;

package/dist/utils/convert-shared.js

@@ -1,179 +0,0 @@
-// Copyright 2026 Conéctate Soluciones y Aplicaciones SL under the Apache License, Version 2.0.
-// File: src/utils/convert-shared.ts
-export function isPlainObject(value) {
-    return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
-}
-export function codingFromValue(value) {
-    if (!value)
-        return undefined;
-    const [system, code] = value.split('|');
-    if (!code)
-        return [{ code: system }];
-    return [{ system, code }];
-}
-export function codingToValue(coding) {
-    if (!coding?.code)
-        return undefined;
-    return coding.system ? `${coding.system}|${coding.code}` : coding.code;
-}
-export function referenceToValue(reference) {
-    return reference?.reference;
-}
-export function referenceListToCsv(references) {
-    const values = (references || [])
-        .map((item) => item?.reference)
-        .filter((item) => Boolean(item));
-    return values.length ? values.join(',') : undefined;
-}
-export function codingListToCsv(codings) {
-    const values = (codings || [])
-        .map((item) => codingToValue(item))
-        .filter((item) => Boolean(item));
-    return values.length ? values.join(',') : undefined;
-}
-export function requireClaim(claims, key) {
-    const value = claims[key];
-    if (!value)
-        throw new Error(`Missing required claim: ${key}`);
-    return value;
-}
-export function requireSubjectIdentifier(value, key) {
-    if (!value.startsWith('urn:') && !value.startsWith('did:web:')) {
-        throw new Error(`Invalid ${key}: expected urn:* or did:web:*`);
-    }
-}
-export function requireDidWeb(value, key) {
-    if (!value.startsWith('did:web:')) {
-        throw new Error(`Invalid ${key}: expected did:web:*`);
-    }
-}
-function stringifyClaimLeaf(value) {
-    if (value === undefined || value === null)
-        return undefined;
-    if (typeof value === 'string')
-        return value;
-    if (typeof value === 'number' || typeof value === 'boolean')
-        return String(value);
-    return undefined;
-}
-function flattenClaimPath(prefix, value, out) {
-    const primitive = stringifyClaimLeaf(value);
-    if (primitive !== undefined) {
-        out[prefix] = primitive;
-        if (typeof value === 'number' || typeof value === 'boolean') {
-            out[`${prefix}#type`] = typeof value;
-        }
-        return;
-    }
-    if (Array.isArray(value)) {
-        value.forEach((entry, index) => {
-            flattenClaimPath(`${prefix}[${index}]`, entry, out);
-        });
-        return;
-    }
-    if (isPlainObject(value)) {
-        for (const [key, nestedValue] of Object.entries(value)) {
-            if (key === 'meta' && isPlainObject(nestedValue) && 'claims' in nestedValue) {
-                const nestedMeta = { ...nestedValue };
-                delete nestedMeta.claims;
-                if (Object.keys(nestedMeta).length === 0)
-                    continue;
-                flattenClaimPath(`${prefix}.${key}`, nestedMeta, out);
-                continue;
-            }
-            flattenClaimPath(`${prefix}.${key}`, nestedValue, out);
-        }
-    }
-}
-function parseClaimPath(path) {
-    const segments = [];
-    const re = /([^[.\]]+)|\[(\d+)\]/g;
-    let match;
-    while ((match = re.exec(path)) !== null) {
-        if (match[1])
-            segments.push(match[1]);
-        else if (match[2])
-            segments.push(Number(match[2]));
-    }
-    return segments;
-}
-function coerceClaimLeaf(value, typeHint) {
-    if (typeHint === 'boolean')
-        return value === 'true';
-    if (typeHint === 'number')
-        return Number(value);
-    return value;
-}
-function assignInflatedPath(target, path, value, typeHint) {
-    const segments = parseClaimPath(path);
-    if (segments.length === 0)
-        return;
-    let cursor = target;
-    for (let index = 0; index < segments.length; index += 1) {
-        const segment = segments[index];
-        const nextSegment = segments[index + 1];
-        const isLast = index === segments.length - 1;
-        if (typeof segment === 'number') {
-            if (!Array.isArray(cursor))
-                return;
-            if (isLast) {
-                cursor[segment] = coerceClaimLeaf(value, typeHint);
-                return;
-            }
-            if (cursor[segment] === undefined)
-                cursor[segment] = typeof nextSegment === 'number' ? [] : {};
-            cursor = cursor[segment];
-            continue;
-        }
-        if (!isPlainObject(cursor))
-            return;
-        if (isLast) {
-            cursor[segment] = coerceClaimLeaf(value, typeHint);
-            return;
-        }
-        if (cursor[segment] === undefined)
-            cursor[segment] = typeof nextSegment === 'number' ? [] : {};
-        cursor = cursor[segment];
-    }
-}
-/**
- * Generic structural fallback for unsupported resources.
- */
-export function fhirResourceToFlatClaims(resource, context = 'org.hl7.fhir.r4') {
-    if (!resource?.resourceType) {
-        throw new Error('FHIR resource must define resourceType.');
-    }
-    const out = { '@context': context };
-    for (const [key, value] of Object.entries(resource)) {
-        if (key === 'resourceType')
-            continue;
-        flattenClaimPath(`${resource.resourceType}.${key}`, value, out);
-    }
-    return out;
-}
-/**
- * Generic structural regeneration for unsupported resources.
- */
-export function flatClaimsToFhirResource(claims) {
-    const typeHints = new Map();
-    for (const [key, value] of Object.entries(claims || {})) {
-        if (key.endsWith('#type') && typeof value === 'string') {
-            typeHints.set(key.slice(0, -5), value);
-        }
-    }
-    const entries = Object.entries(claims || {}).filter(([key, value]) => key !== '@context' && !key.endsWith('#type') && value !== undefined);
-    const firstClaimKey = entries[0]?.[0];
-    if (!firstClaimKey || !firstClaimKey.includes('.')) {
-        throw new Error('Flat claims must contain at least one contextualized resource claim.');
-    }
-    const resourceType = firstClaimKey.split('.')[0];
-    const resource = { resourceType };
-    for (const [key, value] of entries) {
-        if (typeof value !== 'string')
-            continue;
-        if (!key.startsWith(`${resourceType}.`))
-            continue;
-        assignInflatedPath(resource, key.slice(resourceType.length + 1), value, typeHints.get(key));
-    }
-    return resource;
-}

package/dist/utils/coverage-claim-helpers.d.ts

@@ -1,10 +0,0 @@
-import { type GenericInteroperableClaims } from './claim-list-helpers.js';
-export type CoverageInteroperableClaims = GenericInteroperableClaims;
-export declare function getCoverageClaimList(claims: CoverageInteroperableClaims, claimKey: string): string[];
-export declare function setCoverageClaimList(claims: CoverageInteroperableClaims, claimKey: string, values: string | readonly string[]): CoverageInteroperableClaims;
-export declare function addCoverageClaimList(claims: CoverageInteroperableClaims, claimKey: string, values: string | readonly string[]): CoverageInteroperableClaims;
-export declare function removeCoverageClaimList(claims: CoverageInteroperableClaims, claimKey: string, values: string | readonly string[]): CoverageInteroperableClaims;
-export declare function getCoverageIdentifier(claims: CoverageInteroperableClaims): string;
-export declare function setCoverageIdentifier(claims: CoverageInteroperableClaims, value: string): CoverageInteroperableClaims;
-export declare function getCoveragePayorList(claims: CoverageInteroperableClaims): string[];
-export declare function setCoveragePayorList(claims: CoverageInteroperableClaims, values: string | readonly string[]): CoverageInteroperableClaims;

package/dist/utils/coverage-claim-helpers.js

@@ -1,26 +0,0 @@
-import { CoverageClaim } from '../models/interoperable-claims/coverage-claims.js';
-import { addClaimValues, getClaimValues, normalizeClaimScalar, removeClaimValues, setClaimValues, } from './claim-list-helpers.js';
-export function getCoverageClaimList(claims, claimKey) {
-    return getClaimValues(claims, claimKey);
-}
-export function setCoverageClaimList(claims, claimKey, values) {
-    return setClaimValues(claims, claimKey, values);
-}
-export function addCoverageClaimList(claims, claimKey, values) {
-    return addClaimValues(claims, claimKey, values);
-}
-export function removeCoverageClaimList(claims, claimKey, values) {
-    return removeClaimValues(claims, claimKey, values);
-}
-export function getCoverageIdentifier(claims) {
-    return normalizeClaimScalar(claims[CoverageClaim.Identifier]);
-}
-export function setCoverageIdentifier(claims, value) {
-    return { ...claims, [CoverageClaim.Identifier]: normalizeClaimScalar(value) };
-}
-export function getCoveragePayorList(claims) {
-    return getCoverageClaimList(claims, CoverageClaim.Payor);
-}
-export function setCoveragePayorList(claims, values) {
-    return setCoverageClaimList(claims, CoverageClaim.Payor, values);
-}

package/dist/utils/diagnostic-report-claim-helpers.d.ts

@@ -1,12 +0,0 @@
-import { type GenericInteroperableClaims } from './claim-list-helpers.js';
-export type DiagnosticReportInteroperableClaims = GenericInteroperableClaims;
-export declare function getDiagnosticReportClaimList(claims: DiagnosticReportInteroperableClaims, claimKey: string): string[];
-export declare function setDiagnosticReportClaimList(claims: DiagnosticReportInteroperableClaims, claimKey: string, values: string | readonly string[]): DiagnosticReportInteroperableClaims;
-export declare function addDiagnosticReportClaimList(claims: DiagnosticReportInteroperableClaims, claimKey: string, values: string | readonly string[]): DiagnosticReportInteroperableClaims;
-export declare function removeDiagnosticReportClaimList(claims: DiagnosticReportInteroperableClaims, claimKey: string, values: string | readonly string[]): DiagnosticReportInteroperableClaims;
-export declare function getDiagnosticReportIdentifier(claims: DiagnosticReportInteroperableClaims): string;
-export declare function setDiagnosticReportIdentifier(claims: DiagnosticReportInteroperableClaims, value: string): DiagnosticReportInteroperableClaims;
-export declare function getDiagnosticReportResultList(claims: DiagnosticReportInteroperableClaims): string[];
-export declare function setDiagnosticReportResultList(claims: DiagnosticReportInteroperableClaims, values: string | readonly string[]): DiagnosticReportInteroperableClaims;
-export declare function getDiagnosticReportContainedDocumentIdentifierList(claims: DiagnosticReportInteroperableClaims): string[];
-export declare function setDiagnosticReportContainedDocumentIdentifierList(claims: DiagnosticReportInteroperableClaims, values: string | readonly string[]): DiagnosticReportInteroperableClaims;

package/dist/utils/diagnostic-report-claim-helpers.js

@@ -1,32 +0,0 @@
-import { DiagnosticReportClaim } from '../models/interoperable-claims/diagnostic-report-claims.js';
-import { addClaimValues, getClaimValues, normalizeClaimScalar, removeClaimValues, setClaimValues, } from './claim-list-helpers.js';
-export function getDiagnosticReportClaimList(claims, claimKey) {
-    return getClaimValues(claims, claimKey);
-}
-export function setDiagnosticReportClaimList(claims, claimKey, values) {
-    return setClaimValues(claims, claimKey, values);
-}
-export function addDiagnosticReportClaimList(claims, claimKey, values) {
-    return addClaimValues(claims, claimKey, values);
-}
-export function removeDiagnosticReportClaimList(claims, claimKey, values) {
-    return removeClaimValues(claims, claimKey, values);
-}
-export function getDiagnosticReportIdentifier(claims) {
-    return normalizeClaimScalar(claims[DiagnosticReportClaim.Identifier]);
-}
-export function setDiagnosticReportIdentifier(claims, value) {
-    return { ...claims, [DiagnosticReportClaim.Identifier]: normalizeClaimScalar(value) };
-}
-export function getDiagnosticReportResultList(claims) {
-    return getDiagnosticReportClaimList(claims, DiagnosticReportClaim.Result);
-}
-export function setDiagnosticReportResultList(claims, values) {
-    return setDiagnosticReportClaimList(claims, DiagnosticReportClaim.Result, values);
-}
-export function getDiagnosticReportContainedDocumentIdentifierList(claims) {
-    return getDiagnosticReportClaimList(claims, DiagnosticReportClaim.ContainedDocuments);
-}
-export function setDiagnosticReportContainedDocumentIdentifierList(claims, values) {
-    return setDiagnosticReportClaimList(claims, DiagnosticReportClaim.ContainedDocuments, values);
-}