@blackcode_sa/metaestetics-api 1.13.18 → 1.13.20

package/dist/admin/index.d.mts

@@ -1882,6 +1882,8 @@ declare enum SyncedCalendarProvider {
 declare enum CalendarEventStatus {
     PENDING = "pending",// When event is created, but not confirmed
     CONFIRMED = "confirmed",// When event is confirmed and ready to be used
+    CHECKED_IN = "checked_in",// Patient has arrived and checked in
+    IN_PROGRESS = "in_progress",// Procedure has started
     REJECTED = "rejected",// When event is rejected by the clinic administrator or patient
     CANCELED = "canceled",// When event is canceled by the patient
     RESCHEDULED = "rescheduled",// When event is rescheduled by the clinic administrator

package/dist/admin/index.d.ts

@@ -1882,6 +1882,8 @@ declare enum SyncedCalendarProvider {
 declare enum CalendarEventStatus {
     PENDING = "pending",// When event is created, but not confirmed
     CONFIRMED = "confirmed",// When event is confirmed and ready to be used
+    CHECKED_IN = "checked_in",// Patient has arrived and checked in
+    IN_PROGRESS = "in_progress",// Procedure has started
     REJECTED = "rejected",// When event is rejected by the clinic administrator or patient
     CANCELED = "canceled",// When event is canceled by the patient
     RESCHEDULED = "rescheduled",// When event is rescheduled by the clinic administrator

package/dist/index.d.mts

@@ -2756,6 +2756,8 @@ declare const SYNCED_CALENDARS_COLLECTION = "syncedCalendars";
 declare enum CalendarEventStatus {
     PENDING = "pending",// When event is created, but not confirmed
     CONFIRMED = "confirmed",// When event is confirmed and ready to be used
+    CHECKED_IN = "checked_in",// Patient has arrived and checked in
+    IN_PROGRESS = "in_progress",// Procedure has started
     REJECTED = "rejected",// When event is rejected by the clinic administrator or patient
     CANCELED = "canceled",// When event is canceled by the patient
     RESCHEDULED = "rescheduled",// When event is rescheduled by the clinic administrator

package/dist/index.d.ts

@@ -2756,6 +2756,8 @@ declare const SYNCED_CALENDARS_COLLECTION = "syncedCalendars";
 declare enum CalendarEventStatus {
     PENDING = "pending",// When event is created, but not confirmed
     CONFIRMED = "confirmed",// When event is confirmed and ready to be used
+    CHECKED_IN = "checked_in",// Patient has arrived and checked in
+    IN_PROGRESS = "in_progress",// Procedure has started
     REJECTED = "rejected",// When event is rejected by the clinic administrator or patient
     CANCELED = "canceled",// When event is canceled by the patient
     RESCHEDULED = "rescheduled",// When event is rescheduled by the clinic administrator

package/dist/index.js

@@ -4473,6 +4473,8 @@ var import_firestore6 = require("firebase/firestore");
 var CalendarEventStatus = /* @__PURE__ */ ((CalendarEventStatus4) => {
   CalendarEventStatus4["PENDING"] = "pending";
   CalendarEventStatus4["CONFIRMED"] = "confirmed";
+  CalendarEventStatus4["CHECKED_IN"] = "checked_in";
+  CalendarEventStatus4["IN_PROGRESS"] = "in_progress";
   CalendarEventStatus4["REJECTED"] = "rejected";
   CalendarEventStatus4["CANCELED"] = "canceled";
   CalendarEventStatus4["RESCHEDULED"] = "rescheduled";
@@ -4604,7 +4606,7 @@ async function updateAppointmentUtil(db, appointmentId, data) {
         updateData.confirmationTime = import_firestore6.Timestamp.now();
       }
       if (currentAppointment.calendarEventId) {
-        await updateCalendarEventStatus(db, currentAppointment.calendarEventId, data.status);
+        await updateCalendarEventStatus(db, currentAppointment, data.status);
       }
     }
     await (0, import_firestore6.updateDoc)(appointmentRef, updateData);
@@ -4618,21 +4620,30 @@ async function updateAppointmentUtil(db, appointmentId, data) {
     throw error;
   }
 }
-async function updateCalendarEventStatus(db, calendarEventId, appointmentStatus) {
+async function updateCalendarEventStatus(db, appointment, appointmentStatus) {
   try {
-    const calendarEventRef = (0, import_firestore6.doc)(db, CALENDAR_COLLECTION, calendarEventId);
-    const calendarEventDoc = await (0, import_firestore6.getDoc)(calendarEventRef);
-    if (!calendarEventDoc.exists()) {
-      console.warn(`Calendar event with ID ${calendarEventId} not found`);
+    const calendarEventId = appointment.calendarEventId;
+    if (!calendarEventId) {
+      console.warn(`Appointment ${appointment.id} has no calendarEventId, skipping calendar event update`);
       return;
     }
     let calendarStatus;
     switch (appointmentStatus) {
+      case "pending" /* PENDING */:
+        calendarStatus = "pending";
+        break;
       case "confirmed" /* CONFIRMED */:
         calendarStatus = "confirmed";
         break;
+      case "checked_in" /* CHECKED_IN */:
+        calendarStatus = "checked_in";
+        break;
+      case "in_progress" /* IN_PROGRESS */:
+        calendarStatus = "in_progress";
+        break;
       case "canceled_patient" /* CANCELED_PATIENT */:
       case "canceled_clinic" /* CANCELED_CLINIC */:
+      case "canceled_patient_rescheduled" /* CANCELED_PATIENT_RESCHEDULED */:
         calendarStatus = "canceled";
         break;
       case "rescheduled_by_clinic" /* RESCHEDULED_BY_CLINIC */:
@@ -4641,15 +4652,55 @@ async function updateCalendarEventStatus(db, calendarEventId, appointmentStatus)
       case "completed" /* COMPLETED */:
         calendarStatus = "completed";
         break;
+      case "no_show" /* NO_SHOW */:
+        calendarStatus = "no_show";
+        break;
       default:
+        console.warn(`Unknown appointment status: ${appointmentStatus}, not updating calendar event`);
         return;
     }
-    await (0, import_firestore6.updateDoc)(calendarEventRef, {
+    const updateData = {
       status: calendarStatus,
       updatedAt: (0, import_firestore6.serverTimestamp)()
-    });
+    };
+    const updatePromises = [];
+    if (appointment.practitionerId) {
+      const practitionerEventRef = (0, import_firestore6.doc)(
+        db,
+        `${PRACTITIONERS_COLLECTION}/${appointment.practitionerId}/${CALENDAR_COLLECTION}/${calendarEventId}`
+      );
+      updatePromises.push(
+        (0, import_firestore6.updateDoc)(practitionerEventRef, updateData).catch((error) => {
+          console.error(`Error updating practitioner calendar event ${calendarEventId}:`, error);
+        })
+      );
+    }
+    if (appointment.patientId) {
+      const patientEventRef = (0, import_firestore6.doc)(
+        db,
+        `${PATIENTS_COLLECTION}/${appointment.patientId}/${CALENDAR_COLLECTION}/${calendarEventId}`
+      );
+      updatePromises.push(
+        (0, import_firestore6.updateDoc)(patientEventRef, updateData).catch((error) => {
+          console.error(`Error updating patient calendar event ${calendarEventId}:`, error);
+        })
+      );
+    }
+    if (appointment.clinicBranchId) {
+      const clinicEventRef = (0, import_firestore6.doc)(
+        db,
+        `${CLINICS_COLLECTION}/${appointment.clinicBranchId}/${CALENDAR_COLLECTION}/${calendarEventId}`
+      );
+      updatePromises.push(
+        (0, import_firestore6.updateDoc)(clinicEventRef, updateData).catch((error) => {
+          console.error(`Error updating clinic calendar event ${calendarEventId}:`, error);
+        })
+      );
+    }
+    await Promise.all(updatePromises);
+    console.log(`Successfully updated calendar event ${calendarEventId} status to ${calendarStatus} across all collections`);
   } catch (error) {
-    console.error(`Error updating calendar event ${calendarEventId}:`, error);
+    console.error(`Error updating calendar events for appointment ${appointment.id}:`, error);
   }
 }
 async function getAppointmentByIdUtil(db, appointmentId) {
@@ -17830,10 +17881,20 @@ var CalendarServiceV2 = class extends BaseService {
       ],
       ["confirmed" /* CONFIRMED */]: [
         "canceled" /* CANCELED */,
+        "checked_in" /* CHECKED_IN */,
         "completed" /* COMPLETED */,
         "rescheduled" /* RESCHEDULED */,
         "no_show" /* NO_SHOW */
       ],
+      ["checked_in" /* CHECKED_IN */]: [
+        "in_progress" /* IN_PROGRESS */,
+        "completed" /* COMPLETED */,
+        "canceled" /* CANCELED */
+      ],
+      ["in_progress" /* IN_PROGRESS */]: [
+        "completed" /* COMPLETED */,
+        "canceled" /* CANCELED */
+      ],
       ["rejected" /* REJECTED */]: [],
       ["canceled" /* CANCELED */]: [],
       ["rescheduled" /* RESCHEDULED */]: [
@@ -22002,12 +22063,18 @@ var ReviewService = class extends BaseService {
         updatedAt: now
       };
       reviewSchema.parse(review);
-      const docRef = (0, import_firestore59.doc)(this.db, REVIEWS_COLLECTION, reviewId);
-      await (0, import_firestore59.setDoc)(docRef, {
+      const firestoreData = {
         ...review,
         createdAt: (0, import_firestore59.serverTimestamp)(),
         updatedAt: (0, import_firestore59.serverTimestamp)()
+      };
+      Object.keys(firestoreData).forEach((key) => {
+        if (firestoreData[key] === void 0) {
+          delete firestoreData[key];
+        }
       });
+      const docRef = (0, import_firestore59.doc)(this.db, REVIEWS_COLLECTION, reviewId);
+      await (0, import_firestore59.setDoc)(docRef, firestoreData);
       console.log("\u2705 ReviewService.createReview - Review saved to Firestore:", {
         reviewId,
         practitionerId: (_e = review.practitionerReview) == null ? void 0 : _e.practitionerId,

package/dist/index.mjs

@@ -4360,6 +4360,8 @@ import {
 var CalendarEventStatus = /* @__PURE__ */ ((CalendarEventStatus4) => {
   CalendarEventStatus4["PENDING"] = "pending";
   CalendarEventStatus4["CONFIRMED"] = "confirmed";
+  CalendarEventStatus4["CHECKED_IN"] = "checked_in";
+  CalendarEventStatus4["IN_PROGRESS"] = "in_progress";
   CalendarEventStatus4["REJECTED"] = "rejected";
   CalendarEventStatus4["CANCELED"] = "canceled";
   CalendarEventStatus4["RESCHEDULED"] = "rescheduled";
@@ -4491,7 +4493,7 @@ async function updateAppointmentUtil(db, appointmentId, data) {
         updateData.confirmationTime = Timestamp5.now();
       }
       if (currentAppointment.calendarEventId) {
-        await updateCalendarEventStatus(db, currentAppointment.calendarEventId, data.status);
+        await updateCalendarEventStatus(db, currentAppointment, data.status);
       }
     }
     await updateDoc2(appointmentRef, updateData);
@@ -4505,21 +4507,30 @@ async function updateAppointmentUtil(db, appointmentId, data) {
     throw error;
   }
 }
-async function updateCalendarEventStatus(db, calendarEventId, appointmentStatus) {
+async function updateCalendarEventStatus(db, appointment, appointmentStatus) {
   try {
-    const calendarEventRef = doc4(db, CALENDAR_COLLECTION, calendarEventId);
-    const calendarEventDoc = await getDoc4(calendarEventRef);
-    if (!calendarEventDoc.exists()) {
-      console.warn(`Calendar event with ID ${calendarEventId} not found`);
+    const calendarEventId = appointment.calendarEventId;
+    if (!calendarEventId) {
+      console.warn(`Appointment ${appointment.id} has no calendarEventId, skipping calendar event update`);
       return;
     }
     let calendarStatus;
     switch (appointmentStatus) {
+      case "pending" /* PENDING */:
+        calendarStatus = "pending";
+        break;
       case "confirmed" /* CONFIRMED */:
         calendarStatus = "confirmed";
         break;
+      case "checked_in" /* CHECKED_IN */:
+        calendarStatus = "checked_in";
+        break;
+      case "in_progress" /* IN_PROGRESS */:
+        calendarStatus = "in_progress";
+        break;
       case "canceled_patient" /* CANCELED_PATIENT */:
       case "canceled_clinic" /* CANCELED_CLINIC */:
+      case "canceled_patient_rescheduled" /* CANCELED_PATIENT_RESCHEDULED */:
         calendarStatus = "canceled";
         break;
       case "rescheduled_by_clinic" /* RESCHEDULED_BY_CLINIC */:
@@ -4528,15 +4539,55 @@ async function updateCalendarEventStatus(db, calendarEventId, appointmentStatus)
       case "completed" /* COMPLETED */:
         calendarStatus = "completed";
         break;
+      case "no_show" /* NO_SHOW */:
+        calendarStatus = "no_show";
+        break;
       default:
+        console.warn(`Unknown appointment status: ${appointmentStatus}, not updating calendar event`);
         return;
     }
-    await updateDoc2(calendarEventRef, {
+    const updateData = {
       status: calendarStatus,
       updatedAt: serverTimestamp()
-    });
+    };
+    const updatePromises = [];
+    if (appointment.practitionerId) {
+      const practitionerEventRef = doc4(
+        db,
+        `${PRACTITIONERS_COLLECTION}/${appointment.practitionerId}/${CALENDAR_COLLECTION}/${calendarEventId}`
+      );
+      updatePromises.push(
+        updateDoc2(practitionerEventRef, updateData).catch((error) => {
+          console.error(`Error updating practitioner calendar event ${calendarEventId}:`, error);
+        })
+      );
+    }
+    if (appointment.patientId) {
+      const patientEventRef = doc4(
+        db,
+        `${PATIENTS_COLLECTION}/${appointment.patientId}/${CALENDAR_COLLECTION}/${calendarEventId}`
+      );
+      updatePromises.push(
+        updateDoc2(patientEventRef, updateData).catch((error) => {
+          console.error(`Error updating patient calendar event ${calendarEventId}:`, error);
+        })
+      );
+    }
+    if (appointment.clinicBranchId) {
+      const clinicEventRef = doc4(
+        db,
+        `${CLINICS_COLLECTION}/${appointment.clinicBranchId}/${CALENDAR_COLLECTION}/${calendarEventId}`
+      );
+      updatePromises.push(
+        updateDoc2(clinicEventRef, updateData).catch((error) => {
+          console.error(`Error updating clinic calendar event ${calendarEventId}:`, error);
+        })
+      );
+    }
+    await Promise.all(updatePromises);
+    console.log(`Successfully updated calendar event ${calendarEventId} status to ${calendarStatus} across all collections`);
   } catch (error) {
-    console.error(`Error updating calendar event ${calendarEventId}:`, error);
+    console.error(`Error updating calendar events for appointment ${appointment.id}:`, error);
   }
 }
 async function getAppointmentByIdUtil(db, appointmentId) {
@@ -17987,10 +18038,20 @@ var CalendarServiceV2 = class extends BaseService {
       ],
       ["confirmed" /* CONFIRMED */]: [
         "canceled" /* CANCELED */,
+        "checked_in" /* CHECKED_IN */,
         "completed" /* COMPLETED */,
         "rescheduled" /* RESCHEDULED */,
         "no_show" /* NO_SHOW */
       ],
+      ["checked_in" /* CHECKED_IN */]: [
+        "in_progress" /* IN_PROGRESS */,
+        "completed" /* COMPLETED */,
+        "canceled" /* CANCELED */
+      ],
+      ["in_progress" /* IN_PROGRESS */]: [
+        "completed" /* COMPLETED */,
+        "canceled" /* CANCELED */
+      ],
       ["rejected" /* REJECTED */]: [],
       ["canceled" /* CANCELED */]: [],
       ["rescheduled" /* RESCHEDULED */]: [
@@ -22248,12 +22309,18 @@ var ReviewService = class extends BaseService {
         updatedAt: now
       };
       reviewSchema.parse(review);
-      const docRef = doc40(this.db, REVIEWS_COLLECTION, reviewId);
-      await setDoc28(docRef, {
+      const firestoreData = {
         ...review,
         createdAt: serverTimestamp32(),
         updatedAt: serverTimestamp32()
+      };
+      Object.keys(firestoreData).forEach((key) => {
+        if (firestoreData[key] === void 0) {
+          delete firestoreData[key];
+        }
       });
+      const docRef = doc40(this.db, REVIEWS_COLLECTION, reviewId);
+      await setDoc28(docRef, firestoreData);
       console.log("\u2705 ReviewService.createReview - Review saved to Firestore:", {
         reviewId,
         practitionerId: (_e = review.practitionerReview) == null ? void 0 : _e.practitionerId,

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@blackcode_sa/metaestetics-api",
   "private": false,
-  "version": "1.13.18",
+  "version": "1.13.20",
   "description": "Firebase authentication service with anonymous upgrade support",
   "main": "dist/index.js",
   "module": "dist/index.mjs",

package/src/services/appointment/utils/appointment.utils.ts

@@ -28,6 +28,9 @@ import {
 import { CalendarEvent, CALENDAR_COLLECTION } from '../../../types/calendar';
 import { ProcedureSummaryInfo } from '../../../types/procedure';
 import { ClinicInfo, PatientProfileInfo, PractitionerProfileInfo } from '../../../types/profile';
+import { PRACTITIONERS_COLLECTION } from '../../../types/practitioner';
+import { PATIENTS_COLLECTION } from '../../../types/patient';
+import { CLINICS_COLLECTION } from '../../../types/clinic';
 import { BlockingCondition } from '../../../backoffice/types/static/blocking-condition.types';
 import { Requirement } from '../../../backoffice/types/requirement.types';
 import { PRACTITIONERS_COLLECTION } from '../../../types/practitioner';
@@ -379,7 +382,7 @@ export async function updateAppointmentUtil(
 
       // Update the related calendar event status if needed
       if (currentAppointment.calendarEventId) {
-        await updateCalendarEventStatus(db, currentAppointment.calendarEventId, data.status);
+        await updateCalendarEventStatus(db, currentAppointment, data.status);
       }
     }
 
@@ -400,34 +403,43 @@ export async function updateAppointmentUtil(
 }
 
 /**
- * Updates the status of a calendar event based on appointment status changes.
+ * Updates the status of calendar events across all collections (practitioner, patient, clinic)
+ * based on appointment status changes.
  *
  * @param db Firestore instance
- * @param calendarEventId ID of the calendar event
+ * @param appointment The appointment object containing calendar event references
  * @param appointmentStatus New appointment status
  */
 async function updateCalendarEventStatus(
   db: Firestore,
-  calendarEventId: string,
+  appointment: Appointment,
   appointmentStatus: AppointmentStatus,
 ): Promise<void> {
   try {
-    const calendarEventRef = doc(db, CALENDAR_COLLECTION, calendarEventId);
-    const calendarEventDoc = await getDoc(calendarEventRef);
-
-    if (!calendarEventDoc.exists()) {
-      console.warn(`Calendar event with ID ${calendarEventId} not found`);
+    const calendarEventId = appointment.calendarEventId;
+    if (!calendarEventId) {
+      console.warn(`Appointment ${appointment.id} has no calendarEventId, skipping calendar event update`);
       return;
     }
 
     // Map appointment status to calendar event status
-    let calendarStatus;
+    let calendarStatus: string;
     switch (appointmentStatus) {
+      case AppointmentStatus.PENDING:
+        calendarStatus = 'pending';
+        break;
       case AppointmentStatus.CONFIRMED:
         calendarStatus = 'confirmed';
         break;
+      case AppointmentStatus.CHECKED_IN:
+        calendarStatus = 'checked_in';
+        break;
+      case AppointmentStatus.IN_PROGRESS:
+        calendarStatus = 'in_progress';
+        break;
       case AppointmentStatus.CANCELED_PATIENT:
       case AppointmentStatus.CANCELED_CLINIC:
+      case AppointmentStatus.CANCELED_PATIENT_RESCHEDULED:
         calendarStatus = 'canceled';
         break;
       case AppointmentStatus.RESCHEDULED_BY_CLINIC:
@@ -436,17 +448,67 @@ async function updateCalendarEventStatus(
       case AppointmentStatus.COMPLETED:
         calendarStatus = 'completed';
         break;
+      case AppointmentStatus.NO_SHOW:
+        calendarStatus = 'no_show';
+        break;
       default:
-        // For other states, don't update the calendar status
+        // For unknown states, don't update the calendar status
+        console.warn(`Unknown appointment status: ${appointmentStatus}, not updating calendar event`);
         return;
     }
 
-    await updateDoc(calendarEventRef, {
+    const updateData = {
       status: calendarStatus,
       updatedAt: serverTimestamp(),
-    });
+    };
+
+    // Update all three calendar event collections in parallel
+    const updatePromises: Promise<void>[] = [];
+
+    // Update practitioner calendar event
+    if (appointment.practitionerId) {
+      const practitionerEventRef = doc(
+        db,
+        `${PRACTITIONERS_COLLECTION}/${appointment.practitionerId}/${CALENDAR_COLLECTION}/${calendarEventId}`
+      );
+      updatePromises.push(
+        updateDoc(practitionerEventRef, updateData).catch(error => {
+          console.error(`Error updating practitioner calendar event ${calendarEventId}:`, error);
+        })
+      );
+    }
+
+    // Update patient calendar event
+    if (appointment.patientId) {
+      const patientEventRef = doc(
+        db,
+        `${PATIENTS_COLLECTION}/${appointment.patientId}/${CALENDAR_COLLECTION}/${calendarEventId}`
+      );
+      updatePromises.push(
+        updateDoc(patientEventRef, updateData).catch(error => {
+          console.error(`Error updating patient calendar event ${calendarEventId}:`, error);
+        })
+      );
+    }
+
+    // Update clinic calendar event
+    if (appointment.clinicBranchId) {
+      const clinicEventRef = doc(
+        db,
+        `${CLINICS_COLLECTION}/${appointment.clinicBranchId}/${CALENDAR_COLLECTION}/${calendarEventId}`
+      );
+      updatePromises.push(
+        updateDoc(clinicEventRef, updateData).catch(error => {
+          console.error(`Error updating clinic calendar event ${calendarEventId}:`, error);
+        })
+      );
+    }
+
+    // Wait for all updates to complete
+    await Promise.all(updatePromises);
+    console.log(`Successfully updated calendar event ${calendarEventId} status to ${calendarStatus} across all collections`);
   } catch (error) {
-    console.error(`Error updating calendar event ${calendarEventId}:`, error);
+    console.error(`Error updating calendar events for appointment ${appointment.id}:`, error);
     // Don't throw error to avoid failing the appointment update
   }
 }

package/src/services/calendar/calendar.v2.service.ts

@@ -1140,10 +1140,20 @@ export class CalendarServiceV2 extends BaseService {
         ],
         [CalendarEventStatus.CONFIRMED]: [
           CalendarEventStatus.CANCELED,
+          CalendarEventStatus.CHECKED_IN,
           CalendarEventStatus.COMPLETED,
           CalendarEventStatus.RESCHEDULED,
           CalendarEventStatus.NO_SHOW,
         ],
+        [CalendarEventStatus.CHECKED_IN]: [
+          CalendarEventStatus.IN_PROGRESS,
+          CalendarEventStatus.COMPLETED,
+          CalendarEventStatus.CANCELED,
+        ],
+        [CalendarEventStatus.IN_PROGRESS]: [
+          CalendarEventStatus.COMPLETED,
+          CalendarEventStatus.CANCELED,
+        ],
         [CalendarEventStatus.REJECTED]: [],
         [CalendarEventStatus.CANCELED]: [],
         [CalendarEventStatus.RESCHEDULED]: [

package/src/services/reviews/reviews.service.ts

@@ -213,14 +213,25 @@ export class ReviewService extends BaseService {
       // Validate complete review object
       reviewSchema.parse(review);
 
-      // Save the review to Firestore
-      const docRef = doc(this.db, REVIEWS_COLLECTION, reviewId);
-      await setDoc(docRef, {
+      // Prepare Firestore document, filtering out undefined values
+      // Firebase doesn't accept undefined values, so we omit them
+      const firestoreData: any = {
         ...review,
         createdAt: serverTimestamp(),
         updatedAt: serverTimestamp(),
+      };
+
+      // Remove undefined fields to prevent Firebase errors
+      Object.keys(firestoreData).forEach((key) => {
+        if (firestoreData[key] === undefined) {
+          delete firestoreData[key];
+        }
       });
 
+      // Save the review to Firestore
+      const docRef = doc(this.db, REVIEWS_COLLECTION, reviewId);
+      await setDoc(docRef, firestoreData);
+
       console.log('✅ ReviewService.createReview - Review saved to Firestore:', {
         reviewId,
         practitionerId: review.practitionerReview?.practitionerId,

package/src/types/calendar/index.ts

@@ -23,6 +23,8 @@ import type {
 export enum CalendarEventStatus {
   PENDING = "pending", // When event is created, but not confirmed
   CONFIRMED = "confirmed", // When event is confirmed and ready to be used
+  CHECKED_IN = "checked_in", // Patient has arrived and checked in
+  IN_PROGRESS = "in_progress", // Procedure has started
   REJECTED = "rejected", // When event is rejected by the clinic administrator or patient
   CANCELED = "canceled", // When event is canceled by the patient
   RESCHEDULED = "rescheduled", // When event is rescheduled by the clinic administrator