@blackcode_sa/metaestetics-api 1.6.2 → 1.6.4

package/dist/index.js

@@ -81,9 +81,13 @@ __export(index_exports, {
   PATIENT_LOCATION_INFO_COLLECTION: () => PATIENT_LOCATION_INFO_COLLECTION,
   PATIENT_MEDICAL_HISTORY_COLLECTION: () => PATIENT_MEDICAL_HISTORY_COLLECTION,
   PATIENT_MEDICAL_INFO_COLLECTION: () => PATIENT_MEDICAL_INFO_COLLECTION,
+  PATIENT_REQUIREMENTS_SUBCOLLECTION_NAME: () => PATIENT_REQUIREMENTS_SUBCOLLECTION_NAME,
   PATIENT_SENSITIVE_INFO_COLLECTION: () => PATIENT_SENSITIVE_INFO_COLLECTION,
   PRACTITIONERS_COLLECTION: () => PRACTITIONERS_COLLECTION,
   PROCEDURES_COLLECTION: () => PROCEDURES_COLLECTION,
+  PatientInstructionStatus: () => PatientInstructionStatus,
+  PatientRequirementOverallStatus: () => PatientRequirementOverallStatus,
+  PatientRequirementsService: () => PatientRequirementsService,
   PatientService: () => PatientService,
   PaymentStatus: () => PaymentStatus,
   PracticeType: () => PracticeType,
@@ -148,6 +152,7 @@ __export(index_exports, {
   createDefaultClinicGroupSchema: () => createDefaultClinicGroupSchema,
   createDocumentTemplateSchema: () => createDocumentTemplateSchema,
   createDraftPractitionerSchema: () => createDraftPractitionerSchema,
+  createFilledDocumentDataSchema: () => createFilledDocumentDataSchema,
   createPatientLocationInfoSchema: () => createPatientLocationInfoSchema,
   createPatientMedicalInfoSchema: () => createPatientMedicalInfoSchema,
   createPatientProfileSchema: () => createPatientProfileSchema,
@@ -163,6 +168,8 @@ __export(index_exports, {
   documentTemplateSchema: () => documentTemplateSchema,
   emailSchema: () => emailSchema,
   emergencyContactSchema: () => emergencyContactSchema,
+  filledDocumentSchema: () => filledDocumentSchema,
+  filledDocumentStatusSchema: () => filledDocumentStatusSchema,
   gamificationSchema: () => gamificationSchema,
   getFirebaseApp: () => getFirebaseApp,
   getFirebaseAuth: () => getFirebaseAuth,
@@ -212,6 +219,7 @@ __export(index_exports, {
   updateClinicSchema: () => updateClinicSchema,
   updateContraindicationSchema: () => updateContraindicationSchema,
   updateDocumentTemplateSchema: () => updateDocumentTemplateSchema,
+  updateFilledDocumentDataSchema: () => updateFilledDocumentDataSchema,
   updateMedicationSchema: () => updateMedicationSchema,
   updatePatientMedicalInfoSchema: () => updatePatientMedicalInfoSchema,
   updateVitalStatsSchema: () => updateVitalStatsSchema,
@@ -224,19 +232,20 @@ __export(index_exports, {
 module.exports = __toCommonJS(index_exports);
 
 // src/validations/appointment.schema.ts
-var import_zod = require("zod");
+var import_zod2 = require("zod");
 
 // src/types/appointment/index.ts
 var AppointmentStatus = /* @__PURE__ */ ((AppointmentStatus2) => {
-  AppointmentStatus2["SCHEDULED"] = "scheduled";
+  AppointmentStatus2["PENDING"] = "pending";
   AppointmentStatus2["CONFIRMED"] = "confirmed";
   AppointmentStatus2["CHECKED_IN"] = "checked_in";
   AppointmentStatus2["IN_PROGRESS"] = "in_progress";
   AppointmentStatus2["COMPLETED"] = "completed";
   AppointmentStatus2["CANCELED_PATIENT"] = "canceled_patient";
+  AppointmentStatus2["CANCELED_PATIENT_RESCHEDULED"] = "canceled_patient_rescheduled";
   AppointmentStatus2["CANCELED_CLINIC"] = "canceled_clinic";
   AppointmentStatus2["NO_SHOW"] = "no_show";
-  AppointmentStatus2["RESCHEDULED"] = "rescheduled";
+  AppointmentStatus2["RESCHEDULED_BY_CLINIC"] = "rescheduled_by_clinic";
   return AppointmentStatus2;
 })(AppointmentStatus || {});
 var PaymentStatus = /* @__PURE__ */ ((PaymentStatus3) => {
@@ -247,82 +256,444 @@ var PaymentStatus = /* @__PURE__ */ ((PaymentStatus3) => {
   PaymentStatus3["NOT_APPLICABLE"] = "not_applicable";
   return PaymentStatus3;
 })(PaymentStatus || {});
+var MediaType = /* @__PURE__ */ ((MediaType2) => {
+  MediaType2["BEFORE_PHOTO"] = "before_photo";
+  MediaType2["AFTER_PHOTO"] = "after_photo";
+  MediaType2["CONSENT_SCAN"] = "consent_scan";
+  MediaType2["OTHER_DOCUMENT"] = "other_document";
+  return MediaType2;
+})(MediaType || {});
 var APPOINTMENTS_COLLECTION = "appointments";
 
+// src/validations/documentation-templates/template.schema.ts
+var import_zod = require("zod");
+
+// src/types/documentation-templates/index.ts
+var DOCUMENTATION_TEMPLATES_COLLECTION = "documentation-templates";
+var FILLED_DOCUMENTS_COLLECTION = "filled-documents";
+var USER_FORMS_SUBCOLLECTION = "user-forms";
+var DOCTOR_FORMS_SUBCOLLECTION = "doctor-forms";
+var DocumentElementType = /* @__PURE__ */ ((DocumentElementType2) => {
+  DocumentElementType2["HEADING"] = "heading";
+  DocumentElementType2["PARAGRAPH"] = "paragraph";
+  DocumentElementType2["LIST"] = "list";
+  DocumentElementType2["DYNAMIC_TEXT"] = "dynamic_text";
+  DocumentElementType2["BINARY_CHOICE"] = "binary_choice";
+  DocumentElementType2["MULTIPLE_CHOICE"] = "multiple_choice";
+  DocumentElementType2["SINGLE_CHOICE"] = "single_choice";
+  DocumentElementType2["RATING_SCALE"] = "rating_scale";
+  DocumentElementType2["TEXT_INPUT"] = "text_input";
+  DocumentElementType2["DATE_PICKER"] = "date_picker";
+  DocumentElementType2["SIGNATURE"] = "signature";
+  DocumentElementType2["DITIGAL_SIGNATURE"] = "digital_signature";
+  DocumentElementType2["FILE_UPLOAD"] = "file_upload";
+  return DocumentElementType2;
+})(DocumentElementType || {});
+var ListType = /* @__PURE__ */ ((ListType2) => {
+  ListType2["ORDERED"] = "ordered";
+  ListType2["UNORDERED"] = "unordered";
+  return ListType2;
+})(ListType || {});
+var HeadingLevel = /* @__PURE__ */ ((HeadingLevel2) => {
+  HeadingLevel2["H1"] = "h1";
+  HeadingLevel2["H2"] = "h2";
+  HeadingLevel2["H3"] = "h3";
+  HeadingLevel2["H4"] = "h4";
+  HeadingLevel2["H5"] = "h5";
+  HeadingLevel2["H6"] = "h6";
+  return HeadingLevel2;
+})(HeadingLevel || {});
+var DynamicVariable = /* @__PURE__ */ ((DynamicVariable2) => {
+  DynamicVariable2["PATIENT_NAME"] = "[PATIENT_NAME]";
+  DynamicVariable2["DOCTOR_NAME"] = "[DOCTOR_NAME]";
+  DynamicVariable2["CLINIC_NAME"] = "[CLINIC_NAME]";
+  DynamicVariable2["PATIENT_BIRTHDAY"] = "[PATIENT_BIRTHDAY]";
+  DynamicVariable2["APPOINTMENT_DATE"] = "[APPOINTMENT_DATE]";
+  DynamicVariable2["CURRENT_DATE"] = "[CURRENT_DATE]";
+  DynamicVariable2["PROCEDURE_NAME"] = "[PROCEDURE_NAME]";
+  DynamicVariable2["PROCEDURE_DESCRIPTION"] = "[PROCEDURE_DESCRIPTION]";
+  DynamicVariable2["PROCEDURE_COST"] = "[PROCEDURE_COST]";
+  DynamicVariable2["PROCEDURE_DURATION"] = "[PROCEDURE_DURATION]";
+  DynamicVariable2["PROCEDURE_RISK"] = "[PROCEDURE_RISK]";
+  return DynamicVariable2;
+})(DynamicVariable || {});
+var FilledDocumentStatus = /* @__PURE__ */ ((FilledDocumentStatus2) => {
+  FilledDocumentStatus2["DRAFT"] = "draft";
+  FilledDocumentStatus2["SKIPPED"] = "skipped";
+  FilledDocumentStatus2["PENDING"] = "pending";
+  FilledDocumentStatus2["COMPLETED"] = "completed";
+  FilledDocumentStatus2["SIGNED"] = "signed";
+  FilledDocumentStatus2["REJECTED"] = "rejected";
+  return FilledDocumentStatus2;
+})(FilledDocumentStatus || {});
+
+// src/validations/documentation-templates/template.schema.ts
+var baseElementSchema = import_zod.z.object({
+  id: import_zod.z.string().optional(),
+  // Make id optional so we can omit it later
+  type: import_zod.z.nativeEnum(DocumentElementType),
+  required: import_zod.z.boolean().optional()
+});
+var headingElementSchema = baseElementSchema.extend({
+  type: import_zod.z.literal("heading" /* HEADING */),
+  text: import_zod.z.string().min(1).max(200),
+  level: import_zod.z.nativeEnum(HeadingLevel)
+});
+var paragraphElementSchema = baseElementSchema.extend({
+  type: import_zod.z.literal("paragraph" /* PARAGRAPH */),
+  text: import_zod.z.string().min(1).max(5e3)
+});
+var listElementSchema = baseElementSchema.extend({
+  type: import_zod.z.literal("list" /* LIST */),
+  items: import_zod.z.array(import_zod.z.string().min(1).max(500)).min(1).max(100),
+  listType: import_zod.z.nativeEnum(ListType)
+});
+var dynamicTextElementSchema = baseElementSchema.extend({
+  type: import_zod.z.literal("dynamic_text" /* DYNAMIC_TEXT */),
+  text: import_zod.z.string().min(1).max(5e3)
+});
+var binaryChoiceElementSchema = baseElementSchema.extend({
+  type: import_zod.z.literal("binary_choice" /* BINARY_CHOICE */),
+  question: import_zod.z.string().min(1).max(500),
+  defaultValue: import_zod.z.boolean().optional()
+});
+var multipleChoiceElementSchema = baseElementSchema.extend({
+  type: import_zod.z.literal("multiple_choice" /* MULTIPLE_CHOICE */),
+  question: import_zod.z.string().min(1).max(500),
+  options: import_zod.z.array(import_zod.z.string().min(1).max(200)).min(2).max(50),
+  defaultValues: import_zod.z.array(import_zod.z.string()).optional()
+});
+var singleChoiceElementSchema = baseElementSchema.extend({
+  type: import_zod.z.literal("single_choice" /* SINGLE_CHOICE */),
+  question: import_zod.z.string().min(1).max(500),
+  options: import_zod.z.array(import_zod.z.string().min(1).max(200)).min(2).max(50),
+  defaultValue: import_zod.z.string().optional()
+});
+var ratingScaleElementSchema = baseElementSchema.extend({
+  type: import_zod.z.literal("rating_scale" /* RATING_SCALE */),
+  question: import_zod.z.string().min(1).max(500),
+  min: import_zod.z.number().int().min(0).max(10),
+  max: import_zod.z.number().int().min(1).max(10),
+  labels: import_zod.z.record(import_zod.z.string()).optional(),
+  defaultValue: import_zod.z.number().int().optional()
+});
+var textInputElementSchema = baseElementSchema.extend({
+  type: import_zod.z.literal("text_input" /* TEXT_INPUT */),
+  label: import_zod.z.string().min(1).max(200),
+  placeholder: import_zod.z.string().max(200).optional(),
+  multiline: import_zod.z.boolean().optional(),
+  defaultValue: import_zod.z.string().optional()
+});
+var datePickerElementSchema = baseElementSchema.extend({
+  type: import_zod.z.literal("date_picker" /* DATE_PICKER */),
+  label: import_zod.z.string().min(1).max(200),
+  defaultValue: import_zod.z.string().optional()
+  // ISO date string
+});
+var signatureElementSchema = baseElementSchema.extend({
+  type: import_zod.z.literal("signature" /* SIGNATURE */),
+  label: import_zod.z.string().min(1).max(200)
+});
+var digitalSignatureElementSchema = baseElementSchema.extend({
+  type: import_zod.z.literal("digital_signature" /* DITIGAL_SIGNATURE */),
+  // Matching your type enum
+  label: import_zod.z.string().min(1).max(200)
+});
+var fileUploadElementSchema = baseElementSchema.extend({
+  type: import_zod.z.literal("file_upload" /* FILE_UPLOAD */),
+  label: import_zod.z.string().min(1).max(200),
+  allowedFileTypes: import_zod.z.array(import_zod.z.string()).optional(),
+  maxFileSizeMB: import_zod.z.number().positive().optional()
+});
+var documentElementSchema = import_zod.z.discriminatedUnion("type", [
+  headingElementSchema,
+  paragraphElementSchema,
+  listElementSchema,
+  dynamicTextElementSchema,
+  binaryChoiceElementSchema,
+  multipleChoiceElementSchema,
+  singleChoiceElementSchema,
+  ratingScaleElementSchema,
+  textInputElementSchema,
+  datePickerElementSchema,
+  signatureElementSchema,
+  digitalSignatureElementSchema,
+  fileUploadElementSchema
+]);
+var documentElementWithoutIdSchema = import_zod.z.discriminatedUnion("type", [
+  headingElementSchema.omit({ id: true }),
+  paragraphElementSchema.omit({ id: true }),
+  listElementSchema.omit({ id: true }),
+  dynamicTextElementSchema.omit({ id: true }),
+  binaryChoiceElementSchema.omit({ id: true }),
+  multipleChoiceElementSchema.omit({ id: true }),
+  singleChoiceElementSchema.omit({ id: true }),
+  ratingScaleElementSchema.omit({ id: true }),
+  textInputElementSchema.omit({ id: true }),
+  datePickerElementSchema.omit({ id: true }),
+  signatureElementSchema.omit({ id: true }),
+  digitalSignatureElementSchema.omit({ id: true }),
+  fileUploadElementSchema.omit({ id: true })
+]);
+var createDocumentTemplateSchema = import_zod.z.object({
+  title: import_zod.z.string().min(1).max(200),
+  description: import_zod.z.string().max(1e3).optional(),
+  elements: import_zod.z.array(documentElementWithoutIdSchema).min(1).max(100),
+  tags: import_zod.z.array(import_zod.z.string().min(1).max(50)).max(20).optional(),
+  isUserForm: import_zod.z.boolean().optional().default(false),
+  isRequired: import_zod.z.boolean().optional().default(false),
+  sortingOrder: import_zod.z.number().int().optional().default(0)
+});
+var updateDocumentTemplateSchema = import_zod.z.object({
+  title: import_zod.z.string().min(1).max(200).optional(),
+  description: import_zod.z.string().max(1e3).optional(),
+  elements: import_zod.z.array(documentElementWithoutIdSchema).min(1).max(100).optional(),
+  tags: import_zod.z.array(import_zod.z.string().min(1).max(50)).max(20).optional(),
+  isActive: import_zod.z.boolean().optional(),
+  isUserForm: import_zod.z.boolean().optional(),
+  isRequired: import_zod.z.boolean().optional(),
+  sortingOrder: import_zod.z.number().int().optional()
+});
+var documentTemplateSchema = import_zod.z.object({
+  id: import_zod.z.string(),
+  title: import_zod.z.string().min(1).max(200),
+  description: import_zod.z.string().max(1e3).optional(),
+  createdAt: import_zod.z.number(),
+  updatedAt: import_zod.z.number(),
+  createdBy: import_zod.z.string(),
+  elements: import_zod.z.array(documentElementSchema),
+  tags: import_zod.z.array(import_zod.z.string().min(1).max(50)).max(20).optional(),
+  version: import_zod.z.number().int().positive(),
+  isActive: import_zod.z.boolean(),
+  isUserForm: import_zod.z.boolean().optional().default(false),
+  isRequired: import_zod.z.boolean().optional().default(false),
+  sortingOrder: import_zod.z.number().int().optional().default(0)
+});
+var filledDocumentStatusSchema = import_zod.z.nativeEnum(FilledDocumentStatus);
+var filledDocumentSchema = import_zod.z.object({
+  id: import_zod.z.string(),
+  templateId: import_zod.z.string(),
+  templateVersion: import_zod.z.number(),
+  isUserForm: import_zod.z.boolean(),
+  procedureId: import_zod.z.string(),
+  appointmentId: import_zod.z.string(),
+  patientId: import_zod.z.string(),
+  practitionerId: import_zod.z.string(),
+  clinicId: import_zod.z.string(),
+  createdAt: import_zod.z.number(),
+  updatedAt: import_zod.z.number(),
+  values: import_zod.z.record(import_zod.z.string(), import_zod.z.any()),
+  status: filledDocumentStatusSchema
+});
+var createFilledDocumentDataSchema = import_zod.z.object({
+  templateId: import_zod.z.string(),
+  procedureId: import_zod.z.string(),
+  appointmentId: import_zod.z.string(),
+  patientId: import_zod.z.string(),
+  practitionerId: import_zod.z.string(),
+  clinicId: import_zod.z.string(),
+  values: import_zod.z.record(import_zod.z.string(), import_zod.z.any()).optional().default({}),
+  status: filledDocumentStatusSchema.optional().default("draft" /* DRAFT */)
+});
+var updateFilledDocumentDataSchema = import_zod.z.object({
+  values: import_zod.z.record(import_zod.z.string(), import_zod.z.any()).optional(),
+  status: filledDocumentStatusSchema.optional()
+});
+
 // src/validations/appointment.schema.ts
-var createAppointmentSchema = import_zod.z.object({
-  calendarEventId: import_zod.z.string().min(1, "Calendar event ID is required"),
-  clinicBranchId: import_zod.z.string().min(1, "Clinic branch ID is required"),
-  practitionerId: import_zod.z.string().min(1, "Practitioner ID is required"),
-  patientId: import_zod.z.string().min(1, "Patient ID is required"),
-  procedureId: import_zod.z.string().min(1, "Procedure ID is required"),
-  appointmentStartTime: import_zod.z.any().refine(
-    (val) => val instanceof Date || (val == null ? void 0 : val._seconds) !== void 0,
-    "Appointment start time must be a valid timestamp"
+var MIN_STRING_LENGTH = 1;
+var MAX_STRING_LENGTH = 1024;
+var MAX_STRING_LENGTH_LONG = 4096;
+var MAX_ARRAY_LENGTH = 100;
+var appointmentStatusSchema = import_zod2.z.nativeEnum(AppointmentStatus);
+var paymentStatusSchema = import_zod2.z.nativeEnum(PaymentStatus);
+var mediaTypeSchema = import_zod2.z.nativeEnum(MediaType);
+var appointmentMediaItemSchema = import_zod2.z.object({
+  id: import_zod2.z.string().min(MIN_STRING_LENGTH, "Media item ID is required"),
+  type: mediaTypeSchema,
+  url: import_zod2.z.string().url("Media URL must be a valid URL"),
+  fileName: import_zod2.z.string().optional(),
+  uploadedAt: import_zod2.z.any().refine(
+    (val) => val instanceof Date || (val == null ? void 0 : val._seconds) !== void 0 || typeof val === "number",
+    "uploadedAt must be a valid timestamp or Date object"
+  ),
+  uploadedBy: import_zod2.z.string().min(MIN_STRING_LENGTH, "Uploaded by user ID is required"),
+  description: import_zod2.z.string().max(MAX_STRING_LENGTH, "Description too long").optional()
+});
+var procedureExtendedInfoSchema = import_zod2.z.object({
+  id: import_zod2.z.string().min(MIN_STRING_LENGTH),
+  name: import_zod2.z.string().min(MIN_STRING_LENGTH),
+  description: import_zod2.z.string(),
+  cost: import_zod2.z.number().min(0),
+  duration: import_zod2.z.number().min(0),
+  procedureFamily: import_zod2.z.any(),
+  procedureCategoryId: import_zod2.z.string(),
+  procedureCategoryName: import_zod2.z.string(),
+  procedureSubCategoryId: import_zod2.z.string(),
+  procedureSubCategoryName: import_zod2.z.string(),
+  procedureTechnologyId: import_zod2.z.string(),
+  procedureTechnologyName: import_zod2.z.string(),
+  procedureProductBrandId: import_zod2.z.string(),
+  procedureProductBrandName: import_zod2.z.string(),
+  procedureProductId: import_zod2.z.string(),
+  procedureProductName: import_zod2.z.string()
+});
+var linkedFormInfoSchema = import_zod2.z.object({
+  formId: import_zod2.z.string().min(MIN_STRING_LENGTH, "Form ID is required"),
+  templateId: import_zod2.z.string().min(MIN_STRING_LENGTH, "Template ID is required"),
+  templateVersion: import_zod2.z.number().int().positive("Template version must be a positive integer"),
+  title: import_zod2.z.string().min(MIN_STRING_LENGTH, "Form title is required"),
+  isUserForm: import_zod2.z.boolean(),
+  status: filledDocumentStatusSchema,
+  path: import_zod2.z.string().min(MIN_STRING_LENGTH, "Form path is required"),
+  submittedAt: import_zod2.z.any().refine(
+    (val) => val === void 0 || val instanceof Date || (val == null ? void 0 : val._seconds) !== void 0 || typeof val === "number",
+    "submittedAt must be a valid timestamp or Date object"
+  ).optional(),
+  completedAt: import_zod2.z.any().refine(
+    (val) => val === void 0 || val instanceof Date || (val == null ? void 0 : val._seconds) !== void 0 || typeof val === "number",
+    "completedAt must be a valid timestamp or Date object"
+  ).optional()
+});
+var patientReviewInfoSchema = import_zod2.z.object({
+  reviewId: import_zod2.z.string().min(MIN_STRING_LENGTH, "Review ID is required"),
+  rating: import_zod2.z.number().min(1).max(5, "Rating must be between 1 and 5"),
+  comment: import_zod2.z.string().max(MAX_STRING_LENGTH_LONG, "Comment too long").optional(),
+  reviewedAt: import_zod2.z.any().refine(
+    (val) => val instanceof Date || (val == null ? void 0 : val._seconds) !== void 0 || typeof val === "number",
+    "reviewedAt must be a valid timestamp or Date object"
+  )
+});
+var finalizedDetailsSchema = import_zod2.z.object({
+  by: import_zod2.z.string().min(MIN_STRING_LENGTH, "Finalized by user ID is required"),
+  at: import_zod2.z.any().refine(
+    (val) => val instanceof Date || (val == null ? void 0 : val._seconds) !== void 0 || typeof val === "number",
+    "Finalized at must be a valid timestamp or Date object"
   ),
-  appointmentEndTime: import_zod.z.any().refine(
-    (val) => val instanceof Date || (val == null ? void 0 : val._seconds) !== void 0,
-    "Appointment end time must be a valid timestamp"
+  notes: import_zod2.z.string().max(MAX_STRING_LENGTH_LONG, "Finalization notes too long").optional()
+});
+var createAppointmentSchema = import_zod2.z.object({
+  calendarEventId: import_zod2.z.string().min(MIN_STRING_LENGTH, "Calendar event ID is required"),
+  clinicBranchId: import_zod2.z.string().min(MIN_STRING_LENGTH, "Clinic branch ID is required"),
+  practitionerId: import_zod2.z.string().min(MIN_STRING_LENGTH, "Practitioner ID is required"),
+  patientId: import_zod2.z.string().min(MIN_STRING_LENGTH, "Patient ID is required"),
+  procedureId: import_zod2.z.string().min(MIN_STRING_LENGTH, "Procedure ID is required"),
+  appointmentStartTime: import_zod2.z.any().refine(
+    (val) => val instanceof Date || (val == null ? void 0 : val._seconds) !== void 0 || typeof val === "number",
+    "Appointment start time must be a valid timestamp or Date object"
   ),
-  cost: import_zod.z.number().min(0, "Cost must be a non-negative number"),
-  currency: import_zod.z.string().min(1, "Currency is required"),
-  patientNotes: import_zod.z.string().nullable().optional(),
-  initialStatus: import_zod.z.nativeEnum(AppointmentStatus, {
-    errorMap: () => ({ message: "Invalid appointment status" })
-  }),
-  initialPaymentStatus: import_zod.z.nativeEnum(PaymentStatus, {
-    errorMap: () => ({ message: "Invalid payment status" })
-  }).optional().default("unpaid" /* UNPAID */)
+  appointmentEndTime: import_zod2.z.any().refine(
+    (val) => val instanceof Date || (val == null ? void 0 : val._seconds) !== void 0 || typeof val === "number",
+    "Appointment end time must be a valid timestamp or Date object"
+  ),
+  cost: import_zod2.z.number().min(0, "Cost must be a non-negative number"),
+  currency: import_zod2.z.string().min(1, "Currency is required"),
+  patientNotes: import_zod2.z.string().max(MAX_STRING_LENGTH, "Patient notes too long").nullable().optional(),
+  initialStatus: appointmentStatusSchema,
+  initialPaymentStatus: paymentStatusSchema.optional().default("unpaid" /* UNPAID */)
+}).refine((data) => data.appointmentEndTime > data.appointmentStartTime, {
+  message: "Appointment end time must be after start time",
+  path: ["appointmentEndTime"]
 });
-var updateAppointmentSchema = import_zod.z.object({
-  status: import_zod.z.nativeEnum(AppointmentStatus, {
-    errorMap: () => ({ message: "Invalid appointment status" })
-  }).optional(),
-  confirmationTime: import_zod.z.any().refine(
-    (val) => val === null || val === void 0 || val instanceof Date || (val == null ? void 0 : val._seconds) !== void 0,
-    "Confirmation time must be a valid timestamp or null"
+var updateAppointmentSchema = import_zod2.z.object({
+  status: appointmentStatusSchema.optional(),
+  confirmationTime: import_zod2.z.any().optional().nullable(),
+  cancellationTime: import_zod2.z.any().optional().nullable(),
+  rescheduleTime: import_zod2.z.any().optional().nullable(),
+  procedureActualStartTime: import_zod2.z.any().optional().nullable(),
+  actualDurationMinutes: import_zod2.z.number().int().positive("Duration must be a positive integer").optional(),
+  cancellationReason: import_zod2.z.string().max(MAX_STRING_LENGTH, "Cancellation reason too long").nullable().optional(),
+  canceledBy: import_zod2.z.enum(["patient", "clinic", "practitioner", "system"]).optional(),
+  internalNotes: import_zod2.z.string().max(MAX_STRING_LENGTH_LONG, "Internal notes too long").nullable().optional(),
+  patientNotes: import_zod2.z.any().optional().nullable(),
+  paymentStatus: paymentStatusSchema.optional(),
+  paymentTransactionId: import_zod2.z.any().optional().nullable(),
+  completedPreRequirements: import_zod2.z.union([import_zod2.z.array(import_zod2.z.string()), import_zod2.z.any()]).optional(),
+  completedPostRequirements: import_zod2.z.union([import_zod2.z.array(import_zod2.z.string()), import_zod2.z.any()]).optional(),
+  pendingUserFormsIds: import_zod2.z.union([import_zod2.z.array(import_zod2.z.string()), import_zod2.z.any()]).optional(),
+  appointmentStartTime: import_zod2.z.any().refine(
+    (val) => val === void 0 || val instanceof Date || (val == null ? void 0 : val._seconds) !== void 0 || typeof val === "number",
+    "Appointment start time must be a valid timestamp or Date object"
   ).optional(),
-  actualDurationMinutes: import_zod.z.number().positive("Duration must be positive").optional(),
-  cancellationReason: import_zod.z.string().nullable().optional(),
-  canceledBy: import_zod.z.enum(["patient", "clinic", "practitioner", "system"]).optional(),
-  internalNotes: import_zod.z.string().nullable().optional(),
-  paymentStatus: import_zod.z.nativeEnum(PaymentStatus, {
-    errorMap: () => ({ message: "Invalid payment status" })
-  }).optional(),
-  paymentTransactionId: import_zod.z.string().nullable().optional(),
-  completedPreRequirements: import_zod.z.array(import_zod.z.string()).optional(),
-  completedPostRequirements: import_zod.z.array(import_zod.z.string()).optional()
+  appointmentEndTime: import_zod2.z.any().refine(
+    (val) => val === void 0 || val instanceof Date || (val == null ? void 0 : val._seconds) !== void 0 || typeof val === "number",
+    "Appointment end time must be a valid timestamp or Date object"
+  ).optional(),
+  calendarEventId: import_zod2.z.string().min(MIN_STRING_LENGTH).optional(),
+  cost: import_zod2.z.number().min(0).optional(),
+  clinicBranchId: import_zod2.z.string().min(MIN_STRING_LENGTH).optional(),
+  practitionerId: import_zod2.z.string().min(MIN_STRING_LENGTH).optional(),
+  linkedForms: import_zod2.z.union([import_zod2.z.array(linkedFormInfoSchema).max(MAX_ARRAY_LENGTH), import_zod2.z.any()]).optional(),
+  media: import_zod2.z.union([
+    import_zod2.z.array(appointmentMediaItemSchema).max(MAX_ARRAY_LENGTH),
+    import_zod2.z.any()
+  ]).optional(),
+  reviewInfo: import_zod2.z.union([patientReviewInfoSchema.nullable(), import_zod2.z.any()]).optional(),
+  finalizedDetails: import_zod2.z.union([finalizedDetailsSchema.nullable(), import_zod2.z.any()]).optional(),
+  isArchived: import_zod2.z.boolean().optional(),
+  updatedAt: import_zod2.z.any().optional()
 }).refine(
   (data) => {
-    if (data.status === "canceled_clinic" /* CANCELED_CLINIC */ || data.status === "canceled_patient" /* CANCELED_PATIENT */) {
+    if (data.status === "canceled_clinic" /* CANCELED_CLINIC */ || data.status === "canceled_patient" /* CANCELED_PATIENT */ || data.status === "canceled_patient_rescheduled" /* CANCELED_PATIENT_RESCHEDULED */) {
       return !!data.cancellationReason && !!data.canceledBy;
     }
     return true;
   },
   {
-    message: "Cancellation reason and canceled by must be provided when canceling an appointment",
+    message: "Cancellation reason and canceled by must be provided when canceling an appointment with patient or clinic origin.",
     path: ["status"]
   }
+).refine(
+  (data) => {
+    if (data.appointmentStartTime && data.appointmentEndTime) {
+      return data.appointmentEndTime > data.appointmentStartTime;
+    }
+    return true;
+  },
+  {
+    message: "Appointment end time must be after start time if both are provided",
+    path: ["appointmentEndTime"]
+  }
 );
-var searchAppointmentsSchema = import_zod.z.object({
-  patientId: import_zod.z.string().optional(),
-  practitionerId: import_zod.z.string().optional(),
-  clinicBranchId: import_zod.z.string().optional(),
-  startDate: import_zod.z.date().optional(),
-  endDate: import_zod.z.date().optional(),
-  status: import_zod.z.union([
-    import_zod.z.nativeEnum(AppointmentStatus),
-    import_zod.z.array(import_zod.z.nativeEnum(AppointmentStatus))
+var searchAppointmentsSchema = import_zod2.z.object({
+  patientId: import_zod2.z.string().optional(),
+  practitionerId: import_zod2.z.string().optional(),
+  clinicBranchId: import_zod2.z.string().optional(),
+  startDate: import_zod2.z.any().refine(
+    (val) => val === void 0 || val instanceof Date || (val == null ? void 0 : val._seconds) !== void 0 || typeof val === "number",
+    "Start date must be a valid timestamp or Date object"
+  ).optional(),
+  endDate: import_zod2.z.any().refine(
+    (val) => val === void 0 || val instanceof Date || (val == null ? void 0 : val._seconds) !== void 0 || typeof val === "number",
+    "End date must be a valid timestamp or Date object"
+  ).optional(),
+  status: import_zod2.z.union([
+    appointmentStatusSchema,
+    import_zod2.z.array(appointmentStatusSchema).nonempty()
   ]).optional(),
-  limit: import_zod.z.number().positive().optional(),
-  startAfter: import_zod.z.any().optional()
+  limit: import_zod2.z.number().positive().int().optional().default(20),
+  startAfter: import_zod2.z.any().optional()
 }).refine(
   (data) => {
-    return !!(data.patientId || data.practitionerId || data.clinicBranchId);
+    if (!data.startDate && !data.endDate && !data.status) {
+      return !!(data.patientId || data.practitionerId || data.clinicBranchId);
+    }
+    return true;
   },
   {
-    message: "At least one of patientId, practitionerId, or clinicBranchId must be provided",
-    path: ["searchCriteria"]
+    message: "At least one of patientId, practitionerId, or clinicBranchId must be provided if no date or status filters are set.",
+    path: ["patientId"]
+  }
+).refine(
+  (data) => {
+    if (data.startDate && data.endDate) {
+      return data.endDate >= data.startDate;
+    }
+    return true;
+  },
+  {
+    message: "End date must be after or the same as start date",
+    path: ["endDate"]
   }
 );
 
@@ -371,54 +742,6 @@ var getFirebaseApp = async () => {
 var import_auth5 = require("firebase/auth");
 var import_firestore22 = require("firebase/firestore");
 
-// src/types/documentation-templates/index.ts
-var DOCUMENTATION_TEMPLATES_COLLECTION = "documentation-templates";
-var FILLED_DOCUMENTS_COLLECTION = "filled-documents";
-var DocumentElementType = /* @__PURE__ */ ((DocumentElementType2) => {
-  DocumentElementType2["HEADING"] = "heading";
-  DocumentElementType2["PARAGRAPH"] = "paragraph";
-  DocumentElementType2["LIST"] = "list";
-  DocumentElementType2["DYNAMIC_TEXT"] = "dynamic_text";
-  DocumentElementType2["BINARY_CHOICE"] = "binary_choice";
-  DocumentElementType2["MULTIPLE_CHOICE"] = "multiple_choice";
-  DocumentElementType2["SINGLE_CHOICE"] = "single_choice";
-  DocumentElementType2["RATING_SCALE"] = "rating_scale";
-  DocumentElementType2["TEXT_INPUT"] = "text_input";
-  DocumentElementType2["DATE_PICKER"] = "date_picker";
-  DocumentElementType2["SIGNATURE"] = "signature";
-  DocumentElementType2["FILE_UPLOAD"] = "file_upload";
-  return DocumentElementType2;
-})(DocumentElementType || {});
-var ListType = /* @__PURE__ */ ((ListType2) => {
-  ListType2["ORDERED"] = "ordered";
-  ListType2["UNORDERED"] = "unordered";
-  return ListType2;
-})(ListType || {});
-var HeadingLevel = /* @__PURE__ */ ((HeadingLevel2) => {
-  HeadingLevel2["H1"] = "h1";
-  HeadingLevel2["H2"] = "h2";
-  HeadingLevel2["H3"] = "h3";
-  HeadingLevel2["H4"] = "h4";
-  HeadingLevel2["H5"] = "h5";
-  HeadingLevel2["H6"] = "h6";
-  return HeadingLevel2;
-})(HeadingLevel || {});
-var DynamicVariable = /* @__PURE__ */ ((DynamicVariable2) => {
-  DynamicVariable2["PATIENT_NAME"] = "[PATIENT_NAME]";
-  DynamicVariable2["DOCTOR_NAME"] = "[DOCTOR_NAME]";
-  DynamicVariable2["CLINIC_NAME"] = "[CLINIC_NAME]";
-  DynamicVariable2["PATIENT_BIRTHDAY"] = "[PATIENT_BIRTHDAY]";
-  DynamicVariable2["APPOINTMENT_DATE"] = "[APPOINTMENT_DATE]";
-  DynamicVariable2["CURRENT_DATE"] = "[CURRENT_DATE]";
-  return DynamicVariable2;
-})(DynamicVariable || {});
-var FilledDocumentStatus = /* @__PURE__ */ ((FilledDocumentStatus2) => {
-  FilledDocumentStatus2["DRAFT"] = "draft";
-  FilledDocumentStatus2["COMPLETED"] = "completed";
-  FilledDocumentStatus2["SIGNED"] = "signed";
-  return FilledDocumentStatus2;
-})(FilledDocumentStatus || {});
-
 // src/types/calendar/index.ts
 var CalendarEventStatus = /* @__PURE__ */ ((CalendarEventStatus4) => {
   CalendarEventStatus4["PENDING"] = "pending";
@@ -465,136 +788,6 @@ var import_zod19 = require("zod");
 
 // src/validations/schemas.ts
 var import_zod3 = require("zod");
-
-// src/validations/documentation-templates/template.schema.ts
-var import_zod2 = require("zod");
-var baseElementSchema = import_zod2.z.object({
-  id: import_zod2.z.string().optional(),
-  // Make id optional so we can omit it later
-  type: import_zod2.z.nativeEnum(DocumentElementType),
-  required: import_zod2.z.boolean().optional()
-});
-var headingElementSchema = baseElementSchema.extend({
-  type: import_zod2.z.literal("heading" /* HEADING */),
-  text: import_zod2.z.string().min(1).max(200),
-  level: import_zod2.z.nativeEnum(HeadingLevel)
-});
-var paragraphElementSchema = baseElementSchema.extend({
-  type: import_zod2.z.literal("paragraph" /* PARAGRAPH */),
-  text: import_zod2.z.string().min(1).max(5e3)
-});
-var listElementSchema = baseElementSchema.extend({
-  type: import_zod2.z.literal("list" /* LIST */),
-  items: import_zod2.z.array(import_zod2.z.string().min(1).max(500)).min(1).max(100),
-  listType: import_zod2.z.nativeEnum(ListType)
-});
-var dynamicTextElementSchema = baseElementSchema.extend({
-  type: import_zod2.z.literal("dynamic_text" /* DYNAMIC_TEXT */),
-  text: import_zod2.z.string().min(1).max(5e3)
-});
-var binaryChoiceElementSchema = baseElementSchema.extend({
-  type: import_zod2.z.literal("binary_choice" /* BINARY_CHOICE */),
-  question: import_zod2.z.string().min(1).max(500),
-  defaultValue: import_zod2.z.boolean().optional()
-});
-var multipleChoiceElementSchema = baseElementSchema.extend({
-  type: import_zod2.z.literal("multiple_choice" /* MULTIPLE_CHOICE */),
-  question: import_zod2.z.string().min(1).max(500),
-  options: import_zod2.z.array(import_zod2.z.string().min(1).max(200)).min(2).max(50),
-  defaultValues: import_zod2.z.array(import_zod2.z.string()).optional()
-});
-var singleChoiceElementSchema = baseElementSchema.extend({
-  type: import_zod2.z.literal("single_choice" /* SINGLE_CHOICE */),
-  question: import_zod2.z.string().min(1).max(500),
-  options: import_zod2.z.array(import_zod2.z.string().min(1).max(200)).min(2).max(50),
-  defaultValue: import_zod2.z.string().optional()
-});
-var ratingScaleElementSchema = baseElementSchema.extend({
-  type: import_zod2.z.literal("rating_scale" /* RATING_SCALE */),
-  question: import_zod2.z.string().min(1).max(500),
-  min: import_zod2.z.number().int().min(0).max(10),
-  max: import_zod2.z.number().int().min(1).max(10),
-  labels: import_zod2.z.record(import_zod2.z.string()).optional(),
-  defaultValue: import_zod2.z.number().int().optional()
-});
-var textInputElementSchema = baseElementSchema.extend({
-  type: import_zod2.z.literal("text_input" /* TEXT_INPUT */),
-  label: import_zod2.z.string().min(1).max(200),
-  placeholder: import_zod2.z.string().max(200).optional(),
-  multiline: import_zod2.z.boolean().optional(),
-  defaultValue: import_zod2.z.string().optional()
-});
-var datePickerElementSchema = baseElementSchema.extend({
-  type: import_zod2.z.literal("date_picker" /* DATE_PICKER */),
-  label: import_zod2.z.string().min(1).max(200),
-  defaultValue: import_zod2.z.string().optional()
-  // ISO date string
-});
-var signatureElementSchema = baseElementSchema.extend({
-  type: import_zod2.z.literal("signature" /* SIGNATURE */),
-  label: import_zod2.z.string().min(1).max(200)
-});
-var fileUploadElementSchema = baseElementSchema.extend({
-  type: import_zod2.z.literal("file_upload" /* FILE_UPLOAD */),
-  label: import_zod2.z.string().min(1).max(200),
-  allowedFileTypes: import_zod2.z.array(import_zod2.z.string()).optional(),
-  maxFileSizeMB: import_zod2.z.number().positive().optional()
-});
-var documentElementSchema = import_zod2.z.discriminatedUnion("type", [
-  headingElementSchema,
-  paragraphElementSchema,
-  listElementSchema,
-  dynamicTextElementSchema,
-  binaryChoiceElementSchema,
-  multipleChoiceElementSchema,
-  singleChoiceElementSchema,
-  ratingScaleElementSchema,
-  textInputElementSchema,
-  datePickerElementSchema,
-  signatureElementSchema,
-  fileUploadElementSchema
-]);
-var documentElementWithoutIdSchema = import_zod2.z.discriminatedUnion("type", [
-  headingElementSchema.omit({ id: true }),
-  paragraphElementSchema.omit({ id: true }),
-  listElementSchema.omit({ id: true }),
-  dynamicTextElementSchema.omit({ id: true }),
-  binaryChoiceElementSchema.omit({ id: true }),
-  multipleChoiceElementSchema.omit({ id: true }),
-  singleChoiceElementSchema.omit({ id: true }),
-  ratingScaleElementSchema.omit({ id: true }),
-  textInputElementSchema.omit({ id: true }),
-  datePickerElementSchema.omit({ id: true }),
-  signatureElementSchema.omit({ id: true }),
-  fileUploadElementSchema.omit({ id: true })
-]);
-var createDocumentTemplateSchema = import_zod2.z.object({
-  title: import_zod2.z.string().min(1).max(200),
-  description: import_zod2.z.string().max(1e3).optional(),
-  elements: import_zod2.z.array(documentElementWithoutIdSchema).min(1).max(100),
-  tags: import_zod2.z.array(import_zod2.z.string().min(1).max(50)).max(20).optional()
-});
-var updateDocumentTemplateSchema = import_zod2.z.object({
-  title: import_zod2.z.string().min(1).max(200).optional(),
-  description: import_zod2.z.string().max(1e3).optional(),
-  elements: import_zod2.z.array(documentElementWithoutIdSchema).min(1).max(100).optional(),
-  tags: import_zod2.z.array(import_zod2.z.string().min(1).max(50)).max(20).optional(),
-  isActive: import_zod2.z.boolean().optional()
-});
-var documentTemplateSchema = import_zod2.z.object({
-  id: import_zod2.z.string(),
-  title: import_zod2.z.string().min(1).max(200),
-  description: import_zod2.z.string().max(1e3).optional(),
-  createdAt: import_zod2.z.number(),
-  updatedAt: import_zod2.z.number(),
-  createdBy: import_zod2.z.string(),
-  elements: import_zod2.z.array(documentElementSchema),
-  tags: import_zod2.z.array(import_zod2.z.string().min(1).max(50)).max(20).optional(),
-  version: import_zod2.z.number().int().positive(),
-  isActive: import_zod2.z.boolean()
-});
-
-// src/validations/schemas.ts
 var emailSchema = import_zod3.z.string().email("Invalid email format").min(5, "Email must be at least 5 characters").max(255, "Email must be less than 255 characters");
 var passwordSchema = import_zod3.z.string().min(8, "Password must be at least 8 characters").max(100, "Password must be less than 100 characters").regex(
   /^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)[a-zA-Z\d\w\W]{8,}$/,
@@ -1607,9 +1800,9 @@ var addAllergyUtil = async (db, patientId, data, userRef) => {
 var updateAllergyUtil = async (db, patientId, data, userRef) => {
   const validatedData = updateAllergySchema.parse(data);
   const { allergyIndex, ...updateData } = validatedData;
-  const doc32 = await (0, import_firestore5.getDoc)(getMedicalInfoDocRef(db, patientId));
-  if (!doc32.exists()) throw new Error("Medical info not found");
-  const medicalInfo = doc32.data();
+  const doc33 = await (0, import_firestore5.getDoc)(getMedicalInfoDocRef(db, patientId));
+  if (!doc33.exists()) throw new Error("Medical info not found");
+  const medicalInfo = doc33.data();
   if (allergyIndex >= medicalInfo.allergies.length) {
     throw new Error("Invalid allergy index");
   }
@@ -1625,9 +1818,9 @@ var updateAllergyUtil = async (db, patientId, data, userRef) => {
   });
 };
 var removeAllergyUtil = async (db, patientId, allergyIndex, userRef) => {
-  const doc32 = await (0, import_firestore5.getDoc)(getMedicalInfoDocRef(db, patientId));
-  if (!doc32.exists()) throw new Error("Medical info not found");
-  const medicalInfo = doc32.data();
+  const doc33 = await (0, import_firestore5.getDoc)(getMedicalInfoDocRef(db, patientId));
+  if (!doc33.exists()) throw new Error("Medical info not found");
+  const medicalInfo = doc33.data();
   if (allergyIndex >= medicalInfo.allergies.length) {
     throw new Error("Invalid allergy index");
   }
@@ -1652,9 +1845,9 @@ var addBlockingConditionUtil = async (db, patientId, data, userRef) => {
 var updateBlockingConditionUtil = async (db, patientId, data, userRef) => {
   const validatedData = updateBlockingConditionSchema.parse(data);
   const { conditionIndex, ...updateData } = validatedData;
-  const doc32 = await (0, import_firestore5.getDoc)(getMedicalInfoDocRef(db, patientId));
-  if (!doc32.exists()) throw new Error("Medical info not found");
-  const medicalInfo = doc32.data();
+  const doc33 = await (0, import_firestore5.getDoc)(getMedicalInfoDocRef(db, patientId));
+  if (!doc33.exists()) throw new Error("Medical info not found");
+  const medicalInfo = doc33.data();
   if (conditionIndex >= medicalInfo.blockingConditions.length) {
     throw new Error("Invalid blocking condition index");
   }
@@ -1670,9 +1863,9 @@ var updateBlockingConditionUtil = async (db, patientId, data, userRef) => {
   });
 };
 var removeBlockingConditionUtil = async (db, patientId, conditionIndex, userRef) => {
-  const doc32 = await (0, import_firestore5.getDoc)(getMedicalInfoDocRef(db, patientId));
-  if (!doc32.exists()) throw new Error("Medical info not found");
-  const medicalInfo = doc32.data();
+  const doc33 = await (0, import_firestore5.getDoc)(getMedicalInfoDocRef(db, patientId));
+  if (!doc33.exists()) throw new Error("Medical info not found");
+  const medicalInfo = doc33.data();
   if (conditionIndex >= medicalInfo.blockingConditions.length) {
     throw new Error("Invalid blocking condition index");
   }
@@ -1697,9 +1890,9 @@ var addContraindicationUtil = async (db, patientId, data, userRef) => {
 var updateContraindicationUtil = async (db, patientId, data, userRef) => {
   const validatedData = updateContraindicationSchema.parse(data);
   const { contraindicationIndex, ...updateData } = validatedData;
-  const doc32 = await (0, import_firestore5.getDoc)(getMedicalInfoDocRef(db, patientId));
-  if (!doc32.exists()) throw new Error("Medical info not found");
-  const medicalInfo = doc32.data();
+  const doc33 = await (0, import_firestore5.getDoc)(getMedicalInfoDocRef(db, patientId));
+  if (!doc33.exists()) throw new Error("Medical info not found");
+  const medicalInfo = doc33.data();
   if (contraindicationIndex >= medicalInfo.contraindications.length) {
     throw new Error("Invalid contraindication index");
   }
@@ -1715,9 +1908,9 @@ var updateContraindicationUtil = async (db, patientId, data, userRef) => {
   });
 };
 var removeContraindicationUtil = async (db, patientId, contraindicationIndex, userRef) => {
-  const doc32 = await (0, import_firestore5.getDoc)(getMedicalInfoDocRef(db, patientId));
-  if (!doc32.exists()) throw new Error("Medical info not found");
-  const medicalInfo = doc32.data();
+  const doc33 = await (0, import_firestore5.getDoc)(getMedicalInfoDocRef(db, patientId));
+  if (!doc33.exists()) throw new Error("Medical info not found");
+  const medicalInfo = doc33.data();
   if (contraindicationIndex >= medicalInfo.contraindications.length) {
     throw new Error("Invalid contraindication index");
   }
@@ -1742,9 +1935,9 @@ var addMedicationUtil = async (db, patientId, data, userRef) => {
 var updateMedicationUtil = async (db, patientId, data, userRef) => {
   const validatedData = updateMedicationSchema.parse(data);
   const { medicationIndex, ...updateData } = validatedData;
-  const doc32 = await (0, import_firestore5.getDoc)(getMedicalInfoDocRef(db, patientId));
-  if (!doc32.exists()) throw new Error("Medical info not found");
-  const medicalInfo = doc32.data();
+  const doc33 = await (0, import_firestore5.getDoc)(getMedicalInfoDocRef(db, patientId));
+  if (!doc33.exists()) throw new Error("Medical info not found");
+  const medicalInfo = doc33.data();
   if (medicationIndex >= medicalInfo.currentMedications.length) {
     throw new Error("Invalid medication index");
   }
@@ -1760,9 +1953,9 @@ var updateMedicationUtil = async (db, patientId, data, userRef) => {
   });
 };
 var removeMedicationUtil = async (db, patientId, medicationIndex, userRef) => {
-  const doc32 = await (0, import_firestore5.getDoc)(getMedicalInfoDocRef(db, patientId));
-  if (!doc32.exists()) throw new Error("Medical info not found");
-  const medicalInfo = doc32.data();
+  const doc33 = await (0, import_firestore5.getDoc)(getMedicalInfoDocRef(db, patientId));
+  if (!doc33.exists()) throw new Error("Medical info not found");
+  const medicalInfo = doc33.data();
   if (medicationIndex >= medicalInfo.currentMedications.length) {
     throw new Error("Invalid medication index");
   }
@@ -2040,7 +2233,7 @@ var searchPatientsUtil = async (db, params, requester) => {
   try {
     const finalQuery = (0, import_firestore6.query)(patientsCollectionRef, ...constraints);
     const querySnapshot = await (0, import_firestore6.getDocs)(finalQuery);
-    const patients = querySnapshot.docs.map((doc32) => doc32.data());
+    const patients = querySnapshot.docs.map((doc33) => doc33.data());
     console.log(`[searchPatientsUtil] Found ${patients.length} patients matching criteria.`);
     return patients;
   } catch (error) {
@@ -2064,8 +2257,8 @@ var getAllPatientsUtil = async (db, options) => {
     }
     const patientsSnapshot = await (0, import_firestore6.getDocs)(q);
     const patients = [];
-    patientsSnapshot.forEach((doc32) => {
-      patients.push(doc32.data());
+    patientsSnapshot.forEach((doc33) => {
+      patients.push(doc33.data());
     });
     console.log(`[getAllPatientsUtil] Found ${patients.length} patients`);
     return patients;
@@ -2277,8 +2470,8 @@ var getPatientsByPractitionerUtil = async (db, practitionerId, options) => {
     }
     const patientsSnapshot = await (0, import_firestore9.getDocs)(q);
     const patients = [];
-    patientsSnapshot.forEach((doc32) => {
-      patients.push(doc32.data());
+    patientsSnapshot.forEach((doc33) => {
+      patients.push(doc33.data());
     });
     console.log(
       `[getPatientsByPractitionerUtil] Found ${patients.length} patients for practitioner ID: ${practitionerId}`
@@ -2294,6 +2487,51 @@ var getPatientsByPractitionerUtil = async (db, practitionerId, options) => {
     );
   }
 };
+var getPatientsByPractitionerWithDetailsUtil = async (db, practitionerId, options) => {
+  try {
+    console.log(
+      `[getPatientsByPractitionerWithDetailsUtil] Fetching detailed patient profiles for practitioner ID: ${practitionerId} with options:`,
+      options
+    );
+    const patientProfiles = await getPatientsByPractitionerUtil(
+      db,
+      practitionerId,
+      options
+    );
+    const patientProfilesWithDetails = await Promise.all(
+      patientProfiles.map(async (profile) => {
+        try {
+          const sensitiveInfoDoc = await (0, import_firestore9.getDoc)(
+            getSensitiveInfoDocRef(db, profile.id)
+          );
+          const sensitiveInfo = sensitiveInfoDoc.exists() ? sensitiveInfoDoc.data() : void 0;
+          return {
+            patientProfile: profile,
+            patientSensitiveInfo: sensitiveInfo
+          };
+        } catch (error) {
+          console.error(
+            `[getPatientsByPractitionerWithDetailsUtil] Error fetching sensitive info for patient ${profile.id}:`,
+            error
+          );
+          return { patientProfile: profile };
+        }
+      })
+    );
+    console.log(
+      `[getPatientsByPractitionerWithDetailsUtil] Found ${patientProfilesWithDetails.length} detailed patient profiles for practitioner ID: ${practitionerId}`
+    );
+    return patientProfilesWithDetails;
+  } catch (error) {
+    console.error(
+      `[getPatientsByPractitionerWithDetailsUtil] Error fetching detailed patient profiles:`,
+      error
+    );
+    throw new Error(
+      `Failed to retrieve detailed patient profiles: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+};
 
 // src/services/patient/utils/clinic.utils.ts
 var import_firestore10 = require("firebase/firestore");
@@ -2321,8 +2559,8 @@ var getPatientsByClinicUtil = async (db, clinicId, options) => {
     }
     const patientsSnapshot = await (0, import_firestore10.getDocs)(q);
     const patients = [];
-    patientsSnapshot.forEach((doc32) => {
-      patients.push(doc32.data());
+    patientsSnapshot.forEach((doc33) => {
+      patients.push(doc33.data());
     });
     console.log(
       `[getPatientsByClinicUtil] Found ${patients.length} patients for clinic ID: ${clinicId}`
@@ -2622,6 +2860,25 @@ var PatientService = class extends BaseService {
     );
     return getPatientsByPractitionerUtil(this.db, practitionerId, options);
   }
+  /**
+   * Gets all patients associated with a specific practitioner with their sensitive information.
+   *
+   * @param {string} practitionerId - ID of the practitioner whose patients to retrieve
+   * @param {Object} options - Optional parameters for pagination
+   * @param {number} options.limit - Maximum number of profiles to return
+   * @param {string} options.startAfter - The ID of the document to start after (for pagination)
+   * @returns {Promise<PatientProfileForDoctor[]>} A promise resolving to an array of patient profiles with sensitive info
+   */
+  async getPatientsByPractitionerWithDetails(practitionerId, options) {
+    console.log(
+      `[PatientService.getPatientsByPractitionerWithDetails] Fetching detailed patient profiles for practitioner: ${practitionerId}`
+    );
+    return getPatientsByPractitionerWithDetailsUtil(
+      this.db,
+      practitionerId,
+      options
+    );
+  }
   /**
    * Gets all patients associated with a specific clinic.
    *
@@ -3416,7 +3673,7 @@ async function getClinicAdminsByGroup(db, clinicGroupId) {
     (0, import_firestore13.where)("clinicGroupId", "==", clinicGroupId)
   );
   const querySnapshot = await (0, import_firestore13.getDocs)(q);
-  return querySnapshot.docs.map((doc32) => doc32.data());
+  return querySnapshot.docs.map((doc33) => doc33.data());
 }
 async function updateClinicAdmin(db, adminId, data) {
   const admin = await getClinicAdmin(db, adminId);
@@ -3677,6 +3934,8 @@ var ClinicAdminService = class extends BaseService {
       this.getClinicService()
     );
   }
+  // TODO: Add more methods for clinic admins for managing permissions, editing profiles by the admin, or by the clinic group owner and so on
+  // Generally refactor admin permissions and clinic group permissions and systems for admin management
 };
 
 // src/services/practitioner/practitioner.service.ts
@@ -4113,7 +4372,7 @@ var PractitionerService = class extends BaseService {
       (0, import_firestore15.where)("expiresAt", ">", import_firestore15.Timestamp.now())
     );
     const querySnapshot = await (0, import_firestore15.getDocs)(q);
-    return querySnapshot.docs.map((doc32) => doc32.data());
+    return querySnapshot.docs.map((doc33) => doc33.data());
   }
   /**
    * Gets a token by its string value and validates it
@@ -4196,7 +4455,7 @@ var PractitionerService = class extends BaseService {
       (0, import_firestore15.where)("status", "==", "active" /* ACTIVE */)
     );
     const querySnapshot = await (0, import_firestore15.getDocs)(q);
-    return querySnapshot.docs.map((doc32) => doc32.data());
+    return querySnapshot.docs.map((doc33) => doc33.data());
   }
   /**
    * Dohvata sve zdravstvene radnike za određenu kliniku
@@ -4208,7 +4467,7 @@ var PractitionerService = class extends BaseService {
       (0, import_firestore15.where)("isActive", "==", true)
     );
     const querySnapshot = await (0, import_firestore15.getDocs)(q);
-    return querySnapshot.docs.map((doc32) => doc32.data());
+    return querySnapshot.docs.map((doc33) => doc33.data());
   }
   /**
    * Dohvata sve draft zdravstvene radnike za određenu kliniku sa statusom DRAFT
@@ -4220,7 +4479,7 @@ var PractitionerService = class extends BaseService {
       (0, import_firestore15.where)("status", "==", "draft" /* DRAFT */)
     );
     const querySnapshot = await (0, import_firestore15.getDocs)(q);
-    return querySnapshot.docs.map((doc32) => doc32.data());
+    return querySnapshot.docs.map((doc33) => doc33.data());
   }
   /**
    * Updates a practitioner
@@ -4402,7 +4661,7 @@ var PractitionerService = class extends BaseService {
       );
       const querySnapshot = await (0, import_firestore15.getDocs)(q);
       const practitioners = querySnapshot.docs.map(
-        (doc32) => doc32.data()
+        (doc33) => doc33.data()
       );
       const lastDoc = querySnapshot.docs.length > 0 ? querySnapshot.docs[querySnapshot.docs.length - 1] : null;
       return {
@@ -4473,8 +4732,8 @@ var PractitionerService = class extends BaseService {
       console.log(
         `[PRACTITIONER_SERVICE] Found ${querySnapshot.docs.length} practitioners with base query`
       );
-      let practitioners = querySnapshot.docs.map((doc32) => {
-        return { ...doc32.data(), id: doc32.id };
+      let practitioners = querySnapshot.docs.map((doc33) => {
+        return { ...doc33.data(), id: doc33.id };
       });
       const lastDoc = querySnapshot.docs.length > 0 ? querySnapshot.docs[querySnapshot.docs.length - 1] : null;
       if (filters.nameSearch && filters.nameSearch.trim() !== "") {
@@ -4728,7 +4987,7 @@ var UserService = class extends BaseService {
     ];
     const q = (0, import_firestore16.query)((0, import_firestore16.collection)(this.db, USERS_COLLECTION), ...constraints);
     const querySnapshot = await (0, import_firestore16.getDocs)(q);
-    const users = querySnapshot.docs.map((doc32) => doc32.data());
+    const users = querySnapshot.docs.map((doc33) => doc33.data());
     return Promise.all(users.map((userData) => userSchema.parse(userData)));
   }
   /**
@@ -5092,7 +5351,7 @@ async function getAllActiveGroups(db) {
     (0, import_firestore17.where)("isActive", "==", true)
   );
   const querySnapshot = await (0, import_firestore17.getDocs)(q);
-  return querySnapshot.docs.map((doc32) => doc32.data());
+  return querySnapshot.docs.map((doc33) => doc33.data());
 }
 async function updateClinicGroup(db, groupId, data, app) {
   console.log("[CLINIC_GROUP] Updating clinic group", { groupId });
@@ -5464,6 +5723,11 @@ var ClinicGroupService = class extends BaseService {
       this.app
     );
   }
+  // TODO: Add a method to get all admin tokens for a clinic group (not just active ones)
+  // TODO: Refactor admin token methods not to add tokens to the clinicGroup document,
+  // but to add them to a subcollection called adminTokens that belongs to a specific clinicGroup document
+  // TODO: Add granular control over admin permissions, e.g. only allow admins to manage certain clinics to tokens directly
+  // TODO: Generally refactor admin tokens and invites, also create cloud function to send invites and send updates when sombody uses the token
 };
 
 // src/services/clinic/clinic.service.ts
@@ -5490,7 +5754,7 @@ async function getClinicsByGroup(db, groupId) {
     (0, import_firestore18.where)("isActive", "==", true)
   );
   const querySnapshot = await (0, import_firestore18.getDocs)(q);
-  return querySnapshot.docs.map((doc32) => doc32.data());
+  return querySnapshot.docs.map((doc33) => doc33.data());
 }
 async function updateClinic(db, clinicId, data, adminId, clinicAdminService, app) {
   console.log("[CLINIC] Starting clinic update", { clinicId, adminId });
@@ -5684,7 +5948,7 @@ async function getClinicsByAdmin(db, adminId, options = {}, clinicAdminService,
   }
   const q = (0, import_firestore18.query)((0, import_firestore18.collection)(db, CLINICS_COLLECTION), ...constraints);
   const querySnapshot = await (0, import_firestore18.getDocs)(q);
-  return querySnapshot.docs.map((doc32) => doc32.data());
+  return querySnapshot.docs.map((doc33) => doc33.data());
 }
 async function getActiveClinicsByAdmin(db, adminId, clinicAdminService, clinicGroupService) {
   return getClinicsByAdmin(
@@ -5729,11 +5993,11 @@ async function getAllClinics(db, pagination, lastDoc) {
     }
     const clinicsSnapshot = await (0, import_firestore18.getDocs)(clinicsQuery);
     const lastVisible = clinicsSnapshot.docs[clinicsSnapshot.docs.length - 1];
-    const clinics = clinicsSnapshot.docs.map((doc32) => {
-      const data = doc32.data();
+    const clinics = clinicsSnapshot.docs.map((doc33) => {
+      const data = doc33.data();
       return {
         ...data,
-        id: doc32.id
+        id: doc33.id
       };
     });
     return {
@@ -5760,8 +6024,8 @@ async function getAllClinicsInRange(db, center, rangeInKm, pagination, lastDoc)
     ];
     const q = (0, import_firestore18.query)((0, import_firestore18.collection)(db, CLINICS_COLLECTION), ...constraints);
     const querySnapshot = await (0, import_firestore18.getDocs)(q);
-    for (const doc32 of querySnapshot.docs) {
-      const clinic = doc32.data();
+    for (const doc33 of querySnapshot.docs) {
+      const clinic = doc33.data();
       const distance = (0, import_geofire_common4.distanceBetween)(
         [center.latitude, center.longitude],
         [clinic.location.latitude, clinic.location.longitude]
@@ -5878,8 +6142,8 @@ async function findClinicsInRadius(db, center, radiusInKm, filters) {
     }
     const q = (0, import_firestore19.query)((0, import_firestore19.collection)(db, CLINICS_COLLECTION), ...constraints);
     const querySnapshot = await (0, import_firestore19.getDocs)(q);
-    for (const doc32 of querySnapshot.docs) {
-      const clinic = doc32.data();
+    for (const doc33 of querySnapshot.docs) {
+      const clinic = doc33.data();
       const distance = (0, import_geofire_common5.distanceBetween)(
         [center.latitude, center.longitude],
         [clinic.location.latitude, clinic.location.longitude]
@@ -5967,8 +6231,8 @@ async function getClinicsByFilters(db, filters) {
       console.log(
         `[FILTER_UTILS] Found ${querySnapshot.docs.length} clinics in geo bound`
       );
-      for (const doc32 of querySnapshot.docs) {
-        const clinic = { ...doc32.data(), id: doc32.id };
+      for (const doc33 of querySnapshot.docs) {
+        const clinic = { ...doc33.data(), id: doc33.id };
         const distance = (0, import_geofire_common6.distanceBetween)(
           [center.latitude, center.longitude],
           [clinic.location.latitude, clinic.location.longitude]
@@ -6024,8 +6288,8 @@ async function getClinicsByFilters(db, filters) {
     console.log(
       `[FILTER_UTILS] Found ${querySnapshot.docs.length} clinics with regular query`
     );
-    const clinics = querySnapshot.docs.map((doc32) => {
-      return { ...doc32.data(), id: doc32.id };
+    const clinics = querySnapshot.docs.map((doc33) => {
+      return { ...doc33.data(), id: doc33.id };
     });
     let filteredClinics = clinics;
     if (filters.center) {
@@ -7237,17 +7501,28 @@ var import_firestore23 = require("firebase/firestore");
 
 // src/types/notifications/index.ts
 var NotificationType = /* @__PURE__ */ ((NotificationType3) => {
-  NotificationType3["PRE_REQUIREMENT"] = "preRequirement";
-  NotificationType3["POST_REQUIREMENT"] = "postRequirement";
   NotificationType3["APPOINTMENT_REMINDER"] = "appointmentReminder";
-  NotificationType3["APPOINTMENT_NOTIFICATION"] = "appointmentNotification";
+  NotificationType3["APPOINTMENT_STATUS_CHANGE"] = "appointmentStatusChange";
+  NotificationType3["APPOINTMENT_RESCHEDULED_PROPOSAL"] = "appointmentRescheduledProposal";
+  NotificationType3["APPOINTMENT_CANCELLED"] = "appointmentCancelled";
+  NotificationType3["REQUIREMENT_INSTRUCTION_DUE"] = "requirementInstructionDue";
+  NotificationType3["FORM_REMINDER"] = "formReminder";
+  NotificationType3["FORM_SUBMISSION_CONFIRMATION"] = "formSubmissionConfirmation";
+  NotificationType3["REVIEW_REQUEST"] = "reviewRequest";
+  NotificationType3["PAYMENT_DUE"] = "paymentDue";
+  NotificationType3["PAYMENT_CONFIRMATION"] = "paymentConfirmation";
+  NotificationType3["PAYMENT_FAILED"] = "paymentFailed";
+  NotificationType3["GENERAL_MESSAGE"] = "generalMessage";
+  NotificationType3["ACCOUNT_NOTIFICATION"] = "accountNotification";
   return NotificationType3;
 })(NotificationType || {});
 var NOTIFICATIONS_COLLECTION = "notifications";
 var NotificationStatus = /* @__PURE__ */ ((NotificationStatus2) => {
   NotificationStatus2["PENDING"] = "pending";
+  NotificationStatus2["PROCESSING"] = "processing";
   NotificationStatus2["SENT"] = "sent";
   NotificationStatus2["FAILED"] = "failed";
+  NotificationStatus2["DELIVERED"] = "delivered";
   NotificationStatus2["CANCELLED"] = "cancelled";
   NotificationStatus2["PARTIAL_SUCCESS"] = "partialSuccess";
   return NotificationStatus2;
@@ -7303,9 +7578,9 @@ var NotificationService = class extends BaseService {
       (0, import_firestore23.orderBy)("notificationTime", "desc")
     );
     const querySnapshot = await (0, import_firestore23.getDocs)(q);
-    return querySnapshot.docs.map((doc32) => ({
-      id: doc32.id,
-      ...doc32.data()
+    return querySnapshot.docs.map((doc33) => ({
+      id: doc33.id,
+      ...doc33.data()
     }));
   }
   /**
@@ -7319,9 +7594,9 @@ var NotificationService = class extends BaseService {
       (0, import_firestore23.orderBy)("notificationTime", "desc")
     );
     const querySnapshot = await (0, import_firestore23.getDocs)(q);
-    return querySnapshot.docs.map((doc32) => ({
-      id: doc32.id,
-      ...doc32.data()
+    return querySnapshot.docs.map((doc33) => ({
+      id: doc33.id,
+      ...doc33.data()
     }));
   }
   /**
@@ -7393,9 +7668,9 @@ var NotificationService = class extends BaseService {
       (0, import_firestore23.orderBy)("notificationTime", "desc")
     );
     const querySnapshot = await (0, import_firestore23.getDocs)(q);
-    return querySnapshot.docs.map((doc32) => ({
-      id: doc32.id,
-      ...doc32.data()
+    return querySnapshot.docs.map((doc33) => ({
+      id: doc33.id,
+      ...doc33.data()
     }));
   }
   /**
@@ -7408,9 +7683,9 @@ var NotificationService = class extends BaseService {
       (0, import_firestore23.orderBy)("notificationTime", "desc")
     );
     const querySnapshot = await (0, import_firestore23.getDocs)(q);
-    return querySnapshot.docs.map((doc32) => ({
-      id: doc32.id,
-      ...doc32.data()
+    return querySnapshot.docs.map((doc33) => ({
+      id: doc33.id,
+      ...doc33.data()
     }));
   }
 };
@@ -7627,7 +7902,7 @@ var ProcedureService = class extends BaseService {
       (0, import_firestore24.where)("isActive", "==", true)
     );
     const snapshot = await (0, import_firestore24.getDocs)(q);
-    return snapshot.docs.map((doc32) => doc32.data());
+    return snapshot.docs.map((doc33) => doc33.data());
   }
   /**
    * Gets all procedures for a practitioner
@@ -7641,7 +7916,7 @@ var ProcedureService = class extends BaseService {
       (0, import_firestore24.where)("isActive", "==", true)
     );
     const snapshot = await (0, import_firestore24.getDocs)(q);
-    return snapshot.docs.map((doc32) => doc32.data());
+    return snapshot.docs.map((doc33) => doc33.data());
   }
   /**
    * Updates a procedure
@@ -7824,20 +8099,20 @@ var ProcedureService = class extends BaseService {
       const proceduresCollection = (0, import_firestore24.collection)(this.db, PROCEDURES_COLLECTION);
       let proceduresQuery = (0, import_firestore24.query)(proceduresCollection);
       if (pagination && pagination > 0) {
-        const { limit: limit11, startAfter: startAfter11 } = await import("firebase/firestore");
+        const { limit: limit12, startAfter: startAfter12 } = await import("firebase/firestore");
         if (lastDoc) {
           proceduresQuery = (0, import_firestore24.query)(
             proceduresCollection,
             (0, import_firestore24.orderBy)("name"),
             // Use imported orderBy
-            startAfter11(lastDoc),
-            limit11(pagination)
+            startAfter12(lastDoc),
+            limit12(pagination)
           );
         } else {
           proceduresQuery = (0, import_firestore24.query)(
             proceduresCollection,
             (0, import_firestore24.orderBy)("name"),
-            limit11(pagination)
+            limit12(pagination)
           );
         }
       } else {
@@ -7845,11 +8120,11 @@ var ProcedureService = class extends BaseService {
       }
       const proceduresSnapshot = await (0, import_firestore24.getDocs)(proceduresQuery);
       const lastVisible = proceduresSnapshot.docs[proceduresSnapshot.docs.length - 1];
-      const procedures = proceduresSnapshot.docs.map((doc32) => {
-        const data = doc32.data();
+      const procedures = proceduresSnapshot.docs.map((doc33) => {
+        const data = doc33.data();
         return {
           ...data,
-          id: doc32.id
+          id: doc33.id
           // Ensure ID is present
         };
       });
@@ -7931,8 +8206,8 @@ var ProcedureService = class extends BaseService {
           console.log(
             `[PROCEDURE_SERVICE] Found ${querySnapshot.docs.length} procedures in geo bound`
           );
-          for (const doc32 of querySnapshot.docs) {
-            const procedure = { ...doc32.data(), id: doc32.id };
+          for (const doc33 of querySnapshot.docs) {
+            const procedure = { ...doc33.data(), id: doc33.id };
             const distance = (0, import_geofire_common8.distanceBetween)(
               [center.latitude, center.longitude],
               [
@@ -7983,8 +8258,8 @@ var ProcedureService = class extends BaseService {
         console.log(
           `[PROCEDURE_SERVICE] Found ${querySnapshot.docs.length} procedures with regular query`
         );
-        const procedures = querySnapshot.docs.map((doc32) => {
-          return { ...doc32.data(), id: doc32.id };
+        const procedures = querySnapshot.docs.map((doc33) => {
+          return { ...doc33.data(), id: doc33.id };
         });
         if (filters.location) {
           const center = filters.location;
@@ -8124,7 +8399,10 @@ var DocumentationTemplateService = class extends BaseService {
       createdBy: userId,
       version: 1,
       isActive: true,
-      tags: validatedData.tags || []
+      tags: validatedData.tags || [],
+      isUserForm: validatedData.isUserForm || false,
+      isRequired: validatedData.isRequired || false,
+      sortingOrder: validatedData.sortingOrder || 0
     };
     const docRef = (0, import_firestore25.doc)(this.collectionRef, templateId);
     await (0, import_firestore25.setDoc)(docRef, template);
@@ -8159,21 +8437,31 @@ var DocumentationTemplateService = class extends BaseService {
     if (validatedData.elements) {
       updatedElements = validatedData.elements.map((element) => ({
         ...element,
-        id: this.generateId()
+        id: element.id || this.generateId()
       }));
     }
-    const updateData = {
-      ...validatedData,
+    const updatePayload = {
       elements: updatedElements,
       updatedAt: Date.now(),
       version: template.version + 1
     };
+    if (validatedData.title !== void 0)
+      updatePayload.title = validatedData.title;
+    if (validatedData.description !== void 0)
+      updatePayload.description = validatedData.description;
+    if (validatedData.isActive !== void 0)
+      updatePayload.isActive = validatedData.isActive;
+    if (validatedData.tags !== void 0)
+      updatePayload.tags = validatedData.tags;
+    if (validatedData.isUserForm !== void 0)
+      updatePayload.isUserForm = validatedData.isUserForm;
+    if (validatedData.isRequired !== void 0)
+      updatePayload.isRequired = validatedData.isRequired;
+    if (validatedData.sortingOrder !== void 0)
+      updatePayload.sortingOrder = validatedData.sortingOrder;
     const docRef = (0, import_firestore25.doc)(this.collectionRef, templateId);
-    await (0, import_firestore25.updateDoc)(docRef, updateData);
-    return {
-      ...template,
-      ...updateData
-    };
+    await (0, import_firestore25.updateDoc)(docRef, updatePayload);
+    return { ...template, ...updatePayload };
   }
   /**
    * Delete a document template
@@ -8202,9 +8490,9 @@ var DocumentationTemplateService = class extends BaseService {
     const querySnapshot = await (0, import_firestore25.getDocs)(q);
     const templates = [];
     let lastVisible = null;
-    querySnapshot.forEach((doc32) => {
-      templates.push(doc32.data());
-      lastVisible = doc32;
+    querySnapshot.forEach((doc33) => {
+      templates.push(doc33.data());
+      lastVisible = doc33;
     });
     return {
       templates,
@@ -8232,9 +8520,9 @@ var DocumentationTemplateService = class extends BaseService {
     const querySnapshot = await (0, import_firestore25.getDocs)(q);
     const templates = [];
     let lastVisible = null;
-    querySnapshot.forEach((doc32) => {
-      templates.push(doc32.data());
-      lastVisible = doc32;
+    querySnapshot.forEach((doc33) => {
+      templates.push(doc33.data());
+      lastVisible = doc33;
     });
     return {
       templates,
@@ -8261,9 +8549,9 @@ var DocumentationTemplateService = class extends BaseService {
     const querySnapshot = await (0, import_firestore25.getDocs)(q);
     const templates = [];
     let lastVisible = null;
-    querySnapshot.forEach((doc32) => {
-      templates.push(doc32.data());
-      lastVisible = doc32;
+    querySnapshot.forEach((doc33) => {
+      templates.push(doc33.data());
+      lastVisible = doc33;
     });
     return {
       templates,
@@ -8277,50 +8565,80 @@ var import_firestore26 = require("firebase/firestore");
 var FilledDocumentService = class extends BaseService {
   constructor(...args) {
     super(...args);
-    this.collectionRef = (0, import_firestore26.collection)(
-      this.db,
-      FILLED_DOCUMENTS_COLLECTION
-    );
     this.templateService = new DocumentationTemplateService(...args);
   }
+  getFormSubcollectionPath(isUserForm) {
+    return isUserForm ? USER_FORMS_SUBCOLLECTION : DOCTOR_FORMS_SUBCOLLECTION;
+  }
   /**
-   * Create a new filled document
-   * @param templateId - ID of the template to use
-   * @param patientId - ID of the patient
-   * @param practitionerId - ID of the practitioner
-   * @param clinicId - ID of the clinic
-   * @returns The created filled document
+   * Create a new filled document within an appointment's subcollection.
+   * @param templateId - ID of the template to use.
+   * @param appointmentId - ID of the appointment this form belongs to.
+   * @param procedureId - ID of the procedure associated with this form.
+   * @param patientId - ID of the patient.
+   * @param practitionerId - ID of the practitioner (can be system/generic if patient is filling).
+   * @param clinicId - ID of the clinic.
+   * @param initialValues - Optional initial values for the form elements.
+   * @param initialStatus - Optional initial status for the form.
+   * @returns The created filled document.
    */
-  async createFilledDocument(templateId, patientId, practitionerId, clinicId) {
+  async createFilledDocumentForAppointment(templateId, appointmentId, procedureId, patientId, practitionerId, clinicId, initialValues = {}, initialStatus = "draft" /* DRAFT */) {
     const template = await this.templateService.getTemplateById(templateId);
     if (!template) {
       throw new Error(`Template with ID ${templateId} not found`);
     }
     const documentId3 = this.generateId();
     const now = Date.now();
+    const isUserForm = template.isUserForm || false;
+    const formSubcollection = this.getFormSubcollectionPath(isUserForm);
     const filledDocument = {
       id: documentId3,
       templateId,
       templateVersion: template.version,
+      isUserForm,
+      // Set based on template
+      isRequired: template.isRequired || false,
+      // Inherit isRequired from the template
+      appointmentId,
+      // NEW
+      procedureId,
+      // NEW
       patientId,
       practitionerId,
       clinicId,
       createdAt: now,
       updatedAt: now,
-      values: {},
-      status: "draft" /* DRAFT */
+      values: initialValues,
+      status: initialStatus
     };
-    const docRef = (0, import_firestore26.doc)(this.collectionRef, documentId3);
+    const docRef = (0, import_firestore26.doc)(
+      this.db,
+      APPOINTMENTS_COLLECTION,
+      // Replaced "appointments"
+      appointmentId,
+      formSubcollection,
+      documentId3
+    );
     await (0, import_firestore26.setDoc)(docRef, filledDocument);
     return filledDocument;
   }
   /**
-   * Get a filled document by ID
-   * @param documentId - ID of the filled document to retrieve
-   * @returns The filled document or null if not found
+   * Get a specific filled document from an appointment's subcollection.
+   * @param appointmentId - ID of the appointment.
+   * @param formId - ID of the filled document.
+   * @param isUserForm - Boolean indicating if it's a user form or doctor form.
+   * @returns The filled document or null if not found.
    */
-  async getFilledDocumentById(documentId3) {
-    const docRef = (0, import_firestore26.doc)(this.collectionRef, documentId3);
+  async getFilledDocumentFromAppointmentById(appointmentId, formId, isUserForm) {
+    const formSubcollection = this.getFormSubcollectionPath(isUserForm);
+    const docRef = (0, import_firestore26.doc)(
+      this.db,
+      APPOINTMENTS_COLLECTION,
+      // Replaced "appointments"
+      appointmentId,
+      formSubcollection,
+      formId
+    );
     const docSnap = await (0, import_firestore26.getDoc)(docRef);
     if (!docSnap.exists()) {
       return null;
@@ -8328,178 +8646,183 @@ var FilledDocumentService = class extends BaseService {
     return docSnap.data();
   }
   /**
-   * Update values in a filled document
-   * @param documentId - ID of the filled document to update
-   * @param values - Updated values for elements
-   * @param status - Optional new status for the document
-   * @returns The updated filled document
+   * Update values or status in a filled document within an appointment's subcollection.
+   * @param appointmentId - ID of the appointment.
+   * @param formId - ID of the filled document to update.
+   * @param isUserForm - Boolean indicating if it's a user form or doctor form.
+   * @param values - Updated values for elements.
+   * @param status - Optional new status for the document.
+   * @returns The updated filled document.
    */
-  async updateFilledDocument(documentId3, values, status) {
-    const filledDocument = await this.getFilledDocumentById(documentId3);
-    if (!filledDocument) {
-      throw new Error(`Filled document with ID ${documentId3} not found`);
+  async updateFilledDocumentInAppointment(appointmentId, formId, isUserForm, values, status) {
+    const formSubcollection = this.getFormSubcollectionPath(isUserForm);
+    const docRef = (0, import_firestore26.doc)(
+      this.db,
+      APPOINTMENTS_COLLECTION,
+      // Replaced "appointments"
+      appointmentId,
+      formSubcollection,
+      formId
+    );
+    const existingDoc = await this.getFilledDocumentFromAppointmentById(
+      appointmentId,
+      formId,
+      isUserForm
+    );
+    if (!existingDoc) {
+      throw new Error(
+        `Filled document with ID ${formId} not found in appointment ${appointmentId} ${formSubcollection}`
+      );
     }
-    const updateData = {
-      values: {
-        ...filledDocument.values,
-        ...values
-      },
+    const updatePayload = {
       updatedAt: Date.now()
     };
+    if (values) {
+      updatePayload.values = {
+        ...existingDoc.values,
+        ...values
+      };
+    }
     if (status) {
-      updateData.status = status;
+      updatePayload.status = status;
     }
-    const docRef = (0, import_firestore26.doc)(this.collectionRef, documentId3);
-    await (0, import_firestore26.updateDoc)(docRef, updateData);
-    return {
-      ...filledDocument,
-      ...updateData
-    };
+    if (Object.keys(updatePayload).length === 1 && "updatedAt" in updatePayload) {
+    }
+    await (0, import_firestore26.updateDoc)(docRef, updatePayload);
+    return { ...existingDoc, ...updatePayload };
   }
   /**
-   * Get filled documents for a patient
-   * @param patientId - ID of the patient
-   * @param pageSize - Number of documents to retrieve
-   * @param lastDoc - Last document from previous page for pagination
-   * @returns Array of filled documents and the last document for pagination
+   * Get all filled user forms for a specific appointment.
+   * @param appointmentId ID of the appointment.
+   * @param pageSize Number of documents to retrieve.
+   * @param lastDoc Last document from previous page for pagination.
    */
-  async getFilledDocumentsByPatient(patientId, pageSize = 20, lastDoc) {
+  async getFilledUserFormsForAppointment(appointmentId, pageSize = 20, lastDoc) {
+    const subcollectionRef = (0, import_firestore26.collection)(
+      this.db,
+      APPOINTMENTS_COLLECTION,
+      // Replaced "appointments"
+      appointmentId,
+      USER_FORMS_SUBCOLLECTION
+    );
     let q = (0, import_firestore26.query)(
-      this.collectionRef,
-      (0, import_firestore26.where)("patientId", "==", patientId),
+      subcollectionRef,
       (0, import_firestore26.orderBy)("updatedAt", "desc"),
       (0, import_firestore26.limit)(pageSize)
     );
     if (lastDoc) {
       q = (0, import_firestore26.query)(q, (0, import_firestore26.startAfter)(lastDoc));
     }
-    const querySnapshot = await (0, import_firestore26.getDocs)(q);
-    const documents = [];
-    let lastVisible = null;
-    querySnapshot.forEach((doc32) => {
-      documents.push(doc32.data());
-      lastVisible = doc32;
-    });
-    return {
-      documents,
-      lastDoc: lastVisible
-    };
+    return this.executeQuery(q);
   }
   /**
-   * Get filled documents for a practitioner
-   * @param practitionerId - ID of the practitioner
-   * @param pageSize - Number of documents to retrieve
-   * @param lastDoc - Last document from previous page for pagination
-   * @returns Array of filled documents and the last document for pagination
+   * Get all filled doctor forms for a specific appointment.
+   * @param appointmentId ID of the appointment.
+   * @param pageSize Number of documents to retrieve.
+   * @param lastDoc Last document from previous page for pagination.
    */
-  async getFilledDocumentsByPractitioner(practitionerId, pageSize = 20, lastDoc) {
+  async getFilledDoctorFormsForAppointment(appointmentId, pageSize = 20, lastDoc) {
+    const subcollectionRef = (0, import_firestore26.collection)(
+      this.db,
+      APPOINTMENTS_COLLECTION,
+      // Replaced "appointments"
+      appointmentId,
+      DOCTOR_FORMS_SUBCOLLECTION
+    );
     let q = (0, import_firestore26.query)(
-      this.collectionRef,
-      (0, import_firestore26.where)("practitionerId", "==", practitionerId),
+      subcollectionRef,
       (0, import_firestore26.orderBy)("updatedAt", "desc"),
       (0, import_firestore26.limit)(pageSize)
     );
     if (lastDoc) {
       q = (0, import_firestore26.query)(q, (0, import_firestore26.startAfter)(lastDoc));
     }
+    return this.executeQuery(q);
+  }
+  // Helper to execute query and return documents + lastDoc
+  async executeQuery(q) {
     const querySnapshot = await (0, import_firestore26.getDocs)(q);
     const documents = [];
     let lastVisible = null;
-    querySnapshot.forEach((doc32) => {
-      documents.push(doc32.data());
-      lastVisible = doc32;
+    querySnapshot.forEach((doc33) => {
+      documents.push(doc33.data());
+      lastVisible = doc33;
     });
     return {
       documents,
       lastDoc: lastVisible
     };
   }
+  // IMPORTANT: The following methods that query across all patients/practitioners/clinics
+  // (e.g., getFilledDocumentsByPatient, getFilledDocumentsByPractitioner)
+  // will NOT work correctly if FILLED_DOCUMENTS_COLLECTION is no longer a top-level collection
+  // and data is only in appointment subcollections. You would need to use
+  // Firestore Collection Group Queries for that, which require an index and a different query approach.
+  // These methods are left here for now but would need significant rework or removal.
   /**
-   * Get filled documents for a clinic
-   * @param clinicId - ID of the clinic
+   * Get filled documents for a patient (NEEDS REWORK for subcollections or Collection Group Query)
+   * @param patientId - ID of the patient
    * @param pageSize - Number of documents to retrieve
    * @param lastDoc - Last document from previous page for pagination
    * @returns Array of filled documents and the last document for pagination
    */
-  async getFilledDocumentsByClinic(clinicId, pageSize = 20, lastDoc) {
-    let q = (0, import_firestore26.query)(
-      this.collectionRef,
-      (0, import_firestore26.where)("clinicId", "==", clinicId),
-      (0, import_firestore26.orderBy)("updatedAt", "desc"),
-      (0, import_firestore26.limit)(pageSize)
+  async getFilledDocumentsByPatient(patientId, pageSize = 20, lastDoc) {
+    console.warn(
+      "getFilledDocumentsByPatient needs rework for subcollection model or Collection Group Queries."
     );
-    if (lastDoc) {
-      q = (0, import_firestore26.query)(q, (0, import_firestore26.startAfter)(lastDoc));
-    }
-    const querySnapshot = await (0, import_firestore26.getDocs)(q);
-    const documents = [];
-    let lastVisible = null;
-    querySnapshot.forEach((doc32) => {
-      documents.push(doc32.data());
-      lastVisible = doc32;
-    });
-    return {
-      documents,
-      lastDoc: lastVisible
-    };
+    return { documents: [], lastDoc: null };
   }
   /**
-   * Get filled documents by template
-   * @param templateId - ID of the template
+   * Get filled documents for a practitioner (NEEDS REWORK for subcollections or Collection Group Query)
+   * @param practitionerId - ID of the practitioner
    * @param pageSize - Number of documents to retrieve
    * @param lastDoc - Last document from previous page for pagination
    * @returns Array of filled documents and the last document for pagination
    */
-  async getFilledDocumentsByTemplate(templateId, pageSize = 20, lastDoc) {
-    let q = (0, import_firestore26.query)(
-      this.collectionRef,
-      (0, import_firestore26.where)("templateId", "==", templateId),
-      (0, import_firestore26.orderBy)("updatedAt", "desc"),
-      (0, import_firestore26.limit)(pageSize)
+  async getFilledDocumentsByPractitioner(practitionerId, pageSize = 20, lastDoc) {
+    console.warn(
+      "getFilledDocumentsByPractitioner needs rework for subcollection model or Collection Group Queries."
     );
-    if (lastDoc) {
-      q = (0, import_firestore26.query)(q, (0, import_firestore26.startAfter)(lastDoc));
-    }
-    const querySnapshot = await (0, import_firestore26.getDocs)(q);
-    const documents = [];
-    let lastVisible = null;
-    querySnapshot.forEach((doc32) => {
-      documents.push(doc32.data());
-      lastVisible = doc32;
-    });
-    return {
-      documents,
-      lastDoc: lastVisible
-    };
+    return { documents: [], lastDoc: null };
+  }
+  /**
+   * Get filled documents for a clinic (NEEDS REWORK for subcollections or Collection Group Query)
+   * @param clinicId - ID of the clinic
+   * @param pageSize - Number of documents to retrieve
+   * @param lastDoc - Last document from previous page for pagination
+   * @returns Array of filled documents and the last document for pagination
+   */
+  async getFilledDocumentsByClinic(clinicId, pageSize = 20, lastDoc) {
+    console.warn(
+      "getFilledDocumentsByClinic needs rework for subcollection model or Collection Group Queries."
+    );
+    return { documents: [], lastDoc: null };
   }
   /**
-   * Get filled documents by status
+   * Get filled documents by template (NEEDS REWORK for subcollections or Collection Group Query)
+   * @param templateId - ID of the template
+   * @param pageSize - Number of documents to retrieve
+   * @param lastDoc - Last document from previous page for pagination
+   * @returns Array of filled documents and the last document for pagination
+   */
+  async getFilledDocumentsByTemplate(templateId, pageSize = 20, lastDoc) {
+    console.warn(
+      "getFilledDocumentsByTemplate needs rework for subcollection model or Collection Group Queries."
+    );
+    return { documents: [], lastDoc: null };
+  }
+  /**
+   * Get filled documents by status (NEEDS REWORK for subcollections or Collection Group Query)
    * @param status - Status to filter by
    * @param pageSize - Number of documents to retrieve
    * @param lastDoc - Last document from previous page for pagination
    * @returns Array of filled documents and the last document for pagination
    */
   async getFilledDocumentsByStatus(status, pageSize = 20, lastDoc) {
-    let q = (0, import_firestore26.query)(
-      this.collectionRef,
-      (0, import_firestore26.where)("status", "==", status),
-      (0, import_firestore26.orderBy)("updatedAt", "desc"),
-      (0, import_firestore26.limit)(pageSize)
+    console.warn(
+      "getFilledDocumentsByStatus needs rework for subcollection model or Collection Group Queries."
     );
-    if (lastDoc) {
-      q = (0, import_firestore26.query)(q, (0, import_firestore26.startAfter)(lastDoc));
-    }
-    const querySnapshot = await (0, import_firestore26.getDocs)(q);
-    const documents = [];
-    let lastVisible = null;
-    querySnapshot.forEach((doc32) => {
-      documents.push(doc32.data());
-      lastVisible = doc32;
-    });
-    return {
-      documents,
-      lastDoc: lastVisible
-    };
+    return { documents: [], lastDoc: null };
   }
 };
 
@@ -8991,7 +9314,7 @@ async function searchCalendarEventsUtil(db, params) {
     const finalQuery = (0, import_firestore33.query)(collectionRef, ...constraints);
     const querySnapshot = await (0, import_firestore33.getDocs)(finalQuery);
     const events = querySnapshot.docs.map(
-      (doc32) => ({ id: doc32.id, ...doc32.data() })
+      (doc33) => ({ id: doc33.id, ...doc33.data() })
     );
     return events;
   } catch (error) {
@@ -9073,7 +9396,7 @@ async function getPractitionerSyncedCalendarsUtil(db, practitionerId) {
   );
   const q = (0, import_firestore34.query)(calendarsRef, (0, import_firestore34.orderBy)("createdAt", "desc"));
   const querySnapshot = await (0, import_firestore34.getDocs)(q);
-  return querySnapshot.docs.map((doc32) => doc32.data());
+  return querySnapshot.docs.map((doc33) => doc33.data());
 }
 async function getPatientSyncedCalendarUtil(db, patientId, calendarId) {
   const calendarRef = getPatientSyncedCalendarDocRef(db, patientId, calendarId);
@@ -9090,7 +9413,7 @@ async function getPatientSyncedCalendarsUtil(db, patientId) {
   );
   const q = (0, import_firestore34.query)(calendarsRef, (0, import_firestore34.orderBy)("createdAt", "desc"));
   const querySnapshot = await (0, import_firestore34.getDocs)(q);
-  return querySnapshot.docs.map((doc32) => doc32.data());
+  return querySnapshot.docs.map((doc33) => doc33.data());
 }
 async function getClinicSyncedCalendarUtil(db, clinicId, calendarId) {
   const calendarRef = getClinicSyncedCalendarDocRef(db, clinicId, calendarId);
@@ -9107,7 +9430,7 @@ async function getClinicSyncedCalendarsUtil(db, clinicId) {
   );
   const q = (0, import_firestore34.query)(calendarsRef, (0, import_firestore34.orderBy)("createdAt", "desc"));
   const querySnapshot = await (0, import_firestore34.getDocs)(q);
-  return querySnapshot.docs.map((doc32) => doc32.data());
+  return querySnapshot.docs.map((doc33) => doc33.data());
 }
 async function updatePractitionerSyncedCalendarUtil(db, practitionerId, calendarId, updateData) {
   const calendarRef = getPractitionerSyncedCalendarDocRef(
@@ -10462,9 +10785,9 @@ var CalendarServiceV2 = class extends BaseService {
         (0, import_firestore37.where)("eventTime.start", "<=", import_firestore36.Timestamp.fromDate(endDate))
       );
       const eventsSnapshot = await (0, import_firestore37.getDocs)(q);
-      const events = eventsSnapshot.docs.map((doc32) => ({
-        id: doc32.id,
-        ...doc32.data()
+      const events = eventsSnapshot.docs.map((doc33) => ({
+        id: doc33.id,
+        ...doc33.data()
       }));
       const calendars = await this.syncedCalendarsService.getPractitionerSyncedCalendars(
         doctorId
@@ -11096,7 +11419,7 @@ var CalendarServiceV2 = class extends BaseService {
       ])
     );
     const querySnapshot = await (0, import_firestore37.getDocs)(q);
-    return querySnapshot.docs.map((doc32) => doc32.data());
+    return querySnapshot.docs.map((doc33) => doc33.data());
   }
   /**
    * Calculates available time slots based on working hours, schedule and existing appointments
@@ -11363,7 +11686,7 @@ var ReviewService = class extends BaseService {
       (0, import_firestore38.where)("patientId", "==", patientId)
     );
     const snapshot = await (0, import_firestore38.getDocs)(q);
-    return snapshot.docs.map((doc32) => doc32.data());
+    return snapshot.docs.map((doc33) => doc33.data());
   }
   /**
    * Gets all reviews for a specific clinic
@@ -11376,7 +11699,7 @@ var ReviewService = class extends BaseService {
       (0, import_firestore38.where)("clinicReview.clinicId", "==", clinicId)
     );
     const snapshot = await (0, import_firestore38.getDocs)(q);
-    return snapshot.docs.map((doc32) => doc32.data());
+    return snapshot.docs.map((doc33) => doc33.data());
   }
   /**
    * Gets all reviews for a specific practitioner
@@ -11389,7 +11712,7 @@ var ReviewService = class extends BaseService {
       (0, import_firestore38.where)("practitionerReview.practitionerId", "==", practitionerId)
     );
     const snapshot = await (0, import_firestore38.getDocs)(q);
-    return snapshot.docs.map((doc32) => doc32.data());
+    return snapshot.docs.map((doc33) => doc33.data());
   }
   /**
    * Gets all reviews for a specific procedure
@@ -11402,7 +11725,7 @@ var ReviewService = class extends BaseService {
       (0, import_firestore38.where)("procedureReview.procedureId", "==", procedureId)
     );
     const snapshot = await (0, import_firestore38.getDocs)(q);
-    return snapshot.docs.map((doc32) => doc32.data());
+    return snapshot.docs.map((doc33) => doc33.data());
   }
   /**
    * Gets all reviews for a specific appointment
@@ -12101,7 +12424,7 @@ async function updateCalendarEventStatus(db, calendarEventId, appointmentStatus)
       case "canceled_clinic" /* CANCELED_CLINIC */:
         calendarStatus = "canceled";
         break;
-      case "rescheduled" /* RESCHEDULED */:
+      case AppointmentStatus.RESCHEDULED:
         calendarStatus = "rescheduled";
         break;
       case "completed" /* COMPLETED */:
@@ -12175,7 +12498,7 @@ async function searchAppointmentsUtil(db, params) {
     const q = (0, import_firestore39.query)((0, import_firestore39.collection)(db, APPOINTMENTS_COLLECTION), ...constraints);
     const querySnapshot = await (0, import_firestore39.getDocs)(q);
     const appointments = querySnapshot.docs.map(
-      (doc32) => doc32.data()
+      (doc33) => doc33.data()
     );
     const lastDoc = querySnapshot.docs.length > 0 ? querySnapshot.docs[querySnapshot.docs.length - 1] : null;
     return { appointments, lastDoc };
@@ -12198,12 +12521,13 @@ var AppointmentService = class extends BaseService {
    * @param practitionerService Practitioner service instance
    * @param clinicService Clinic service instance
    */
-  constructor(db, auth, app, calendarService, patientService, practitionerService, clinicService) {
+  constructor(db, auth, app, calendarService, patientService, practitionerService, clinicService, filledDocumentService) {
     super(db, auth, app);
     this.calendarService = calendarService;
     this.patientService = patientService;
     this.practitionerService = practitionerService;
     this.clinicService = clinicService;
+    this.filledDocumentService = filledDocumentService;
     this.functions = (0, import_functions.getFunctions)(app, "europe-west6");
   }
   /**
@@ -12559,152 +12883,331 @@ var AppointmentService = class extends BaseService {
    *
    * @param appointmentId ID of the appointment
    * @param newStatus New status to set
-   * @param cancellationReason Required if canceling the appointment
-   * @param canceledBy Required if canceling the appointment
+   * @param details Optional details for the status change
    * @returns The updated appointment
    */
-  async updateAppointmentStatus(appointmentId, newStatus, cancellationReason, canceledBy) {
+  async updateAppointmentStatus(appointmentId, newStatus, details) {
     console.log(
       `[APPOINTMENT_SERVICE] Updating status of appointment ${appointmentId} to ${newStatus}`
     );
-    const updateData = { status: newStatus };
-    if (newStatus === "canceled_clinic" /* CANCELED_CLINIC */ || newStatus === "canceled_patient" /* CANCELED_PATIENT */) {
-      if (!cancellationReason) {
-        throw new Error(
-          "Cancellation reason is required when canceling an appointment"
-        );
+    const updateData = {
+      status: newStatus,
+      updatedAt: (0, import_firestore40.serverTimestamp)()
+    };
+    if (newStatus === "canceled_clinic" /* CANCELED_CLINIC */ || newStatus === "canceled_patient" /* CANCELED_PATIENT */ || newStatus === "canceled_patient_rescheduled" /* CANCELED_PATIENT_RESCHEDULED */) {
+      if (!(details == null ? void 0 : details.cancellationReason)) {
+        throw new Error("Cancellation reason is required when canceling.");
       }
-      if (!canceledBy) {
-        throw new Error(
-          "Canceled by is required when canceling an appointment"
-        );
+      if (!(details == null ? void 0 : details.canceledBy)) {
+        throw new Error("Canceled by is required when canceling.");
       }
-      updateData.cancellationReason = cancellationReason;
-      updateData.canceledBy = canceledBy;
+      updateData.cancellationReason = details.cancellationReason;
+      updateData.canceledBy = details.canceledBy;
+      updateData.cancellationTime = import_firestore40.Timestamp.now();
     }
     if (newStatus === "confirmed" /* CONFIRMED */) {
       updateData.confirmationTime = import_firestore40.Timestamp.now();
     }
+    if (newStatus === "rescheduled_by_clinic" /* RESCHEDULED_BY_CLINIC */) {
+      updateData.rescheduleTime = import_firestore40.Timestamp.now();
+    }
     return this.updateAppointment(appointmentId, updateData);
   }
   /**
-   * Confirms an appointment.
-   *
-   * @param appointmentId ID of the appointment to confirm
-   * @returns The confirmed appointment
+   * Confirms a PENDING appointment by an Admin/Clinic.
    */
-  async confirmAppointment(appointmentId) {
+  async confirmAppointmentAdmin(appointmentId) {
     console.log(
-      `[APPOINTMENT_SERVICE] Confirming appointment: ${appointmentId}`
+      `[APPOINTMENT_SERVICE] Admin confirming appointment: ${appointmentId}`
     );
+    const appointment = await this.getAppointmentById(appointmentId);
+    if (!appointment)
+      throw new Error(`Appointment ${appointmentId} not found.`);
+    if (appointment.status !== "pending" /* PENDING */) {
+      throw new Error(
+        `Appointment ${appointmentId} is not in PENDING state to be confirmed.`
+      );
+    }
     return this.updateAppointmentStatus(
       appointmentId,
       "confirmed" /* CONFIRMED */
     );
   }
   /**
-   * Cancels an appointment from the clinic side.
-   *
-   * @param appointmentId ID of the appointment to cancel
-   * @param reason Reason for cancellation
-   * @returns The canceled appointment
+   * Cancels an appointment by the User (Patient).
+   */
+  async cancelAppointmentUser(appointmentId, reason) {
+    console.log(
+      `[APPOINTMENT_SERVICE] User canceling appointment: ${appointmentId}`
+    );
+    return this.updateAppointmentStatus(
+      appointmentId,
+      "canceled_patient" /* CANCELED_PATIENT */,
+      {
+        cancellationReason: reason,
+        canceledBy: "patient"
+      }
+    );
+  }
+  /**
+   * Cancels an appointment by an Admin/Clinic.
    */
-  async cancelAppointmentByClinic(appointmentId, reason) {
+  async cancelAppointmentAdmin(appointmentId, reason) {
     console.log(
-      `[APPOINTMENT_SERVICE] Canceling appointment by clinic: ${appointmentId}`
+      `[APPOINTMENT_SERVICE] Admin canceling appointment: ${appointmentId}`
     );
     return this.updateAppointmentStatus(
       appointmentId,
       "canceled_clinic" /* CANCELED_CLINIC */,
-      reason,
-      "clinic"
+      {
+        cancellationReason: reason,
+        canceledBy: "clinic"
+      }
     );
   }
   /**
-   * Cancels an appointment from the patient side.
-   *
-   * @param appointmentId ID of the appointment to cancel
-   * @param reason Reason for cancellation
-   * @returns The canceled appointment
+   * Admin proposes to reschedule an appointment.
+   * Sets status to RESCHEDULED_BY_CLINIC and updates times.
+   */
+  async rescheduleAppointmentAdmin(appointmentId, newStartTime, newEndTime) {
+    console.log(
+      `[APPOINTMENT_SERVICE] Admin rescheduling appointment: ${appointmentId}`
+    );
+    if (newEndTime.toMillis() <= newStartTime.toMillis()) {
+      throw new Error("New end time must be after new start time.");
+    }
+    const updateData = {
+      status: "rescheduled_by_clinic" /* RESCHEDULED_BY_CLINIC */,
+      appointmentStartTime: newStartTime,
+      appointmentEndTime: newEndTime,
+      rescheduleTime: import_firestore40.Timestamp.now(),
+      confirmationTime: null,
+      updatedAt: (0, import_firestore40.serverTimestamp)()
+    };
+    return this.updateAppointment(appointmentId, updateData);
+  }
+  /**
+   * User confirms a reschedule proposed by the clinic.
+   * Status changes from RESCHEDULED_BY_CLINIC to CONFIRMED.
    */
-  async cancelAppointmentByPatient(appointmentId, reason) {
+  async rescheduleAppointmentConfirmUser(appointmentId) {
     console.log(
-      `[APPOINTMENT_SERVICE] Canceling appointment by patient: ${appointmentId}`
+      `[APPOINTMENT_SERVICE] User confirming reschedule for: ${appointmentId}`
     );
+    const appointment = await this.getAppointmentById(appointmentId);
+    if (!appointment)
+      throw new Error(`Appointment ${appointmentId} not found.`);
+    if (appointment.status !== "rescheduled_by_clinic" /* RESCHEDULED_BY_CLINIC */) {
+      throw new Error(
+        `Appointment ${appointmentId} is not in RESCHEDULED_BY_CLINIC state.`
+      );
+    }
     return this.updateAppointmentStatus(
       appointmentId,
-      "canceled_patient" /* CANCELED_PATIENT */,
-      reason,
-      "patient"
+      "confirmed" /* CONFIRMED */
     );
   }
   /**
-   * Marks an appointment as checked in.
-   *
-   * @param appointmentId ID of the appointment
-   * @returns The updated appointment
+   * User rejects a reschedule proposed by the clinic.
+   * Status changes from RESCHEDULED_BY_CLINIC to CANCELED_PATIENT_RESCHEDULED.
    */
-  async checkInAppointment(appointmentId) {
+  async rescheduleAppointmentRejectUser(appointmentId, reason) {
     console.log(
-      `[APPOINTMENT_SERVICE] Checking in appointment: ${appointmentId}`
+      `[APPOINTMENT_SERVICE] User rejecting reschedule for: ${appointmentId}`
     );
+    const appointment = await this.getAppointmentById(appointmentId);
+    if (!appointment)
+      throw new Error(`Appointment ${appointmentId} not found.`);
+    if (appointment.status !== "rescheduled_by_clinic" /* RESCHEDULED_BY_CLINIC */) {
+      throw new Error(
+        `Appointment ${appointmentId} is not in RESCHEDULED_BY_CLINIC state.`
+      );
+    }
     return this.updateAppointmentStatus(
       appointmentId,
-      "checked_in" /* CHECKED_IN */
+      "canceled_patient_rescheduled" /* CANCELED_PATIENT_RESCHEDULED */,
+      {
+        cancellationReason: reason,
+        canceledBy: "patient"
+      }
     );
   }
   /**
-   * Marks an appointment as in progress.
-   *
-   * @param appointmentId ID of the appointment
-   * @returns The updated appointment
+   * Admin checks in a patient for their appointment.
+   * Requires all pending user forms to be completed.
    */
-  async startAppointment(appointmentId) {
-    console.log(`[APPOINTMENT_SERVICE] Starting appointment: ${appointmentId}`);
+  async checkInPatientAdmin(appointmentId) {
+    console.log(
+      `[APPOINTMENT_SERVICE] Admin checking in patient for: ${appointmentId}`
+    );
+    const appointment = await this.getAppointmentById(appointmentId);
+    if (!appointment)
+      throw new Error(`Appointment ${appointmentId} not found.`);
+    if (appointment.pendingUserFormsIds && appointment.pendingUserFormsIds.length > 0) {
+      throw new Error(
+        `Cannot check in: Patient has ${appointment.pendingUserFormsIds.length} pending required form(s). IDs: ${appointment.pendingUserFormsIds.join(
+          ", "
+        )}`
+      );
+    }
+    if (appointment.status !== "confirmed" /* CONFIRMED */ && appointment.status !== "rescheduled_by_clinic" /* RESCHEDULED_BY_CLINIC */) {
+      console.warn(
+        `Checking in appointment ${appointmentId} with status ${appointment.status}. Ensure this is intended.`
+      );
+    }
     return this.updateAppointmentStatus(
       appointmentId,
-      "in_progress" /* IN_PROGRESS */
+      "checked_in" /* CHECKED_IN */
     );
   }
   /**
-   * Marks an appointment as completed.
-   *
-   * @param appointmentId ID of the appointment
-   * @param actualDurationMinutes Actual duration of the appointment in minutes
-   * @returns The updated appointment
+   * Doctor starts the appointment procedure.
    */
-  async completeAppointment(appointmentId, actualDurationMinutes) {
+  async startAppointmentDoctor(appointmentId) {
     console.log(
-      `[APPOINTMENT_SERVICE] Completing appointment: ${appointmentId}`
+      `[APPOINTMENT_SERVICE] Doctor starting appointment: ${appointmentId}`
     );
+    const appointment = await this.getAppointmentById(appointmentId);
+    if (!appointment)
+      throw new Error(`Appointment ${appointmentId} not found.`);
+    if (appointment.status !== "checked_in" /* CHECKED_IN */) {
+      throw new Error(
+        `Appointment ${appointmentId} must be CHECKED_IN to start.`
+      );
+    }
+    const updateData = {
+      status: "in_progress" /* IN_PROGRESS */,
+      procedureActualStartTime: import_firestore40.Timestamp.now(),
+      // Set actual start time
+      updatedAt: (0, import_firestore40.serverTimestamp)()
+    };
+    return this.updateAppointment(appointmentId, updateData);
+  }
+  /**
+   * Doctor completes and finalizes the appointment.
+   */
+  async completeAppointmentDoctor(appointmentId, finalizationNotes, actualDurationMinutesInput) {
+    console.log(
+      `[APPOINTMENT_SERVICE] Doctor completing appointment: ${appointmentId}`
+    );
+    const currentUser = this.auth.currentUser;
+    if (!currentUser)
+      throw new Error("Authentication required to complete appointment.");
+    const appointment = await this.getAppointmentById(appointmentId);
+    if (!appointment)
+      throw new Error(`Appointment ${appointmentId} not found.`);
+    let calculatedDurationMinutes = actualDurationMinutesInput;
+    const procedureCompletionTime = import_firestore40.Timestamp.now();
+    if (calculatedDurationMinutes === void 0 && appointment.procedureActualStartTime) {
+      const startTimeMillis = appointment.procedureActualStartTime.toMillis();
+      const endTimeMillis = procedureCompletionTime.toMillis();
+      if (endTimeMillis > startTimeMillis) {
+        calculatedDurationMinutes = Math.round(
+          (endTimeMillis - startTimeMillis) / 6e4
+        );
+      }
+    }
     const updateData = {
       status: "completed" /* COMPLETED */,
-      actualDurationMinutes
+      actualDurationMinutes: calculatedDurationMinutes,
+      // Use calculated or provided duration
+      finalizedDetails: {
+        by: currentUser.uid,
+        // This is used ID, not practitioner's profile ID (just so we know who completed the appointment)
+        at: procedureCompletionTime,
+        // Use consistent completion timestamp
+        notes: finalizationNotes
+      },
+      // Optionally update appointmentEndTime to the actual completion time
+      // appointmentEndTime: procedureCompletionTime,
+      updatedAt: (0, import_firestore40.serverTimestamp)()
     };
     return this.updateAppointment(appointmentId, updateData);
   }
   /**
-   * Marks an appointment as no-show.
-   *
-   * @param appointmentId ID of the appointment
-   * @returns The updated appointment
+   * Admin marks an appointment as No-Show.
    */
-  async markNoShow(appointmentId) {
+  async markNoShowAdmin(appointmentId) {
     console.log(
-      `[APPOINTMENT_SERVICE] Marking appointment as no-show: ${appointmentId}`
+      `[APPOINTMENT_SERVICE] Admin marking no-show for: ${appointmentId}`
     );
+    const appointment = await this.getAppointmentById(appointmentId);
+    if (!appointment)
+      throw new Error(`Appointment ${appointmentId} not found.`);
+    if (import_firestore40.Timestamp.now().toMillis() < appointment.appointmentStartTime.toMillis()) {
+      throw new Error("Cannot mark no-show before appointment start time.");
+    }
     return this.updateAppointmentStatus(
       appointmentId,
-      "no_show" /* NO_SHOW */
+      "no_show" /* NO_SHOW */,
+      {
+        cancellationReason: "Patient did not show up for the appointment.",
+        canceledBy: "clinic"
+      }
+    );
+  }
+  /**
+   * Adds a media item to an appointment.
+   */
+  async addMediaToAppointment(appointmentId, mediaItemData) {
+    console.log(
+      `[APPOINTMENT_SERVICE] Adding media to appointment ${appointmentId}`
+    );
+    const currentUser = this.auth.currentUser;
+    if (!currentUser) throw new Error("Authentication required.");
+    const newMediaItem = {
+      ...mediaItemData,
+      id: this.generateId(),
+      uploadedAt: import_firestore40.Timestamp.now(),
+      uploadedBy: currentUser.uid
+    };
+    const updateData = {
+      media: (0, import_firestore40.arrayUnion)(newMediaItem),
+      updatedAt: (0, import_firestore40.serverTimestamp)()
+    };
+    return this.updateAppointment(appointmentId, updateData);
+  }
+  /**
+   * Removes a media item from an appointment.
+   */
+  async removeMediaFromAppointment(appointmentId, mediaItemId) {
+    console.log(
+      `[APPOINTMENT_SERVICE] Removing media ${mediaItemId} from appointment ${appointmentId}`
+    );
+    const appointment = await this.getAppointmentById(appointmentId);
+    if (!appointment || !appointment.media) {
+      throw new Error("Appointment or media list not found.");
+    }
+    const mediaToRemove = appointment.media.find((m) => m.id === mediaItemId);
+    if (!mediaToRemove) {
+      throw new Error(`Media item ${mediaItemId} not found in appointment.`);
+    }
+    const updateData = {
+      media: (0, import_firestore40.arrayRemove)(mediaToRemove),
+      updatedAt: (0, import_firestore40.serverTimestamp)()
+    };
+    return this.updateAppointment(appointmentId, updateData);
+  }
+  /**
+   * Adds or updates review information for an appointment.
+   */
+  async addReviewToAppointment(appointmentId, reviewData) {
+    console.log(
+      `[APPOINTMENT_SERVICE] Adding review to appointment ${appointmentId}`
     );
+    const newReviewInfo = {
+      ...reviewData,
+      reviewId: this.generateId(),
+      reviewedAt: import_firestore40.Timestamp.now()
+    };
+    const updateData = {
+      reviewInfo: newReviewInfo,
+      updatedAt: (0, import_firestore40.serverTimestamp)()
+    };
+    return this.updateAppointment(appointmentId, updateData);
   }
   /**
    * Updates the payment status of an appointment.
-   *
-   * @param appointmentId ID of the appointment
-   * @param paymentStatus New payment status
-   * @param paymentTransactionId Optional transaction ID for the payment
-   * @returns The updated appointment
    */
   async updatePaymentStatus(appointmentId, paymentStatus, paymentTransactionId) {
     console.log(
@@ -12712,7 +13215,8 @@ var AppointmentService = class extends BaseService {
     );
     const updateData = {
       paymentStatus,
-      paymentTransactionId: paymentTransactionId || null
+      paymentTransactionId: paymentTransactionId || null,
+      updatedAt: (0, import_firestore40.serverTimestamp)()
     };
     return this.updateAppointment(appointmentId, updateData);
   }
@@ -12785,9 +13289,203 @@ var AppointmentService = class extends BaseService {
   }
 };
 
-// src/backoffice/services/brand.service.ts
+// src/services/patient/patientRequirements.service.ts
 var import_firestore41 = require("firebase/firestore");
 
+// src/types/patient/patient-requirements.ts
+var PatientInstructionStatus = /* @__PURE__ */ ((PatientInstructionStatus2) => {
+  PatientInstructionStatus2["PENDING_NOTIFICATION"] = "pendingNotification";
+  PatientInstructionStatus2["ACTION_DUE"] = "actionDue";
+  PatientInstructionStatus2["ACTION_TAKEN"] = "actionTaken";
+  PatientInstructionStatus2["MISSED"] = "missed";
+  PatientInstructionStatus2["CANCELLED"] = "cancelled";
+  PatientInstructionStatus2["SKIPPED"] = "skipped";
+  return PatientInstructionStatus2;
+})(PatientInstructionStatus || {});
+var PatientRequirementOverallStatus = /* @__PURE__ */ ((PatientRequirementOverallStatus2) => {
+  PatientRequirementOverallStatus2["ACTIVE"] = "active";
+  PatientRequirementOverallStatus2["ALL_INSTRUCTIONS_MET"] = "allInstructionsMet";
+  PatientRequirementOverallStatus2["PARTIALLY_COMPLETED"] = "partiallyCompleted";
+  PatientRequirementOverallStatus2["FAILED"] = "failed";
+  PatientRequirementOverallStatus2["CANCELLED_APPOINTMENT"] = "cancelledAppointment";
+  PatientRequirementOverallStatus2["SUPERSEDED_RESCHEDULE"] = "supersededReschedule";
+  PatientRequirementOverallStatus2["FAILED_TO_PROCESS"] = "failedToProcess";
+  return PatientRequirementOverallStatus2;
+})(PatientRequirementOverallStatus || {});
+var PATIENT_REQUIREMENTS_SUBCOLLECTION_NAME = "patientRequirements";
+
+// src/services/patient/patientRequirements.service.ts
+var PatientRequirementsService = class extends BaseService {
+  constructor(db, auth, app) {
+    super(db, auth, app);
+  }
+  getPatientRequirementsCollectionRef(patientId) {
+    return (0, import_firestore41.collection)(
+      this.db,
+      `patients/${patientId}/${PATIENT_REQUIREMENTS_SUBCOLLECTION_NAME}`
+    );
+  }
+  getPatientRequirementDocRef(patientId, instanceId) {
+    return (0, import_firestore41.doc)(
+      this.getPatientRequirementsCollectionRef(patientId),
+      instanceId
+    );
+  }
+  /**
+   * Gets a specific patient requirement instance by its ID.
+   * @param patientId - The ID of the patient.
+   * @param instanceId - The ID of the requirement instance.
+   * @returns The patient requirement instance or null if not found.
+   */
+  async getPatientRequirementInstance(patientId, instanceId) {
+    const docRef = this.getPatientRequirementDocRef(patientId, instanceId);
+    const docSnap = await (0, import_firestore41.getDoc)(docRef);
+    if (!docSnap.exists()) {
+      return null;
+    }
+    const data = docSnap.data();
+    return { id: docSnap.id, ...data };
+  }
+  /**
+   * Retrieves patient requirement instances based on specified filters.
+   * This is a flexible query method.
+   *
+   * @param patientId - The ID of the patient.
+   * @param filters - Optional filters for appointmentId, overall statuses, instruction statuses, and due timeframes.
+   * @param pageLimit - Optional limit for pagination.
+   * @param lastVisible - Optional last document snapshot for pagination.
+   * @returns A promise resolving to an array of matching patient requirement instances and the last document snapshot.
+   */
+  async getAllPatientRequirementInstances(patientId, filters, pageLimit = 20, lastVisible) {
+    const collRef = this.getPatientRequirementsCollectionRef(patientId);
+    let q = (0, import_firestore41.query)(collRef, (0, import_firestore41.orderBy)("createdAt", "desc"));
+    const queryConstraints = [];
+    if ((filters == null ? void 0 : filters.appointmentId) && filters.appointmentId !== "all") {
+      queryConstraints.push(
+        (0, import_firestore41.where)("appointmentId", "==", filters.appointmentId)
+      );
+    }
+    if ((filters == null ? void 0 : filters.statuses) && filters.statuses.length > 0) {
+      queryConstraints.push((0, import_firestore41.where)("overallStatus", "in", filters.statuses));
+    }
+    if (lastVisible) {
+      queryConstraints.push((0, import_firestore41.startAfter)(lastVisible));
+    }
+    queryConstraints.push((0, import_firestore41.limit)(pageLimit));
+    q = (0, import_firestore41.query)(collRef, ...queryConstraints);
+    const snapshot = await (0, import_firestore41.getDocs)(q);
+    let requirements = snapshot.docs.map((docSnap) => {
+      const data = docSnap.data();
+      return { id: docSnap.id, ...data };
+    });
+    if ((filters == null ? void 0 : filters.instructionStatuses) && filters.instructionStatuses.length > 0) {
+      requirements = requirements.filter(
+        (req) => req.instructions.some(
+          (instr) => filters.instructionStatuses.includes(instr.status)
+        )
+      );
+    }
+    if (filters == null ? void 0 : filters.dueBefore) {
+      const dueBeforeMillis = filters.dueBefore.toMillis();
+      requirements = requirements.filter(
+        (req) => req.instructions.some(
+          (instr) => instr.dueTime.toMillis() < dueBeforeMillis
+        )
+      );
+    }
+    if (filters == null ? void 0 : filters.dueAfter) {
+      const dueAfterMillis = filters.dueAfter.toMillis();
+      requirements = requirements.filter(
+        (req) => req.instructions.some(
+          (instr) => instr.dueTime.toMillis() > dueAfterMillis
+        )
+      );
+    }
+    const newLastVisible = snapshot.docs[snapshot.docs.length - 1] || null;
+    return { requirements, lastDoc: newLastVisible };
+  }
+  /**
+   * Marks a specific instruction within a PatientRequirementInstance as ACTION_TAKEN.
+   * If all instructions are actioned, updates the overallStatus of the instance.
+   *
+   * @param patientId - The ID of the patient.
+   * @param instanceId - The ID of the PatientRequirementInstance.
+   * @param instructionId - The ID of the instruction to complete.
+   * @returns The updated PatientRequirementInstance.
+   * @throws Error if the instance or instruction is not found, or if the instruction is not in a completable state.
+   */
+  async completeInstruction(patientId, instanceId, instructionId) {
+    const instanceRef = this.getPatientRequirementDocRef(patientId, instanceId);
+    const instanceSnap = await (0, import_firestore41.getDoc)(instanceRef);
+    if (!instanceSnap.exists()) {
+      throw new Error(
+        `PatientRequirementInstance ${instanceId} not found for patient ${patientId}.`
+      );
+    }
+    const instanceData = instanceSnap.data();
+    const instance = { id: instanceSnap.id, ...instanceData };
+    const instructionIndex = instance.instructions.findIndex(
+      (instr) => instr.instructionId === instructionId
+    );
+    if (instructionIndex === -1) {
+      throw new Error(
+        `Instruction ${instructionId} not found in instance ${instanceId}.`
+      );
+    }
+    const instructionToUpdate = instance.instructions[instructionIndex];
+    if (instructionToUpdate.status !== "pendingNotification" /* PENDING_NOTIFICATION */ && instructionToUpdate.status !== "actionDue" /* ACTION_DUE */ && instructionToUpdate.status !== "missed" /* MISSED */) {
+      if (instructionToUpdate.status === "actionTaken" /* ACTION_TAKEN */) {
+        console.warn(
+          `Instruction ${instructionId} is already marked as ACTION_TAKEN.`
+        );
+        return instance;
+      }
+      throw new Error(
+        `Instruction ${instructionId} is in status ${instructionToUpdate.status} and cannot be marked as completed.`
+      );
+    }
+    const now = import_firestore41.Timestamp.now();
+    const updatedInstructions = [...instance.instructions];
+    updatedInstructions[instructionIndex] = {
+      ...instructionToUpdate,
+      status: "actionTaken" /* ACTION_TAKEN */,
+      actionTakenAt: now,
+      updatedAt: now
+    };
+    const allActionTaken = updatedInstructions.every(
+      (instr) => instr.status === "actionTaken" /* ACTION_TAKEN */
+    );
+    let newOverallStatus = instance.overallStatus;
+    if (allActionTaken) {
+      newOverallStatus = "allInstructionsMet" /* ALL_INSTRUCTIONS_MET */;
+    } else if (updatedInstructions.some(
+      (instr) => instr.status === "actionTaken" /* ACTION_TAKEN */
+    )) {
+      newOverallStatus = "partiallyCompleted" /* PARTIALLY_COMPLETED */;
+    }
+    const updatePayload = {
+      // Using a general type for updateDoc payload
+      instructions: updatedInstructions,
+      updatedAt: now
+    };
+    if (newOverallStatus !== instance.overallStatus) {
+      updatePayload.overallStatus = newOverallStatus;
+    }
+    await (0, import_firestore41.updateDoc)(instanceRef, updatePayload);
+    return {
+      ...instance,
+      instructions: updatedInstructions,
+      updatedAt: now,
+      overallStatus: newOverallStatus
+    };
+  }
+  // Note: As per the request, full CRUD (create, direct update of instance, delete) is not part of this light service,
+  // as those will be handled by Cloud Functions reacting to appointment lifecycle events.
+};
+
+// src/backoffice/services/brand.service.ts
+var import_firestore42 = require("firebase/firestore");
+
 // src/backoffice/types/brand.types.ts
 var BRANDS_COLLECTION = "brands";
 
@@ -12797,7 +13495,7 @@ var BrandService = class extends BaseService {
    * Gets reference to brands collection
    */
   getBrandsRef() {
-    return (0, import_firestore41.collection)(this.db, BRANDS_COLLECTION);
+    return (0, import_firestore42.collection)(this.db, BRANDS_COLLECTION);
   }
   /**
    * Creates a new brand
@@ -12810,19 +13508,19 @@ var BrandService = class extends BaseService {
       updatedAt: now,
       isActive: true
     };
-    const docRef = await (0, import_firestore41.addDoc)(this.getBrandsRef(), newBrand);
+    const docRef = await (0, import_firestore42.addDoc)(this.getBrandsRef(), newBrand);
     return { id: docRef.id, ...newBrand };
   }
   /**
    * Gets all active brands
    */
   async getAll() {
-    const q = (0, import_firestore41.query)(this.getBrandsRef(), (0, import_firestore41.where)("isActive", "==", true));
-    const snapshot = await (0, import_firestore41.getDocs)(q);
+    const q = (0, import_firestore42.query)(this.getBrandsRef(), (0, import_firestore42.where)("isActive", "==", true));
+    const snapshot = await (0, import_firestore42.getDocs)(q);
     return snapshot.docs.map(
-      (doc32) => ({
-        id: doc32.id,
-        ...doc32.data()
+      (doc33) => ({
+        id: doc33.id,
+        ...doc33.data()
       })
     );
   }
@@ -12834,8 +13532,8 @@ var BrandService = class extends BaseService {
       ...brand,
       updatedAt: /* @__PURE__ */ new Date()
     };
-    const docRef = (0, import_firestore41.doc)(this.getBrandsRef(), brandId);
-    await (0, import_firestore41.updateDoc)(docRef, updateData);
+    const docRef = (0, import_firestore42.doc)(this.getBrandsRef(), brandId);
+    await (0, import_firestore42.updateDoc)(docRef, updateData);
     return this.getById(brandId);
   }
   /**
@@ -12850,8 +13548,8 @@ var BrandService = class extends BaseService {
    * Gets a brand by ID
    */
   async getById(brandId) {
-    const docRef = (0, import_firestore41.doc)(this.getBrandsRef(), brandId);
-    const docSnap = await (0, import_firestore41.getDoc)(docRef);
+    const docRef = (0, import_firestore42.doc)(this.getBrandsRef(), brandId);
+    const docSnap = await (0, import_firestore42.getDoc)(docRef);
     if (!docSnap.exists()) return null;
     return {
       id: docSnap.id,
@@ -12861,7 +13559,7 @@ var BrandService = class extends BaseService {
 };
 
 // src/backoffice/services/category.service.ts
-var import_firestore42 = require("firebase/firestore");
+var import_firestore43 = require("firebase/firestore");
 
 // src/backoffice/types/category.types.ts
 var CATEGORIES_COLLECTION = "backoffice_categories";
@@ -12872,7 +13570,7 @@ var CategoryService = class extends BaseService {
    * Referenca na Firestore kolekciju kategorija
    */
   get categoriesRef() {
-    return (0, import_firestore42.collection)(this.db, CATEGORIES_COLLECTION);
+    return (0, import_firestore43.collection)(this.db, CATEGORIES_COLLECTION);
   }
   /**
    * Kreira novu kategoriju u sistemu
@@ -12887,7 +13585,7 @@ var CategoryService = class extends BaseService {
       updatedAt: now,
       isActive: true
     };
-    const docRef = await (0, import_firestore42.addDoc)(this.categoriesRef, newCategory);
+    const docRef = await (0, import_firestore43.addDoc)(this.categoriesRef, newCategory);
     return { id: docRef.id, ...newCategory };
   }
   /**
@@ -12895,12 +13593,12 @@ var CategoryService = class extends BaseService {
    * @returns Lista aktivnih kategorija
    */
   async getAll() {
-    const q = (0, import_firestore42.query)(this.categoriesRef, (0, import_firestore42.where)("isActive", "==", true));
-    const snapshot = await (0, import_firestore42.getDocs)(q);
+    const q = (0, import_firestore43.query)(this.categoriesRef, (0, import_firestore43.where)("isActive", "==", true));
+    const snapshot = await (0, import_firestore43.getDocs)(q);
     return snapshot.docs.map(
-      (doc32) => ({
-        id: doc32.id,
-        ...doc32.data()
+      (doc33) => ({
+        id: doc33.id,
+        ...doc33.data()
       })
     );
   }
@@ -12910,16 +13608,16 @@ var CategoryService = class extends BaseService {
    * @returns Lista kategorija koje pripadaju traženoj familiji
    */
   async getAllByFamily(family) {
-    const q = (0, import_firestore42.query)(
+    const q = (0, import_firestore43.query)(
       this.categoriesRef,
-      (0, import_firestore42.where)("family", "==", family),
-      (0, import_firestore42.where)("isActive", "==", true)
+      (0, import_firestore43.where)("family", "==", family),
+      (0, import_firestore43.where)("isActive", "==", true)
     );
-    const snapshot = await (0, import_firestore42.getDocs)(q);
+    const snapshot = await (0, import_firestore43.getDocs)(q);
     return snapshot.docs.map(
-      (doc32) => ({
-        id: doc32.id,
-        ...doc32.data()
+      (doc33) => ({
+        id: doc33.id,
+        ...doc33.data()
       })
     );
   }
@@ -12934,8 +13632,8 @@ var CategoryService = class extends BaseService {
       ...category,
       updatedAt: /* @__PURE__ */ new Date()
     };
-    const docRef = (0, import_firestore42.doc)(this.categoriesRef, id);
-    await (0, import_firestore42.updateDoc)(docRef, updateData);
+    const docRef = (0, import_firestore43.doc)(this.categoriesRef, id);
+    await (0, import_firestore43.updateDoc)(docRef, updateData);
     return this.getById(id);
   }
   /**
@@ -12951,8 +13649,8 @@ var CategoryService = class extends BaseService {
    * @returns Kategorija ili null ako ne postoji
    */
   async getById(id) {
-    const docRef = (0, import_firestore42.doc)(this.categoriesRef, id);
-    const docSnap = await (0, import_firestore42.getDoc)(docRef);
+    const docRef = (0, import_firestore43.doc)(this.categoriesRef, id);
+    const docSnap = await (0, import_firestore43.getDoc)(docRef);
     if (!docSnap.exists()) return null;
     return {
       id: docSnap.id,
@@ -12962,7 +13660,7 @@ var CategoryService = class extends BaseService {
 };
 
 // src/backoffice/services/subcategory.service.ts
-var import_firestore43 = require("firebase/firestore");
+var import_firestore44 = require("firebase/firestore");
 
 // src/backoffice/types/subcategory.types.ts
 var SUBCATEGORIES_COLLECTION = "subcategories";
@@ -12974,7 +13672,7 @@ var SubcategoryService = class extends BaseService {
    * @param categoryId - ID roditeljske kategorije
    */
   getSubcategoriesRef(categoryId) {
-    return (0, import_firestore43.collection)(
+    return (0, import_firestore44.collection)(
       this.db,
       CATEGORIES_COLLECTION,
       categoryId,
@@ -12996,7 +13694,7 @@ var SubcategoryService = class extends BaseService {
       updatedAt: now,
       isActive: true
     };
-    const docRef = await (0, import_firestore43.addDoc)(
+    const docRef = await (0, import_firestore44.addDoc)(
       this.getSubcategoriesRef(categoryId),
       newSubcategory
     );
@@ -13008,15 +13706,15 @@ var SubcategoryService = class extends BaseService {
    * @returns Lista aktivnih podkategorija
    */
   async getAllByCategoryId(categoryId) {
-    const q = (0, import_firestore43.query)(
+    const q = (0, import_firestore44.query)(
       this.getSubcategoriesRef(categoryId),
-      (0, import_firestore43.where)("isActive", "==", true)
+      (0, import_firestore44.where)("isActive", "==", true)
     );
-    const snapshot = await (0, import_firestore43.getDocs)(q);
+    const snapshot = await (0, import_firestore44.getDocs)(q);
     return snapshot.docs.map(
-      (doc32) => ({
-        id: doc32.id,
-        ...doc32.data()
+      (doc33) => ({
+        id: doc33.id,
+        ...doc33.data()
       })
     );
   }
@@ -13032,8 +13730,8 @@ var SubcategoryService = class extends BaseService {
       ...subcategory,
       updatedAt: /* @__PURE__ */ new Date()
     };
-    const docRef = (0, import_firestore43.doc)(this.getSubcategoriesRef(categoryId), subcategoryId);
-    await (0, import_firestore43.updateDoc)(docRef, updateData);
+    const docRef = (0, import_firestore44.doc)(this.getSubcategoriesRef(categoryId), subcategoryId);
+    await (0, import_firestore44.updateDoc)(docRef, updateData);
     return this.getById(categoryId, subcategoryId);
   }
   /**
@@ -13051,8 +13749,8 @@ var SubcategoryService = class extends BaseService {
    * @returns Podkategorija ili null ako ne postoji
    */
   async getById(categoryId, subcategoryId) {
-    const docRef = (0, import_firestore43.doc)(this.getSubcategoriesRef(categoryId), subcategoryId);
-    const docSnap = await (0, import_firestore43.getDoc)(docRef);
+    const docRef = (0, import_firestore44.doc)(this.getSubcategoriesRef(categoryId), subcategoryId);
+    const docSnap = await (0, import_firestore44.getDoc)(docRef);
     if (!docSnap.exists()) return null;
     return {
       id: docSnap.id,
@@ -13062,7 +13760,7 @@ var SubcategoryService = class extends BaseService {
 };
 
 // src/backoffice/services/technology.service.ts
-var import_firestore44 = require("firebase/firestore");
+var import_firestore45 = require("firebase/firestore");
 var DEFAULT_CERTIFICATION_REQUIREMENT = {
   minimumLevel: "aesthetician" /* AESTHETICIAN */,
   requiredSpecialties: []
@@ -13072,7 +13770,7 @@ var TechnologyService = class extends BaseService {
    * Vraća referencu na Firestore kolekciju tehnologija
    */
   getTechnologiesRef() {
-    return (0, import_firestore44.collection)(this.db, TECHNOLOGIES_COLLECTION);
+    return (0, import_firestore45.collection)(this.db, TECHNOLOGIES_COLLECTION);
   }
   /**
    * Kreira novu tehnologiju
@@ -13095,7 +13793,7 @@ var TechnologyService = class extends BaseService {
       benefits: technology.benefits || [],
       certificationRequirement: technology.certificationRequirement || DEFAULT_CERTIFICATION_REQUIREMENT
     };
-    const docRef = await (0, import_firestore44.addDoc)(this.getTechnologiesRef(), newTechnology);
+    const docRef = await (0, import_firestore45.addDoc)(this.getTechnologiesRef(), newTechnology);
     return { id: docRef.id, ...newTechnology };
   }
   /**
@@ -13103,12 +13801,12 @@ var TechnologyService = class extends BaseService {
    * @returns Lista aktivnih tehnologija
    */
   async getAll() {
-    const q = (0, import_firestore44.query)(this.getTechnologiesRef(), (0, import_firestore44.where)("isActive", "==", true));
-    const snapshot = await (0, import_firestore44.getDocs)(q);
+    const q = (0, import_firestore45.query)(this.getTechnologiesRef(), (0, import_firestore45.where)("isActive", "==", true));
+    const snapshot = await (0, import_firestore45.getDocs)(q);
     return snapshot.docs.map(
-      (doc32) => ({
-        id: doc32.id,
-        ...doc32.data()
+      (doc33) => ({
+        id: doc33.id,
+        ...doc33.data()
       })
     );
   }
@@ -13118,16 +13816,16 @@ var TechnologyService = class extends BaseService {
    * @returns Lista aktivnih tehnologija
    */
   async getAllByFamily(family) {
-    const q = (0, import_firestore44.query)(
+    const q = (0, import_firestore45.query)(
       this.getTechnologiesRef(),
-      (0, import_firestore44.where)("isActive", "==", true),
-      (0, import_firestore44.where)("family", "==", family)
+      (0, import_firestore45.where)("isActive", "==", true),
+      (0, import_firestore45.where)("family", "==", family)
     );
-    const snapshot = await (0, import_firestore44.getDocs)(q);
+    const snapshot = await (0, import_firestore45.getDocs)(q);
     return snapshot.docs.map(
-      (doc32) => ({
-        id: doc32.id,
-        ...doc32.data()
+      (doc33) => ({
+        id: doc33.id,
+        ...doc33.data()
       })
     );
   }
@@ -13137,16 +13835,16 @@ var TechnologyService = class extends BaseService {
    * @returns Lista aktivnih tehnologija
    */
   async getAllByCategoryId(categoryId) {
-    const q = (0, import_firestore44.query)(
+    const q = (0, import_firestore45.query)(
       this.getTechnologiesRef(),
-      (0, import_firestore44.where)("isActive", "==", true),
-      (0, import_firestore44.where)("categoryId", "==", categoryId)
+      (0, import_firestore45.where)("isActive", "==", true),
+      (0, import_firestore45.where)("categoryId", "==", categoryId)
     );
-    const snapshot = await (0, import_firestore44.getDocs)(q);
+    const snapshot = await (0, import_firestore45.getDocs)(q);
     return snapshot.docs.map(
-      (doc32) => ({
-        id: doc32.id,
-        ...doc32.data()
+      (doc33) => ({
+        id: doc33.id,
+        ...doc33.data()
       })
     );
   }
@@ -13156,16 +13854,16 @@ var TechnologyService = class extends BaseService {
    * @returns Lista aktivnih tehnologija
    */
   async getAllBySubcategoryId(subcategoryId) {
-    const q = (0, import_firestore44.query)(
+    const q = (0, import_firestore45.query)(
       this.getTechnologiesRef(),
-      (0, import_firestore44.where)("isActive", "==", true),
-      (0, import_firestore44.where)("subcategoryId", "==", subcategoryId)
+      (0, import_firestore45.where)("isActive", "==", true),
+      (0, import_firestore45.where)("subcategoryId", "==", subcategoryId)
     );
-    const snapshot = await (0, import_firestore44.getDocs)(q);
+    const snapshot = await (0, import_firestore45.getDocs)(q);
     return snapshot.docs.map(
-      (doc32) => ({
-        id: doc32.id,
-        ...doc32.data()
+      (doc33) => ({
+        id: doc33.id,
+        ...doc33.data()
       })
     );
   }
@@ -13180,8 +13878,8 @@ var TechnologyService = class extends BaseService {
       ...technology,
       updatedAt: /* @__PURE__ */ new Date()
     };
-    const docRef = (0, import_firestore44.doc)(this.getTechnologiesRef(), technologyId);
-    await (0, import_firestore44.updateDoc)(docRef, updateData);
+    const docRef = (0, import_firestore45.doc)(this.getTechnologiesRef(), technologyId);
+    await (0, import_firestore45.updateDoc)(docRef, updateData);
     return this.getById(technologyId);
   }
   /**
@@ -13199,8 +13897,8 @@ var TechnologyService = class extends BaseService {
    * @returns Tehnologija ili null ako ne postoji
    */
   async getById(technologyId) {
-    const docRef = (0, import_firestore44.doc)(this.getTechnologiesRef(), technologyId);
-    const docSnap = await (0, import_firestore44.getDoc)(docRef);
+    const docRef = (0, import_firestore45.doc)(this.getTechnologiesRef(), technologyId);
+    const docSnap = await (0, import_firestore45.getDoc)(docRef);
     if (!docSnap.exists()) return null;
     return {
       id: docSnap.id,
@@ -13214,10 +13912,10 @@ var TechnologyService = class extends BaseService {
    * @returns Ažurirana tehnologija sa novim zahtevom
    */
   async addRequirement(technologyId, requirement) {
-    const docRef = (0, import_firestore44.doc)(this.getTechnologiesRef(), technologyId);
+    const docRef = (0, import_firestore45.doc)(this.getTechnologiesRef(), technologyId);
     const requirementType = requirement.type === "pre" ? "requirements.pre" : "requirements.post";
-    await (0, import_firestore44.updateDoc)(docRef, {
-      [requirementType]: (0, import_firestore44.arrayUnion)(requirement),
+    await (0, import_firestore45.updateDoc)(docRef, {
+      [requirementType]: (0, import_firestore45.arrayUnion)(requirement),
       updatedAt: /* @__PURE__ */ new Date()
     });
     return this.getById(technologyId);
@@ -13229,10 +13927,10 @@ var TechnologyService = class extends BaseService {
    * @returns Ažurirana tehnologija bez uklonjenog zahteva
    */
   async removeRequirement(technologyId, requirement) {
-    const docRef = (0, import_firestore44.doc)(this.getTechnologiesRef(), technologyId);
+    const docRef = (0, import_firestore45.doc)(this.getTechnologiesRef(), technologyId);
     const requirementType = requirement.type === "pre" ? "requirements.pre" : "requirements.post";
-    await (0, import_firestore44.updateDoc)(docRef, {
-      [requirementType]: (0, import_firestore44.arrayRemove)(requirement),
+    await (0, import_firestore45.updateDoc)(docRef, {
+      [requirementType]: (0, import_firestore45.arrayRemove)(requirement),
       updatedAt: /* @__PURE__ */ new Date()
     });
     return this.getById(technologyId);
@@ -13269,9 +13967,9 @@ var TechnologyService = class extends BaseService {
    * @returns Ažurirana tehnologija
    */
   async addBlockingCondition(technologyId, condition) {
-    const docRef = (0, import_firestore44.doc)(this.getTechnologiesRef(), technologyId);
-    await (0, import_firestore44.updateDoc)(docRef, {
-      blockingConditions: (0, import_firestore44.arrayUnion)(condition),
+    const docRef = (0, import_firestore45.doc)(this.getTechnologiesRef(), technologyId);
+    await (0, import_firestore45.updateDoc)(docRef, {
+      blockingConditions: (0, import_firestore45.arrayUnion)(condition),
       updatedAt: /* @__PURE__ */ new Date()
     });
     return this.getById(technologyId);
@@ -13283,9 +13981,9 @@ var TechnologyService = class extends BaseService {
    * @returns Ažurirana tehnologija
    */
   async removeBlockingCondition(technologyId, condition) {
-    const docRef = (0, import_firestore44.doc)(this.getTechnologiesRef(), technologyId);
-    await (0, import_firestore44.updateDoc)(docRef, {
-      blockingConditions: (0, import_firestore44.arrayRemove)(condition),
+    const docRef = (0, import_firestore45.doc)(this.getTechnologiesRef(), technologyId);
+    await (0, import_firestore45.updateDoc)(docRef, {
+      blockingConditions: (0, import_firestore45.arrayRemove)(condition),
       updatedAt: /* @__PURE__ */ new Date()
     });
     return this.getById(technologyId);
@@ -13297,9 +13995,9 @@ var TechnologyService = class extends BaseService {
    * @returns Ažurirana tehnologija
    */
   async addContraindication(technologyId, contraindication) {
-    const docRef = (0, import_firestore44.doc)(this.getTechnologiesRef(), technologyId);
-    await (0, import_firestore44.updateDoc)(docRef, {
-      contraindications: (0, import_firestore44.arrayUnion)(contraindication),
+    const docRef = (0, import_firestore45.doc)(this.getTechnologiesRef(), technologyId);
+    await (0, import_firestore45.updateDoc)(docRef, {
+      contraindications: (0, import_firestore45.arrayUnion)(contraindication),
       updatedAt: /* @__PURE__ */ new Date()
     });
     return this.getById(technologyId);
@@ -13311,9 +14009,9 @@ var TechnologyService = class extends BaseService {
    * @returns Ažurirana tehnologija
    */
   async removeContraindication(technologyId, contraindication) {
-    const docRef = (0, import_firestore44.doc)(this.getTechnologiesRef(), technologyId);
-    await (0, import_firestore44.updateDoc)(docRef, {
-      contraindications: (0, import_firestore44.arrayRemove)(contraindication),
+    const docRef = (0, import_firestore45.doc)(this.getTechnologiesRef(), technologyId);
+    await (0, import_firestore45.updateDoc)(docRef, {
+      contraindications: (0, import_firestore45.arrayRemove)(contraindication),
       updatedAt: /* @__PURE__ */ new Date()
     });
     return this.getById(technologyId);
@@ -13325,9 +14023,9 @@ var TechnologyService = class extends BaseService {
    * @returns Ažurirana tehnologija
    */
   async addBenefit(technologyId, benefit) {
-    const docRef = (0, import_firestore44.doc)(this.getTechnologiesRef(), technologyId);
-    await (0, import_firestore44.updateDoc)(docRef, {
-      benefits: (0, import_firestore44.arrayUnion)(benefit),
+    const docRef = (0, import_firestore45.doc)(this.getTechnologiesRef(), technologyId);
+    await (0, import_firestore45.updateDoc)(docRef, {
+      benefits: (0, import_firestore45.arrayUnion)(benefit),
       updatedAt: /* @__PURE__ */ new Date()
     });
     return this.getById(technologyId);
@@ -13339,9 +14037,9 @@ var TechnologyService = class extends BaseService {
    * @returns Ažurirana tehnologija
    */
   async removeBenefit(technologyId, benefit) {
-    const docRef = (0, import_firestore44.doc)(this.getTechnologiesRef(), technologyId);
-    await (0, import_firestore44.updateDoc)(docRef, {
-      benefits: (0, import_firestore44.arrayRemove)(benefit),
+    const docRef = (0, import_firestore45.doc)(this.getTechnologiesRef(), technologyId);
+    await (0, import_firestore45.updateDoc)(docRef, {
+      benefits: (0, import_firestore45.arrayRemove)(benefit),
       updatedAt: /* @__PURE__ */ new Date()
     });
     return this.getById(technologyId);
@@ -13380,8 +14078,8 @@ var TechnologyService = class extends BaseService {
    * @returns Ažurirana tehnologija
    */
   async updateCertificationRequirement(technologyId, certificationRequirement) {
-    const docRef = (0, import_firestore44.doc)(this.getTechnologiesRef(), technologyId);
-    await (0, import_firestore44.updateDoc)(docRef, {
+    const docRef = (0, import_firestore45.doc)(this.getTechnologiesRef(), technologyId);
+    await (0, import_firestore45.updateDoc)(docRef, {
       certificationRequirement,
       updatedAt: /* @__PURE__ */ new Date()
     });
@@ -13481,7 +14179,7 @@ var TechnologyService = class extends BaseService {
 };
 
 // src/backoffice/services/product.service.ts
-var import_firestore45 = require("firebase/firestore");
+var import_firestore46 = require("firebase/firestore");
 
 // src/backoffice/types/product.types.ts
 var PRODUCTS_COLLECTION = "products";
@@ -13494,7 +14192,7 @@ var ProductService = class extends BaseService {
    * @returns Firestore collection reference
    */
   getProductsRef(technologyId) {
-    return (0, import_firestore45.collection)(
+    return (0, import_firestore46.collection)(
       this.db,
       TECHNOLOGIES_COLLECTION,
       technologyId,
@@ -13514,7 +14212,7 @@ var ProductService = class extends BaseService {
       updatedAt: now,
       isActive: true
     };
-    const productRef = await (0, import_firestore45.addDoc)(
+    const productRef = await (0, import_firestore46.addDoc)(
       this.getProductsRef(technologyId),
       newProduct
     );
@@ -13524,15 +14222,15 @@ var ProductService = class extends BaseService {
    * Gets all products for a technology
    */
   async getAllByTechnology(technologyId) {
-    const q = (0, import_firestore45.query)(
+    const q = (0, import_firestore46.query)(
       this.getProductsRef(technologyId),
-      (0, import_firestore45.where)("isActive", "==", true)
+      (0, import_firestore46.where)("isActive", "==", true)
     );
-    const snapshot = await (0, import_firestore45.getDocs)(q);
+    const snapshot = await (0, import_firestore46.getDocs)(q);
     return snapshot.docs.map(
-      (doc32) => ({
-        id: doc32.id,
-        ...doc32.data()
+      (doc33) => ({
+        id: doc33.id,
+        ...doc33.data()
       })
     );
   }
@@ -13540,21 +14238,21 @@ var ProductService = class extends BaseService {
    * Gets all products for a brand by filtering through all technologies
    */
   async getAllByBrand(brandId) {
-    const allTechnologiesRef = (0, import_firestore45.collection)(this.db, TECHNOLOGIES_COLLECTION);
-    const technologiesSnapshot = await (0, import_firestore45.getDocs)(allTechnologiesRef);
+    const allTechnologiesRef = (0, import_firestore46.collection)(this.db, TECHNOLOGIES_COLLECTION);
+    const technologiesSnapshot = await (0, import_firestore46.getDocs)(allTechnologiesRef);
     const products = [];
     for (const techDoc of technologiesSnapshot.docs) {
-      const q = (0, import_firestore45.query)(
+      const q = (0, import_firestore46.query)(
         this.getProductsRef(techDoc.id),
-        (0, import_firestore45.where)("brandId", "==", brandId),
-        (0, import_firestore45.where)("isActive", "==", true)
+        (0, import_firestore46.where)("brandId", "==", brandId),
+        (0, import_firestore46.where)("isActive", "==", true)
       );
-      const snapshot = await (0, import_firestore45.getDocs)(q);
+      const snapshot = await (0, import_firestore46.getDocs)(q);
       products.push(
         ...snapshot.docs.map(
-          (doc32) => ({
-            id: doc32.id,
-            ...doc32.data()
+          (doc33) => ({
+            id: doc33.id,
+            ...doc33.data()
           })
         )
       );
@@ -13569,8 +14267,8 @@ var ProductService = class extends BaseService {
       ...product,
       updatedAt: /* @__PURE__ */ new Date()
     };
-    const docRef = (0, import_firestore45.doc)(this.getProductsRef(technologyId), productId);
-    await (0, import_firestore45.updateDoc)(docRef, updateData);
+    const docRef = (0, import_firestore46.doc)(this.getProductsRef(technologyId), productId);
+    await (0, import_firestore46.updateDoc)(docRef, updateData);
     return this.getById(technologyId, productId);
   }
   /**
@@ -13585,8 +14283,8 @@ var ProductService = class extends BaseService {
    * Gets a product by ID
    */
   async getById(technologyId, productId) {
-    const docRef = (0, import_firestore45.doc)(this.getProductsRef(technologyId), productId);
-    const docSnap = await (0, import_firestore45.getDoc)(docRef);
+    const docRef = (0, import_firestore46.doc)(this.getProductsRef(technologyId), productId);
+    const docSnap = await (0, import_firestore46.getDoc)(docRef);
     if (!docSnap.exists()) return null;
     return {
       id: docSnap.id,
@@ -13615,14 +14313,14 @@ var baseNotificationSchema = import_zod24.z.object({
   userRole: import_zod24.z.nativeEnum(UserRole)
 });
 var preRequirementNotificationSchema = baseNotificationSchema.extend({
-  notificationType: import_zod24.z.literal("preRequirement" /* PRE_REQUIREMENT */),
+  notificationType: import_zod24.z.literal("requirementInstructionDue" /* REQUIREMENT_INSTRUCTION_DUE */),
   treatmentId: import_zod24.z.string(),
   requirements: import_zod24.z.array(import_zod24.z.string()),
   deadline: import_zod24.z.any()
   // Timestamp
 });
 var postRequirementNotificationSchema = baseNotificationSchema.extend({
-  notificationType: import_zod24.z.literal("postRequirement" /* POST_REQUIREMENT */),
+  notificationType: import_zod24.z.literal("requirementInstructionDue" /* REQUIREMENT_INSTRUCTION_DUE */),
   treatmentId: import_zod24.z.string(),
   requirements: import_zod24.z.array(import_zod24.z.string()),
   deadline: import_zod24.z.any()
@@ -13637,7 +14335,7 @@ var appointmentReminderNotificationSchema = baseNotificationSchema.extend({
   doctorName: import_zod24.z.string()
 });
 var appointmentNotificationSchema = baseNotificationSchema.extend({
-  notificationType: import_zod24.z.literal("appointmentNotification" /* APPOINTMENT_NOTIFICATION */),
+  notificationType: import_zod24.z.literal("appointmentStatusChange" /* APPOINTMENT_STATUS_CHANGE */),
   appointmentId: import_zod24.z.string(),
   appointmentStatus: import_zod24.z.string(),
   previousStatus: import_zod24.z.string(),
@@ -13734,9 +14432,13 @@ var RequirementType = /* @__PURE__ */ ((RequirementType2) => {
   PATIENT_LOCATION_INFO_COLLECTION,
   PATIENT_MEDICAL_HISTORY_COLLECTION,
   PATIENT_MEDICAL_INFO_COLLECTION,
+  PATIENT_REQUIREMENTS_SUBCOLLECTION_NAME,
   PATIENT_SENSITIVE_INFO_COLLECTION,
   PRACTITIONERS_COLLECTION,
   PROCEDURES_COLLECTION,
+  PatientInstructionStatus,
+  PatientRequirementOverallStatus,
+  PatientRequirementsService,
   PatientService,
   PaymentStatus,
   PracticeType,
@@ -13801,6 +14503,7 @@ var RequirementType = /* @__PURE__ */ ((RequirementType2) => {
   createDefaultClinicGroupSchema,
   createDocumentTemplateSchema,
   createDraftPractitionerSchema,
+  createFilledDocumentDataSchema,
   createPatientLocationInfoSchema,
   createPatientMedicalInfoSchema,
   createPatientProfileSchema,
@@ -13816,6 +14519,8 @@ var RequirementType = /* @__PURE__ */ ((RequirementType2) => {
   documentTemplateSchema,
   emailSchema,
   emergencyContactSchema,
+  filledDocumentSchema,
+  filledDocumentStatusSchema,
   gamificationSchema,
   getFirebaseApp,
   getFirebaseAuth,
@@ -13865,6 +14570,7 @@ var RequirementType = /* @__PURE__ */ ((RequirementType2) => {
   updateClinicSchema,
   updateContraindicationSchema,
   updateDocumentTemplateSchema,
+  updateFilledDocumentDataSchema,
   updateMedicationSchema,
   updatePatientMedicalInfoSchema,
   updateVitalStatsSchema,