vet-data-utils-ts 0.5.31 → 0.5.32

package/dist/immunization-draft.d.ts

@@ -0,0 +1,43 @@
+import { type FlatClaimResourceEntry } from 'sos-data-utils-ts/flat-claim-resource-graph';
+import { type VeterinaryImmunizationCoding } from './immunization-flat-claims.js';
+export type VeterinaryImmunizationDraftAttachment = Readonly<{
+    entryId: string;
+    identifier: string;
+    contentType: 'application/pdf' | 'image/jpeg' | 'image/png';
+    contentHash: string;
+    title?: string;
+    dataBase64?: string;
+}>;
+export type VeterinaryImmunizationDraft = Readonly<{
+    status: 'preparation' | 'confirmed';
+    administrationDate: string;
+    vaccineCode: VeterinaryImmunizationCoding;
+    targetDiseases: readonly VeterinaryImmunizationCoding[];
+    productName?: string;
+    productCode?: VeterinaryImmunizationCoding;
+    productIdentifiers: readonly Readonly<{
+        system: string;
+        value: string;
+    }>[];
+    manufacturer?: string;
+    lotNumber?: string;
+    productExpirationDate?: string;
+    barcode?: string;
+    routeCode?: string;
+    siteCode?: string;
+    doseValue?: string;
+    doseUnit?: string;
+    nextDoseDate?: string;
+    attachments: readonly VeterinaryImmunizationDraftAttachment[];
+    confirmedAt?: string;
+}>;
+/** Normalizes the same reviewable draft for web, chat, WhatsApp and telephone adapters. */
+export declare function prepareVeterinaryImmunizationDraft(input: Partial<Omit<VeterinaryImmunizationDraft, 'status' | 'confirmedAt'>>): VeterinaryImmunizationDraft;
+/** Records the channel's explicit human readback/preview confirmation. */
+export declare function confirmVeterinaryImmunizationDraft(draft: VeterinaryImmunizationDraft, confirmedAt: string): VeterinaryImmunizationDraft;
+/** Completes a confirmed channel draft with server-owned subject and performer coordinates. */
+export declare function materializeVeterinaryImmunizationDraft(draft: VeterinaryImmunizationDraft, context: Readonly<{
+    entryId: string;
+    animalReference: string;
+    performerReference: string;
+}>): readonly FlatClaimResourceEntry[];

package/dist/immunization-draft.js

@@ -0,0 +1,94 @@
+import { buildDocumentReferenceFlatEntry } from 'sos-data-utils-ts/flat-claim-resource-graph';
+import { buildVeterinaryImmunizationFlatGraph, } from './immunization-flat-claims.js';
+/** Normalizes the same reviewable draft for web, chat, WhatsApp and telephone adapters. */
+export function prepareVeterinaryImmunizationDraft(input) {
+    const administrationDate = date(input.administrationDate, 'veterinary_immunization_date_invalid');
+    const vaccineCode = coding(input.vaccineCode, 'veterinary_immunization_vaccine_code_required');
+    const productExpirationDate = input.productExpirationDate ? date(input.productExpirationDate, 'veterinary_medication_expiration_date_invalid') : undefined;
+    const nextDoseDate = input.nextDoseDate ? date(input.nextDoseDate, 'veterinary_immunization_next_dose_date_invalid') : undefined;
+    return Object.freeze({
+        status: 'preparation', administrationDate, vaccineCode,
+        targetDiseases: Object.freeze((input.targetDiseases ?? []).map((value) => coding(value, 'veterinary_immunization_target_disease_invalid'))),
+        ...(text(input.productName) ? { productName: text(input.productName) } : {}),
+        ...(input.productCode ? { productCode: coding(input.productCode, 'veterinary_immunization_product_code_invalid') } : {}),
+        productIdentifiers: Object.freeze((input.productIdentifiers ?? []).map(({ system, value }) => Object.freeze({
+            system: required(system, 'veterinary_immunization_product_identifier_invalid'),
+            value: required(value, 'veterinary_immunization_product_identifier_invalid'),
+        }))),
+        ...(text(input.manufacturer) ? { manufacturer: text(input.manufacturer) } : {}),
+        ...(text(input.lotNumber) ? { lotNumber: text(input.lotNumber) } : {}),
+        ...(productExpirationDate ? { productExpirationDate } : {}),
+        ...(text(input.barcode) ? { barcode: text(input.barcode) } : {}),
+        ...(text(input.routeCode) ? { routeCode: text(input.routeCode) } : {}),
+        ...(text(input.siteCode) ? { siteCode: text(input.siteCode) } : {}),
+        ...(text(input.doseValue) ? { doseValue: text(input.doseValue) } : {}),
+        ...(text(input.doseUnit) ? { doseUnit: text(input.doseUnit) } : {}),
+        ...(nextDoseDate ? { nextDoseDate } : {}),
+        attachments: Object.freeze([...(input.attachments ?? [])]),
+    });
+}
+/** Records the channel's explicit human readback/preview confirmation. */
+export function confirmVeterinaryImmunizationDraft(draft, confirmedAt) {
+    if (draft.status !== 'preparation')
+        throw new TypeError('veterinary_immunization_draft_already_confirmed');
+    const instant = required(confirmedAt, 'veterinary_immunization_confirmation_time_required');
+    if (Number.isNaN(Date.parse(instant)))
+        throw new TypeError('veterinary_immunization_confirmation_time_invalid');
+    return Object.freeze({ ...draft, status: 'confirmed', confirmedAt: instant });
+}
+/** Completes a confirmed channel draft with server-owned subject and performer coordinates. */
+export function materializeVeterinaryImmunizationDraft(draft, context) {
+    if (draft.status !== 'confirmed')
+        throw new TypeError('veterinary_immunization_draft_confirmation_required');
+    const attachments = draft.attachments.map(attachment => buildDocumentReferenceFlatEntry(attachment));
+    const hasMedication = Boolean(draft.productName || draft.productCode || draft.productIdentifiers.length
+        || draft.manufacturer || draft.lotNumber || draft.productExpirationDate || draft.barcode);
+    return buildVeterinaryImmunizationFlatGraph({
+        entryId: required(context.entryId, 'veterinary_immunization_entry_id_required'),
+        animalReference: required(context.animalReference, 'veterinary_immunization_animal_reference_required'),
+        performerReference: required(context.performerReference, 'veterinary_immunization_performer_required'),
+        administrationDate: draft.administrationDate,
+        vaccineCode: draft.vaccineCode,
+        targetDiseases: draft.targetDiseases,
+        ...(draft.routeCode ? { route: { system: 'http://terminology.hl7.org/CodeSystem/v3-RouteOfAdministration', code: draft.routeCode } } : {}),
+        ...(draft.siteCode ? { site: { system: 'http://terminology.hl7.org/CodeSystem/v3-ActSite', code: draft.siteCode } } : {}),
+        ...(draft.doseValue ? { dose: { value: draft.doseValue, ...(draft.doseUnit ? { unit: draft.doseUnit } : {}) } } : {}),
+        ...(draft.nextDoseDate ? { nextDoseDate: draft.nextDoseDate } : {}),
+        ...(hasMedication ? { medication: {
+                entryId: `${context.entryId}-medication`,
+                productName: draft.productName || draft.vaccineCode.display || `${draft.vaccineCode.system}|${draft.vaccineCode.code}`,
+                ...(draft.productCode ? { productCode: draft.productCode } : {}),
+                identifiers: draft.productIdentifiers,
+                ...(draft.manufacturer ? { manufacturer: draft.manufacturer } : {}),
+                ...(draft.lotNumber ? { lotNumber: draft.lotNumber } : {}),
+                ...(draft.productExpirationDate ? { expirationDate: draft.productExpirationDate } : {}),
+                ...(draft.barcode ? { barcode: draft.barcode } : {}),
+            } } : {}),
+        attachments,
+        attachmentEntryIds: attachments.map(({ entryId }) => entryId),
+    });
+}
+function coding(value, error) {
+    if (!value || typeof value !== 'object')
+        throw new TypeError(error);
+    const candidate = value;
+    return Object.freeze({
+        system: required(candidate.system, error), code: required(candidate.code, error),
+        ...(text(candidate.display) ? { display: text(candidate.display) } : {}),
+    });
+}
+function date(value, error) {
+    const normalized = required(value, error);
+    if (!/^\d{4}-\d{2}-\d{2}$/.test(normalized) || Number.isNaN(Date.parse(normalized)))
+        throw new TypeError(error);
+    return normalized;
+}
+function required(value, error) {
+    const normalized = text(value);
+    if (!normalized)
+        throw new TypeError(error);
+    return normalized;
+}
+function text(value) {
+    return typeof value === 'string' ? value.trim() : '';
+}

package/dist/immunization-flat-claims.d.ts

@@ -0,0 +1,55 @@
+import { type FlatClaimResourceEntry } from 'sos-data-utils-ts/flat-claim-resource-graph';
+export type VeterinaryImmunizationCoding = Readonly<{
+    system: string;
+    code: string;
+    display?: string;
+}>;
+export type VeterinaryImmunizationFlatInput = Readonly<{
+    entryId: string;
+    identifier?: string;
+    animalReference: string;
+    administrationDate: string;
+    vaccineCode: VeterinaryImmunizationCoding;
+    performerReference: string;
+    targetDiseases?: readonly VeterinaryImmunizationCoding[];
+    route?: VeterinaryImmunizationCoding;
+    site?: VeterinaryImmunizationCoding;
+    dose?: Readonly<{
+        value: string;
+        unit?: string;
+    }>;
+    nextDoseDate?: string;
+    medication?: Readonly<{
+        entryId: string;
+        productName: string;
+        productCode?: VeterinaryImmunizationCoding;
+        identifiers?: readonly Readonly<{
+            system: string;
+            value: string;
+        }>[];
+        manufacturer?: string;
+        lotNumber?: string;
+        expirationDate?: string;
+        barcode?: string;
+    }>;
+    attachments?: readonly FlatClaimResourceEntry[];
+    attachmentEntryIds?: readonly string[];
+}>;
+/**
+ * Creates a version-neutral flat graph. SearchParameter names are preferred
+ * (`Immunization.date`, `Medication.expiration-date`) and product evidence is
+ * kept in Medication instead of overloading credential validity.
+ */
+export declare function buildVeterinaryImmunizationFlatGraph(input: VeterinaryImmunizationFlatInput): readonly FlatClaimResourceEntry[];
+export type FhirExportRelease = 'R4' | 'R5' | 'R6';
+/** Explicit adapter boundary from canonical flat claims to a selected FHIR release. */
+export declare function exportVeterinaryImmunizationFlatGraph(graph: readonly FlatClaimResourceEntry[], release: FhirExportRelease): Readonly<{
+    resourceType: 'Bundle';
+    type: 'collection';
+    entry: readonly Readonly<{
+        fullUrl: string;
+        resource: Record<string, unknown>;
+    }>[];
+}>;
+/** De-identified three-event fixture based on the supplied Canadian certificate; no owner contact data is retained. */
+export declare const NALA_VACCINATION_FLAT_GRAPH_TEST_DATA: readonly FlatClaimResourceEntry[];

package/dist/immunization-flat-claims.js

@@ -0,0 +1,224 @@
+import { buildDocumentReferenceFlatEntry, buildFlatClaimResourceEntry, linkFlatClaimResourceEntries, } from 'sos-data-utils-ts/flat-claim-resource-graph';
+/**
+ * Creates a version-neutral flat graph. SearchParameter names are preferred
+ * (`Immunization.date`, `Medication.expiration-date`) and product evidence is
+ * kept in Medication instead of overloading credential validity.
+ */
+export function buildVeterinaryImmunizationFlatGraph(input) {
+    const vaccineCode = codingToken(input.vaccineCode);
+    const claims = {
+        'Immunization.status': 'completed',
+        'Immunization.patient': required(input.animalReference, 'veterinary_immunization_animal_reference_required'),
+        'Immunization.date': isoDate(input.administrationDate, 'veterinary_immunization_date_invalid'),
+        'Immunization.vaccine-code': vaccineCode,
+        'Immunization.performer': required(input.performerReference, 'veterinary_immunization_performer_required'),
+    };
+    if (input.identifier)
+        claims['Immunization.identifier'] = required(input.identifier, 'veterinary_immunization_identifier_invalid');
+    if (input.vaccineCode.display)
+        claims['Immunization.vaccine-code-display'] = input.vaccineCode.display.trim();
+    if (input.targetDiseases?.length)
+        claims['Immunization.target-disease'] = input.targetDiseases.map(codingToken).join(',');
+    if (input.route)
+        claims['Immunization.route'] = codingToken(input.route);
+    if (input.site)
+        claims['Immunization.site'] = codingToken(input.site);
+    if (input.dose) {
+        claims['Immunization.dose-quantity-value'] = required(input.dose.value, 'veterinary_immunization_dose_invalid');
+        if (input.dose.unit)
+            claims['Immunization.dose-quantity-unit'] = input.dose.unit.trim();
+    }
+    const immunization = buildFlatClaimResourceEntry({ entryId: input.entryId, resourceType: 'Immunization', claims });
+    const children = [];
+    if (input.medication)
+        children.push(buildMedicationEntry(input.medication));
+    if (input.nextDoseDate) {
+        children.push(buildFlatClaimResourceEntry({
+            entryId: `${input.entryId}-recommendation`,
+            resourceType: 'ImmunizationRecommendation',
+            claims: {
+                'ImmunizationRecommendation.patient': input.animalReference,
+                'ImmunizationRecommendation.date': isoDate(input.nextDoseDate, 'veterinary_immunization_next_dose_date_invalid'),
+                'ImmunizationRecommendation.vaccine-code': vaccineCode,
+            },
+        }));
+    }
+    for (const attachment of input.attachments ?? []) {
+        if (attachment.resourceType !== 'DocumentReference')
+            throw new TypeError('veterinary_immunization_attachment_invalid');
+        children.push(attachment);
+    }
+    const graph = uniqueEntries([immunization, ...children]);
+    const childEntryIds = [
+        ...(input.medication ? [input.medication.entryId] : []),
+        ...(input.nextDoseDate ? [`${input.entryId}-recommendation`] : []),
+        ...(input.attachmentEntryIds ?? []),
+    ];
+    return childEntryIds.length
+        ? linkFlatClaimResourceEntries(graph, { parentEntryId: input.entryId, childEntryIds })
+        : graph;
+}
+function buildMedicationEntry(input) {
+    const claims = {
+        'Medication.code': input.productCode ? codingToken(input.productCode) : required(input.productName, 'veterinary_medication_product_required'),
+        'Medication.code-text': required(input.productName, 'veterinary_medication_product_required'),
+    };
+    if (input.identifiers?.length) {
+        claims['Medication.identifier'] = input.identifiers.map(({ system, value }) => (`${required(system, 'veterinary_medication_identifier_invalid')}|${required(value, 'veterinary_medication_identifier_invalid')}`)).join(',');
+    }
+    if (input.manufacturer)
+        claims['Medication.manufacturer'] = input.manufacturer.trim();
+    if (input.lotNumber)
+        claims['Medication.lot-number'] = input.lotNumber.trim();
+    if (input.expirationDate)
+        claims['Medication.expiration-date'] = isoDate(input.expirationDate, 'veterinary_medication_expiration_date_invalid');
+    if (input.barcode)
+        claims['Medication.serial-number'] = input.barcode.trim();
+    return buildFlatClaimResourceEntry({ entryId: input.entryId, resourceType: 'Medication', claims });
+}
+/** Explicit adapter boundary from canonical flat claims to a selected FHIR release. */
+export function exportVeterinaryImmunizationFlatGraph(graph, release) {
+    const byReference = new Map(graph.map((entry) => [entry.reference, entry]));
+    return Object.freeze({
+        resourceType: 'Bundle',
+        type: 'collection',
+        entry: Object.freeze(graph.map((entry) => Object.freeze({
+            fullUrl: entry.reference,
+            resource: exportEntry(entry, release, byReference),
+        }))),
+    });
+}
+function exportEntry(entry, release, byReference) {
+    const claims = entry.claims;
+    if (entry.resourceType === 'Immunization') {
+        const vaccineCode = codeableConcept(claims['Immunization.vaccine-code'], claims['Immunization.vaccine-code-display']);
+        const children = splitCsv(claims['Immunization.contained-reference-list']).map((reference) => byReference.get(reference)).filter(Boolean);
+        const medication = children.find((child) => child?.resourceType === 'Medication');
+        const resource = {
+            resourceType: 'Immunization', id: entry.entryId, status: claims['Immunization.status'],
+            vaccineCode, patient: { reference: claims['Immunization.patient'] },
+            occurrenceDateTime: claims['Immunization.date'],
+            performer: [{ actor: { reference: claims['Immunization.performer'] } }],
+        };
+        if (claims['Immunization.identifier'])
+            resource.identifier = [{ value: claims['Immunization.identifier'] }];
+        if (claims['Immunization.route'])
+            resource.route = codeableConcept(claims['Immunization.route']);
+        if (claims['Immunization.site'])
+            resource.site = codeableConcept(claims['Immunization.site']);
+        if (claims['Immunization.target-disease'])
+            resource.protocolApplied = [{ targetDisease: splitCsv(claims['Immunization.target-disease']).map((code) => codeableConcept(code)) }];
+        if (medication && release !== 'R4')
+            resource.administeredProduct = { reference: { reference: medication.reference } };
+        return resource;
+    }
+    if (entry.resourceType === 'Medication') {
+        const lotNumber = claims['Medication.lot-number'];
+        const expirationDate = claims['Medication.expiration-date'];
+        const resource = {
+            resourceType: 'Medication', id: entry.entryId,
+            code: codeableConcept(claims['Medication.code'], claims['Medication.code-text']),
+        };
+        if (claims['Medication.identifier'])
+            resource.identifier = splitCsv(claims['Medication.identifier']).map(identifierFromToken);
+        if (lotNumber || expirationDate)
+            resource[release === 'R6' ? 'instance' : 'batch'] = {
+                ...(lotNumber ? { lotNumber } : {}), ...(expirationDate ? { expirationDate } : {}),
+            };
+        return resource;
+    }
+    if (entry.resourceType === 'ImmunizationRecommendation')
+        return {
+            resourceType: 'ImmunizationRecommendation', id: entry.entryId,
+            patient: { reference: claims['ImmunizationRecommendation.patient'] },
+            date: claims['ImmunizationRecommendation.date'],
+            recommendation: [{ vaccineCode: [codeableConcept(claims['ImmunizationRecommendation.vaccine-code'])] }],
+        };
+    if (entry.resourceType === 'DocumentReference')
+        return {
+            resourceType: 'DocumentReference', id: entry.entryId, status: 'current',
+            identifier: [{ value: claims['DocumentReference.identifier'] }],
+            content: [{ attachment: {
+                        contentType: claims['DocumentReference.content-type'],
+                        ...(claims['DocumentReference.url'] ? { url: claims['DocumentReference.url'] } : {}),
+                        ...(claims['DocumentReference.title'] ? { title: claims['DocumentReference.title'] } : {}),
+                    } }],
+        };
+    return { resourceType: entry.resourceType, id: entry.entryId, meta: { claims: { ...claims } } };
+}
+function codeableConcept(token, display) {
+    const value = required(token, 'veterinary_coding_required');
+    const separator = value.lastIndexOf('|');
+    if (separator <= 0 || separator === value.length - 1)
+        return { text: display || value };
+    return { coding: [{ system: value.slice(0, separator), code: value.slice(separator + 1), ...(display ? { display } : {}) }] };
+}
+function identifierFromToken(token) {
+    const separator = token.lastIndexOf('|');
+    return separator > 0 ? { system: token.slice(0, separator), value: token.slice(separator + 1) } : { value: token };
+}
+function codingToken(coding) {
+    return `${required(coding.system, 'veterinary_coding_system_required')}|${required(coding.code, 'veterinary_coding_code_required')}`;
+}
+function isoDate(value, error) {
+    const normalized = required(value, error);
+    if (!/^\d{4}-\d{2}-\d{2}(?:T.*)?$/.test(normalized) || Number.isNaN(Date.parse(normalized)))
+        throw new TypeError(error);
+    return normalized;
+}
+function required(value, error) {
+    if (typeof value !== 'string' || !value.trim())
+        throw new TypeError(error);
+    return value.trim();
+}
+function splitCsv(value) {
+    return value?.split(',').map((item) => item.trim()).filter(Boolean) ?? [];
+}
+function uniqueEntries(entries) {
+    const byId = new Map();
+    for (const entry of entries) {
+        const existing = byId.get(entry.entryId);
+        if (existing && existing.reference !== entry.reference)
+            throw new TypeError('flat_claim_entry_id_collision');
+        byId.set(entry.entryId, existing ?? entry);
+    }
+    return Object.freeze([...byId.values()]);
+}
+const atcVet = 'http://www.whocc.no/atcvet';
+const certificate = buildDocumentReferenceFlatEntry({
+    entryId: 'nala-vaccination-certificate', identifier: 'urn:uuid:nala-vaccination-certificate',
+    contentType: 'image/jpeg', contentHash: 'sha256:test-only-nala-certificate-digest', title: 'Vaccination certificate',
+});
+/** De-identified three-event fixture based on the supplied Canadian certificate; no owner contact data is retained. */
+export const NALA_VACCINATION_FLAT_GRAPH_TEST_DATA = uniqueEntries([
+    ...buildVeterinaryImmunizationFlatGraph({
+        entryId: 'nala-rabies', animalReference: 'Patient/nala', administrationDate: '2024-05-23',
+        performerReference: 'PractitionerRole/certificate-veterinarian',
+        vaccineCode: { system: atcVet, code: 'QI07AA02', display: 'Inactivated rabies virus vaccines' },
+        targetDiseases: [{ system: 'http://snomed.info/sct', code: '14168008', display: 'Rabies' }],
+        nextDoseDate: '2027-05-23',
+        medication: {
+            entryId: 'nala-rabies-product', productName: 'Imrab 3 TF',
+            productCode: { system: atcVet, code: 'QI07AA02' }, manufacturer: 'Boehringer Ingelheim',
+            identifiers: [
+                { system: 'https://inspection.canada.ca/ccvb', value: '820VV/R1.14/R2.1' },
+                { system: 'https://www.aphis.usda.gov/cvb/product-code', value: '1905.26' },
+            ],
+            lotNumber: '18595', expirationDate: '2025-06-28',
+        },
+        route: { system: 'http://terminology.hl7.org/CodeSystem/v3-RouteOfAdministration', code: 'SQ', display: 'Subcutaneous' },
+        attachments: [certificate], attachmentEntryIds: [certificate.entryId],
+    }),
+    ...buildVeterinaryImmunizationFlatGraph({
+        entryId: 'nala-da2plp', animalReference: 'Patient/nala', administrationDate: '2024-05-23',
+        performerReference: 'PractitionerRole/certificate-veterinarian',
+        vaccineCode: { system: atcVet, code: 'QI07AI02', display: 'Canine viral and bacterial combination vaccines' },
+        nextDoseDate: '2025-05-23', attachments: [certificate], attachmentEntryIds: [certificate.entryId],
+    }),
+    ...buildVeterinaryImmunizationFlatGraph({
+        entryId: 'nala-lyme', animalReference: 'Patient/nala', administrationDate: '2024-05-23',
+        performerReference: 'PractitionerRole/certificate-veterinarian',
+        vaccineCode: { system: atcVet, code: 'QI07AB04', display: 'Borrelia vaccines' },
+        nextDoseDate: '2025-05-23', attachments: [certificate], attachmentEntryIds: [certificate.entryId],
+    }),
+]);

package/dist/index.d.ts

@@ -10,6 +10,8 @@ export * from './financial.js';
 export * from './group.js';
 export * from './health-dcat.js';
 export * from './immunization.js';
+export * from './immunization-flat-claims.js';
+export * from './immunization-draft.js';
 export * from './international-health-card.js';
 export * from './index-projection-tags.js';
 export * from './insurance-consent.js';

package/dist/index.js

@@ -10,6 +10,8 @@ export * from './financial.js';
 export * from './group.js';
 export * from './health-dcat.js';
 export * from './immunization.js';
+export * from './immunization-flat-claims.js';
+export * from './immunization-draft.js';
 export * from './international-health-card.js';
 export * from './index-projection-tags.js';
 export * from './insurance-consent.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vet-data-utils-ts",
-  "version": "0.5.31",
+  "version": "0.5.32",
   "description": "Browser-safe governed VetChain data contracts",
   "license": "Apache-2.0",
   "author": "Connecting Solution & Applications Ltd",
@@ -56,6 +56,14 @@
       "types": "./dist/immunization.d.ts",
       "default": "./dist/immunization.js"
     },
+    "./immunization-flat-claims": {
+      "types": "./dist/immunization-flat-claims.d.ts",
+      "default": "./dist/immunization-flat-claims.js"
+    },
+    "./immunization-draft": {
+      "types": "./dist/immunization-draft.d.ts",
+      "default": "./dist/immunization-draft.js"
+    },
     "./international-health-card": {
       "types": "./dist/international-health-card.d.ts",
       "default": "./dist/international-health-card.js"
@@ -142,7 +150,8 @@
   },
   "dependencies": {
     "gdc-common-utils-ts": "2.9.12",
-    "pako": "^2.2.0"
+    "pako": "^2.2.0",
+    "sos-data-utils-ts": "0.3.1"
   },
   "engines": {
     "node": ">=20"