vet-sdk-core-ts 0.4.24 → 0.4.26

package/dist/scheduling.d.ts

@@ -1,62 +1,62 @@
-import { type VeterinarySchedulingFlatClaimsResource, type VeterinarySchedulingResourceType } from 'vet-data-utils-ts/scheduling';
-export type VeterinarySchedulingBatchMethod = 'POST' | 'PUT';
-export type VeterinarySchedulingBatch = Readonly<{
+import { type SchedulingFlatClaimsResource, type SchedulingResourceType } from 'vet-data-utils-ts/scheduling';
+export type SchedulingBatchMethod = 'POST' | 'PUT';
+export type SchedulingBatch = Readonly<{
     data: readonly Readonly<{
-        type: `${VeterinarySchedulingResourceType}-v5.0.0`;
-        resource: VeterinarySchedulingFlatClaimsResource;
+        type: `${SchedulingResourceType}-v5.0.0`;
+        resource: SchedulingFlatClaimsResource;
         request: Readonly<{
-            method: VeterinarySchedulingBatchMethod;
+            method: SchedulingBatchMethod;
             url: string;
         }>;
     }>[];
 }>;
 /**
- * Extends the generic GW JSON:API batch boundary for VetChain scheduling.
- * Resources are revalidated at this product boundary and remain claims-only.
+ * Extends the generic GW JSON:API batch boundary for reusable scheduling.
+ * Resources are revalidated at this product boundary; only SearchParameters are indexed.
  */
-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<{
+export declare function buildSchedulingBatch(resources: readonly unknown[], method?: SchedulingBatchMethod): SchedulingBatch;
+/** Builds the governed claims-first search envelope accepted by a GW. */
+export declare function buildSchedulingSearch(resourceType: SchedulingResourceType, claims: Readonly<Record<string, unknown>>): Readonly<{
     data: readonly Readonly<{
-        resource: Readonly<{
-            resourceType: VeterinarySchedulingResourceType;
+        resource: Readonly<Record<string, unknown> & {
+            resourceType: SchedulingResourceType;
             id: string;
-            meta: Readonly<{
+            meta: Readonly<Record<string, unknown> & {
                 claims: Readonly<Record<string, readonly string[]>>;
             }>;
         }>;
     }>[];
 }>;
-/** Builds the clinic-wide `_search` envelope for responses recorded inside an inclusive time period. */
-export declare function buildVeterinaryAppointmentResponseSearchPeriod(input: Readonly<{
+/** Builds the organization-wide `_search` envelope for responses recorded inside an inclusive time period. */
+export declare function buildAppointmentResponseSearchPeriod(input: Readonly<{
     from: string;
     to: string;
 }>): Readonly<{
     data: readonly Readonly<{
-        resource: Readonly<{
-            resourceType: VeterinarySchedulingResourceType;
+        resource: Readonly<Record<string, unknown> & {
+            resourceType: SchedulingResourceType;
             id: string;
-            meta: Readonly<{
+            meta: Readonly<Record<string, unknown> & {
                 claims: Readonly<Record<string, readonly string[]>>;
             }>;
         }>;
     }>[];
 }>;
-export type VeterinaryAppointmentResponseEmailPayload = Readonly<{
+export type AppointmentResponseEmailPayload = Readonly<{
     to: string;
     subject: string;
     text: string;
     metadata: Readonly<Record<string, string>>;
 }>;
 /** Converts the governed English AppointmentResponse Communication projection into an email-adapter payload. */
-export declare function convertVeterinaryAppointmentResponseCommunicationToEnglishEmail(input: Readonly<{
+export declare function convertAppointmentResponseCommunicationToEnglishEmail(input: Readonly<{
     recipientEmail: string;
     communication: unknown;
-}>): VeterinaryAppointmentResponseEmailPayload;
+}>): AppointmentResponseEmailPayload;
 /** 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[];
+export declare function readSchedulingSearch(body: unknown, expectedResourceType: SchedulingResourceType): readonly SchedulingFlatClaimsResource[];
+export type ScheduleReconciliation = Readonly<{
+    appointments: readonly SchedulingFlatClaimsResource[];
     notifications: readonly Readonly<{
         resourceType: 'Communication';
         id: string;
@@ -70,9 +70,29 @@ export type VeterinaryScheduleReconciliation = Readonly<{
  * 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<{
+export declare function reconcileAppointmentsAfterSlotChange(input: Readonly<{
     appointments: readonly unknown[];
     availableSlotReferences: ReadonlySet<string>;
-    subjectReferenceFor: (appointment: VeterinarySchedulingFlatClaimsResource) => string;
+    subjectReferenceFor: (appointment: SchedulingFlatClaimsResource) => string;
     reason: string;
-}>): VeterinaryScheduleReconciliation;
+}>): ScheduleReconciliation;
+/** @deprecated Use {@link SchedulingBatchMethod}. */
+export type VeterinarySchedulingBatchMethod = SchedulingBatchMethod;
+/** @deprecated Use {@link SchedulingBatch}. */
+export type VeterinarySchedulingBatch = SchedulingBatch;
+/** @deprecated Use {@link buildSchedulingBatch}. */
+export declare const buildVeterinarySchedulingBatch: typeof buildSchedulingBatch;
+/** @deprecated Use {@link buildSchedulingSearch}. */
+export declare const buildVeterinarySchedulingSearch: typeof buildSchedulingSearch;
+/** @deprecated Use {@link buildAppointmentResponseSearchPeriod}. */
+export declare const buildVeterinaryAppointmentResponseSearchPeriod: typeof buildAppointmentResponseSearchPeriod;
+/** @deprecated Use {@link AppointmentResponseEmailPayload}. */
+export type VeterinaryAppointmentResponseEmailPayload = AppointmentResponseEmailPayload;
+/** @deprecated Use {@link convertAppointmentResponseCommunicationToEnglishEmail}. */
+export declare const convertVeterinaryAppointmentResponseCommunicationToEnglishEmail: typeof convertAppointmentResponseCommunicationToEnglishEmail;
+/** @deprecated Use {@link readSchedulingSearch}. */
+export declare const readVeterinarySchedulingSearch: typeof readSchedulingSearch;
+/** @deprecated Use {@link ScheduleReconciliation}. */
+export type VeterinaryScheduleReconciliation = ScheduleReconciliation;
+/** @deprecated Use {@link reconcileAppointmentsAfterSlotChange}. */
+export declare const reconcileVeterinaryAppointmentsAfterSlotChange: typeof reconcileAppointmentsAfterSlotChange;

package/dist/scheduling.js

@@ -1,16 +1,16 @@
-import { buildVeterinaryAppointmentNotificationResource, normalizeVeterinarySchedulingFlatClaimsResource, } from 'vet-data-utils-ts/scheduling';
+import { buildAppointmentNotificationResource, normalizeSchedulingFlatClaimsResource, } 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.
+ * Extends the generic GW JSON:API batch boundary for reusable scheduling.
+ * Resources are revalidated at this product boundary; only SearchParameters are indexed.
  */
-export function buildVeterinarySchedulingBatch(resources, method = 'POST') {
+export function buildSchedulingBatch(resources, method = 'POST') {
     return Object.freeze({
         data: Object.freeze(resources.map(candidate => {
-            const resource = normalizeVeterinarySchedulingFlatClaimsResource(candidate);
+            const resource = normalizeSchedulingFlatClaimsResource(candidate);
             return Object.freeze({
                 type: `${resource.resourceType}-v5.0.0`,
                 resource,
@@ -19,27 +19,27 @@ export function buildVeterinarySchedulingBatch(resources, method = 'POST') {
         })),
     });
 }
-/** Builds the governed claims-first search envelope accepted by GW VET. */
-export function buildVeterinarySchedulingSearch(resourceType, claims) {
-    const resource = normalizeVeterinarySchedulingFlatClaimsResource({
+/** Builds the governed claims-first search envelope accepted by a GW. */
+export function buildSchedulingSearch(resourceType, claims) {
+    const resource = normalizeSchedulingFlatClaimsResource({
         resourceType,
         id: 'search',
         meta: { claims },
     });
     return Object.freeze({ data: Object.freeze([Object.freeze({ resource })]) });
 }
-/** Builds the clinic-wide `_search` envelope for responses recorded inside an inclusive time period. */
-export function buildVeterinaryAppointmentResponseSearchPeriod(input) {
+/** Builds the organization-wide `_search` envelope for responses recorded inside an inclusive time period. */
+export function buildAppointmentResponseSearchPeriod(input) {
     const from = Date.parse(input.from);
     const to = Date.parse(input.to);
     if (!Number.isFinite(from) || !Number.isFinite(to) || from > to)
         throw new Error('appointment_response_search_period_invalid');
-    return buildVeterinarySchedulingSearch('AppointmentResponse', {
-        'VeterinaryAppointmentResponse.respondedAt': [`ge${new Date(from).toISOString()}`, `le${new Date(to).toISOString()}`],
+    return buildSchedulingSearch('AppointmentResponse', {
+        'AppointmentResponse._lastUpdated': [`ge${new Date(from).toISOString()}`, `le${new Date(to).toISOString()}`],
     });
 }
 /** Converts the governed English AppointmentResponse Communication projection into an email-adapter payload. */
-export function convertVeterinaryAppointmentResponseCommunicationToEnglishEmail(input) {
+export function convertAppointmentResponseCommunicationToEnglishEmail(input) {
     const email = String(input.recipientEmail || '').trim().toLowerCase();
     const resource = input.communication;
     const claims = resource?.resourceType === 'Communication' ? resource?.meta?.claims : undefined;
@@ -53,22 +53,22 @@ export function convertVeterinaryAppointmentResponseCommunicationToEnglishEmail(
     return Object.freeze({ to: email, subject: 'Appointment response', text, metadata: Object.freeze({ appointmentResponse, appointment, recipient, language: 'en' }) });
 }
 /** Reads canonical GW search matches from `body.data[].resource`. */
-export function readVeterinarySchedulingSearch(body, expectedResourceType) {
+export function readSchedulingSearch(body, expectedResourceType) {
     if (!body || typeof body !== 'object' || !Array.isArray(body.data)) {
-        throw new TypeError('veterinary_scheduling_search_invalid');
+        throw new TypeError('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');
+            throw new TypeError('scheduling_search_resource_invalid');
         }
         try {
-            const resource = normalizeVeterinarySchedulingFlatClaimsResource(entry.resource);
+            const resource = normalizeSchedulingFlatClaimsResource(entry.resource);
             if (resource.resourceType !== expectedResourceType)
                 throw new Error('wrong type');
             return resource;
         }
         catch {
-            throw new TypeError('veterinary_scheduling_search_resource_invalid');
+            throw new TypeError('scheduling_search_resource_invalid');
         }
     }));
 }
@@ -77,26 +77,26 @@ export function readVeterinarySchedulingSearch(body, expectedResourceType) {
  * It deliberately does not cancel: the patient receives a durable
  * Communication and may choose another slot before a final decline.
  */
-export function reconcileVeterinaryAppointmentsAfterSlotChange(input) {
+export function reconcileAppointmentsAfterSlotChange(input) {
     const appointments = [];
     const notifications = [];
     for (const candidate of input.appointments) {
-        const appointment = normalizeVeterinarySchedulingFlatClaimsResource(candidate);
+        const appointment = normalizeSchedulingFlatClaimsResource(candidate);
         if (appointment.resourceType !== 'Appointment')
-            throw new TypeError('veterinary_scheduling_appointment_required');
+            throw new TypeError('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({
+        const updated = normalizeSchedulingFlatClaimsResource({
             ...appointment,
-            meta: { claims: {
+            description: input.reason,
+            meta: { ...appointment.meta, claims: {
                     ...appointment.meta.claims,
                     'Appointment.status': ['pending'],
-                    'VeterinaryAppointment.reschedulingReason': [input.reason],
                 } },
         });
         appointments.push(updated);
-        const notification = buildVeterinaryAppointmentNotificationResource({
+        const notification = buildAppointmentNotificationResource({
             id: `${appointment.id}-schedule-change`,
             appointmentReference: `Appointment/${appointment.id}`,
             subjectReference: input.subjectReferenceFor(appointment),
@@ -110,3 +110,15 @@ export function reconcileVeterinaryAppointmentsAfterSlotChange(input) {
     }
     return Object.freeze({ appointments: Object.freeze(appointments), notifications: Object.freeze(notifications) });
 }
+/** @deprecated Use {@link buildSchedulingBatch}. */
+export const buildVeterinarySchedulingBatch = buildSchedulingBatch;
+/** @deprecated Use {@link buildSchedulingSearch}. */
+export const buildVeterinarySchedulingSearch = buildSchedulingSearch;
+/** @deprecated Use {@link buildAppointmentResponseSearchPeriod}. */
+export const buildVeterinaryAppointmentResponseSearchPeriod = buildAppointmentResponseSearchPeriod;
+/** @deprecated Use {@link convertAppointmentResponseCommunicationToEnglishEmail}. */
+export const convertVeterinaryAppointmentResponseCommunicationToEnglishEmail = convertAppointmentResponseCommunicationToEnglishEmail;
+/** @deprecated Use {@link readSchedulingSearch}. */
+export const readVeterinarySchedulingSearch = readSchedulingSearch;
+/** @deprecated Use {@link reconcileAppointmentsAfterSlotChange}. */
+export const reconcileVeterinaryAppointmentsAfterSlotChange = reconcileAppointmentsAfterSlotChange;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vet-sdk-core-ts",
-  "version": "0.4.24",
+  "version": "0.4.26",
   "description": "Browser-safe VetChain core contracts and governed animal species identifiers",
   "license": "Apache-2.0",
   "author": "Connecting Solution & Applications Ltd",
@@ -76,6 +76,6 @@
   "dependencies": {
     "@noble/hashes": "^2.2.0",
     "gdc-common-utils-ts": "2.9.10",
-    "vet-data-utils-ts": "0.5.13"
+    "vet-data-utils-ts": "0.5.16"
   }
 }