vet-sdk-core-ts 0.4.21 → 0.4.23

package/README.md

@@ -9,6 +9,15 @@ UHC SDK packages and must not import them.
 The SDK consumes governed browser-safe values from `vet-data-utils-ts` and
 owns gateway request construction. GW VET remains the policy authority.
 
+## Veterinary scheduling bundles
+
+The `vet-sdk-core-ts/scheduling` entrypoint extends the generic GW bundle
+boundary without changing `gdc-*`. It builds claims-first JSON:API batches,
+reads canonical `body.data[].resource` search matches and reconciles removed
+occupied Slots as pending Appointments plus durable rescheduling
+Communications. The same product extension can later be promoted for SOSChain
+or UHC/UNID after their resource policy is defined.
+
 ## Veterinary health-card issuance
 
 `issueVeterinaryHealthCardCredential(...)` accepts only an authoritative

package/dist/health-card-issuance.d.ts

@@ -1,5 +1,7 @@
 import { type PostQuantumCompanionProofQrOptions, type SmartHealthCardPayloadReferences } from 'vet-data-utils-ts/shc';
 import { type InternationalHealthCardPrintData } from 'vet-data-utils-ts/international-health-card';
+import { type ClinicalBundleReaderOptions } from 'vet-data-utils-ts/clinical-bundle-reader';
+import type { SmartHealthCardPayload } from 'vet-data-utils-ts/shc';
 export type VeterinaryHealthCardAttester = Readonly<{
     /** Signs the exact uncompressed, deterministic SHC payload as RFC 7797 JWS. */
     signDetachedPqc(payloadBytes: Uint8Array): Promise<string>;
@@ -44,3 +46,24 @@ export declare function verifyVeterinaryHealthCardCredential(input: Readonly<{
     pqcCompanionProofs: readonly boolean[];
     valid: boolean;
 }>>;
+/**
+ * Verifies every scanned proof before exposing the SHC Bundle to the shared
+ * IPS reader. Terminology enrichment runs only on a presentation copy after
+ * verification, so neither signature bytes nor payload hashes can change.
+ */
+export declare function readVerifiedVeterinaryHealthCardCredential(input: Readonly<{
+    shcQr: readonly string[];
+    pqcQr: readonly (readonly string[])[];
+    language: string;
+    verifyEs256(compactJws: string): Promise<boolean>;
+    verifyDetachedPqc(payloadBytes: Uint8Array, detachedJws: string): Promise<boolean>;
+    resolveTerminology: ClinicalBundleReaderOptions['resolveTerminology'];
+}>): Promise<Readonly<{
+    verification: Readonly<{
+        shc: boolean;
+        pqcCompanionProofs: readonly boolean[];
+        valid: boolean;
+    }>;
+    payload: SmartHealthCardPayload;
+    bundle: Record<string, unknown>;
+}>>;

package/dist/health-card-issuance.js

@@ -1,5 +1,6 @@
 import { assembleSmartHealthCardJws, buildSmartHealthCardPayloadReferences, decodePostQuantumCompanionProofQr, decodeSmartHealthCardPayloadBytes, decodeSmartHealthCardQr, encodePostQuantumCompanionProofUri, encodePostQuantumCompanionProofQr, encodeSmartHealthCardQr, prepareSmartHealthCard, } from 'vet-data-utils-ts/shc';
 import { buildInternationalHealthCardPrintData, } from 'vet-data-utils-ts/international-health-card';
+import { projectClinicalBundleForReading, } from 'vet-data-utils-ts/clinical-bundle-reader';
 /**
  * Issues transport values only after the caller supplies GW's authoritative
  * readback Bundle. The tenant issuer owns the standard ES256 signature. Every
@@ -54,3 +55,24 @@ export async function verifyVeterinaryHealthCardCredential(input) {
         valid: shc && pqcCompanionProofs.length > 0 && pqcCompanionProofs.every(Boolean),
     };
 }
+/**
+ * Verifies every scanned proof before exposing the SHC Bundle to the shared
+ * IPS reader. Terminology enrichment runs only on a presentation copy after
+ * verification, so neither signature bytes nor payload hashes can change.
+ */
+export async function readVerifiedVeterinaryHealthCardCredential(input) {
+    const compactJws = decodeSmartHealthCardQr(input.shcQr);
+    const payloadBytes = decodeSmartHealthCardPayloadBytes(compactJws);
+    const shc = await input.verifyEs256(compactJws);
+    const pqcCompanionProofs = await Promise.all(input.pqcQr.map(qrSet => (input.verifyDetachedPqc(payloadBytes, decodePostQuantumCompanionProofQr(qrSet)))));
+    const verification = {
+        shc,
+        pqcCompanionProofs,
+        valid: shc && pqcCompanionProofs.length > 0 && pqcCompanionProofs.every(Boolean),
+    };
+    if (!verification.valid)
+        throw new TypeError('veterinary_health_card_proof_invalid');
+    const payload = JSON.parse(new TextDecoder().decode(payloadBytes));
+    const bundle = await projectClinicalBundleForReading(payload.vc.credentialSubject.fhirBundle, { language: input.language, resolveTerminology: input.resolveTerminology });
+    return { verification, payload, bundle };
+}

package/dist/index.d.ts

@@ -7,4 +7,5 @@ export * from "./reusable-bff.js";
 export * from "./research-study.js";
 export * from "./payment.js";
 export * from "./health-card-issuance.js";
+export * from "./scheduling.js";
 export * from "vet-data-utils-ts";

package/dist/index.js

@@ -7,4 +7,5 @@ export * from "./reusable-bff.js";
 export * from "./research-study.js";
 export * from "./payment.js";
 export * from "./health-card-issuance.js";
+export * from "./scheduling.js";
 export * from "vet-data-utils-ts";

package/dist/scheduling.d.ts

@@ -0,0 +1,52 @@
+import { type VeterinarySchedulingFlatClaimsResource, type VeterinarySchedulingResourceType } from 'vet-data-utils-ts/scheduling';
+export type VeterinarySchedulingBatchMethod = 'POST' | 'PUT';
+export type VeterinarySchedulingBatch = Readonly<{
+    data: readonly Readonly<{
+        type: `${VeterinarySchedulingResourceType}-v5.0.0`;
+        resource: VeterinarySchedulingFlatClaimsResource;
+        request: Readonly<{
+            method: VeterinarySchedulingBatchMethod;
+            url: string;
+        }>;
+    }>[];
+}>;
+/**
+ * Extends the generic GW JSON:API batch boundary for VetChain scheduling.
+ * Resources are revalidated at this product boundary and remain claims-only.
+ */
+export declare function buildVeterinarySchedulingBatch(resources: readonly unknown[], method?: VeterinarySchedulingBatchMethod): VeterinarySchedulingBatch;
+/** Builds the governed claims-first search envelope accepted by GW VET. */
+export declare function buildVeterinarySchedulingSearch(resourceType: VeterinarySchedulingResourceType, claims: Readonly<Record<string, unknown>>): Readonly<{
+    data: readonly Readonly<{
+        resource: Readonly<{
+            resourceType: VeterinarySchedulingResourceType;
+            id: string;
+            meta: Readonly<{
+                claims: Readonly<Record<string, readonly string[]>>;
+            }>;
+        }>;
+    }>[];
+}>;
+/** Reads canonical GW search matches from `body.data[].resource`. */
+export declare function readVeterinarySchedulingSearch(body: unknown, expectedResourceType: VeterinarySchedulingResourceType): readonly VeterinarySchedulingFlatClaimsResource[];
+export type VeterinaryScheduleReconciliation = Readonly<{
+    appointments: readonly VeterinarySchedulingFlatClaimsResource[];
+    notifications: readonly Readonly<{
+        resourceType: 'Communication';
+        id: string;
+        meta: Readonly<{
+            claims: Readonly<Record<string, readonly string[]>>;
+        }>;
+    }>[];
+}>;
+/**
+ * Produces recoverable updates for bookings whose slots disappeared.
+ * It deliberately does not cancel: the patient receives a durable
+ * Communication and may choose another slot before a final decline.
+ */
+export declare function reconcileVeterinaryAppointmentsAfterSlotChange(input: Readonly<{
+    appointments: readonly unknown[];
+    availableSlotReferences: ReadonlySet<string>;
+    subjectReferenceFor: (appointment: VeterinarySchedulingFlatClaimsResource) => string;
+    reason: string;
+}>): VeterinaryScheduleReconciliation;

package/dist/scheduling.js

@@ -0,0 +1,88 @@
+import { buildVeterinaryAppointmentNotificationResource, normalizeVeterinarySchedulingFlatClaimsResource, } from 'vet-data-utils-ts/scheduling';
+const asArrayClaims = (claims) => Object.freeze(Object.fromEntries(Object.entries(claims).map(([name, raw]) => [
+    name,
+    Object.freeze((Array.isArray(raw) ? raw : [raw]).map(value => String(value))),
+])));
+/**
+ * Extends the generic GW JSON:API batch boundary for VetChain scheduling.
+ * Resources are revalidated at this product boundary and remain claims-only.
+ */
+export function buildVeterinarySchedulingBatch(resources, method = 'POST') {
+    return Object.freeze({
+        data: Object.freeze(resources.map(candidate => {
+            const resource = normalizeVeterinarySchedulingFlatClaimsResource(candidate);
+            return Object.freeze({
+                type: `${resource.resourceType}-v5.0.0`,
+                resource,
+                request: Object.freeze({ method, url: `${resource.resourceType}/${resource.id}` }),
+            });
+        })),
+    });
+}
+/** Builds the governed claims-first search envelope accepted by GW VET. */
+export function buildVeterinarySchedulingSearch(resourceType, claims) {
+    const resource = normalizeVeterinarySchedulingFlatClaimsResource({
+        resourceType,
+        id: 'search',
+        meta: { claims },
+    });
+    return Object.freeze({ data: Object.freeze([Object.freeze({ resource })]) });
+}
+/** Reads canonical GW search matches from `body.data[].resource`. */
+export function readVeterinarySchedulingSearch(body, expectedResourceType) {
+    if (!body || typeof body !== 'object' || !Array.isArray(body.data)) {
+        throw new TypeError('veterinary_scheduling_search_invalid');
+    }
+    return Object.freeze(body.data.map(entry => {
+        if (!entry || typeof entry !== 'object' || !('resource' in entry)) {
+            throw new TypeError('veterinary_scheduling_search_resource_invalid');
+        }
+        try {
+            const resource = normalizeVeterinarySchedulingFlatClaimsResource(entry.resource);
+            if (resource.resourceType !== expectedResourceType)
+                throw new Error('wrong type');
+            return resource;
+        }
+        catch {
+            throw new TypeError('veterinary_scheduling_search_resource_invalid');
+        }
+    }));
+}
+/**
+ * Produces recoverable updates for bookings whose slots disappeared.
+ * It deliberately does not cancel: the patient receives a durable
+ * Communication and may choose another slot before a final decline.
+ */
+export function reconcileVeterinaryAppointmentsAfterSlotChange(input) {
+    const appointments = [];
+    const notifications = [];
+    for (const candidate of input.appointments) {
+        const appointment = normalizeVeterinarySchedulingFlatClaimsResource(candidate);
+        if (appointment.resourceType !== 'Appointment')
+            throw new TypeError('veterinary_scheduling_appointment_required');
+        const slots = appointment.meta.claims['Appointment.slot'] ?? [];
+        if (slots.length > 0 && slots.every(slot => input.availableSlotReferences.has(slot)))
+            continue;
+        const updated = normalizeVeterinarySchedulingFlatClaimsResource({
+            ...appointment,
+            meta: { claims: {
+                    ...appointment.meta.claims,
+                    'Appointment.status': ['pending'],
+                    'VeterinaryAppointment.reschedulingReason': [input.reason],
+                } },
+        });
+        appointments.push(updated);
+        const notification = buildVeterinaryAppointmentNotificationResource({
+            id: `${appointment.id}-schedule-change`,
+            appointmentReference: `Appointment/${appointment.id}`,
+            subjectReference: input.subjectReferenceFor(appointment),
+            reason: input.reason,
+        });
+        notifications.push(Object.freeze({
+            resourceType: 'Communication',
+            id: notification.id,
+            meta: Object.freeze({ claims: asArrayClaims(notification.meta.claims) }),
+        }));
+    }
+    return Object.freeze({ appointments: Object.freeze(appointments), notifications: Object.freeze(notifications) });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vet-sdk-core-ts",
-  "version": "0.4.21",
+  "version": "0.4.23",
   "description": "Browser-safe VetChain core contracts and governed animal species identifiers",
   "license": "Apache-2.0",
   "author": "Connecting Solution & Applications Ltd",
@@ -47,6 +47,10 @@
     "./health-card-issuance": {
       "types": "./dist/health-card-issuance.d.ts",
       "default": "./dist/health-card-issuance.js"
+    },
+    "./scheduling": {
+      "types": "./dist/scheduling.d.ts",
+      "default": "./dist/scheduling.js"
     }
   },
   "files": [
@@ -72,6 +76,6 @@
   "dependencies": {
     "@noble/hashes": "^2.2.0",
     "gdc-common-utils-ts": "2.9.10",
-    "vet-data-utils-ts": "0.5.8"
+    "vet-data-utils-ts": "0.5.10"
   }
 }