@blackcode_sa/metaestetics-api 1.6.4 → 1.6.5

package/dist/admin/index.js

@@ -18496,6 +18496,7 @@ var CLINICS_COLLECTION = "clinics";
 
 // src/types/patient/index.ts
 var PATIENTS_COLLECTION = "patients";
+var PATIENT_SENSITIVE_INFO_COLLECTION = "sensitive-info";
 
 // src/admin/aggregation/clinic/clinic.aggregation.service.ts
 var CALENDAR_SUBCOLLECTION_ID = "calendar";
@@ -20364,838 +20365,257 @@ var PractitionerInviteMailingService = class extends BaseMailingService {
 // src/admin/booking/booking.admin.ts
 var admin7 = __toESM(require("firebase-admin"));
 
-// src/admin/booking/booking.calculator.ts
-var import_firestore = require("firebase/firestore");
-var BookingAvailabilityCalculator = class {
+// node_modules/@firebase/util/dist/node-esm/index.node.esm.js
+var CONSTANTS = {
   /**
-   * Calculate available booking slots based on the provided data
-   *
-   * @param request - The request containing all necessary data for calculation
-   * @returns Response with available booking slots
+   * @define {boolean} Whether this is the client Node.js SDK.
    */
-  static calculateSlots(request) {
-    const {
-      clinic,
-      practitioner,
-      procedure,
-      timeframe,
-      clinicCalendarEvents,
-      practitionerCalendarEvents
-    } = request;
-    const schedulingIntervalMinutes = clinic.schedulingInterval || this.DEFAULT_INTERVAL_MINUTES;
-    const procedureDurationMinutes = procedure.duration;
-    console.log(
-      `Calculating slots with interval: ${schedulingIntervalMinutes}min and procedure duration: ${procedureDurationMinutes}min`
-    );
-    let availableIntervals = [
-      { start: timeframe.start, end: timeframe.end }
-    ];
-    availableIntervals = this.applyClinicWorkingHours(
-      availableIntervals,
-      clinic.workingHours,
-      timeframe
-    );
-    availableIntervals = this.subtractBlockingEvents(
-      availableIntervals,
-      clinicCalendarEvents
-    );
-    availableIntervals = this.applyPractitionerWorkingHours(
-      availableIntervals,
-      practitioner,
-      clinic.id,
-      timeframe
-    );
-    availableIntervals = this.subtractPractitionerBusyTimes(
-      availableIntervals,
-      practitionerCalendarEvents
-    );
-    console.log(
-      `After all filters, have ${availableIntervals.length} available intervals`
-    );
-    const availableSlots = this.generateAvailableSlots(
-      availableIntervals,
-      schedulingIntervalMinutes,
-      procedureDurationMinutes
-    );
-    return { availableSlots };
-  }
+  NODE_CLIENT: false,
   /**
-   * Apply clinic working hours to available intervals
-   *
-   * @param intervals - Current available intervals
-   * @param workingHours - Clinic working hours
-   * @param timeframe - Overall timeframe being considered
-   * @returns Intervals filtered by clinic working hours
+   * @define {boolean} Whether this is the Admin Node.js SDK.
    */
-  static applyClinicWorkingHours(intervals, workingHours, timeframe) {
-    if (!intervals.length) return [];
-    console.log(
-      `Applying clinic working hours to ${intervals.length} intervals`
-    );
-    const workingIntervals = this.createWorkingHoursIntervals(
-      workingHours,
-      timeframe.start.toDate(),
-      timeframe.end.toDate()
-    );
-    return this.intersectIntervals(intervals, workingIntervals);
-  }
+  NODE_ADMIN: false,
   /**
-   * Create time intervals for working hours across multiple days
-   *
-   * @param workingHours - Working hours definition
-   * @param startDate - Start date of the overall timeframe
-   * @param endDate - End date of the overall timeframe
-   * @returns Array of time intervals representing working hours
+   * Firebase SDK Version
    */
-  static createWorkingHoursIntervals(workingHours, startDate, endDate) {
-    const workingIntervals = [];
-    const currentDate = new Date(startDate);
-    currentDate.setHours(0, 0, 0, 0);
-    const dayNameToNumber = {
-      sunday: 0,
-      monday: 1,
-      tuesday: 2,
-      wednesday: 3,
-      thursday: 4,
-      friday: 5,
-      saturday: 6
-    };
-    while (currentDate <= endDate) {
-      const dayOfWeek = currentDate.getDay();
-      const dayName = Object.keys(dayNameToNumber).find(
-        (key) => dayNameToNumber[key] === dayOfWeek
-      );
-      if (dayName && workingHours[dayName]) {
-        const daySchedule = workingHours[dayName];
-        if (daySchedule) {
-          const [openHours, openMinutes] = daySchedule.open.split(":").map(Number);
-          const [closeHours, closeMinutes] = daySchedule.close.split(":").map(Number);
-          const workStart = new Date(currentDate);
-          workStart.setHours(openHours, openMinutes, 0, 0);
-          const workEnd = new Date(currentDate);
-          workEnd.setHours(closeHours, closeMinutes, 0, 0);
-          if (workEnd > startDate && workStart < endDate) {
-            const intervalStart = workStart < startDate ? startDate : workStart;
-            const intervalEnd = workEnd > endDate ? endDate : workEnd;
-            workingIntervals.push({
-              start: import_firestore.Timestamp.fromDate(intervalStart),
-              end: import_firestore.Timestamp.fromDate(intervalEnd)
-            });
-            if (daySchedule.breaks && daySchedule.breaks.length > 0) {
-              for (const breakTime of daySchedule.breaks) {
-                const [breakStartHours, breakStartMinutes] = breakTime.start.split(":").map(Number);
-                const [breakEndHours, breakEndMinutes] = breakTime.end.split(":").map(Number);
-                const breakStart = new Date(currentDate);
-                breakStart.setHours(breakStartHours, breakStartMinutes, 0, 0);
-                const breakEnd = new Date(currentDate);
-                breakEnd.setHours(breakEndHours, breakEndMinutes, 0, 0);
-                workingIntervals.splice(
-                  -1,
-                  1,
-                  ...this.subtractInterval(
-                    workingIntervals[workingIntervals.length - 1],
-                    {
-                      start: import_firestore.Timestamp.fromDate(breakStart),
-                      end: import_firestore.Timestamp.fromDate(breakEnd)
-                    }
-                  )
-                );
-              }
-            }
-          }
-        }
-      }
-      currentDate.setDate(currentDate.getDate() + 1);
+  SDK_VERSION: "${JSCORE_VERSION}"
+};
+var stringToByteArray$1 = function(str) {
+  const out = [];
+  let p = 0;
+  for (let i = 0; i < str.length; i++) {
+    let c = str.charCodeAt(i);
+    if (c < 128) {
+      out[p++] = c;
+    } else if (c < 2048) {
+      out[p++] = c >> 6 | 192;
+      out[p++] = c & 63 | 128;
+    } else if ((c & 64512) === 55296 && i + 1 < str.length && (str.charCodeAt(i + 1) & 64512) === 56320) {
+      c = 65536 + ((c & 1023) << 10) + (str.charCodeAt(++i) & 1023);
+      out[p++] = c >> 18 | 240;
+      out[p++] = c >> 12 & 63 | 128;
+      out[p++] = c >> 6 & 63 | 128;
+      out[p++] = c & 63 | 128;
+    } else {
+      out[p++] = c >> 12 | 224;
+      out[p++] = c >> 6 & 63 | 128;
+      out[p++] = c & 63 | 128;
     }
-    return workingIntervals;
   }
-  /**
-   * Subtract blocking events from available intervals
-   *
-   * @param intervals - Current available intervals
-   * @param events - Calendar events to subtract
-   * @returns Available intervals after removing blocking events
-   */
-  static subtractBlockingEvents(intervals, events) {
-    if (!intervals.length) return [];
-    console.log(`Subtracting ${events.length} blocking events`);
-    const blockingEvents = events.filter(
-      (event) => event.eventType === "blocking" /* BLOCKING */ || event.eventType === "break" /* BREAK */ || event.eventType === "free_day" /* FREE_DAY */
-    );
-    let result = [...intervals];
-    for (const event of blockingEvents) {
-      const { start, end } = event.eventTime;
-      const blockingInterval = { start, end };
-      const newResult = [];
-      for (const interval of result) {
-        const remainingIntervals = this.subtractInterval(
-          interval,
-          blockingInterval
-        );
-        newResult.push(...remainingIntervals);
-      }
-      result = newResult;
+  return out;
+};
+var byteArrayToString = function(bytes) {
+  const out = [];
+  let pos = 0, c = 0;
+  while (pos < bytes.length) {
+    const c1 = bytes[pos++];
+    if (c1 < 128) {
+      out[c++] = String.fromCharCode(c1);
+    } else if (c1 > 191 && c1 < 224) {
+      const c2 = bytes[pos++];
+      out[c++] = String.fromCharCode((c1 & 31) << 6 | c2 & 63);
+    } else if (c1 > 239 && c1 < 365) {
+      const c2 = bytes[pos++];
+      const c3 = bytes[pos++];
+      const c4 = bytes[pos++];
+      const u = ((c1 & 7) << 18 | (c2 & 63) << 12 | (c3 & 63) << 6 | c4 & 63) - 65536;
+      out[c++] = String.fromCharCode(55296 + (u >> 10));
+      out[c++] = String.fromCharCode(56320 + (u & 1023));
+    } else {
+      const c2 = bytes[pos++];
+      const c3 = bytes[pos++];
+      out[c++] = String.fromCharCode((c1 & 15) << 12 | (c2 & 63) << 6 | c3 & 63);
     }
-    return result;
   }
+  return out.join("");
+};
+var base64 = {
   /**
-   * Apply practitioner's specific working hours for the given clinic
-   *
-   * @param intervals - Current available intervals
-   * @param practitioner - Practitioner object
-   * @param clinicId - ID of the clinic
-   * @param timeframe - Overall timeframe being considered
-   * @returns Intervals filtered by practitioner's working hours
+   * Maps bytes to characters.
    */
-  static applyPractitionerWorkingHours(intervals, practitioner, clinicId, timeframe) {
-    if (!intervals.length) return [];
-    console.log(`Applying practitioner working hours for clinic ${clinicId}`);
-    const clinicWorkingHours = practitioner.clinicWorkingHours.find(
-      (hours) => hours.clinicId === clinicId && hours.isActive
-    );
-    if (!clinicWorkingHours) {
-      console.log(
-        `No working hours found for practitioner at clinic ${clinicId}`
-      );
-      return [];
-    }
-    const workingIntervals = this.createPractitionerWorkingHoursIntervals(
-      clinicWorkingHours.workingHours,
-      timeframe.start.toDate(),
-      timeframe.end.toDate()
-    );
-    return this.intersectIntervals(intervals, workingIntervals);
-  }
+  byteToCharMap_: null,
   /**
-   * Create time intervals for practitioner's working hours across multiple days
-   *
-   * @param workingHours - Practitioner's working hours definition
-   * @param startDate - Start date of the overall timeframe
-   * @param endDate - End date of the overall timeframe
-   * @returns Array of time intervals representing practitioner's working hours
+   * Maps characters to bytes.
    */
-  static createPractitionerWorkingHoursIntervals(workingHours, startDate, endDate) {
-    const workingIntervals = [];
-    const currentDate = new Date(startDate);
-    currentDate.setHours(0, 0, 0, 0);
-    const dayNameToNumber = {
-      sunday: 0,
-      monday: 1,
-      tuesday: 2,
-      wednesday: 3,
-      thursday: 4,
-      friday: 5,
-      saturday: 6
-    };
-    while (currentDate <= endDate) {
-      const dayOfWeek = currentDate.getDay();
-      const dayName = Object.keys(dayNameToNumber).find(
-        (key) => dayNameToNumber[key] === dayOfWeek
-      );
-      if (dayName && workingHours[dayName]) {
-        const daySchedule = workingHours[dayName];
-        if (daySchedule) {
-          const [startHours, startMinutes] = daySchedule.start.split(":").map(Number);
-          const [endHours, endMinutes] = daySchedule.end.split(":").map(Number);
-          const workStart = new Date(currentDate);
-          workStart.setHours(startHours, startMinutes, 0, 0);
-          const workEnd = new Date(currentDate);
-          workEnd.setHours(endHours, endMinutes, 0, 0);
-          if (workEnd > startDate && workStart < endDate) {
-            const intervalStart = workStart < startDate ? startDate : workStart;
-            const intervalEnd = workEnd > endDate ? endDate : workEnd;
-            workingIntervals.push({
-              start: import_firestore.Timestamp.fromDate(intervalStart),
-              end: import_firestore.Timestamp.fromDate(intervalEnd)
-            });
-          }
-        }
-      }
-      currentDate.setDate(currentDate.getDate() + 1);
-    }
-    return workingIntervals;
-  }
+  charToByteMap_: null,
   /**
-   * Subtract practitioner's busy times from available intervals
-   *
-   * @param intervals - Current available intervals
-   * @param events - Practitioner's calendar events
-   * @returns Available intervals after removing busy times
+   * Maps bytes to websafe characters.
+   * @private
    */
-  static subtractPractitionerBusyTimes(intervals, events) {
-    if (!intervals.length) return [];
-    console.log(`Subtracting ${events.length} practitioner events`);
-    const busyEvents = events.filter(
-      (event) => (
-        // Include all blocking events
-        event.eventType === "blocking" /* BLOCKING */ || event.eventType === "break" /* BREAK */ || event.eventType === "free_day" /* FREE_DAY */ || // Include appointments that are pending, confirmed, or rescheduled
-        event.eventType === "appointment" /* APPOINTMENT */ && (event.status === "pending" /* PENDING */ || event.status === "confirmed" /* CONFIRMED */ || event.status === "rescheduled" /* RESCHEDULED */)
-      )
-    );
-    let result = [...intervals];
-    for (const event of busyEvents) {
-      const { start, end } = event.eventTime;
-      const busyInterval = { start, end };
-      const newResult = [];
-      for (const interval of result) {
-        const remainingIntervals = this.subtractInterval(
-          interval,
-          busyInterval
-        );
-        newResult.push(...remainingIntervals);
-      }
-      result = newResult;
-    }
-    return result;
-  }
+  byteToCharMapWebSafe_: null,
   /**
-   * Generate available booking slots based on the final available intervals
-   *
-   * @param intervals - Final available intervals
-   * @param intervalMinutes - Scheduling interval in minutes
-   * @param durationMinutes - Procedure duration in minutes
-   * @returns Array of available booking slots
+   * Maps websafe characters to bytes.
+   * @private
    */
-  static generateAvailableSlots(intervals, intervalMinutes, durationMinutes) {
-    const slots = [];
-    console.log(
-      `Generating slots with ${intervalMinutes}min intervals for ${durationMinutes}min procedure`
-    );
-    const durationMs = durationMinutes * 60 * 1e3;
-    const intervalMs = intervalMinutes * 60 * 1e3;
-    for (const interval of intervals) {
-      const intervalStart = interval.start.toDate();
-      const intervalEnd = interval.end.toDate();
-      let slotStart = new Date(intervalStart);
-      const minutesIntoDay = slotStart.getHours() * 60 + slotStart.getMinutes();
-      const minutesRemainder = minutesIntoDay % intervalMinutes;
-      if (minutesRemainder > 0) {
-        slotStart.setMinutes(
-          slotStart.getMinutes() + (intervalMinutes - minutesRemainder)
-        );
-      }
-      while (slotStart.getTime() + durationMs <= intervalEnd.getTime()) {
-        const slotEnd = new Date(slotStart.getTime() + durationMs);
-        if (this.isSlotFullyAvailable(slotStart, slotEnd, intervals)) {
-          slots.push({
-            start: import_firestore.Timestamp.fromDate(slotStart)
-          });
-        }
-        slotStart = new Date(slotStart.getTime() + intervalMs);
-      }
-    }
-    console.log(`Generated ${slots.length} available slots`);
-    return slots;
-  }
+  charToByteMapWebSafe_: null,
   /**
-   * Check if a time slot is fully available within the given intervals
+   * Our default alphabet, shared between
+   * ENCODED_VALS and ENCODED_VALS_WEBSAFE
+   */
+  ENCODED_VALS_BASE: "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789",
+  /**
+   * Our default alphabet. Value 64 (=) is special; it means "nothing."
+   */
+  get ENCODED_VALS() {
+    return this.ENCODED_VALS_BASE + "+/=";
+  },
+  /**
+   * Our websafe alphabet.
+   */
+  get ENCODED_VALS_WEBSAFE() {
+    return this.ENCODED_VALS_BASE + "-_.";
+  },
+  /**
+   * Whether this browser supports the atob and btoa functions. This extension
+   * started at Mozilla but is now implemented by many browsers. We use the
+   * ASSUME_* variables to avoid pulling in the full useragent detection library
+   * but still allowing the standard per-browser compilations.
    *
-   * @param slotStart - Start time of the slot
-   * @param slotEnd - End time of the slot
-   * @param intervals - Available intervals
-   * @returns True if the slot is fully contained within an available interval
    */
-  static isSlotFullyAvailable(slotStart, slotEnd, intervals) {
-    return intervals.some((interval) => {
-      const intervalStart = interval.start.toDate();
-      const intervalEnd = interval.end.toDate();
-      return slotStart >= intervalStart && slotEnd <= intervalEnd;
-    });
-  }
+  HAS_NATIVE_SUPPORT: typeof atob === "function",
   /**
-   * Intersect two sets of time intervals
+   * Base64-encode an array of bytes.
    *
-   * @param intervalsA - First set of intervals
-   * @param intervalsB - Second set of intervals
-   * @returns Intersection of the two sets of intervals
+   * @param input An array of bytes (numbers with
+   *     value in [0, 255]) to encode.
+   * @param webSafe Boolean indicating we should use the
+   *     alternative alphabet.
+   * @return The base64 encoded string.
    */
-  static intersectIntervals(intervalsA, intervalsB) {
-    const result = [];
-    for (const intervalA of intervalsA) {
-      for (const intervalB of intervalsB) {
-        const intersectionStart = intervalA.start.toMillis() > intervalB.start.toMillis() ? intervalA.start : intervalB.start;
-        const intersectionEnd = intervalA.end.toMillis() < intervalB.end.toMillis() ? intervalA.end : intervalB.end;
-        if (intersectionStart.toMillis() < intersectionEnd.toMillis()) {
-          result.push({
-            start: intersectionStart,
-            end: intersectionEnd
-          });
+  encodeByteArray(input, webSafe) {
+    if (!Array.isArray(input)) {
+      throw Error("encodeByteArray takes an array as a parameter");
+    }
+    this.init_();
+    const byteToCharMap = webSafe ? this.byteToCharMapWebSafe_ : this.byteToCharMap_;
+    const output = [];
+    for (let i = 0; i < input.length; i += 3) {
+      const byte1 = input[i];
+      const haveByte2 = i + 1 < input.length;
+      const byte2 = haveByte2 ? input[i + 1] : 0;
+      const haveByte3 = i + 2 < input.length;
+      const byte3 = haveByte3 ? input[i + 2] : 0;
+      const outByte1 = byte1 >> 2;
+      const outByte2 = (byte1 & 3) << 4 | byte2 >> 4;
+      let outByte3 = (byte2 & 15) << 2 | byte3 >> 6;
+      let outByte4 = byte3 & 63;
+      if (!haveByte3) {
+        outByte4 = 64;
+        if (!haveByte2) {
+          outByte3 = 64;
         }
       }
+      output.push(byteToCharMap[outByte1], byteToCharMap[outByte2], byteToCharMap[outByte3], byteToCharMap[outByte4]);
     }
-    return this.mergeOverlappingIntervals(result);
-  }
+    return output.join("");
+  },
   /**
-   * Subtract one interval from another, potentially resulting in 0, 1, or 2 intervals
+   * Base64-encode a string.
    *
-   * @param interval - Interval to subtract from
-   * @param subtrahend - Interval to subtract
-   * @returns Array of remaining intervals after subtraction
+   * @param input A string to encode.
+   * @param webSafe If true, we should use the
+   *     alternative alphabet.
+   * @return The base64 encoded string.
    */
-  static subtractInterval(interval, subtrahend) {
-    if (interval.end.toMillis() <= subtrahend.start.toMillis() || interval.start.toMillis() >= subtrahend.end.toMillis()) {
-      return [interval];
-    }
-    if (subtrahend.start.toMillis() <= interval.start.toMillis() && subtrahend.end.toMillis() >= interval.end.toMillis()) {
-      return [];
-    }
-    if (subtrahend.start.toMillis() > interval.start.toMillis() && subtrahend.end.toMillis() < interval.end.toMillis()) {
-      return [
-        {
-          start: interval.start,
-          end: subtrahend.start
-        },
-        {
-          start: subtrahend.end,
-          end: interval.end
-        }
-      ];
-    }
-    if (subtrahend.start.toMillis() <= interval.start.toMillis() && subtrahend.end.toMillis() > interval.start.toMillis()) {
-      return [
-        {
-          start: subtrahend.end,
-          end: interval.end
-        }
-      ];
+  encodeString(input, webSafe) {
+    if (this.HAS_NATIVE_SUPPORT && !webSafe) {
+      return btoa(input);
     }
-    return [
-      {
-        start: interval.start,
-        end: subtrahend.start
-      }
-    ];
-  }
+    return this.encodeByteArray(stringToByteArray$1(input), webSafe);
+  },
   /**
-   * Merge overlapping intervals to simplify the result
+   * Base64-decode a string.
    *
-   * @param intervals - Intervals to merge
-   * @returns Merged intervals
+   * @param input to decode.
+   * @param webSafe True if we should use the
+   *     alternative alphabet.
+   * @return string representing the decoded value.
    */
-  static mergeOverlappingIntervals(intervals) {
-    if (intervals.length <= 1) return intervals;
-    const sorted = [...intervals].sort(
-      (a, b) => a.start.toMillis() - b.start.toMillis()
-    );
-    const result = [sorted[0]];
-    for (let i = 1; i < sorted.length; i++) {
-      const current = sorted[i];
-      const lastResult = result[result.length - 1];
-      if (current.start.toMillis() <= lastResult.end.toMillis()) {
-        if (current.end.toMillis() > lastResult.end.toMillis()) {
-          lastResult.end = current.end;
-        }
-      } else {
-        result.push(current);
-      }
+  decodeString(input, webSafe) {
+    if (this.HAS_NATIVE_SUPPORT && !webSafe) {
+      return atob(input);
     }
-    return result;
-  }
-};
-/** Default scheduling interval in minutes if not specified by the clinic */
-BookingAvailabilityCalculator.DEFAULT_INTERVAL_MINUTES = 15;
-
-// src/admin/booking/booking.admin.ts
-var BookingAdmin = class {
-  /**
-   * Creates a new BookingAdmin instance
-   * @param firestore - Firestore instance provided by the caller
-   */
-  constructor(firestore9) {
-    this.db = firestore9 || admin7.firestore();
-  }
+    return byteArrayToString(this.decodeStringToByteArray(input, webSafe));
+  },
   /**
-   * Gets available booking time slots for a specific clinic, practitioner, and procedure
+   * Base64-decode a string.
    *
-   * @param clinicId - ID of the clinic
-   * @param practitionerId - ID of the practitioner
-   * @param procedureId - ID of the procedure
-   * @param timeframe - Time range to check for availability
-   * @returns Promise resolving to an array of available booking slots
+   * In base-64 decoding, groups of four characters are converted into three
+   * bytes.  If the encoder did not apply padding, the input length may not
+   * be a multiple of 4.
+   *
+   * In this case, the last group will have fewer than 4 characters, and
+   * padding will be inferred.  If the group has one or two characters, it decodes
+   * to one byte.  If the group has three characters, it decodes to two bytes.
+   *
+   * @param input Input to decode.
+   * @param webSafe True if we should use the web-safe alphabet.
+   * @return bytes representing the decoded value.
    */
-  async getAvailableBookingSlots(clinicId, practitionerId, procedureId, timeframe) {
-    try {
-      console.log(
-        `[BookingAdmin] Getting available slots for clinic ${clinicId}, practitioner ${practitionerId}, procedure ${procedureId}`
-      );
-      const start = timeframe.start instanceof Date ? admin7.firestore.Timestamp.fromDate(timeframe.start) : timeframe.start;
-      const end = timeframe.end instanceof Date ? admin7.firestore.Timestamp.fromDate(timeframe.end) : timeframe.end;
-      const clinicDoc = await this.db.collection("clinics").doc(clinicId).get();
-      if (!clinicDoc.exists) {
-        throw new Error(`Clinic ${clinicId} not found`);
-      }
-      const clinic = clinicDoc.data();
-      const practitionerDoc = await this.db.collection("practitioners").doc(practitionerId).get();
-      if (!practitionerDoc.exists) {
-        throw new Error(`Practitioner ${practitionerId} not found`);
+  decodeStringToByteArray(input, webSafe) {
+    this.init_();
+    const charToByteMap = webSafe ? this.charToByteMapWebSafe_ : this.charToByteMap_;
+    const output = [];
+    for (let i = 0; i < input.length; ) {
+      const byte1 = charToByteMap[input.charAt(i++)];
+      const haveByte2 = i < input.length;
+      const byte2 = haveByte2 ? charToByteMap[input.charAt(i)] : 0;
+      ++i;
+      const haveByte3 = i < input.length;
+      const byte3 = haveByte3 ? charToByteMap[input.charAt(i)] : 64;
+      ++i;
+      const haveByte4 = i < input.length;
+      const byte4 = haveByte4 ? charToByteMap[input.charAt(i)] : 64;
+      ++i;
+      if (byte1 == null || byte2 == null || byte3 == null || byte4 == null) {
+        throw new DecodeBase64StringError();
       }
-      const practitioner = practitionerDoc.data();
-      const procedureDoc = await this.db.collection("procedures").doc(procedureId).get();
-      if (!procedureDoc.exists) {
-        throw new Error(`Procedure ${procedureId} not found`);
+      const outByte1 = byte1 << 2 | byte2 >> 4;
+      output.push(outByte1);
+      if (byte3 !== 64) {
+        const outByte2 = byte2 << 4 & 240 | byte3 >> 2;
+        output.push(outByte2);
+        if (byte4 !== 64) {
+          const outByte3 = byte3 << 6 & 192 | byte4;
+          output.push(outByte3);
+        }
       }
-      const procedure = procedureDoc.data();
-      const clinicCalendarEvents = await this.getClinicCalendarEvents(
-        clinicId,
-        start,
-        end
-      );
-      const practitionerCalendarEvents = await this.getPractitionerCalendarEvents(practitionerId, start, end);
-      const convertedTimeframe = {
-        start: this.adminTimestampToClientTimestamp(start),
-        end: this.adminTimestampToClientTimestamp(end)
-      };
-      const request = {
-        clinic,
-        practitioner,
-        procedure,
-        timeframe: convertedTimeframe,
-        clinicCalendarEvents: this.convertEventsTimestamps(clinicCalendarEvents),
-        practitionerCalendarEvents: this.convertEventsTimestamps(
-          practitionerCalendarEvents
-        )
-      };
-      const result = BookingAvailabilityCalculator.calculateSlots(request);
-      return {
-        availableSlots: result.availableSlots.map((slot) => ({
-          start: admin7.firestore.Timestamp.fromMillis(slot.start.toMillis())
-        }))
-      };
-    } catch (error) {
-      console.error("[BookingAdmin] Error getting available slots:", error);
-      throw error;
     }
-  }
-  /**
-   * Converts an admin Firestore Timestamp to a client Firestore Timestamp
-   */
-  adminTimestampToClientTimestamp(timestamp) {
-    return {
-      seconds: timestamp.seconds,
-      nanoseconds: timestamp.nanoseconds,
-      toDate: () => timestamp.toDate(),
-      toMillis: () => timestamp.toMillis(),
-      valueOf: () => timestamp.valueOf()
-      // Add any other required methods/properties
-    };
-  }
+    return output;
+  },
   /**
-   * Converts timestamps in calendar events from admin Firestore Timestamps to client Firestore Timestamps
+   * Lazy static initialization function. Called before
+   * accessing any of the static map variables.
+   * @private
    */
-  convertEventsTimestamps(events) {
-    return events.map((event) => ({
-      ...event,
-      eventTime: {
-        start: this.adminTimestampToClientTimestamp(event.eventTime.start),
-        end: this.adminTimestampToClientTimestamp(event.eventTime.end)
+  init_() {
+    if (!this.byteToCharMap_) {
+      this.byteToCharMap_ = {};
+      this.charToByteMap_ = {};
+      this.byteToCharMapWebSafe_ = {};
+      this.charToByteMapWebSafe_ = {};
+      for (let i = 0; i < this.ENCODED_VALS.length; i++) {
+        this.byteToCharMap_[i] = this.ENCODED_VALS.charAt(i);
+        this.charToByteMap_[this.byteToCharMap_[i]] = i;
+        this.byteToCharMapWebSafe_[i] = this.ENCODED_VALS_WEBSAFE.charAt(i);
+        this.charToByteMapWebSafe_[this.byteToCharMapWebSafe_[i]] = i;
+        if (i >= this.ENCODED_VALS_BASE.length) {
+          this.charToByteMap_[this.ENCODED_VALS_WEBSAFE.charAt(i)] = i;
+          this.charToByteMapWebSafe_[this.ENCODED_VALS.charAt(i)] = i;
+        }
       }
-      // Convert any other timestamps in the event if needed
-    }));
-  }
-  /**
-   * Fetches clinic calendar events for a specific time range
-   *
-   * @param clinicId - ID of the clinic
-   * @param start - Start time of the range
-   * @param end - End time of the range
-   * @returns Promise resolving to an array of calendar events
-   */
-  async getClinicCalendarEvents(clinicId, start, end) {
-    try {
-      const eventsRef = this.db.collection(`clinics/${clinicId}/calendar`).where("eventTime.start", ">=", start).where("eventTime.start", "<=", end);
-      const snapshot = await eventsRef.get();
-      return snapshot.docs.map((doc) => ({
-        ...doc.data(),
-        id: doc.id
-      }));
-    } catch (error) {
-      console.error(
-        `[BookingAdmin] Error fetching clinic calendar events:`,
-        error
-      );
-      return [];
     }
   }
-  /**
-   * Fetches practitioner calendar events for a specific time range
-   *
-   * @param practitionerId - ID of the practitioner
-   * @param start - Start time of the range
-   * @param end - End time of the range
-   * @returns Promise resolving to an array of calendar events
-   */
-  async getPractitionerCalendarEvents(practitionerId, start, end) {
-    try {
-      const eventsRef = this.db.collection(`practitioners/${practitionerId}/calendar`).where("eventTime.start", ">=", start).where("eventTime.start", "<=", end);
-      const snapshot = await eventsRef.get();
-      return snapshot.docs.map((doc) => ({
-        ...doc.data(),
-        id: doc.id
-      }));
-    } catch (error) {
-      console.error(
-        `[BookingAdmin] Error fetching practitioner calendar events:`,
-        error
-      );
-      return [];
-    }
+};
+var DecodeBase64StringError = class extends Error {
+  constructor() {
+    super(...arguments);
+    this.name = "DecodeBase64StringError";
   }
 };
-
-// src/admin/requirements/patient-requirements.admin.service.ts
-var admin8 = __toESM(require("firebase-admin"));
-
-// node_modules/@firebase/util/dist/node-esm/index.node.esm.js
-var CONSTANTS = {
-  /**
-   * @define {boolean} Whether this is the client Node.js SDK.
-   */
-  NODE_CLIENT: false,
-  /**
-   * @define {boolean} Whether this is the Admin Node.js SDK.
-   */
-  NODE_ADMIN: false,
-  /**
-   * Firebase SDK Version
-   */
-  SDK_VERSION: "${JSCORE_VERSION}"
-};
-var stringToByteArray$1 = function(str) {
-  const out = [];
-  let p = 0;
-  for (let i = 0; i < str.length; i++) {
-    let c = str.charCodeAt(i);
-    if (c < 128) {
-      out[p++] = c;
-    } else if (c < 2048) {
-      out[p++] = c >> 6 | 192;
-      out[p++] = c & 63 | 128;
-    } else if ((c & 64512) === 55296 && i + 1 < str.length && (str.charCodeAt(i + 1) & 64512) === 56320) {
-      c = 65536 + ((c & 1023) << 10) + (str.charCodeAt(++i) & 1023);
-      out[p++] = c >> 18 | 240;
-      out[p++] = c >> 12 & 63 | 128;
-      out[p++] = c >> 6 & 63 | 128;
-      out[p++] = c & 63 | 128;
-    } else {
-      out[p++] = c >> 12 | 224;
-      out[p++] = c >> 6 & 63 | 128;
-      out[p++] = c & 63 | 128;
-    }
-  }
-  return out;
-};
-var byteArrayToString = function(bytes) {
-  const out = [];
-  let pos = 0, c = 0;
-  while (pos < bytes.length) {
-    const c1 = bytes[pos++];
-    if (c1 < 128) {
-      out[c++] = String.fromCharCode(c1);
-    } else if (c1 > 191 && c1 < 224) {
-      const c2 = bytes[pos++];
-      out[c++] = String.fromCharCode((c1 & 31) << 6 | c2 & 63);
-    } else if (c1 > 239 && c1 < 365) {
-      const c2 = bytes[pos++];
-      const c3 = bytes[pos++];
-      const c4 = bytes[pos++];
-      const u = ((c1 & 7) << 18 | (c2 & 63) << 12 | (c3 & 63) << 6 | c4 & 63) - 65536;
-      out[c++] = String.fromCharCode(55296 + (u >> 10));
-      out[c++] = String.fromCharCode(56320 + (u & 1023));
-    } else {
-      const c2 = bytes[pos++];
-      const c3 = bytes[pos++];
-      out[c++] = String.fromCharCode((c1 & 15) << 12 | (c2 & 63) << 6 | c3 & 63);
-    }
-  }
-  return out.join("");
-};
-var base64 = {
-  /**
-   * Maps bytes to characters.
-   */
-  byteToCharMap_: null,
-  /**
-   * Maps characters to bytes.
-   */
-  charToByteMap_: null,
-  /**
-   * Maps bytes to websafe characters.
-   * @private
-   */
-  byteToCharMapWebSafe_: null,
-  /**
-   * Maps websafe characters to bytes.
-   * @private
-   */
-  charToByteMapWebSafe_: null,
-  /**
-   * Our default alphabet, shared between
-   * ENCODED_VALS and ENCODED_VALS_WEBSAFE
-   */
-  ENCODED_VALS_BASE: "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789",
-  /**
-   * Our default alphabet. Value 64 (=) is special; it means "nothing."
-   */
-  get ENCODED_VALS() {
-    return this.ENCODED_VALS_BASE + "+/=";
-  },
-  /**
-   * Our websafe alphabet.
-   */
-  get ENCODED_VALS_WEBSAFE() {
-    return this.ENCODED_VALS_BASE + "-_.";
-  },
-  /**
-   * Whether this browser supports the atob and btoa functions. This extension
-   * started at Mozilla but is now implemented by many browsers. We use the
-   * ASSUME_* variables to avoid pulling in the full useragent detection library
-   * but still allowing the standard per-browser compilations.
-   *
-   */
-  HAS_NATIVE_SUPPORT: typeof atob === "function",
-  /**
-   * Base64-encode an array of bytes.
-   *
-   * @param input An array of bytes (numbers with
-   *     value in [0, 255]) to encode.
-   * @param webSafe Boolean indicating we should use the
-   *     alternative alphabet.
-   * @return The base64 encoded string.
-   */
-  encodeByteArray(input, webSafe) {
-    if (!Array.isArray(input)) {
-      throw Error("encodeByteArray takes an array as a parameter");
-    }
-    this.init_();
-    const byteToCharMap = webSafe ? this.byteToCharMapWebSafe_ : this.byteToCharMap_;
-    const output = [];
-    for (let i = 0; i < input.length; i += 3) {
-      const byte1 = input[i];
-      const haveByte2 = i + 1 < input.length;
-      const byte2 = haveByte2 ? input[i + 1] : 0;
-      const haveByte3 = i + 2 < input.length;
-      const byte3 = haveByte3 ? input[i + 2] : 0;
-      const outByte1 = byte1 >> 2;
-      const outByte2 = (byte1 & 3) << 4 | byte2 >> 4;
-      let outByte3 = (byte2 & 15) << 2 | byte3 >> 6;
-      let outByte4 = byte3 & 63;
-      if (!haveByte3) {
-        outByte4 = 64;
-        if (!haveByte2) {
-          outByte3 = 64;
-        }
-      }
-      output.push(byteToCharMap[outByte1], byteToCharMap[outByte2], byteToCharMap[outByte3], byteToCharMap[outByte4]);
-    }
-    return output.join("");
-  },
-  /**
-   * Base64-encode a string.
-   *
-   * @param input A string to encode.
-   * @param webSafe If true, we should use the
-   *     alternative alphabet.
-   * @return The base64 encoded string.
-   */
-  encodeString(input, webSafe) {
-    if (this.HAS_NATIVE_SUPPORT && !webSafe) {
-      return btoa(input);
-    }
-    return this.encodeByteArray(stringToByteArray$1(input), webSafe);
-  },
-  /**
-   * Base64-decode a string.
-   *
-   * @param input to decode.
-   * @param webSafe True if we should use the
-   *     alternative alphabet.
-   * @return string representing the decoded value.
-   */
-  decodeString(input, webSafe) {
-    if (this.HAS_NATIVE_SUPPORT && !webSafe) {
-      return atob(input);
-    }
-    return byteArrayToString(this.decodeStringToByteArray(input, webSafe));
-  },
-  /**
-   * Base64-decode a string.
-   *
-   * In base-64 decoding, groups of four characters are converted into three
-   * bytes.  If the encoder did not apply padding, the input length may not
-   * be a multiple of 4.
-   *
-   * In this case, the last group will have fewer than 4 characters, and
-   * padding will be inferred.  If the group has one or two characters, it decodes
-   * to one byte.  If the group has three characters, it decodes to two bytes.
-   *
-   * @param input Input to decode.
-   * @param webSafe True if we should use the web-safe alphabet.
-   * @return bytes representing the decoded value.
-   */
-  decodeStringToByteArray(input, webSafe) {
-    this.init_();
-    const charToByteMap = webSafe ? this.charToByteMapWebSafe_ : this.charToByteMap_;
-    const output = [];
-    for (let i = 0; i < input.length; ) {
-      const byte1 = charToByteMap[input.charAt(i++)];
-      const haveByte2 = i < input.length;
-      const byte2 = haveByte2 ? charToByteMap[input.charAt(i)] : 0;
-      ++i;
-      const haveByte3 = i < input.length;
-      const byte3 = haveByte3 ? charToByteMap[input.charAt(i)] : 64;
-      ++i;
-      const haveByte4 = i < input.length;
-      const byte4 = haveByte4 ? charToByteMap[input.charAt(i)] : 64;
-      ++i;
-      if (byte1 == null || byte2 == null || byte3 == null || byte4 == null) {
-        throw new DecodeBase64StringError();
-      }
-      const outByte1 = byte1 << 2 | byte2 >> 4;
-      output.push(outByte1);
-      if (byte3 !== 64) {
-        const outByte2 = byte2 << 4 & 240 | byte3 >> 2;
-        output.push(outByte2);
-        if (byte4 !== 64) {
-          const outByte3 = byte3 << 6 & 192 | byte4;
-          output.push(outByte3);
-        }
-      }
-    }
-    return output;
-  },
-  /**
-   * Lazy static initialization function. Called before
-   * accessing any of the static map variables.
-   * @private
-   */
-  init_() {
-    if (!this.byteToCharMap_) {
-      this.byteToCharMap_ = {};
-      this.charToByteMap_ = {};
-      this.byteToCharMapWebSafe_ = {};
-      this.charToByteMapWebSafe_ = {};
-      for (let i = 0; i < this.ENCODED_VALS.length; i++) {
-        this.byteToCharMap_[i] = this.ENCODED_VALS.charAt(i);
-        this.charToByteMap_[this.byteToCharMap_[i]] = i;
-        this.byteToCharMapWebSafe_[i] = this.ENCODED_VALS_WEBSAFE.charAt(i);
-        this.charToByteMapWebSafe_[this.byteToCharMapWebSafe_[i]] = i;
-        if (i >= this.ENCODED_VALS_BASE.length) {
-          this.charToByteMap_[this.ENCODED_VALS_WEBSAFE.charAt(i)] = i;
-          this.charToByteMapWebSafe_[this.ENCODED_VALS.charAt(i)] = i;
-        }
-      }
-    }
-  }
-};
-var DecodeBase64StringError = class extends Error {
-  constructor() {
-    super(...arguments);
-    this.name = "DecodeBase64StringError";
-  }
-};
-var base64Encode = function(str) {
-  const utf8Bytes = stringToByteArray$1(str);
-  return base64.encodeByteArray(utf8Bytes, true);
+var base64Encode = function(str) {
+  const utf8Bytes = stringToByteArray$1(str);
+  return base64.encodeByteArray(utf8Bytes, true);
 };
 var base64urlEncodeWithoutPadding = function(str) {
   return base64Encode(str).replace(/\./g, "");
@@ -23052,7 +22472,7 @@ function arrayEquals(left, right, comparator) {
 }
 var MIN_SECONDS = -62135596800;
 var MS_TO_NANOS = 1e6;
-var Timestamp2 = class _Timestamp {
+var Timestamp = class _Timestamp {
   /**
    * Creates a new timestamp with the current date, with millisecond precision.
    *
@@ -23171,10 +22591,10 @@ var SnapshotVersion = class _SnapshotVersion {
     return new _SnapshotVersion(value);
   }
   static min() {
-    return new _SnapshotVersion(new Timestamp2(0, 0));
+    return new _SnapshotVersion(new Timestamp(0, 0));
   }
   static max() {
-    return new _SnapshotVersion(new Timestamp2(253402300799, 1e9 - 1));
+    return new _SnapshotVersion(new Timestamp(253402300799, 1e9 - 1));
   }
   constructor(timestamp) {
     this.timestamp = timestamp;
@@ -23516,7 +22936,7 @@ FieldIndex.UNKNOWN_ID = -1;
 function newIndexOffsetSuccessorFromReadTime(readTime, largestBatchId) {
   const successorSeconds = readTime.toTimestamp().seconds;
   const successorNanos = readTime.toTimestamp().nanoseconds + 1;
-  const successor = SnapshotVersion.fromTimestamp(successorNanos === 1e9 ? new Timestamp2(successorSeconds + 1, 0) : new Timestamp2(successorSeconds, successorNanos));
+  const successor = SnapshotVersion.fromTimestamp(successorNanos === 1e9 ? new Timestamp(successorSeconds + 1, 0) : new Timestamp(successorSeconds, successorNanos));
   return new IndexOffset(successor, DocumentKey.empty(), largestBatchId);
 }
 function newIndexOffsetFromDocument(document2) {
@@ -24563,7 +23983,7 @@ function getPreviousValue(value) {
 }
 function getLocalWriteTime(value) {
   const localWriteTime = normalizeTimestamp(value.mapValue.fields[LOCAL_WRITE_TIME_KEY].timestampValue);
-  return new Timestamp2(localWriteTime.seconds, localWriteTime.nanos);
+  return new Timestamp(localWriteTime.seconds, localWriteTime.nanos);
 }
 var DEFAULT_DATABASE_NAME = "(default)";
 var DatabaseId = class _DatabaseId {
@@ -26577,7 +25997,7 @@ function fromInt32Proto(val) {
 }
 function fromTimestamp(date) {
   const timestamp = normalizeTimestamp(date);
-  return new Timestamp2(timestamp.seconds, timestamp.nanos);
+  return new Timestamp(timestamp.seconds, timestamp.nanos);
 }
 function fromVersion(version3) {
   hardAssert(!!version3);
@@ -27149,7 +26569,7 @@ var LocalDocumentsView = class {
       return this.remoteDocumentCache.getEntry(transaction, key);
     }).next((document2) => {
       if (overlay !== null) {
-        mutationApplyToLocalView(overlay.mutation, document2, FieldMask.empty(), Timestamp2.now());
+        mutationApplyToLocalView(overlay.mutation, document2, FieldMask.empty(), Timestamp.now());
       }
       return document2;
     });
@@ -27233,7 +26653,7 @@ var LocalDocumentsView = class {
         recalculateDocuments = recalculateDocuments.insert(doc.key, doc);
       } else if (overlay !== void 0) {
         mutatedFields.set(doc.key, overlay.mutation.getFieldMask());
-        mutationApplyToLocalView(overlay.mutation, doc, overlay.mutation.getFieldMask(), Timestamp2.now());
+        mutationApplyToLocalView(overlay.mutation, doc, overlay.mutation.getFieldMask(), Timestamp.now());
       } else {
         mutatedFields.set(doc.key, FieldMask.empty());
       }
@@ -27389,7 +26809,7 @@ var LocalDocumentsView = class {
       remoteDocuments.forEach((key, document2) => {
         const overlay = overlays.get(key);
         if (overlay !== void 0) {
-          mutationApplyToLocalView(overlay.mutation, document2, FieldMask.empty(), Timestamp2.now());
+          mutationApplyToLocalView(overlay.mutation, document2, FieldMask.empty(), Timestamp.now());
         }
         if (queryMatches(query, document2)) {
           results = results.insert(key, document2);
@@ -32497,240 +31917,1060 @@ var Firestore$1 = class {
     } else {
       this._terminateTask = "notTerminated";
     }
-  }
-  /** Returns a JSON-serializable representation of this `Firestore` instance. */
-  toJSON() {
-    return {
-      app: this._app,
-      databaseId: this._databaseId,
-      settings: this._settings
-    };
+  }
+  /** Returns a JSON-serializable representation of this `Firestore` instance. */
+  toJSON() {
+    return {
+      app: this._app,
+      databaseId: this._databaseId,
+      settings: this._settings
+    };
+  }
+  /**
+   * Terminates all components used by this client. Subclasses can override
+   * this method to clean up their own dependencies, but must also call this
+   * method.
+   *
+   * Only ever called once.
+   */
+  _terminate() {
+    removeComponents(this);
+    return Promise.resolve();
+  }
+};
+var LOG_TAG = "AsyncQueue";
+var AsyncQueueImpl = class {
+  constructor(tail = Promise.resolve()) {
+    this.retryableOps = [];
+    this._isShuttingDown = false;
+    this.delayedOperations = [];
+    this.failure = null;
+    this.operationInProgress = false;
+    this.skipNonRestrictedTasks = false;
+    this.timerIdsToSkip = [];
+    this.backoff = new ExponentialBackoff(
+      this,
+      "async_queue_retry"
+      /* TimerId.AsyncQueueRetry */
+    );
+    this.visibilityHandler = () => {
+      this.backoff.skipBackoff();
+    };
+    this.tail = tail;
+  }
+  get isShuttingDown() {
+    return this._isShuttingDown;
+  }
+  /**
+   * Adds a new operation to the queue without waiting for it to complete (i.e.
+   * we ignore the Promise result).
+   */
+  enqueueAndForget(op) {
+    this.enqueue(op);
+  }
+  enqueueAndForgetEvenWhileRestricted(op) {
+    this.verifyNotFailed();
+    this.enqueueInternal(op);
+  }
+  enterRestrictedMode(purgeExistingTasks) {
+    if (!this._isShuttingDown) {
+      this._isShuttingDown = true;
+      this.skipNonRestrictedTasks = purgeExistingTasks || false;
+    }
+  }
+  enqueue(op) {
+    this.verifyNotFailed();
+    if (this._isShuttingDown) {
+      return new Promise(() => {
+      });
+    }
+    const task = new Deferred2();
+    return this.enqueueInternal(() => {
+      if (this._isShuttingDown && this.skipNonRestrictedTasks) {
+        return Promise.resolve();
+      }
+      op().then(task.resolve, task.reject);
+      return task.promise;
+    }).then(() => task.promise);
+  }
+  enqueueRetryable(op) {
+    this.enqueueAndForget(() => {
+      this.retryableOps.push(op);
+      return this.retryNextOp();
+    });
+  }
+  /**
+   * Runs the next operation from the retryable queue. If the operation fails,
+   * reschedules with backoff.
+   */
+  async retryNextOp() {
+    if (this.retryableOps.length === 0) {
+      return;
+    }
+    try {
+      await this.retryableOps[0]();
+      this.retryableOps.shift();
+      this.backoff.reset();
+    } catch (e) {
+      if (isIndexedDbTransactionError(e)) {
+        logDebug(LOG_TAG, "Operation failed with retryable error: " + e);
+      } else {
+        throw e;
+      }
+    }
+    if (this.retryableOps.length > 0) {
+      this.backoff.backoffAndRun(() => this.retryNextOp());
+    }
+  }
+  enqueueInternal(op) {
+    const newTail = this.tail.then(() => {
+      this.operationInProgress = true;
+      return op().catch((error) => {
+        this.failure = error;
+        this.operationInProgress = false;
+        const message = getMessageOrStack(error);
+        logError("INTERNAL UNHANDLED ERROR: ", message);
+        throw error;
+      }).then((result) => {
+        this.operationInProgress = false;
+        return result;
+      });
+    });
+    this.tail = newTail;
+    return newTail;
+  }
+  enqueueAfterDelay(timerId, delayMs, op) {
+    this.verifyNotFailed();
+    if (this.timerIdsToSkip.indexOf(timerId) > -1) {
+      delayMs = 0;
+    }
+    const delayedOp = DelayedOperation.createAndSchedule(this, timerId, delayMs, op, (removedOp) => this.removeDelayedOperation(removedOp));
+    this.delayedOperations.push(delayedOp);
+    return delayedOp;
+  }
+  verifyNotFailed() {
+    if (this.failure) {
+      fail();
+    }
+  }
+  verifyOperationInProgress() {
+  }
+  /**
+   * Waits until all currently queued tasks are finished executing. Delayed
+   * operations are not run.
+   */
+  async drain() {
+    let currentTail;
+    do {
+      currentTail = this.tail;
+      await currentTail;
+    } while (currentTail !== this.tail);
+  }
+  /**
+   * For Tests: Determine if a delayed operation with a particular TimerId
+   * exists.
+   */
+  containsDelayedOperation(timerId) {
+    for (const op of this.delayedOperations) {
+      if (op.timerId === timerId) {
+        return true;
+      }
+    }
+    return false;
+  }
+  /**
+   * For Tests: Runs some or all delayed operations early.
+   *
+   * @param lastTimerId - Delayed operations up to and including this TimerId
+   * will be drained. Pass TimerId.All to run all delayed operations.
+   * @returns a Promise that resolves once all operations have been run.
+   */
+  runAllDelayedOperationsUntil(lastTimerId) {
+    return this.drain().then(() => {
+      this.delayedOperations.sort((a, b) => a.targetTimeMs - b.targetTimeMs);
+      for (const op of this.delayedOperations) {
+        op.skipDelay();
+        if (lastTimerId !== "all" && op.timerId === lastTimerId) {
+          break;
+        }
+      }
+      return this.drain();
+    });
+  }
+  /**
+   * For Tests: Skip all subsequent delays for a timer id.
+   */
+  skipDelaysForTimerId(timerId) {
+    this.timerIdsToSkip.push(timerId);
+  }
+  /** Called once a DelayedOperation is run or canceled. */
+  removeDelayedOperation(op) {
+    const index = this.delayedOperations.indexOf(op);
+    this.delayedOperations.splice(index, 1);
+  }
+};
+function getMessageOrStack(error) {
+  let message = error.message || "";
+  if (error.stack) {
+    if (error.stack.includes(error.message)) {
+      message = error.stack;
+    } else {
+      message = error.message + "\n" + error.stack;
+    }
+  }
+  return message;
+}
+var Firestore = class extends Firestore$1 {
+  /** @hideconstructor */
+  constructor(authCredentialsProvider, appCheckCredentialsProvider, databaseId, app) {
+    super(authCredentialsProvider, appCheckCredentialsProvider, databaseId, app);
+    this.type = "firestore";
+    this._queue = new AsyncQueueImpl();
+    this._persistenceKey = (app === null || app === void 0 ? void 0 : app.name) || "[DEFAULT]";
+  }
+  async _terminate() {
+    if (this._firestoreClient) {
+      const terminate = this._firestoreClient.terminate();
+      this._queue = new AsyncQueueImpl(terminate);
+      this._firestoreClient = void 0;
+      await terminate;
+    }
+  }
+};
+function registerFirestore(variant, useFetchStreams = true) {
+  setSDKVersion(SDK_VERSION);
+  _registerComponent(new Component("firestore", (container, { instanceIdentifier: databaseId, options: settings }) => {
+    const app = container.getProvider("app").getImmediate();
+    const firestoreInstance = new Firestore(new FirebaseAuthCredentialsProvider(container.getProvider("auth-internal")), new FirebaseAppCheckTokenProvider(container.getProvider("app-check-internal")), databaseIdFromApp(app, databaseId), app);
+    settings = Object.assign({ useFetchStreams }, settings);
+    firestoreInstance._setSettings(settings);
+    return firestoreInstance;
+  }, "PUBLIC").setMultipleInstances(true));
+  registerVersion(name2, version$12, variant);
+  registerVersion(name2, version$12, "esm2017");
+}
+var FIELD_PATH_RESERVED = new RegExp("[~\\*/\\[\\]]");
+registerFirestore("node");
+
+// src/admin/booking/booking.calculator.ts
+var import_firestore = require("firebase/firestore");
+var BookingAvailabilityCalculator = class {
+  /**
+   * Calculate available booking slots based on the provided data
+   *
+   * @param request - The request containing all necessary data for calculation
+   * @returns Response with available booking slots
+   */
+  static calculateSlots(request) {
+    const {
+      clinic,
+      practitioner,
+      procedure,
+      timeframe,
+      clinicCalendarEvents,
+      practitionerCalendarEvents
+    } = request;
+    const schedulingIntervalMinutes = clinic.schedulingInterval || this.DEFAULT_INTERVAL_MINUTES;
+    const procedureDurationMinutes = procedure.duration;
+    console.log(
+      `Calculating slots with interval: ${schedulingIntervalMinutes}min and procedure duration: ${procedureDurationMinutes}min`
+    );
+    let availableIntervals = [
+      { start: timeframe.start, end: timeframe.end }
+    ];
+    availableIntervals = this.applyClinicWorkingHours(
+      availableIntervals,
+      clinic.workingHours,
+      timeframe
+    );
+    availableIntervals = this.subtractBlockingEvents(
+      availableIntervals,
+      clinicCalendarEvents
+    );
+    availableIntervals = this.applyPractitionerWorkingHours(
+      availableIntervals,
+      practitioner,
+      clinic.id,
+      timeframe
+    );
+    availableIntervals = this.subtractPractitionerBusyTimes(
+      availableIntervals,
+      practitionerCalendarEvents
+    );
+    console.log(
+      `After all filters, have ${availableIntervals.length} available intervals`
+    );
+    const availableSlots = this.generateAvailableSlots(
+      availableIntervals,
+      schedulingIntervalMinutes,
+      procedureDurationMinutes
+    );
+    return { availableSlots };
+  }
+  /**
+   * Apply clinic working hours to available intervals
+   *
+   * @param intervals - Current available intervals
+   * @param workingHours - Clinic working hours
+   * @param timeframe - Overall timeframe being considered
+   * @returns Intervals filtered by clinic working hours
+   */
+  static applyClinicWorkingHours(intervals, workingHours, timeframe) {
+    if (!intervals.length) return [];
+    console.log(
+      `Applying clinic working hours to ${intervals.length} intervals`
+    );
+    const workingIntervals = this.createWorkingHoursIntervals(
+      workingHours,
+      timeframe.start.toDate(),
+      timeframe.end.toDate()
+    );
+    return this.intersectIntervals(intervals, workingIntervals);
+  }
+  /**
+   * Create time intervals for working hours across multiple days
+   *
+   * @param workingHours - Working hours definition
+   * @param startDate - Start date of the overall timeframe
+   * @param endDate - End date of the overall timeframe
+   * @returns Array of time intervals representing working hours
+   */
+  static createWorkingHoursIntervals(workingHours, startDate, endDate) {
+    const workingIntervals = [];
+    const currentDate = new Date(startDate);
+    currentDate.setHours(0, 0, 0, 0);
+    const dayNameToNumber = {
+      sunday: 0,
+      monday: 1,
+      tuesday: 2,
+      wednesday: 3,
+      thursday: 4,
+      friday: 5,
+      saturday: 6
+    };
+    while (currentDate <= endDate) {
+      const dayOfWeek = currentDate.getDay();
+      const dayName = Object.keys(dayNameToNumber).find(
+        (key) => dayNameToNumber[key] === dayOfWeek
+      );
+      if (dayName && workingHours[dayName]) {
+        const daySchedule = workingHours[dayName];
+        if (daySchedule) {
+          const [openHours, openMinutes] = daySchedule.open.split(":").map(Number);
+          const [closeHours, closeMinutes] = daySchedule.close.split(":").map(Number);
+          const workStart = new Date(currentDate);
+          workStart.setHours(openHours, openMinutes, 0, 0);
+          const workEnd = new Date(currentDate);
+          workEnd.setHours(closeHours, closeMinutes, 0, 0);
+          if (workEnd > startDate && workStart < endDate) {
+            const intervalStart = workStart < startDate ? startDate : workStart;
+            const intervalEnd = workEnd > endDate ? endDate : workEnd;
+            workingIntervals.push({
+              start: import_firestore.Timestamp.fromDate(intervalStart),
+              end: import_firestore.Timestamp.fromDate(intervalEnd)
+            });
+            if (daySchedule.breaks && daySchedule.breaks.length > 0) {
+              for (const breakTime of daySchedule.breaks) {
+                const [breakStartHours, breakStartMinutes] = breakTime.start.split(":").map(Number);
+                const [breakEndHours, breakEndMinutes] = breakTime.end.split(":").map(Number);
+                const breakStart = new Date(currentDate);
+                breakStart.setHours(breakStartHours, breakStartMinutes, 0, 0);
+                const breakEnd = new Date(currentDate);
+                breakEnd.setHours(breakEndHours, breakEndMinutes, 0, 0);
+                workingIntervals.splice(
+                  -1,
+                  1,
+                  ...this.subtractInterval(
+                    workingIntervals[workingIntervals.length - 1],
+                    {
+                      start: import_firestore.Timestamp.fromDate(breakStart),
+                      end: import_firestore.Timestamp.fromDate(breakEnd)
+                    }
+                  )
+                );
+              }
+            }
+          }
+        }
+      }
+      currentDate.setDate(currentDate.getDate() + 1);
+    }
+    return workingIntervals;
+  }
+  /**
+   * Subtract blocking events from available intervals
+   *
+   * @param intervals - Current available intervals
+   * @param events - Calendar events to subtract
+   * @returns Available intervals after removing blocking events
+   */
+  static subtractBlockingEvents(intervals, events) {
+    if (!intervals.length) return [];
+    console.log(`Subtracting ${events.length} blocking events`);
+    const blockingEvents = events.filter(
+      (event) => event.eventType === "blocking" /* BLOCKING */ || event.eventType === "break" /* BREAK */ || event.eventType === "free_day" /* FREE_DAY */
+    );
+    let result = [...intervals];
+    for (const event of blockingEvents) {
+      const { start, end } = event.eventTime;
+      const blockingInterval = { start, end };
+      const newResult = [];
+      for (const interval of result) {
+        const remainingIntervals = this.subtractInterval(
+          interval,
+          blockingInterval
+        );
+        newResult.push(...remainingIntervals);
+      }
+      result = newResult;
+    }
+    return result;
+  }
+  /**
+   * Apply practitioner's specific working hours for the given clinic
+   *
+   * @param intervals - Current available intervals
+   * @param practitioner - Practitioner object
+   * @param clinicId - ID of the clinic
+   * @param timeframe - Overall timeframe being considered
+   * @returns Intervals filtered by practitioner's working hours
+   */
+  static applyPractitionerWorkingHours(intervals, practitioner, clinicId, timeframe) {
+    if (!intervals.length) return [];
+    console.log(`Applying practitioner working hours for clinic ${clinicId}`);
+    const clinicWorkingHours = practitioner.clinicWorkingHours.find(
+      (hours) => hours.clinicId === clinicId && hours.isActive
+    );
+    if (!clinicWorkingHours) {
+      console.log(
+        `No working hours found for practitioner at clinic ${clinicId}`
+      );
+      return [];
+    }
+    const workingIntervals = this.createPractitionerWorkingHoursIntervals(
+      clinicWorkingHours.workingHours,
+      timeframe.start.toDate(),
+      timeframe.end.toDate()
+    );
+    return this.intersectIntervals(intervals, workingIntervals);
+  }
+  /**
+   * Create time intervals for practitioner's working hours across multiple days
+   *
+   * @param workingHours - Practitioner's working hours definition
+   * @param startDate - Start date of the overall timeframe
+   * @param endDate - End date of the overall timeframe
+   * @returns Array of time intervals representing practitioner's working hours
+   */
+  static createPractitionerWorkingHoursIntervals(workingHours, startDate, endDate) {
+    const workingIntervals = [];
+    const currentDate = new Date(startDate);
+    currentDate.setHours(0, 0, 0, 0);
+    const dayNameToNumber = {
+      sunday: 0,
+      monday: 1,
+      tuesday: 2,
+      wednesday: 3,
+      thursday: 4,
+      friday: 5,
+      saturday: 6
+    };
+    while (currentDate <= endDate) {
+      const dayOfWeek = currentDate.getDay();
+      const dayName = Object.keys(dayNameToNumber).find(
+        (key) => dayNameToNumber[key] === dayOfWeek
+      );
+      if (dayName && workingHours[dayName]) {
+        const daySchedule = workingHours[dayName];
+        if (daySchedule) {
+          const [startHours, startMinutes] = daySchedule.start.split(":").map(Number);
+          const [endHours, endMinutes] = daySchedule.end.split(":").map(Number);
+          const workStart = new Date(currentDate);
+          workStart.setHours(startHours, startMinutes, 0, 0);
+          const workEnd = new Date(currentDate);
+          workEnd.setHours(endHours, endMinutes, 0, 0);
+          if (workEnd > startDate && workStart < endDate) {
+            const intervalStart = workStart < startDate ? startDate : workStart;
+            const intervalEnd = workEnd > endDate ? endDate : workEnd;
+            workingIntervals.push({
+              start: import_firestore.Timestamp.fromDate(intervalStart),
+              end: import_firestore.Timestamp.fromDate(intervalEnd)
+            });
+          }
+        }
+      }
+      currentDate.setDate(currentDate.getDate() + 1);
+    }
+    return workingIntervals;
+  }
+  /**
+   * Subtract practitioner's busy times from available intervals
+   *
+   * @param intervals - Current available intervals
+   * @param events - Practitioner's calendar events
+   * @returns Available intervals after removing busy times
+   */
+  static subtractPractitionerBusyTimes(intervals, events) {
+    if (!intervals.length) return [];
+    console.log(`Subtracting ${events.length} practitioner events`);
+    const busyEvents = events.filter(
+      (event) => (
+        // Include all blocking events
+        event.eventType === "blocking" /* BLOCKING */ || event.eventType === "break" /* BREAK */ || event.eventType === "free_day" /* FREE_DAY */ || // Include appointments that are pending, confirmed, or rescheduled
+        event.eventType === "appointment" /* APPOINTMENT */ && (event.status === "pending" /* PENDING */ || event.status === "confirmed" /* CONFIRMED */ || event.status === "rescheduled" /* RESCHEDULED */)
+      )
+    );
+    let result = [...intervals];
+    for (const event of busyEvents) {
+      const { start, end } = event.eventTime;
+      const busyInterval = { start, end };
+      const newResult = [];
+      for (const interval of result) {
+        const remainingIntervals = this.subtractInterval(
+          interval,
+          busyInterval
+        );
+        newResult.push(...remainingIntervals);
+      }
+      result = newResult;
+    }
+    return result;
   }
   /**
-   * Terminates all components used by this client. Subclasses can override
-   * this method to clean up their own dependencies, but must also call this
-   * method.
+   * Generate available booking slots based on the final available intervals
    *
-   * Only ever called once.
+   * @param intervals - Final available intervals
+   * @param intervalMinutes - Scheduling interval in minutes
+   * @param durationMinutes - Procedure duration in minutes
+   * @returns Array of available booking slots
    */
-  _terminate() {
-    removeComponents(this);
-    return Promise.resolve();
-  }
-};
-var LOG_TAG = "AsyncQueue";
-var AsyncQueueImpl = class {
-  constructor(tail = Promise.resolve()) {
-    this.retryableOps = [];
-    this._isShuttingDown = false;
-    this.delayedOperations = [];
-    this.failure = null;
-    this.operationInProgress = false;
-    this.skipNonRestrictedTasks = false;
-    this.timerIdsToSkip = [];
-    this.backoff = new ExponentialBackoff(
-      this,
-      "async_queue_retry"
-      /* TimerId.AsyncQueueRetry */
+  static generateAvailableSlots(intervals, intervalMinutes, durationMinutes) {
+    const slots = [];
+    console.log(
+      `Generating slots with ${intervalMinutes}min intervals for ${durationMinutes}min procedure`
     );
-    this.visibilityHandler = () => {
-      this.backoff.skipBackoff();
-    };
-    this.tail = tail;
-  }
-  get isShuttingDown() {
-    return this._isShuttingDown;
+    const durationMs = durationMinutes * 60 * 1e3;
+    const intervalMs = intervalMinutes * 60 * 1e3;
+    for (const interval of intervals) {
+      const intervalStart = interval.start.toDate();
+      const intervalEnd = interval.end.toDate();
+      let slotStart = new Date(intervalStart);
+      const minutesIntoDay = slotStart.getHours() * 60 + slotStart.getMinutes();
+      const minutesRemainder = minutesIntoDay % intervalMinutes;
+      if (minutesRemainder > 0) {
+        slotStart.setMinutes(
+          slotStart.getMinutes() + (intervalMinutes - minutesRemainder)
+        );
+      }
+      while (slotStart.getTime() + durationMs <= intervalEnd.getTime()) {
+        const slotEnd = new Date(slotStart.getTime() + durationMs);
+        if (this.isSlotFullyAvailable(slotStart, slotEnd, intervals)) {
+          slots.push({
+            start: import_firestore.Timestamp.fromDate(slotStart)
+          });
+        }
+        slotStart = new Date(slotStart.getTime() + intervalMs);
+      }
+    }
+    console.log(`Generated ${slots.length} available slots`);
+    return slots;
   }
   /**
-   * Adds a new operation to the queue without waiting for it to complete (i.e.
-   * we ignore the Promise result).
+   * Check if a time slot is fully available within the given intervals
+   *
+   * @param slotStart - Start time of the slot
+   * @param slotEnd - End time of the slot
+   * @param intervals - Available intervals
+   * @returns True if the slot is fully contained within an available interval
    */
-  enqueueAndForget(op) {
-    this.enqueue(op);
-  }
-  enqueueAndForgetEvenWhileRestricted(op) {
-    this.verifyNotFailed();
-    this.enqueueInternal(op);
+  static isSlotFullyAvailable(slotStart, slotEnd, intervals) {
+    return intervals.some((interval) => {
+      const intervalStart = interval.start.toDate();
+      const intervalEnd = interval.end.toDate();
+      return slotStart >= intervalStart && slotEnd <= intervalEnd;
+    });
   }
-  enterRestrictedMode(purgeExistingTasks) {
-    if (!this._isShuttingDown) {
-      this._isShuttingDown = true;
-      this.skipNonRestrictedTasks = purgeExistingTasks || false;
+  /**
+   * Intersect two sets of time intervals
+   *
+   * @param intervalsA - First set of intervals
+   * @param intervalsB - Second set of intervals
+   * @returns Intersection of the two sets of intervals
+   */
+  static intersectIntervals(intervalsA, intervalsB) {
+    const result = [];
+    for (const intervalA of intervalsA) {
+      for (const intervalB of intervalsB) {
+        const intersectionStart = intervalA.start.toMillis() > intervalB.start.toMillis() ? intervalA.start : intervalB.start;
+        const intersectionEnd = intervalA.end.toMillis() < intervalB.end.toMillis() ? intervalA.end : intervalB.end;
+        if (intersectionStart.toMillis() < intersectionEnd.toMillis()) {
+          result.push({
+            start: intersectionStart,
+            end: intersectionEnd
+          });
+        }
+      }
     }
+    return this.mergeOverlappingIntervals(result);
   }
-  enqueue(op) {
-    this.verifyNotFailed();
-    if (this._isShuttingDown) {
-      return new Promise(() => {
-      });
+  /**
+   * Subtract one interval from another, potentially resulting in 0, 1, or 2 intervals
+   *
+   * @param interval - Interval to subtract from
+   * @param subtrahend - Interval to subtract
+   * @returns Array of remaining intervals after subtraction
+   */
+  static subtractInterval(interval, subtrahend) {
+    if (interval.end.toMillis() <= subtrahend.start.toMillis() || interval.start.toMillis() >= subtrahend.end.toMillis()) {
+      return [interval];
     }
-    const task = new Deferred2();
-    return this.enqueueInternal(() => {
-      if (this._isShuttingDown && this.skipNonRestrictedTasks) {
-        return Promise.resolve();
+    if (subtrahend.start.toMillis() <= interval.start.toMillis() && subtrahend.end.toMillis() >= interval.end.toMillis()) {
+      return [];
+    }
+    if (subtrahend.start.toMillis() > interval.start.toMillis() && subtrahend.end.toMillis() < interval.end.toMillis()) {
+      return [
+        {
+          start: interval.start,
+          end: subtrahend.start
+        },
+        {
+          start: subtrahend.end,
+          end: interval.end
+        }
+      ];
+    }
+    if (subtrahend.start.toMillis() <= interval.start.toMillis() && subtrahend.end.toMillis() > interval.start.toMillis()) {
+      return [
+        {
+          start: subtrahend.end,
+          end: interval.end
+        }
+      ];
+    }
+    return [
+      {
+        start: interval.start,
+        end: subtrahend.start
       }
-      op().then(task.resolve, task.reject);
-      return task.promise;
-    }).then(() => task.promise);
-  }
-  enqueueRetryable(op) {
-    this.enqueueAndForget(() => {
-      this.retryableOps.push(op);
-      return this.retryNextOp();
-    });
+    ];
   }
   /**
-   * Runs the next operation from the retryable queue. If the operation fails,
-   * reschedules with backoff.
+   * Merge overlapping intervals to simplify the result
+   *
+   * @param intervals - Intervals to merge
+   * @returns Merged intervals
    */
-  async retryNextOp() {
-    if (this.retryableOps.length === 0) {
-      return;
-    }
-    try {
-      await this.retryableOps[0]();
-      this.retryableOps.shift();
-      this.backoff.reset();
-    } catch (e) {
-      if (isIndexedDbTransactionError(e)) {
-        logDebug(LOG_TAG, "Operation failed with retryable error: " + e);
+  static mergeOverlappingIntervals(intervals) {
+    if (intervals.length <= 1) return intervals;
+    const sorted = [...intervals].sort(
+      (a, b) => a.start.toMillis() - b.start.toMillis()
+    );
+    const result = [sorted[0]];
+    for (let i = 1; i < sorted.length; i++) {
+      const current = sorted[i];
+      const lastResult = result[result.length - 1];
+      if (current.start.toMillis() <= lastResult.end.toMillis()) {
+        if (current.end.toMillis() > lastResult.end.toMillis()) {
+          lastResult.end = current.end;
+        }
       } else {
-        throw e;
+        result.push(current);
       }
     }
-    if (this.retryableOps.length > 0) {
-      this.backoff.backoffAndRun(() => this.retryNextOp());
-    }
-  }
-  enqueueInternal(op) {
-    const newTail = this.tail.then(() => {
-      this.operationInProgress = true;
-      return op().catch((error) => {
-        this.failure = error;
-        this.operationInProgress = false;
-        const message = getMessageOrStack(error);
-        logError("INTERNAL UNHANDLED ERROR: ", message);
-        throw error;
-      }).then((result) => {
-        this.operationInProgress = false;
-        return result;
-      });
-    });
-    this.tail = newTail;
-    return newTail;
+    return result;
   }
-  enqueueAfterDelay(timerId, delayMs, op) {
-    this.verifyNotFailed();
-    if (this.timerIdsToSkip.indexOf(timerId) > -1) {
-      delayMs = 0;
-    }
-    const delayedOp = DelayedOperation.createAndSchedule(this, timerId, delayMs, op, (removedOp) => this.removeDelayedOperation(removedOp));
-    this.delayedOperations.push(delayedOp);
-    return delayedOp;
+};
+/** Default scheduling interval in minutes if not specified by the clinic */
+BookingAvailabilityCalculator.DEFAULT_INTERVAL_MINUTES = 15;
+
+// src/types/appointment/index.ts
+var APPOINTMENTS_COLLECTION = "appointments";
+
+// src/admin/booking/booking.admin.ts
+var BookingAdmin = class {
+  /**
+   * Creates a new BookingAdmin instance
+   * @param firestore - Firestore instance provided by the caller
+   */
+  constructor(firestore9) {
+    this.db = firestore9 || admin7.firestore();
   }
-  verifyNotFailed() {
-    if (this.failure) {
-      fail();
+  /**
+   * Gets available booking time slots for a specific clinic, practitioner, and procedure
+   *
+   * @param clinicId - ID of the clinic
+   * @param practitionerId - ID of the practitioner
+   * @param procedureId - ID of the procedure
+   * @param timeframe - Time range to check for availability
+   * @returns Promise resolving to an array of available booking slots
+   */
+  async getAvailableBookingSlots(clinicId, practitionerId, procedureId, timeframe) {
+    try {
+      console.log(
+        `[BookingAdmin] Getting available slots for clinic ${clinicId}, practitioner ${practitionerId}, procedure ${procedureId}`
+      );
+      const start = timeframe.start instanceof Date ? admin7.firestore.Timestamp.fromDate(timeframe.start) : timeframe.start;
+      const end = timeframe.end instanceof Date ? admin7.firestore.Timestamp.fromDate(timeframe.end) : timeframe.end;
+      const clinicDoc = await this.db.collection("clinics").doc(clinicId).get();
+      if (!clinicDoc.exists) {
+        throw new Error(`Clinic ${clinicId} not found`);
+      }
+      const clinic = clinicDoc.data();
+      const practitionerDoc = await this.db.collection("practitioners").doc(practitionerId).get();
+      if (!practitionerDoc.exists) {
+        throw new Error(`Practitioner ${practitionerId} not found`);
+      }
+      const practitioner = practitionerDoc.data();
+      const procedureDoc = await this.db.collection("procedures").doc(procedureId).get();
+      if (!procedureDoc.exists) {
+        throw new Error(`Procedure ${procedureId} not found`);
+      }
+      const procedure = procedureDoc.data();
+      const clinicCalendarEvents = await this.getClinicCalendarEvents(
+        clinicId,
+        start,
+        end
+      );
+      const practitionerCalendarEvents = await this.getPractitionerCalendarEvents(practitionerId, start, end);
+      const convertedTimeframe = {
+        start: this.adminTimestampToClientTimestamp(start),
+        end: this.adminTimestampToClientTimestamp(end)
+      };
+      const request = {
+        clinic,
+        practitioner,
+        procedure,
+        timeframe: convertedTimeframe,
+        clinicCalendarEvents: this.convertEventsTimestamps(clinicCalendarEvents),
+        practitionerCalendarEvents: this.convertEventsTimestamps(
+          practitionerCalendarEvents
+        )
+      };
+      const result = BookingAvailabilityCalculator.calculateSlots(request);
+      return {
+        availableSlots: result.availableSlots.map((slot) => ({
+          start: admin7.firestore.Timestamp.fromMillis(slot.start.toMillis())
+        }))
+      };
+    } catch (error) {
+      console.error("[BookingAdmin] Error getting available slots:", error);
+      throw error;
     }
   }
-  verifyOperationInProgress() {
-  }
   /**
-   * Waits until all currently queued tasks are finished executing. Delayed
-   * operations are not run.
+   * Converts an admin Firestore Timestamp to a client Firestore Timestamp
    */
-  async drain() {
-    let currentTail;
-    do {
-      currentTail = this.tail;
-      await currentTail;
-    } while (currentTail !== this.tail);
+  adminTimestampToClientTimestamp(timestamp) {
+    return {
+      seconds: timestamp.seconds,
+      nanoseconds: timestamp.nanoseconds,
+      toDate: () => timestamp.toDate(),
+      toMillis: () => timestamp.toMillis(),
+      valueOf: () => timestamp.valueOf()
+      // Add any other required methods/properties
+    };
   }
   /**
-   * For Tests: Determine if a delayed operation with a particular TimerId
-   * exists.
+   * Converts timestamps in calendar events from admin Firestore Timestamps to client Firestore Timestamps
    */
-  containsDelayedOperation(timerId) {
-    for (const op of this.delayedOperations) {
-      if (op.timerId === timerId) {
-        return true;
+  convertEventsTimestamps(events) {
+    return events.map((event) => ({
+      ...event,
+      eventTime: {
+        start: this.adminTimestampToClientTimestamp(event.eventTime.start),
+        end: this.adminTimestampToClientTimestamp(event.eventTime.end)
       }
-    }
-    return false;
+      // Convert any other timestamps in the event if needed
+    }));
   }
   /**
-   * For Tests: Runs some or all delayed operations early.
+   * Fetches clinic calendar events for a specific time range
    *
-   * @param lastTimerId - Delayed operations up to and including this TimerId
-   * will be drained. Pass TimerId.All to run all delayed operations.
-   * @returns a Promise that resolves once all operations have been run.
+   * @param clinicId - ID of the clinic
+   * @param start - Start time of the range
+   * @param end - End time of the range
+   * @returns Promise resolving to an array of calendar events
    */
-  runAllDelayedOperationsUntil(lastTimerId) {
-    return this.drain().then(() => {
-      this.delayedOperations.sort((a, b) => a.targetTimeMs - b.targetTimeMs);
-      for (const op of this.delayedOperations) {
-        op.skipDelay();
-        if (lastTimerId !== "all" && op.timerId === lastTimerId) {
-          break;
-        }
-      }
-      return this.drain();
-    });
+  async getClinicCalendarEvents(clinicId, start, end) {
+    try {
+      const eventsRef = this.db.collection(`clinics/${clinicId}/calendar`).where("eventTime.start", ">=", start).where("eventTime.start", "<=", end);
+      const snapshot = await eventsRef.get();
+      return snapshot.docs.map((doc) => ({
+        ...doc.data(),
+        id: doc.id
+      }));
+    } catch (error) {
+      console.error(
+        `[BookingAdmin] Error fetching clinic calendar events:`,
+        error
+      );
+      return [];
+    }
   }
   /**
-   * For Tests: Skip all subsequent delays for a timer id.
+   * Fetches practitioner calendar events for a specific time range
+   *
+   * @param practitionerId - ID of the practitioner
+   * @param start - Start time of the range
+   * @param end - End time of the range
+   * @returns Promise resolving to an array of calendar events
    */
-  skipDelaysForTimerId(timerId) {
-    this.timerIdsToSkip.push(timerId);
-  }
-  /** Called once a DelayedOperation is run or canceled. */
-  removeDelayedOperation(op) {
-    const index = this.delayedOperations.indexOf(op);
-    this.delayedOperations.splice(index, 1);
-  }
-};
-function getMessageOrStack(error) {
-  let message = error.message || "";
-  if (error.stack) {
-    if (error.stack.includes(error.message)) {
-      message = error.stack;
-    } else {
-      message = error.message + "\n" + error.stack;
+  async getPractitionerCalendarEvents(practitionerId, start, end) {
+    try {
+      const eventsRef = this.db.collection(`practitioners/${practitionerId}/calendar`).where("eventTime.start", ">=", start).where("eventTime.start", "<=", end);
+      const snapshot = await eventsRef.get();
+      return snapshot.docs.map((doc) => ({
+        ...doc.data(),
+        id: doc.id
+      }));
+    } catch (error) {
+      console.error(
+        `[BookingAdmin] Error fetching practitioner calendar events:`,
+        error
+      );
+      return [];
     }
   }
-  return message;
-}
-var Firestore = class extends Firestore$1 {
-  /** @hideconstructor */
-  constructor(authCredentialsProvider, appCheckCredentialsProvider, databaseId, app) {
-    super(authCredentialsProvider, appCheckCredentialsProvider, databaseId, app);
-    this.type = "firestore";
-    this._queue = new AsyncQueueImpl();
-    this._persistenceKey = (app === null || app === void 0 ? void 0 : app.name) || "[DEFAULT]";
-  }
-  async _terminate() {
-    if (this._firestoreClient) {
-      const terminate = this._firestoreClient.terminate();
-      this._queue = new AsyncQueueImpl(terminate);
-      this._firestoreClient = void 0;
-      await terminate;
+  /**
+   * Orchestrates the creation of a new appointment, including data aggregation.
+   * This method is intended to be called from a trusted backend environment (e.g., an Express route handler in a Cloud Function).
+   *
+   * @param data - Data required to create the appointment.
+   * @param authenticatedUserId - The ID of the user making the request (for auditing, and usually is the patientId).
+   * @returns Promise resolving to an object indicating success, and appointmentId or an error message.
+   */
+  async orchestrateAppointmentCreation(data, authenticatedUserId) {
+    var _a;
+    console.log(
+      `[BookingAdmin] Orchestrating appointment creation for patient ${data.patientId} by user ${authenticatedUserId}`
+    );
+    try {
+      if (!data.patientId || !data.procedureId || !data.appointmentStartTime || !data.appointmentEndTime) {
+        return {
+          success: false,
+          error: "Missing required fields: patientId, procedureId, appointmentStartTime, or appointmentEndTime."
+        };
+      }
+      if (data.appointmentEndTime.toMillis() <= data.appointmentStartTime.toMillis()) {
+        return {
+          success: false,
+          error: "Appointment end time must be after start time."
+        };
+      }
+      if (authenticatedUserId !== data.patientId) {
+        console.warn(
+          `[BookingAdmin] Authenticated user ${authenticatedUserId} is booking for a different patient ${data.patientId}. Review authorization if this is not intended.`
+        );
+      }
+      const procedureRef = this.db.collection(PROCEDURES_COLLECTION).doc(data.procedureId);
+      const procedureDoc = await procedureRef.get();
+      if (!procedureDoc.exists) {
+        return {
+          success: false,
+          error: `Procedure ${data.procedureId} not found.`
+        };
+      }
+      const procedure = procedureDoc.data();
+      const clinicRef = this.db.collection(CLINICS_COLLECTION).doc(procedure.clinicBranchId);
+      const clinicSnap = await clinicRef.get();
+      if (!clinicSnap.exists) {
+        return {
+          success: false,
+          error: `Clinic ${procedure.clinicBranchId} not found.`
+        };
+      }
+      const clinicData = clinicSnap.data();
+      const practitionerRef = this.db.collection(PRACTITIONERS_COLLECTION).doc(procedure.practitionerId);
+      const patientProfileRef = this.db.collection(PATIENTS_COLLECTION).doc(data.patientId);
+      const patientSensitiveRef = this.db.collection(PATIENTS_COLLECTION).doc(data.patientId).collection(PATIENT_SENSITIVE_INFO_COLLECTION).doc(data.patientId);
+      const clinicGroupRef = this.db.collection(CLINIC_GROUPS_COLLECTION).doc(clinicData.clinicGroupId);
+      const [
+        practitionerSnap,
+        patientProfileSnap,
+        patientSensitiveSnap,
+        clinicGroupSnap
+      ] = await Promise.all([
+        // clinicRef.get() is already done via clinicSnap
+        practitionerRef.get(),
+        patientProfileRef.get(),
+        patientSensitiveRef.get(),
+        clinicGroupRef.get()
+        // Fetch the defined clinicGroupRef
+      ]);
+      if (!practitionerSnap.exists)
+        return {
+          success: false,
+          error: `Practitioner ${procedure.practitionerId} not found.`
+        };
+      if (!patientProfileSnap.exists)
+        return {
+          success: false,
+          error: `PatientProfile ${data.patientId} not found.`
+        };
+      if (!clinicGroupSnap.exists)
+        return {
+          success: false,
+          error: `ClinicGroup for clinic ${procedure.clinicBranchId} not found.`
+        };
+      const practitionerData = practitionerSnap.data();
+      const patientProfileData = patientProfileSnap.data();
+      const patientSensitiveData = patientSensitiveSnap.exists ? patientSensitiveSnap.data() : void 0;
+      const clinicGroupData = clinicGroupSnap.data();
+      const autoConfirm = clinicGroupData.autoConfirmAppointments || false;
+      const initialStatus = autoConfirm ? "confirmed" /* CONFIRMED */ : "pending" /* PENDING */;
+      const clinicInfo = {
+        id: clinicSnap.id,
+        name: clinicData.name,
+        featuredPhoto: clinicData.coverPhoto || clinicData.logo || "",
+        description: clinicData.description,
+        location: clinicData.location,
+        contactInfo: clinicData.contactInfo
+      };
+      const practitionerInfo = {
+        id: practitionerSnap.id,
+        practitionerPhoto: practitionerData.basicInfo.profileImageUrl || null,
+        name: `${practitionerData.basicInfo.firstName} ${practitionerData.basicInfo.lastName}`,
+        email: practitionerData.basicInfo.email,
+        phone: practitionerData.basicInfo.phoneNumber || null,
+        certification: practitionerData.certification
+      };
+      const patientInfo = {
+        id: patientProfileSnap.id,
+        fullName: `${(patientSensitiveData == null ? void 0 : patientSensitiveData.firstName) || ""} ${(patientSensitiveData == null ? void 0 : patientSensitiveData.lastName) || ""}`.trim() || patientProfileData.displayName,
+        email: (patientSensitiveData == null ? void 0 : patientSensitiveData.email) || "",
+        phone: (patientSensitiveData == null ? void 0 : patientSensitiveData.phoneNumber) || patientProfileData.phoneNumber || null,
+        dateOfBirth: (patientSensitiveData == null ? void 0 : patientSensitiveData.dateOfBirth) || patientProfileData.dateOfBirth || admin7.firestore.Timestamp.now(),
+        gender: (patientSensitiveData == null ? void 0 : patientSensitiveData.gender) || "other" /* OTHER */
+      };
+      const procedureCategory = procedure.category;
+      const procedureSubCategory = procedure.subcategory;
+      const procedureTechnology = procedure.technology;
+      const procedureProduct = procedure.product;
+      const procedureInfo = {
+        id: procedure.id,
+        name: procedure.name,
+        description: procedure.description,
+        family: procedure.family,
+        categoryName: (procedureCategory == null ? void 0 : procedureCategory.name) || "",
+        subcategoryName: (procedureSubCategory == null ? void 0 : procedureSubCategory.name) || "",
+        technologyName: (procedureTechnology == null ? void 0 : procedureTechnology.name) || "",
+        price: procedure.price,
+        pricingMeasure: procedure.pricingMeasure,
+        currency: procedure.currency,
+        duration: procedure.duration,
+        clinicId: procedure.clinicBranchId,
+        clinicName: clinicData.name,
+        practitionerId: procedure.practitionerId,
+        practitionerName: `${practitionerData.basicInfo.firstName} ${practitionerData.basicInfo.lastName}`,
+        photo: ((_a = procedure.photos) == null ? void 0 : _a[0]) || "",
+        brandName: (procedureProduct == null ? void 0 : procedureProduct.brandName) || "",
+        productName: (procedureProduct == null ? void 0 : procedureProduct.name) || ""
+      };
+      const procedureExtendedInfo = {
+        id: procedure.id,
+        name: procedure.name,
+        description: procedure.description,
+        cost: procedure.price,
+        duration: procedure.duration,
+        procedureFamily: procedure.family,
+        procedureCategoryId: (procedureCategory == null ? void 0 : procedureCategory.id) || "",
+        procedureCategoryName: (procedureCategory == null ? void 0 : procedureCategory.name) || "",
+        procedureSubCategoryId: (procedureSubCategory == null ? void 0 : procedureSubCategory.id) || "",
+        procedureSubCategoryName: (procedureSubCategory == null ? void 0 : procedureSubCategory.name) || "",
+        procedureTechnologyId: (procedureTechnology == null ? void 0 : procedureTechnology.id) || "",
+        procedureTechnologyName: (procedureTechnology == null ? void 0 : procedureTechnology.name) || "",
+        procedureProductBrandId: procedureProduct.brandId || "",
+        procedureProductBrandName: procedureProduct.brandName || "",
+        procedureProductId: procedureProduct.id || "",
+        procedureProductName: procedureProduct.name || ""
+      };
+      let pendingUserFormsIds = [];
+      let linkedFormIds = [];
+      if (procedure.documentationTemplates && Array.isArray(procedure.documentationTemplates)) {
+        pendingUserFormsIds = procedure.documentationTemplates.filter(
+          (template) => template.isUserForm && template.isRequired
+        ).map((template) => template.id);
+        linkedFormIds = procedure.documentationTemplates.map(
+          (template) => template.id
+        );
+      }
+      const newAppointmentId = this.db.collection(APPOINTMENTS_COLLECTION).doc().id;
+      const serverTimestampValue = admin7.firestore.FieldValue.serverTimestamp();
+      const adminTsNow = admin7.firestore.Timestamp.now();
+      const newAppointmentData = {
+        id: newAppointmentId,
+        calendarEventId: "",
+        clinicBranchId: procedure.clinicBranchId,
+        clinicInfo,
+        practitionerId: procedure.practitionerId,
+        practitionerInfo,
+        patientId: data.patientId,
+        patientInfo,
+        procedureId: data.procedureId,
+        procedureInfo,
+        procedureExtendedInfo,
+        status: initialStatus,
+        bookingTime: serverTimestampValue,
+        confirmationTime: initialStatus === "confirmed" /* CONFIRMED */ ? serverTimestampValue : null,
+        appointmentStartTime: new Timestamp(
+          data.appointmentStartTime.seconds,
+          data.appointmentStartTime.nanoseconds
+        ),
+        appointmentEndTime: new Timestamp(
+          data.appointmentEndTime.seconds,
+          data.appointmentEndTime.nanoseconds
+        ),
+        cost: procedure.price,
+        currency: procedure.currency,
+        paymentStatus: procedure.price > 0 ? "unpaid" /* UNPAID */ : "not_applicable" /* NOT_APPLICABLE */,
+        patientNotes: data.patientNotes || null,
+        blockingConditions: procedure.blockingConditions || [],
+        contraindications: procedure.contraindications || [],
+        preProcedureRequirements: procedure.preRequirements || [],
+        postProcedureRequirements: procedure.postRequirements || [],
+        pendingUserFormsIds,
+        completedPreRequirements: [],
+        completedPostRequirements: [],
+        linkedFormIds,
+        linkedForms: [],
+        media: [],
+        reviewInfo: null,
+        finalizedDetails: void 0,
+        internalNotes: null,
+        cancellationReason: null,
+        cancellationTime: null,
+        canceledBy: void 0,
+        rescheduleTime: null,
+        procedureActualStartTime: null,
+        actualDurationMinutes: void 0,
+        isRecurring: false,
+        recurringAppointmentId: null,
+        isArchived: false,
+        createdAt: serverTimestampValue,
+        updatedAt: serverTimestampValue
+      };
+      await this.db.collection(APPOINTMENTS_COLLECTION).doc(newAppointmentId).set(newAppointmentData);
+      console.log(
+        `[BookingAdmin] Appointment ${newAppointmentId} created successfully with status ${initialStatus}.`
+      );
+      return {
+        success: true,
+        appointmentId: newAppointmentId,
+        appointmentData: newAppointmentData
+      };
+    } catch (error) {
+      console.error(
+        "[BookingAdmin] Critical error in orchestrateAppointmentCreation:",
+        error
+      );
+      const errorMessage = error instanceof Error ? error.message : "Unknown server error during appointment creation.";
+      return { success: false, error: errorMessage };
     }
   }
 };
-function registerFirestore(variant, useFetchStreams = true) {
-  setSDKVersion(SDK_VERSION);
-  _registerComponent(new Component("firestore", (container, { instanceIdentifier: databaseId, options: settings }) => {
-    const app = container.getProvider("app").getImmediate();
-    const firestoreInstance = new Firestore(new FirebaseAuthCredentialsProvider(container.getProvider("auth-internal")), new FirebaseAppCheckTokenProvider(container.getProvider("app-check-internal")), databaseIdFromApp(app, databaseId), app);
-    settings = Object.assign({ useFetchStreams }, settings);
-    firestoreInstance._setSettings(settings);
-    return firestoreInstance;
-  }, "PUBLIC").setMultipleInstances(true));
-  registerVersion(name2, version$12, variant);
-  registerVersion(name2, version$12, "esm2017");
-}
-var FIELD_PATH_RESERVED = new RegExp("[~\\*/\\[\\]]");
-registerFirestore("node");
+
+// src/admin/requirements/patient-requirements.admin.service.ts
+var admin8 = __toESM(require("firebase-admin"));
 
 // src/types/patient/patient-requirements.ts
 var PatientInstructionStatus = /* @__PURE__ */ ((PatientInstructionStatus2) => {
@@ -32823,7 +33063,7 @@ var PatientRequirementsAdminService = class {
             ...currentInstruction,
             notificationId: void 0,
             status: "cancelled" /* CANCELLED */,
-            updatedAt: new Timestamp2(
+            updatedAt: new Timestamp(
               adminTsNow.seconds,
               adminTsNow.nanoseconds
             )
@@ -32848,7 +33088,7 @@ var PatientRequirementsAdminService = class {
         currentInstruction = {
           ...currentInstruction,
           notificationId: void 0,
-          updatedAt: new Timestamp2(
+          updatedAt: new Timestamp(
             adminTsNow.seconds,
             adminTsNow.nanoseconds
           )
@@ -32884,7 +33124,7 @@ var PatientRequirementsAdminService = class {
             ...currentInstruction,
             notificationId: createdNotificationId,
             status: "pendingNotification" /* PENDING_NOTIFICATION */,
-            updatedAt: new Timestamp2(
+            updatedAt: new Timestamp(
               adminTsNow.seconds,
               adminTsNow.nanoseconds
             )
@@ -32908,7 +33148,7 @@ var PatientRequirementsAdminService = class {
       await instanceDocRef.update({
         instructions: updatedInstructions,
         // Array of instructions with actual Timestamps
-        updatedAt: new Timestamp2(
+        updatedAt: new Timestamp(
           finalAdminTsNow.seconds,
           finalAdminTsNow.nanoseconds
         )
@@ -32990,7 +33230,7 @@ var PatientRequirementsAdminService = class {
         currentInstruction = {
           ...currentInstruction,
           status: "missed" /* MISSED */,
-          updatedAt: new Timestamp2(
+          updatedAt: new Timestamp(
             adminNowForMissed.seconds,
             adminNowForMissed.nanoseconds
           )
@@ -33007,7 +33247,7 @@ var PatientRequirementsAdminService = class {
       await instanceRef.update({
         instructions: updatedInstructions,
         // Array of instructions with actual Timestamps
-        updatedAt: new Timestamp2(
+        updatedAt: new Timestamp(
           finalAdminNowForMissedUpdate.seconds,
           finalAdminNowForMissedUpdate.nanoseconds
         )
@@ -33051,7 +33291,7 @@ var PatientRequirementsAdminService = class {
         );
         await instanceRef.update({
           overallStatus: "active" /* ACTIVE */,
-          updatedAt: new Timestamp2(
+          updatedAt: new Timestamp(
             admin8.firestore.Timestamp.now().seconds,
             admin8.firestore.Timestamp.now().nanoseconds
           )
@@ -33086,7 +33326,7 @@ var PatientRequirementsAdminService = class {
       const adminTsNow = admin8.firestore.Timestamp.now();
       await instanceRef.update({
         overallStatus: newOverallStatus,
-        updatedAt: new Timestamp2(
+        updatedAt: new Timestamp(
           adminTsNow.seconds,
           adminTsNow.nanoseconds
         )