@blackcode_sa/metaestetics-api 1.8.6 → 1.8.7

package/dist/index.js

@@ -146,11 +146,8 @@ __export(index_exports, {
   beforeAfterPerZoneSchema: () => beforeAfterPerZoneSchema,
   billingPerZoneSchema: () => billingPerZoneSchema,
   blockingConditionSchema: () => blockingConditionSchema,
-  buildPractitionerData: () => buildPractitionerData,
   calendarEventSchema: () => calendarEventSchema,
   calendarEventTimeSchema: () => calendarEventTimeSchema,
-  checkEmailExists: () => checkEmailExists,
-  cleanupFirebaseUser: () => cleanupFirebaseUser,
   clinicAdminOptionsSchema: () => clinicAdminOptionsSchema,
   clinicAdminSchema: () => clinicAdminSchema,
   clinicAdminSignupSchema: () => clinicAdminSignupSchema,
@@ -198,7 +195,6 @@ __export(index_exports, {
   documentTemplateSchema: () => documentTemplateSchema,
   emailSchema: () => emailSchema,
   emergencyContactSchema: () => emergencyContactSchema,
-  extractErrorMessage: () => extractErrorMessage,
   filledDocumentSchema: () => filledDocumentSchema,
   filledDocumentStatusSchema: () => filledDocumentStatusSchema,
   finalBillingSchema: () => finalBillingSchema,
@@ -210,10 +206,7 @@ __export(index_exports, {
   getFirebaseFunctions: () => getFirebaseFunctions,
   getFirebaseInstance: () => getFirebaseInstance,
   getFirebaseStorage: () => getFirebaseStorage,
-  handleFirebaseError: () => handleFirebaseError,
-  handleSignupError: () => handleSignupError,
   initializeFirebase: () => initializeFirebase,
-  isPractitionerDataComplete: () => isPractitionerDataComplete,
   linkedFormInfoSchema: () => linkedFormInfoSchema,
   locationDataSchema: () => locationDataSchema,
   mediaResourceSchema: () => mediaResourceSchema,
@@ -285,7 +278,6 @@ __export(index_exports, {
   userRoleSchema: () => userRoleSchema,
   userRolesSchema: () => userRolesSchema,
   userSchema: () => userSchema,
-  validatePractitionerProfileData: () => validatePractitionerProfileData,
   vitalStatsSchema: () => vitalStatsSchema,
   workingHoursSchema: () => workingHoursSchema
 });
@@ -2145,685 +2137,6 @@ var AppointmentService = class extends BaseService {
   }
 };
 
-// src/services/auth/utils/firebase.utils.ts
-var import_auth = require("firebase/auth");
-var checkEmailExists = async (auth, email) => {
-  try {
-    const methods = await (0, import_auth.fetchSignInMethodsForEmail)(auth, email);
-    return methods.length > 0;
-  } catch (error) {
-    console.warn(
-      "[FIREBASE] Could not check email existence, allowing signup to proceed:",
-      error
-    );
-    return false;
-  }
-};
-var cleanupFirebaseUser = async (firebaseUser) => {
-  try {
-    console.log("[FIREBASE] Cleaning up Firebase user", {
-      uid: firebaseUser.uid
-    });
-    await firebaseUser.delete();
-    console.log("[FIREBASE] Firebase user cleanup successful");
-  } catch (cleanupError) {
-    console.error("[FIREBASE] Failed to cleanup Firebase user:", cleanupError);
-  }
-};
-
-// src/services/auth/utils/error.utils.ts
-var import_zod4 = require("zod");
-
-// src/errors/auth.errors.ts
-var AuthError = class extends Error {
-  constructor(message, code, status = 400) {
-    super(message);
-    this.code = code;
-    this.status = status;
-    this.name = "AuthError";
-  }
-};
-var AUTH_ERRORS = {
-  // Basic validation errors
-  INVALID_EMAIL: new AuthError(
-    "Email address is not in a valid format",
-    "AUTH/INVALID_EMAIL",
-    400
-  ),
-  INVALID_PASSWORD: new AuthError(
-    "Password must contain at least 8 characters, one uppercase letter, one number, and one special character",
-    "AUTH/INVALID_PASSWORD",
-    400
-  ),
-  INVALID_ROLE: new AuthError(
-    "Specified user role is not valid",
-    "AUTH/INVALID_ROLE",
-    400
-  ),
-  // Authentication errors
-  NOT_AUTHENTICATED: new AuthError(
-    "User is not authenticated",
-    "AUTH/NOT_AUTHENTICATED",
-    401
-  ),
-  SESSION_EXPIRED: new AuthError(
-    "Your session has expired. Please sign in again",
-    "AUTH/SESSION_EXPIRED",
-    401
-  ),
-  INVALID_TOKEN: new AuthError(
-    "Invalid authentication token",
-    "AUTH/INVALID_TOKEN",
-    401
-  ),
-  // User state errors
-  USER_NOT_FOUND: new AuthError(
-    "User not found in the system",
-    "AUTH/USER_NOT_FOUND",
-    404
-  ),
-  EMAIL_ALREADY_EXISTS: new AuthError(
-    "An account with this email already exists",
-    "AUTH/EMAIL_EXISTS",
-    409
-  ),
-  USER_DISABLED: new AuthError(
-    "This account has been disabled",
-    "AUTH/USER_DISABLED",
-    403
-  ),
-  // Rate limiting and security
-  TOO_MANY_REQUESTS: new AuthError(
-    "Too many login attempts. Please try again later",
-    "AUTH/TOO_MANY_REQUESTS",
-    429
-  ),
-  ACCOUNT_LOCKED: new AuthError(
-    "Account temporarily locked due to too many failed login attempts",
-    "AUTH/ACCOUNT_LOCKED",
-    403
-  ),
-  // Social auth specific
-  POPUP_CLOSED: new AuthError(
-    "Authentication popup was closed before completion",
-    "AUTH/POPUP_CLOSED",
-    400
-  ),
-  POPUP_BLOCKED: new AuthError(
-    "Authentication popup was blocked by the browser",
-    "AUTH/POPUP_BLOCKED",
-    400
-  ),
-  ACCOUNT_EXISTS: new AuthError(
-    "An account already exists with different credentials",
-    "AUTH/ACCOUNT_EXISTS",
-    409
-  ),
-  // Anonymous auth specific
-  NOT_ANONYMOUS: new AuthError(
-    "Current user is not anonymous",
-    "AUTH/NOT_ANONYMOUS_USER",
-    400
-  ),
-  ANONYMOUS_UPGRADE_FAILED: new AuthError(
-    "Failed to upgrade anonymous account",
-    "AUTH/ANONYMOUS_UPGRADE_FAILED",
-    400
-  ),
-  // General errors
-  VALIDATION_ERROR: new AuthError(
-    "Data validation error occurred",
-    "AUTH/VALIDATION_ERROR",
-    400
-  ),
-  OPERATION_NOT_ALLOWED: new AuthError(
-    "This operation is not allowed",
-    "AUTH/OPERATION_NOT_ALLOWED",
-    403
-  ),
-  NETWORK_ERROR: new AuthError(
-    "Network error occurred. Please check your connection",
-    "AUTH/NETWORK_ERROR",
-    503
-  ),
-  REQUIRES_RECENT_LOGIN: new AuthError(
-    "This operation requires recent authentication. Please sign in again",
-    "AUTH/REQUIRES_RECENT_LOGIN",
-    401
-  ),
-  INVALID_PROVIDER: new AuthError(
-    "Invalid authentication provider",
-    "AUTH/INVALID_PROVIDER",
-    400
-  ),
-  INVALID_CREDENTIAL: new AuthError(
-    "The provided credentials are invalid or expired",
-    "AUTH/INVALID_CREDENTIAL",
-    401
-  ),
-  // Resource not found
-  NOT_FOUND: new AuthError(
-    "The requested resource was not found",
-    "AUTH/NOT_FOUND",
-    404
-  ),
-  // Detailed password validation errors
-  PASSWORD_LENGTH_ERROR: new AuthError(
-    "Password must be at least 8 characters long",
-    "AUTH/PASSWORD_LENGTH_ERROR",
-    400
-  ),
-  PASSWORD_UPPERCASE_ERROR: new AuthError(
-    "Password must contain at least one uppercase letter",
-    "AUTH/PASSWORD_UPPERCASE_ERROR",
-    400
-  ),
-  PASSWORD_NUMBER_ERROR: new AuthError(
-    "Password must contain at least one number",
-    "AUTH/PASSWORD_NUMBER_ERROR",
-    400
-  ),
-  PASSWORD_SPECIAL_CHAR_ERROR: new AuthError(
-    "Password must contain at least one special character",
-    "AUTH/PASSWORD_SPECIAL_CHAR_ERROR",
-    400
-  ),
-  // Detailed email validation errors
-  EMAIL_FORMAT_ERROR: new AuthError(
-    "Invalid email format. Please enter a valid email address",
-    "AUTH/EMAIL_FORMAT_ERROR",
-    400
-  ),
-  PASSWORD_VALIDATION_ERROR: new AuthError(
-    "Password validation failed. Please check all requirements",
-    "AUTH/PASSWORD_VALIDATION_ERROR",
-    400
-  ),
-  // Password reset specific errors
-  EXPIRED_ACTION_CODE: new AuthError(
-    "Kod za resetovanje lozinke je istekao. Molimo zatra\u017Eite novi link za resetovanje.",
-    "AUTH/EXPIRED_ACTION_CODE",
-    400
-  ),
-  INVALID_ACTION_CODE: new AuthError(
-    "Kod za resetovanje lozinke je neva\u017Ee\u0107i ili je ve\u0107 iskori\u0161\u0107en. Molimo zatra\u017Eite novi link za resetovanje.",
-    "AUTH/INVALID_ACTION_CODE",
-    400
-  ),
-  WEAK_PASSWORD: new AuthError(
-    "Lozinka je previ\u0161e slaba. Molimo koristite ja\u010Du lozinku.",
-    "AUTH/WEAK_PASSWORD",
-    400
-  )
-};
-
-// src/services/auth/utils/error.utils.ts
-var handleFirebaseError = (error) => {
-  const firebaseError = error;
-  switch (firebaseError.code) {
-    case "auth/email-already-in-use" /* EMAIL_ALREADY_IN_USE */:
-      return AUTH_ERRORS.EMAIL_ALREADY_EXISTS;
-    case "auth/weak-password":
-      return new Error(
-        "Password is too weak. Please choose a stronger password."
-      );
-    case "auth/invalid-email":
-      return new Error("Please enter a valid email address.");
-    case "auth/network-request-failed":
-      return new Error(
-        "Network error. Please check your internet connection and try again."
-      );
-    default:
-      return new Error(
-        `Account creation failed: ${firebaseError.message || "Unknown error"}`
-      );
-  }
-};
-var handleSignupError = (error) => {
-  if (error instanceof import_zod4.z.ZodError) {
-    const errorMessages = error.errors.map((e) => `${e.path.join(".")}: ${e.message}`).join(", ");
-    return new Error(`Validation failed: ${errorMessages}`);
-  }
-  if (error.code && error.code.startsWith("auth/")) {
-    return handleFirebaseError(error);
-  }
-  if (error.message && error.message.includes("token")) {
-    return new Error("Invalid or expired invitation token");
-  }
-  if (error.message && error.message.includes("validation")) {
-    return new Error(`Invalid practitioner data: ${error.message}`);
-  }
-  return new Error(
-    `Registration failed: ${error.message || "Unknown error occurred"}`
-  );
-};
-var extractErrorMessage = (error) => {
-  if (error instanceof Error) {
-    return error.message;
-  }
-  if (typeof error === "string") {
-    return error;
-  }
-  if (error == null ? void 0 : error.message) {
-    return error.message;
-  }
-  return "Unknown error occurred";
-};
-
-// src/backoffice/types/static/certification.types.ts
-var CertificationLevel = /* @__PURE__ */ ((CertificationLevel2) => {
-  CertificationLevel2["AESTHETICIAN"] = "aesthetician";
-  CertificationLevel2["NURSE_ASSISTANT"] = "nurse_assistant";
-  CertificationLevel2["NURSE"] = "nurse";
-  CertificationLevel2["NURSE_PRACTITIONER"] = "nurse_practitioner";
-  CertificationLevel2["PHYSICIAN_ASSISTANT"] = "physician_assistant";
-  CertificationLevel2["DOCTOR"] = "doctor";
-  CertificationLevel2["SPECIALIST"] = "specialist";
-  CertificationLevel2["PLASTIC_SURGEON"] = "plastic_surgeon";
-  return CertificationLevel2;
-})(CertificationLevel || {});
-var CertificationSpecialty = /* @__PURE__ */ ((CertificationSpecialty3) => {
-  CertificationSpecialty3["LASER"] = "laser";
-  CertificationSpecialty3["INJECTABLES"] = "injectables";
-  CertificationSpecialty3["CHEMICAL_PEELS"] = "chemical_peels";
-  CertificationSpecialty3["MICRODERMABRASION"] = "microdermabrasion";
-  CertificationSpecialty3["BODY_CONTOURING"] = "body_contouring";
-  CertificationSpecialty3["SKIN_CARE"] = "skin_care";
-  CertificationSpecialty3["WOUND_CARE"] = "wound_care";
-  CertificationSpecialty3["ANESTHESIA"] = "anesthesia";
-  return CertificationSpecialty3;
-})(CertificationSpecialty || {});
-
-// src/services/auth/utils/practitioner.utils.ts
-var import_zod8 = require("zod");
-
-// src/validations/practitioner.schema.ts
-var import_zod7 = require("zod");
-var import_firestore3 = require("firebase/firestore");
-
-// src/validations/reviews.schema.ts
-var import_zod5 = require("zod");
-var baseReviewSchema = import_zod5.z.object({
-  id: import_zod5.z.string().min(1),
-  patientId: import_zod5.z.string().min(1),
-  fullReviewId: import_zod5.z.string().min(1),
-  createdAt: import_zod5.z.date(),
-  updatedAt: import_zod5.z.date(),
-  comment: import_zod5.z.string().min(1).max(2e3),
-  isVerified: import_zod5.z.boolean(),
-  isPublished: import_zod5.z.boolean()
-});
-var baseReviewCreateSchema = import_zod5.z.object({
-  patientId: import_zod5.z.string().min(1),
-  comment: import_zod5.z.string().min(1).max(2e3),
-  isVerified: import_zod5.z.boolean().default(false),
-  isPublished: import_zod5.z.boolean().default(true)
-});
-var clinicReviewSchema = baseReviewSchema.extend({
-  clinicId: import_zod5.z.string().min(1),
-  cleanliness: import_zod5.z.number().min(1).max(5),
-  facilities: import_zod5.z.number().min(1).max(5),
-  staffFriendliness: import_zod5.z.number().min(1).max(5),
-  waitingTime: import_zod5.z.number().min(1).max(5),
-  accessibility: import_zod5.z.number().min(1).max(5),
-  overallRating: import_zod5.z.number().min(1).max(5),
-  wouldRecommend: import_zod5.z.boolean()
-});
-var createClinicReviewSchema = baseReviewCreateSchema.extend({
-  clinicId: import_zod5.z.string().min(1),
-  cleanliness: import_zod5.z.number().min(1).max(5),
-  facilities: import_zod5.z.number().min(1).max(5),
-  staffFriendliness: import_zod5.z.number().min(1).max(5),
-  waitingTime: import_zod5.z.number().min(1).max(5),
-  accessibility: import_zod5.z.number().min(1).max(5),
-  wouldRecommend: import_zod5.z.boolean()
-});
-var practitionerReviewSchema = baseReviewSchema.extend({
-  practitionerId: import_zod5.z.string().min(1),
-  knowledgeAndExpertise: import_zod5.z.number().min(1).max(5),
-  communicationSkills: import_zod5.z.number().min(1).max(5),
-  bedSideManner: import_zod5.z.number().min(1).max(5),
-  thoroughness: import_zod5.z.number().min(1).max(5),
-  trustworthiness: import_zod5.z.number().min(1).max(5),
-  overallRating: import_zod5.z.number().min(1).max(5),
-  wouldRecommend: import_zod5.z.boolean()
-});
-var createPractitionerReviewSchema = baseReviewCreateSchema.extend({
-  practitionerId: import_zod5.z.string().min(1),
-  knowledgeAndExpertise: import_zod5.z.number().min(1).max(5),
-  communicationSkills: import_zod5.z.number().min(1).max(5),
-  bedSideManner: import_zod5.z.number().min(1).max(5),
-  thoroughness: import_zod5.z.number().min(1).max(5),
-  trustworthiness: import_zod5.z.number().min(1).max(5),
-  wouldRecommend: import_zod5.z.boolean()
-});
-var procedureReviewSchema = baseReviewSchema.extend({
-  procedureId: import_zod5.z.string().min(1),
-  effectivenessOfTreatment: import_zod5.z.number().min(1).max(5),
-  outcomeExplanation: import_zod5.z.number().min(1).max(5),
-  painManagement: import_zod5.z.number().min(1).max(5),
-  followUpCare: import_zod5.z.number().min(1).max(5),
-  valueForMoney: import_zod5.z.number().min(1).max(5),
-  overallRating: import_zod5.z.number().min(1).max(5),
-  wouldRecommend: import_zod5.z.boolean()
-});
-var createProcedureReviewSchema = baseReviewCreateSchema.extend({
-  procedureId: import_zod5.z.string().min(1),
-  effectivenessOfTreatment: import_zod5.z.number().min(1).max(5),
-  outcomeExplanation: import_zod5.z.number().min(1).max(5),
-  painManagement: import_zod5.z.number().min(1).max(5),
-  followUpCare: import_zod5.z.number().min(1).max(5),
-  valueForMoney: import_zod5.z.number().min(1).max(5),
-  wouldRecommend: import_zod5.z.boolean()
-});
-var clinicReviewInfoSchema = import_zod5.z.object({
-  totalReviews: import_zod5.z.number().min(0),
-  averageRating: import_zod5.z.number().min(0).max(5),
-  cleanliness: import_zod5.z.number().min(0).max(5),
-  facilities: import_zod5.z.number().min(0).max(5),
-  staffFriendliness: import_zod5.z.number().min(0).max(5),
-  waitingTime: import_zod5.z.number().min(0).max(5),
-  accessibility: import_zod5.z.number().min(0).max(5),
-  recommendationPercentage: import_zod5.z.number().min(0).max(100)
-});
-var practitionerReviewInfoSchema = import_zod5.z.object({
-  totalReviews: import_zod5.z.number().min(0),
-  averageRating: import_zod5.z.number().min(0).max(5),
-  knowledgeAndExpertise: import_zod5.z.number().min(0).max(5),
-  communicationSkills: import_zod5.z.number().min(0).max(5),
-  bedSideManner: import_zod5.z.number().min(0).max(5),
-  thoroughness: import_zod5.z.number().min(0).max(5),
-  trustworthiness: import_zod5.z.number().min(0).max(5),
-  recommendationPercentage: import_zod5.z.number().min(0).max(100)
-});
-var procedureReviewInfoSchema = import_zod5.z.object({
-  totalReviews: import_zod5.z.number().min(0),
-  averageRating: import_zod5.z.number().min(0).max(5),
-  effectivenessOfTreatment: import_zod5.z.number().min(0).max(5),
-  outcomeExplanation: import_zod5.z.number().min(0).max(5),
-  painManagement: import_zod5.z.number().min(0).max(5),
-  followUpCare: import_zod5.z.number().min(0).max(5),
-  valueForMoney: import_zod5.z.number().min(0).max(5),
-  recommendationPercentage: import_zod5.z.number().min(0).max(100)
-});
-var reviewSchema = import_zod5.z.object({
-  id: import_zod5.z.string().min(1),
-  appointmentId: import_zod5.z.string().min(1),
-  patientId: import_zod5.z.string().min(1),
-  createdAt: import_zod5.z.date(),
-  updatedAt: import_zod5.z.date(),
-  clinicReview: clinicReviewSchema.optional(),
-  practitionerReview: practitionerReviewSchema.optional(),
-  procedureReview: procedureReviewSchema.optional(),
-  overallComment: import_zod5.z.string().min(1).max(2e3),
-  overallRating: import_zod5.z.number().min(1).max(5)
-});
-var createReviewSchema = import_zod5.z.object({
-  patientId: import_zod5.z.string().min(1),
-  clinicReview: createClinicReviewSchema.optional(),
-  practitionerReview: createPractitionerReviewSchema.optional(),
-  procedureReview: createProcedureReviewSchema.optional(),
-  overallComment: import_zod5.z.string().min(1).max(2e3)
-}).refine(
-  (data) => {
-    return data.clinicReview || data.practitionerReview || data.procedureReview;
-  },
-  {
-    message: "At least one review type (clinic, practitioner, or procedure) must be provided",
-    path: ["reviewType"]
-  }
-);
-
-// src/validations/shared.schema.ts
-var import_zod6 = require("zod");
-
-// src/backoffice/types/static/procedure-family.types.ts
-var ProcedureFamily = /* @__PURE__ */ ((ProcedureFamily2) => {
-  ProcedureFamily2["AESTHETICS"] = "aesthetics";
-  ProcedureFamily2["SURGERY"] = "surgery";
-  return ProcedureFamily2;
-})(ProcedureFamily || {});
-
-// src/validations/shared.schema.ts
-var sharedClinicContactInfoSchema = import_zod6.z.object({
-  email: import_zod6.z.string().email(),
-  phoneNumber: import_zod6.z.string(),
-  alternativePhoneNumber: import_zod6.z.string().nullable().optional(),
-  website: import_zod6.z.string().nullable().optional()
-});
-var sharedClinicLocationSchema = import_zod6.z.object({
-  address: import_zod6.z.string(),
-  city: import_zod6.z.string(),
-  country: import_zod6.z.string(),
-  postalCode: import_zod6.z.string(),
-  latitude: import_zod6.z.number().min(-90).max(90),
-  longitude: import_zod6.z.number().min(-180).max(180),
-  geohash: import_zod6.z.string().nullable().optional()
-});
-var procedureSummaryInfoSchema = import_zod6.z.object({
-  id: import_zod6.z.string().min(1),
-  name: import_zod6.z.string().min(1),
-  description: import_zod6.z.string().optional(),
-  photo: import_zod6.z.string().optional(),
-  family: import_zod6.z.nativeEnum(ProcedureFamily),
-  categoryName: import_zod6.z.string(),
-  subcategoryName: import_zod6.z.string(),
-  technologyName: import_zod6.z.string(),
-  price: import_zod6.z.number().nonnegative(),
-  pricingMeasure: import_zod6.z.nativeEnum(PricingMeasure),
-  currency: import_zod6.z.nativeEnum(Currency),
-  duration: import_zod6.z.number().int().positive(),
-  clinicId: import_zod6.z.string().min(1),
-  clinicName: import_zod6.z.string().min(1),
-  practitionerId: import_zod6.z.string().min(1),
-  practitionerName: import_zod6.z.string().min(1)
-});
-var clinicInfoSchema = import_zod6.z.object({
-  id: import_zod6.z.string(),
-  featuredPhoto: import_zod6.z.string(),
-  name: import_zod6.z.string(),
-  description: import_zod6.z.string().nullable().optional(),
-  location: sharedClinicLocationSchema,
-  contactInfo: sharedClinicContactInfoSchema
-});
-var doctorInfoSchema = import_zod6.z.object({
-  id: import_zod6.z.string(),
-  name: import_zod6.z.string(),
-  description: import_zod6.z.string().nullable().optional(),
-  photo: import_zod6.z.string(),
-  rating: import_zod6.z.number().min(0).max(5),
-  services: import_zod6.z.array(import_zod6.z.string())
-  // List of procedure IDs practitioner offers
-});
-
-// src/validations/practitioner.schema.ts
-var practitionerBasicInfoSchema = import_zod7.z.object({
-  firstName: import_zod7.z.string().min(2).max(50),
-  lastName: import_zod7.z.string().min(2).max(50),
-  title: import_zod7.z.string().min(2).max(100),
-  email: import_zod7.z.string().email(),
-  phoneNumber: import_zod7.z.string().regex(/^\+?[1-9]\d{1,14}$/, "Invalid phone number").nullable(),
-  dateOfBirth: import_zod7.z.instanceof(import_firestore3.Timestamp).or(import_zod7.z.date()).nullable(),
-  gender: import_zod7.z.enum(["male", "female", "other"]),
-  profileImageUrl: mediaResourceSchema.optional().nullable(),
-  bio: import_zod7.z.string().max(1e3).optional(),
-  languages: import_zod7.z.array(import_zod7.z.string()).min(1)
-});
-var practitionerCertificationSchema = import_zod7.z.object({
-  level: import_zod7.z.nativeEnum(CertificationLevel),
-  specialties: import_zod7.z.array(import_zod7.z.nativeEnum(CertificationSpecialty)),
-  licenseNumber: import_zod7.z.string().min(3).max(50),
-  issuingAuthority: import_zod7.z.string().min(2).max(100),
-  issueDate: import_zod7.z.instanceof(import_firestore3.Timestamp).or(import_zod7.z.date()),
-  expiryDate: import_zod7.z.instanceof(import_firestore3.Timestamp).or(import_zod7.z.date()).optional().nullable(),
-  verificationStatus: import_zod7.z.enum(["pending", "verified", "rejected"])
-});
-var timeSlotSchema = import_zod7.z.object({
-  start: import_zod7.z.string().regex(/^([01]\d|2[0-3]):([0-5]\d)$/, "Invalid time format"),
-  end: import_zod7.z.string().regex(/^([01]\d|2[0-3]):([0-5]\d)$/, "Invalid time format")
-}).nullable();
-var practitionerWorkingHoursSchema = import_zod7.z.object({
-  practitionerId: import_zod7.z.string().min(1),
-  clinicId: import_zod7.z.string().min(1),
-  monday: timeSlotSchema,
-  tuesday: timeSlotSchema,
-  wednesday: timeSlotSchema,
-  thursday: timeSlotSchema,
-  friday: timeSlotSchema,
-  saturday: timeSlotSchema,
-  sunday: timeSlotSchema,
-  createdAt: import_zod7.z.instanceof(import_firestore3.Timestamp).or(import_zod7.z.date()),
-  updatedAt: import_zod7.z.instanceof(import_firestore3.Timestamp).or(import_zod7.z.date())
-});
-var practitionerClinicWorkingHoursSchema = import_zod7.z.object({
-  clinicId: import_zod7.z.string().min(1),
-  workingHours: import_zod7.z.object({
-    monday: timeSlotSchema,
-    tuesday: timeSlotSchema,
-    wednesday: timeSlotSchema,
-    thursday: timeSlotSchema,
-    friday: timeSlotSchema,
-    saturday: timeSlotSchema,
-    sunday: timeSlotSchema
-  }),
-  isActive: import_zod7.z.boolean(),
-  createdAt: import_zod7.z.instanceof(import_firestore3.Timestamp).or(import_zod7.z.date()),
-  updatedAt: import_zod7.z.instanceof(import_firestore3.Timestamp).or(import_zod7.z.date())
-});
-var practitionerSchema = import_zod7.z.object({
-  id: import_zod7.z.string().min(1),
-  userRef: import_zod7.z.string().min(1),
-  basicInfo: practitionerBasicInfoSchema,
-  certification: practitionerCertificationSchema,
-  clinics: import_zod7.z.array(import_zod7.z.string()),
-  clinicWorkingHours: import_zod7.z.array(practitionerClinicWorkingHoursSchema),
-  clinicsInfo: import_zod7.z.array(clinicInfoSchema),
-  procedures: import_zod7.z.array(import_zod7.z.string()),
-  freeConsultations: import_zod7.z.record(import_zod7.z.string(), import_zod7.z.string()).optional().nullable(),
-  proceduresInfo: import_zod7.z.array(procedureSummaryInfoSchema),
-  reviewInfo: practitionerReviewInfoSchema,
-  isActive: import_zod7.z.boolean(),
-  isVerified: import_zod7.z.boolean(),
-  status: import_zod7.z.nativeEnum(PractitionerStatus),
-  createdAt: import_zod7.z.instanceof(import_firestore3.Timestamp).or(import_zod7.z.date()),
-  updatedAt: import_zod7.z.instanceof(import_firestore3.Timestamp).or(import_zod7.z.date())
-});
-var createPractitionerSchema = import_zod7.z.object({
-  userRef: import_zod7.z.string().min(1),
-  basicInfo: practitionerBasicInfoSchema,
-  certification: practitionerCertificationSchema,
-  clinics: import_zod7.z.array(import_zod7.z.string()).optional(),
-  clinicWorkingHours: import_zod7.z.array(practitionerClinicWorkingHoursSchema).optional(),
-  clinicsInfo: import_zod7.z.array(clinicInfoSchema).optional(),
-  freeConsultations: import_zod7.z.record(import_zod7.z.string(), import_zod7.z.string()).optional().nullable(),
-  proceduresInfo: import_zod7.z.array(procedureSummaryInfoSchema).optional(),
-  isActive: import_zod7.z.boolean(),
-  isVerified: import_zod7.z.boolean(),
-  status: import_zod7.z.nativeEnum(PractitionerStatus).optional()
-});
-var createDraftPractitionerSchema = import_zod7.z.object({
-  basicInfo: practitionerBasicInfoSchema,
-  certification: practitionerCertificationSchema,
-  clinics: import_zod7.z.array(import_zod7.z.string()).optional(),
-  clinicWorkingHours: import_zod7.z.array(practitionerClinicWorkingHoursSchema).optional(),
-  clinicsInfo: import_zod7.z.array(clinicInfoSchema).optional(),
-  freeConsultations: import_zod7.z.record(import_zod7.z.string(), import_zod7.z.string()).optional().nullable(),
-  proceduresInfo: import_zod7.z.array(procedureSummaryInfoSchema).optional(),
-  isActive: import_zod7.z.boolean().optional().default(false),
-  isVerified: import_zod7.z.boolean().optional().default(false)
-});
-var practitionerTokenSchema = import_zod7.z.object({
-  id: import_zod7.z.string().min(1),
-  token: import_zod7.z.string().min(6),
-  practitionerId: import_zod7.z.string().min(1),
-  email: import_zod7.z.string().email(),
-  clinicId: import_zod7.z.string().min(1),
-  status: import_zod7.z.nativeEnum(PractitionerTokenStatus),
-  createdBy: import_zod7.z.string().min(1),
-  createdAt: import_zod7.z.instanceof(import_firestore3.Timestamp).or(import_zod7.z.date()),
-  expiresAt: import_zod7.z.instanceof(import_firestore3.Timestamp).or(import_zod7.z.date()),
-  usedBy: import_zod7.z.string().optional(),
-  usedAt: import_zod7.z.instanceof(import_firestore3.Timestamp).or(import_zod7.z.date()).optional()
-});
-var createPractitionerTokenSchema = import_zod7.z.object({
-  practitionerId: import_zod7.z.string().min(1),
-  email: import_zod7.z.string().email(),
-  clinicId: import_zod7.z.string().min(1),
-  expiresAt: import_zod7.z.date().optional()
-});
-var practitionerSignupSchema = import_zod7.z.object({
-  email: import_zod7.z.string().email(),
-  password: import_zod7.z.string().min(8),
-  firstName: import_zod7.z.string().min(2).max(50).optional(),
-  lastName: import_zod7.z.string().min(2).max(50).optional(),
-  token: import_zod7.z.string().optional(),
-  profileData: import_zod7.z.object({
-    basicInfo: import_zod7.z.object({
-      phoneNumber: import_zod7.z.string().optional(),
-      profileImageUrl: mediaResourceSchema.optional(),
-      gender: import_zod7.z.enum(["male", "female", "other"]).optional(),
-      bio: import_zod7.z.string().optional()
-    }).optional(),
-    certification: import_zod7.z.any().optional()
-  }).optional()
-});
-
-// src/services/auth/utils/practitioner.utils.ts
-var profileDataSchema = import_zod8.z.object({
-  basicInfo: practitionerBasicInfoSchema.partial().optional(),
-  certification: practitionerCertificationSchema.partial().optional()
-}).partial();
-var buildPractitionerData = (data, userRef) => {
-  var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m;
-  const basicInfo = {
-    firstName: data.firstName || "Name",
-    lastName: data.lastName || "Surname",
-    email: data.email,
-    phoneNumber: ((_b = (_a = data.profileData) == null ? void 0 : _a.basicInfo) == null ? void 0 : _b.phoneNumber) || null,
-    profileImageUrl: ((_d = (_c = data.profileData) == null ? void 0 : _c.basicInfo) == null ? void 0 : _d.profileImageUrl) || "",
-    gender: ((_f = (_e = data.profileData) == null ? void 0 : _e.basicInfo) == null ? void 0 : _f.gender) || "other",
-    bio: ((_h = (_g = data.profileData) == null ? void 0 : _g.basicInfo) == null ? void 0 : _h.bio) || "",
-    title: "Practitioner",
-    dateOfBirth: ((_j = (_i = data.profileData) == null ? void 0 : _i.basicInfo) == null ? void 0 : _j.dateOfBirth) || /* @__PURE__ */ new Date(),
-    languages: ((_l = (_k = data.profileData) == null ? void 0 : _k.basicInfo) == null ? void 0 : _l.languages) || ["English"]
-  };
-  const certification = ((_m = data.profileData) == null ? void 0 : _m.certification) || {
-    level: "aesthetician" /* AESTHETICIAN */,
-    specialties: [],
-    licenseNumber: "Pending",
-    issuingAuthority: "Pending",
-    issueDate: /* @__PURE__ */ new Date(),
-    verificationStatus: "pending"
-  };
-  return {
-    userRef,
-    basicInfo,
-    certification,
-    status: "active" /* ACTIVE */,
-    isActive: true,
-    isVerified: false
-  };
-};
-var validatePractitionerProfileData = async (profileData) => {
-  try {
-    await profileDataSchema.parseAsync(profileData);
-  } catch (error) {
-    if (error instanceof import_zod8.z.ZodError) {
-      const errorMessages = error.errors.map((e) => `${e.path.join(".")}: ${e.message}`).join(", ");
-      throw new Error(
-        `Practitioner profile validation failed: ${errorMessages}`
-      );
-    }
-    throw error;
-  }
-};
-var isPractitionerDataComplete = (practitioner) => {
-  const { basicInfo, certification } = practitioner;
-  const hasRequiredBasicInfo = basicInfo.firstName && basicInfo.lastName && basicInfo.email && basicInfo.phoneNumber;
-  const hasRequiredCertification = certification.licenseNumber && certification.licenseNumber !== "Pending" && certification.issuingAuthority && certification.issuingAuthority !== "Pending";
-  return !!(hasRequiredBasicInfo && hasRequiredCertification);
-};
-
 // src/services/auth/auth.service.ts
 var import_auth7 = require("firebase/auth");
 var import_firestore28 = require("firebase/firestore");
@@ -2965,18 +2278,18 @@ var REVIEWS_COLLECTION = "reviews";
 var import_zod23 = require("zod");
 
 // src/validations/schemas.ts
-var import_zod9 = require("zod");
-var emailSchema = import_zod9.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_zod9.z.string().min(8, "Password must be at least 8 characters").max(100, "Password must be less than 100 characters").regex(
+var import_zod4 = require("zod");
+var emailSchema = import_zod4.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_zod4.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,}$/,
   "Password must contain at least one uppercase letter, one lowercase letter, and one number"
 );
-var userRoleSchema = import_zod9.z.nativeEnum(UserRole);
-var userRolesSchema = import_zod9.z.array(userRoleSchema).min(1, "User must have at least one role").max(3, "User cannot have more than 3 roles");
-var clinicAdminOptionsSchema = import_zod9.z.object({
-  isGroupOwner: import_zod9.z.boolean(),
-  groupToken: import_zod9.z.string().optional(),
-  groupId: import_zod9.z.string().optional()
+var userRoleSchema = import_zod4.z.nativeEnum(UserRole);
+var userRolesSchema = import_zod4.z.array(userRoleSchema).min(1, "User must have at least one role").max(3, "User cannot have more than 3 roles");
+var clinicAdminOptionsSchema = import_zod4.z.object({
+  isGroupOwner: import_zod4.z.boolean(),
+  groupToken: import_zod4.z.string().optional(),
+  groupId: import_zod4.z.string().optional()
 }).refine(
   (data) => {
     if (!data.isGroupOwner && (!data.groupToken || !data.groupId)) {
@@ -2991,22 +2304,205 @@ var clinicAdminOptionsSchema = import_zod9.z.object({
     message: "Invalid clinic admin options configuration"
   }
 );
-var createUserOptionsSchema = import_zod9.z.object({
+var createUserOptionsSchema = import_zod4.z.object({
   clinicAdminData: clinicAdminOptionsSchema.optional()
 });
-var userSchema = import_zod9.z.object({
-  uid: import_zod9.z.string(),
-  email: import_zod9.z.string().email().nullable(),
-  roles: import_zod9.z.array(userRoleSchema),
-  isAnonymous: import_zod9.z.boolean(),
-  createdAt: import_zod9.z.any(),
-  updatedAt: import_zod9.z.any(),
-  lastLoginAt: import_zod9.z.any(),
-  patientProfile: import_zod9.z.string().optional(),
-  practitionerProfile: import_zod9.z.string().optional(),
-  adminProfile: import_zod9.z.string().optional()
+var userSchema = import_zod4.z.object({
+  uid: import_zod4.z.string(),
+  email: import_zod4.z.string().email().nullable(),
+  roles: import_zod4.z.array(userRoleSchema),
+  isAnonymous: import_zod4.z.boolean(),
+  createdAt: import_zod4.z.any(),
+  updatedAt: import_zod4.z.any(),
+  lastLoginAt: import_zod4.z.any(),
+  patientProfile: import_zod4.z.string().optional(),
+  practitionerProfile: import_zod4.z.string().optional(),
+  adminProfile: import_zod4.z.string().optional()
 });
 
+// src/errors/auth.errors.ts
+var AuthError = class extends Error {
+  constructor(message, code, status = 400) {
+    super(message);
+    this.code = code;
+    this.status = status;
+    this.name = "AuthError";
+  }
+};
+var AUTH_ERRORS = {
+  // Basic validation errors
+  INVALID_EMAIL: new AuthError(
+    "Email address is not in a valid format",
+    "AUTH/INVALID_EMAIL",
+    400
+  ),
+  INVALID_PASSWORD: new AuthError(
+    "Password must contain at least 8 characters, one uppercase letter, one number, and one special character",
+    "AUTH/INVALID_PASSWORD",
+    400
+  ),
+  INVALID_ROLE: new AuthError(
+    "Specified user role is not valid",
+    "AUTH/INVALID_ROLE",
+    400
+  ),
+  // Authentication errors
+  NOT_AUTHENTICATED: new AuthError(
+    "User is not authenticated",
+    "AUTH/NOT_AUTHENTICATED",
+    401
+  ),
+  SESSION_EXPIRED: new AuthError(
+    "Your session has expired. Please sign in again",
+    "AUTH/SESSION_EXPIRED",
+    401
+  ),
+  INVALID_TOKEN: new AuthError(
+    "Invalid authentication token",
+    "AUTH/INVALID_TOKEN",
+    401
+  ),
+  // User state errors
+  USER_NOT_FOUND: new AuthError(
+    "User not found in the system",
+    "AUTH/USER_NOT_FOUND",
+    404
+  ),
+  EMAIL_ALREADY_EXISTS: new AuthError(
+    "An account with this email already exists",
+    "AUTH/EMAIL_EXISTS",
+    409
+  ),
+  USER_DISABLED: new AuthError(
+    "This account has been disabled",
+    "AUTH/USER_DISABLED",
+    403
+  ),
+  // Rate limiting and security
+  TOO_MANY_REQUESTS: new AuthError(
+    "Too many login attempts. Please try again later",
+    "AUTH/TOO_MANY_REQUESTS",
+    429
+  ),
+  ACCOUNT_LOCKED: new AuthError(
+    "Account temporarily locked due to too many failed login attempts",
+    "AUTH/ACCOUNT_LOCKED",
+    403
+  ),
+  // Social auth specific
+  POPUP_CLOSED: new AuthError(
+    "Authentication popup was closed before completion",
+    "AUTH/POPUP_CLOSED",
+    400
+  ),
+  POPUP_BLOCKED: new AuthError(
+    "Authentication popup was blocked by the browser",
+    "AUTH/POPUP_BLOCKED",
+    400
+  ),
+  ACCOUNT_EXISTS: new AuthError(
+    "An account already exists with different credentials",
+    "AUTH/ACCOUNT_EXISTS",
+    409
+  ),
+  // Anonymous auth specific
+  NOT_ANONYMOUS: new AuthError(
+    "Current user is not anonymous",
+    "AUTH/NOT_ANONYMOUS_USER",
+    400
+  ),
+  ANONYMOUS_UPGRADE_FAILED: new AuthError(
+    "Failed to upgrade anonymous account",
+    "AUTH/ANONYMOUS_UPGRADE_FAILED",
+    400
+  ),
+  // General errors
+  VALIDATION_ERROR: new AuthError(
+    "Data validation error occurred",
+    "AUTH/VALIDATION_ERROR",
+    400
+  ),
+  OPERATION_NOT_ALLOWED: new AuthError(
+    "This operation is not allowed",
+    "AUTH/OPERATION_NOT_ALLOWED",
+    403
+  ),
+  NETWORK_ERROR: new AuthError(
+    "Network error occurred. Please check your connection",
+    "AUTH/NETWORK_ERROR",
+    503
+  ),
+  REQUIRES_RECENT_LOGIN: new AuthError(
+    "This operation requires recent authentication. Please sign in again",
+    "AUTH/REQUIRES_RECENT_LOGIN",
+    401
+  ),
+  INVALID_PROVIDER: new AuthError(
+    "Invalid authentication provider",
+    "AUTH/INVALID_PROVIDER",
+    400
+  ),
+  INVALID_CREDENTIAL: new AuthError(
+    "The provided credentials are invalid or expired",
+    "AUTH/INVALID_CREDENTIAL",
+    401
+  ),
+  // Resource not found
+  NOT_FOUND: new AuthError(
+    "The requested resource was not found",
+    "AUTH/NOT_FOUND",
+    404
+  ),
+  // Detailed password validation errors
+  PASSWORD_LENGTH_ERROR: new AuthError(
+    "Password must be at least 8 characters long",
+    "AUTH/PASSWORD_LENGTH_ERROR",
+    400
+  ),
+  PASSWORD_UPPERCASE_ERROR: new AuthError(
+    "Password must contain at least one uppercase letter",
+    "AUTH/PASSWORD_UPPERCASE_ERROR",
+    400
+  ),
+  PASSWORD_NUMBER_ERROR: new AuthError(
+    "Password must contain at least one number",
+    "AUTH/PASSWORD_NUMBER_ERROR",
+    400
+  ),
+  PASSWORD_SPECIAL_CHAR_ERROR: new AuthError(
+    "Password must contain at least one special character",
+    "AUTH/PASSWORD_SPECIAL_CHAR_ERROR",
+    400
+  ),
+  // Detailed email validation errors
+  EMAIL_FORMAT_ERROR: new AuthError(
+    "Invalid email format. Please enter a valid email address",
+    "AUTH/EMAIL_FORMAT_ERROR",
+    400
+  ),
+  PASSWORD_VALIDATION_ERROR: new AuthError(
+    "Password validation failed. Please check all requirements",
+    "AUTH/PASSWORD_VALIDATION_ERROR",
+    400
+  ),
+  // Password reset specific errors
+  EXPIRED_ACTION_CODE: new AuthError(
+    "Kod za resetovanje lozinke je istekao. Molimo zatra\u017Eite novi link za resetovanje.",
+    "AUTH/EXPIRED_ACTION_CODE",
+    400
+  ),
+  INVALID_ACTION_CODE: new AuthError(
+    "Kod za resetovanje lozinke je neva\u017Ee\u0107i ili je ve\u0107 iskori\u0161\u0107en. Molimo zatra\u017Eite novi link za resetovanje.",
+    "AUTH/INVALID_ACTION_CODE",
+    400
+  ),
+  WEAK_PASSWORD: new AuthError(
+    "Lozinka je previ\u0161e slaba. Molimo koristite ja\u010Du lozinku.",
+    "AUTH/WEAK_PASSWORD",
+    400
+  )
+};
+
 // src/services/user/user.service.ts
 var import_firestore22 = require("firebase/firestore");
 
@@ -3103,15 +2599,15 @@ var USER_ERRORS = {
 };
 
 // src/services/user/user.service.ts
-var import_zod19 = require("zod");
+var import_zod17 = require("zod");
 
 // src/services/patient/patient.service.ts
-var import_firestore19 = require("firebase/firestore");
+var import_firestore18 = require("firebase/firestore");
 
 // src/services/media/media.service.ts
-var import_firestore4 = require("firebase/firestore");
+var import_firestore3 = require("firebase/firestore");
 var import_storage2 = require("firebase/storage");
-var import_firestore5 = require("firebase/firestore");
+var import_firestore4 = require("firebase/firestore");
 var MediaAccessLevel = /* @__PURE__ */ ((MediaAccessLevel2) => {
   MediaAccessLevel2["PUBLIC"] = "public";
   MediaAccessLevel2["PRIVATE"] = "private";
@@ -3152,14 +2648,14 @@ var MediaService = class extends BaseService {
         url: downloadURL,
         contentType: file.type,
         size: file.size,
-        createdAt: import_firestore4.Timestamp.now(),
+        createdAt: import_firestore3.Timestamp.now(),
         accessLevel,
         ownerId,
         collectionName,
         path: filePath
       };
-      const metadataDocRef = (0, import_firestore5.doc)(this.db, MEDIA_METADATA_COLLECTION, mediaId);
-      await (0, import_firestore5.setDoc)(metadataDocRef, metadata);
+      const metadataDocRef = (0, import_firestore4.doc)(this.db, MEDIA_METADATA_COLLECTION, mediaId);
+      await (0, import_firestore4.setDoc)(metadataDocRef, metadata);
       console.log("[MediaService] Metadata stored in Firestore:", mediaId);
       return metadata;
     } catch (error) {
@@ -3174,8 +2670,8 @@ var MediaService = class extends BaseService {
    */
   async getMediaMetadata(mediaId) {
     console.log(`[MediaService] Getting media metadata for ID: ${mediaId}`);
-    const docRef = (0, import_firestore5.doc)(this.db, MEDIA_METADATA_COLLECTION, mediaId);
-    const docSnap = await (0, import_firestore5.getDoc)(docRef);
+    const docRef = (0, import_firestore4.doc)(this.db, MEDIA_METADATA_COLLECTION, mediaId);
+    const docSnap = await (0, import_firestore4.getDoc)(docRef);
     if (docSnap.exists()) {
       console.log("[MediaService] Metadata found:", docSnap.data());
       return docSnap.data();
@@ -3190,13 +2686,13 @@ var MediaService = class extends BaseService {
    */
   async getMediaMetadataByUrl(url) {
     console.log(`[MediaService] Getting media metadata by URL: ${url}`);
-    const q = (0, import_firestore5.query)(
-      (0, import_firestore5.collection)(this.db, MEDIA_METADATA_COLLECTION),
-      (0, import_firestore5.where)("url", "==", url),
-      (0, import_firestore5.limit)(1)
+    const q = (0, import_firestore4.query)(
+      (0, import_firestore4.collection)(this.db, MEDIA_METADATA_COLLECTION),
+      (0, import_firestore4.where)("url", "==", url),
+      (0, import_firestore4.limit)(1)
     );
     try {
-      const querySnapshot = await (0, import_firestore5.getDocs)(q);
+      const querySnapshot = await (0, import_firestore4.getDocs)(q);
       if (!querySnapshot.empty) {
         const metadata = querySnapshot.docs[0].data();
         console.log("[MediaService] Metadata found by URL:", metadata);
@@ -3226,8 +2722,8 @@ var MediaService = class extends BaseService {
     try {
       await (0, import_storage2.deleteObject)(storageFileRef);
       console.log(`[MediaService] File deleted from Storage: ${metadata.path}`);
-      const metadataDocRef = (0, import_firestore5.doc)(this.db, MEDIA_METADATA_COLLECTION, mediaId);
-      await (0, import_firestore5.deleteDoc)(metadataDocRef);
+      const metadataDocRef = (0, import_firestore4.doc)(this.db, MEDIA_METADATA_COLLECTION, mediaId);
+      await (0, import_firestore4.deleteDoc)(metadataDocRef);
       console.log(
         `[MediaService] Metadata deleted from Firestore for ID: ${mediaId}`
       );
@@ -3259,10 +2755,10 @@ var MediaService = class extends BaseService {
       console.log(
         `[MediaService] Media ID ${mediaId} already has access level ${newAccessLevel}. Updating timestamp only.`
       );
-      const metadataDocRef = (0, import_firestore5.doc)(this.db, MEDIA_METADATA_COLLECTION, mediaId);
+      const metadataDocRef = (0, import_firestore4.doc)(this.db, MEDIA_METADATA_COLLECTION, mediaId);
       try {
-        await (0, import_firestore5.updateDoc)(metadataDocRef, { updatedAt: import_firestore4.Timestamp.now() });
-        return { ...metadata, updatedAt: import_firestore4.Timestamp.now() };
+        await (0, import_firestore4.updateDoc)(metadataDocRef, { updatedAt: import_firestore3.Timestamp.now() });
+        return { ...metadata, updatedAt: import_firestore3.Timestamp.now() };
       } catch (error) {
         console.error(
           `[MediaService] Error updating timestamp for media ID ${mediaId}:`,
@@ -3300,14 +2796,14 @@ var MediaService = class extends BaseService {
         accessLevel: newAccessLevel,
         path: newStoragePath,
         url: newDownloadURL,
-        updatedAt: import_firestore4.Timestamp.now()
+        updatedAt: import_firestore3.Timestamp.now()
       };
-      const metadataDocRef = (0, import_firestore5.doc)(this.db, MEDIA_METADATA_COLLECTION, mediaId);
+      const metadataDocRef = (0, import_firestore4.doc)(this.db, MEDIA_METADATA_COLLECTION, mediaId);
       console.log(
         `[MediaService] Updating Firestore metadata for ${mediaId} with new data:`,
         updateData
       );
-      await (0, import_firestore5.updateDoc)(metadataDocRef, updateData);
+      await (0, import_firestore4.updateDoc)(metadataDocRef, updateData);
       console.log(
         `[MediaService] Successfully updated Firestore metadata for ${mediaId}`
       );
@@ -3358,28 +2854,28 @@ var MediaService = class extends BaseService {
    */
   async listMedia(ownerId, collectionName, accessLevel, count, startAfterId) {
     console.log(`[MediaService] Listing media for owner: ${ownerId}`);
-    let qConstraints = [(0, import_firestore5.where)("ownerId", "==", ownerId)];
+    let qConstraints = [(0, import_firestore4.where)("ownerId", "==", ownerId)];
     if (collectionName) {
-      qConstraints.push((0, import_firestore5.where)("collectionName", "==", collectionName));
+      qConstraints.push((0, import_firestore4.where)("collectionName", "==", collectionName));
     }
     if (accessLevel) {
-      qConstraints.push((0, import_firestore5.where)("accessLevel", "==", accessLevel));
+      qConstraints.push((0, import_firestore4.where)("accessLevel", "==", accessLevel));
     }
-    qConstraints.push((0, import_firestore5.orderBy)("createdAt", "desc"));
+    qConstraints.push((0, import_firestore4.orderBy)("createdAt", "desc"));
     if (count) {
-      qConstraints.push((0, import_firestore5.limit)(count));
+      qConstraints.push((0, import_firestore4.limit)(count));
     }
     if (startAfterId) {
       const startAfterDoc = await this.getMediaMetadata(startAfterId);
       if (startAfterDoc) {
       }
     }
-    const finalQuery = (0, import_firestore5.query)(
-      (0, import_firestore5.collection)(this.db, MEDIA_METADATA_COLLECTION),
+    const finalQuery = (0, import_firestore4.query)(
+      (0, import_firestore4.collection)(this.db, MEDIA_METADATA_COLLECTION),
       ...qConstraints
     );
     try {
-      const querySnapshot = await (0, import_firestore5.getDocs)(finalQuery);
+      const querySnapshot = await (0, import_firestore4.getDocs)(finalQuery);
       const mediaList = querySnapshot.docs.map(
         (doc37) => doc37.data()
       );
@@ -3407,33 +2903,33 @@ var MediaService = class extends BaseService {
 };
 
 // src/services/patient/patient.service.ts
-var import_firestore20 = require("firebase/firestore");
+var import_firestore19 = require("firebase/firestore");
 
 // src/services/patient/utils/clinic.utils.ts
-var import_firestore6 = require("firebase/firestore");
+var import_firestore5 = require("firebase/firestore");
 var getPatientsByClinicUtil = async (db, clinicId, options) => {
   try {
     console.log(
       `[getPatientsByClinicUtil] Fetching patients for clinic ID: ${clinicId} with options:`,
       options
     );
-    const patientsCollection = (0, import_firestore6.collection)(db, PATIENTS_COLLECTION);
+    const patientsCollection = (0, import_firestore5.collection)(db, PATIENTS_COLLECTION);
     const constraints = [
-      (0, import_firestore6.where)("clinicIds", "array-contains", clinicId)
+      (0, import_firestore5.where)("clinicIds", "array-contains", clinicId)
     ];
-    let q = (0, import_firestore6.query)(patientsCollection, ...constraints);
+    let q = (0, import_firestore5.query)(patientsCollection, ...constraints);
     if (options == null ? void 0 : options.limit) {
-      q = (0, import_firestore6.query)(q, (0, import_firestore6.limit)(options.limit));
+      q = (0, import_firestore5.query)(q, (0, import_firestore5.limit)(options.limit));
     }
     if (options == null ? void 0 : options.startAfter) {
-      const startAfterDoc = await (0, import_firestore6.getDoc)(
-        (0, import_firestore6.doc)(db, PATIENTS_COLLECTION, options.startAfter)
+      const startAfterDoc = await (0, import_firestore5.getDoc)(
+        (0, import_firestore5.doc)(db, PATIENTS_COLLECTION, options.startAfter)
       );
       if (startAfterDoc.exists()) {
-        q = (0, import_firestore6.query)(q, (0, import_firestore6.startAfter)(startAfterDoc));
+        q = (0, import_firestore5.query)(q, (0, import_firestore5.startAfter)(startAfterDoc));
       }
     }
-    const patientsSnapshot = await (0, import_firestore6.getDocs)(q);
+    const patientsSnapshot = await (0, import_firestore5.getDocs)(q);
     const patients = [];
     patientsSnapshot.forEach((doc37) => {
       patients.push(doc37.data());
@@ -3454,17 +2950,17 @@ var getPatientsByClinicUtil = async (db, clinicId, options) => {
 };
 
 // src/services/patient/utils/docs.utils.ts
-var import_firestore13 = require("firebase/firestore");
+var import_firestore12 = require("firebase/firestore");
 
 // src/services/patient/utils/sensitive.utils.ts
-var import_firestore12 = require("firebase/firestore");
+var import_firestore11 = require("firebase/firestore");
 
 // src/validations/patient.schema.ts
-var import_zod12 = require("zod");
-var import_firestore8 = require("firebase/firestore");
+var import_zod7 = require("zod");
+var import_firestore7 = require("firebase/firestore");
 
 // src/validations/patient/medical-info.schema.ts
-var import_zod11 = require("zod");
+var import_zod6 = require("zod");
 
 // src/backoffice/types/static/blocking-condition.types.ts
 var BlockingCondition = /* @__PURE__ */ ((BlockingCondition2) => {
@@ -3504,85 +3000,85 @@ var Contraindication = /* @__PURE__ */ ((Contraindication2) => {
 })(Contraindication || {});
 
 // src/validations/common.schema.ts
-var import_zod10 = require("zod");
-var import_firestore7 = require("firebase/firestore");
-var timestampSchema = import_zod10.z.union([
-  import_zod10.z.object({
-    seconds: import_zod10.z.number(),
-    nanoseconds: import_zod10.z.number()
+var import_zod5 = require("zod");
+var import_firestore6 = require("firebase/firestore");
+var timestampSchema = import_zod5.z.union([
+  import_zod5.z.object({
+    seconds: import_zod5.z.number(),
+    nanoseconds: import_zod5.z.number()
   }),
-  import_zod10.z.instanceof(import_firestore7.Timestamp),
-  import_zod10.z.instanceof(Date)
+  import_zod5.z.instanceof(import_firestore6.Timestamp),
+  import_zod5.z.instanceof(Date)
   // Add support for Date objects that Firestore returns on client
 ]).transform((data) => {
-  if (data instanceof import_firestore7.Timestamp) {
+  if (data instanceof import_firestore6.Timestamp) {
     return data;
   }
   if (data instanceof Date) {
-    return import_firestore7.Timestamp.fromDate(data);
+    return import_firestore6.Timestamp.fromDate(data);
   }
-  return new import_firestore7.Timestamp(data.seconds, data.nanoseconds);
+  return new import_firestore6.Timestamp(data.seconds, data.nanoseconds);
 });
 
 // src/validations/patient/medical-info.schema.ts
-var allergySubtypeSchema = import_zod11.z.union([
-  import_zod11.z.nativeEnum(MedicationAllergySubtype),
-  import_zod11.z.nativeEnum(FoodAllergySubtype),
-  import_zod11.z.nativeEnum(EnvironmentalAllergySubtype),
-  import_zod11.z.nativeEnum(CosmeticAllergySubtype),
-  import_zod11.z.literal("other")
+var allergySubtypeSchema = import_zod6.z.union([
+  import_zod6.z.nativeEnum(MedicationAllergySubtype),
+  import_zod6.z.nativeEnum(FoodAllergySubtype),
+  import_zod6.z.nativeEnum(EnvironmentalAllergySubtype),
+  import_zod6.z.nativeEnum(CosmeticAllergySubtype),
+  import_zod6.z.literal("other")
 ]);
-var allergySchema = import_zod11.z.object({
-  type: import_zod11.z.nativeEnum(AllergyType),
+var allergySchema = import_zod6.z.object({
+  type: import_zod6.z.nativeEnum(AllergyType),
   subtype: allergySubtypeSchema,
-  name: import_zod11.z.string().optional().nullable(),
-  severity: import_zod11.z.enum(["mild", "moderate", "severe"]).optional(),
-  reaction: import_zod11.z.string().optional().nullable(),
+  name: import_zod6.z.string().optional().nullable(),
+  severity: import_zod6.z.enum(["mild", "moderate", "severe"]).optional(),
+  reaction: import_zod6.z.string().optional().nullable(),
   diagnosed: timestampSchema.optional().nullable(),
-  notes: import_zod11.z.string().optional().nullable()
+  notes: import_zod6.z.string().optional().nullable()
 });
-var vitalStatsSchema = import_zod11.z.object({
-  height: import_zod11.z.number().positive().optional(),
-  weight: import_zod11.z.number().positive().optional(),
-  bloodType: import_zod11.z.enum(["A+", "A-", "B+", "B-", "AB+", "AB-", "O+", "O-"]).optional(),
-  bloodPressure: import_zod11.z.object({
-    systolic: import_zod11.z.number().min(70).max(200),
-    diastolic: import_zod11.z.number().min(40).max(130),
+var vitalStatsSchema = import_zod6.z.object({
+  height: import_zod6.z.number().positive().optional(),
+  weight: import_zod6.z.number().positive().optional(),
+  bloodType: import_zod6.z.enum(["A+", "A-", "B+", "B-", "AB+", "AB-", "O+", "O-"]).optional(),
+  bloodPressure: import_zod6.z.object({
+    systolic: import_zod6.z.number().min(70).max(200),
+    diastolic: import_zod6.z.number().min(40).max(130),
     lastMeasured: timestampSchema
   }).optional()
 });
-var blockingConditionSchema = import_zod11.z.object({
-  condition: import_zod11.z.nativeEnum(BlockingCondition),
+var blockingConditionSchema = import_zod6.z.object({
+  condition: import_zod6.z.nativeEnum(BlockingCondition),
   diagnosedAt: timestampSchema,
-  notes: import_zod11.z.string().optional().nullable(),
-  isActive: import_zod11.z.boolean()
+  notes: import_zod6.z.string().optional().nullable(),
+  isActive: import_zod6.z.boolean()
 });
-var contraindicationSchema = import_zod11.z.object({
-  condition: import_zod11.z.nativeEnum(Contraindication),
+var contraindicationSchema = import_zod6.z.object({
+  condition: import_zod6.z.nativeEnum(Contraindication),
   lastOccurrence: timestampSchema,
-  frequency: import_zod11.z.enum(["rare", "occasional", "frequent"]),
-  notes: import_zod11.z.string().optional().nullable(),
-  isActive: import_zod11.z.boolean()
+  frequency: import_zod6.z.enum(["rare", "occasional", "frequent"]),
+  notes: import_zod6.z.string().optional().nullable(),
+  isActive: import_zod6.z.boolean()
 });
-var medicationSchema = import_zod11.z.object({
-  name: import_zod11.z.string().min(1),
-  dosage: import_zod11.z.string().min(1),
-  frequency: import_zod11.z.string().min(1),
+var medicationSchema = import_zod6.z.object({
+  name: import_zod6.z.string().min(1),
+  dosage: import_zod6.z.string().min(1),
+  frequency: import_zod6.z.string().min(1),
   startDate: timestampSchema.optional().nullable(),
   endDate: timestampSchema.optional().nullable(),
-  prescribedBy: import_zod11.z.string().optional().nullable()
+  prescribedBy: import_zod6.z.string().optional().nullable()
 });
-var patientMedicalInfoSchema = import_zod11.z.object({
-  patientId: import_zod11.z.string(),
+var patientMedicalInfoSchema = import_zod6.z.object({
+  patientId: import_zod6.z.string(),
   vitalStats: vitalStatsSchema,
-  blockingConditions: import_zod11.z.array(blockingConditionSchema),
-  contraindications: import_zod11.z.array(contraindicationSchema),
-  allergies: import_zod11.z.array(allergySchema),
-  currentMedications: import_zod11.z.array(medicationSchema),
-  emergencyNotes: import_zod11.z.string().optional(),
+  blockingConditions: import_zod6.z.array(blockingConditionSchema),
+  contraindications: import_zod6.z.array(contraindicationSchema),
+  allergies: import_zod6.z.array(allergySchema),
+  currentMedications: import_zod6.z.array(medicationSchema),
+  emergencyNotes: import_zod6.z.string().optional(),
   lastUpdated: timestampSchema,
-  updatedBy: import_zod11.z.string(),
-  verifiedBy: import_zod11.z.string().optional(),
+  updatedBy: import_zod6.z.string(),
+  verifiedBy: import_zod6.z.string().optional(),
   verifiedAt: timestampSchema.optional()
 });
 var createPatientMedicalInfoSchema = patientMedicalInfoSchema.omit({
@@ -3596,155 +3092,155 @@ var updatePatientMedicalInfoSchema = createPatientMedicalInfoSchema.partial();
 var updateVitalStatsSchema = vitalStatsSchema;
 var addAllergySchema = allergySchema;
 var updateAllergySchema = allergySchema.partial().extend({
-  allergyIndex: import_zod11.z.number().min(0)
+  allergyIndex: import_zod6.z.number().min(0)
 });
 var addBlockingConditionSchema = blockingConditionSchema;
 var updateBlockingConditionSchema = blockingConditionSchema.partial().extend({
-  conditionIndex: import_zod11.z.number().min(0)
+  conditionIndex: import_zod6.z.number().min(0)
 });
 var addContraindicationSchema = contraindicationSchema;
 var updateContraindicationSchema = contraindicationSchema.partial().extend({
-  contraindicationIndex: import_zod11.z.number().min(0)
+  contraindicationIndex: import_zod6.z.number().min(0)
 });
 var addMedicationSchema = medicationSchema;
 var updateMedicationSchema = medicationSchema.partial().extend({
-  medicationIndex: import_zod11.z.number().min(0)
+  medicationIndex: import_zod6.z.number().min(0)
 });
 
 // src/validations/patient.schema.ts
-var locationDataSchema = import_zod12.z.object({
-  latitude: import_zod12.z.number().min(-90).max(90),
-  longitude: import_zod12.z.number().min(-180).max(180),
-  geohash: import_zod12.z.string().optional()
+var locationDataSchema = import_zod7.z.object({
+  latitude: import_zod7.z.number().min(-90).max(90),
+  longitude: import_zod7.z.number().min(-180).max(180),
+  geohash: import_zod7.z.string().optional()
 });
-var addressDataSchema = import_zod12.z.object({
-  address: import_zod12.z.string(),
-  city: import_zod12.z.string(),
-  country: import_zod12.z.string(),
-  postalCode: import_zod12.z.string()
+var addressDataSchema = import_zod7.z.object({
+  address: import_zod7.z.string(),
+  city: import_zod7.z.string(),
+  country: import_zod7.z.string(),
+  postalCode: import_zod7.z.string()
 });
-var emergencyContactSchema = import_zod12.z.object({
-  name: import_zod12.z.string(),
-  relationship: import_zod12.z.string(),
-  phoneNumber: import_zod12.z.string(),
-  isNotifiable: import_zod12.z.boolean()
+var emergencyContactSchema = import_zod7.z.object({
+  name: import_zod7.z.string(),
+  relationship: import_zod7.z.string(),
+  phoneNumber: import_zod7.z.string(),
+  isNotifiable: import_zod7.z.boolean()
 });
-var gamificationSchema = import_zod12.z.object({
-  level: import_zod12.z.number(),
-  points: import_zod12.z.number()
+var gamificationSchema = import_zod7.z.object({
+  level: import_zod7.z.number(),
+  points: import_zod7.z.number()
 });
-var patientLocationInfoSchema = import_zod12.z.object({
-  patientId: import_zod12.z.string(),
-  userRef: import_zod12.z.string().optional(),
+var patientLocationInfoSchema = import_zod7.z.object({
+  patientId: import_zod7.z.string(),
+  userRef: import_zod7.z.string().optional(),
   locationData: locationDataSchema,
-  createdAt: import_zod12.z.instanceof(import_firestore8.Timestamp),
-  updatedAt: import_zod12.z.instanceof(import_firestore8.Timestamp)
+  createdAt: import_zod7.z.instanceof(import_firestore7.Timestamp),
+  updatedAt: import_zod7.z.instanceof(import_firestore7.Timestamp)
 });
-var createPatientLocationInfoSchema = import_zod12.z.object({
-  patientId: import_zod12.z.string(),
-  userRef: import_zod12.z.string().optional(),
+var createPatientLocationInfoSchema = import_zod7.z.object({
+  patientId: import_zod7.z.string(),
+  userRef: import_zod7.z.string().optional(),
   locationData: locationDataSchema
 });
-var patientSensitiveInfoSchema = import_zod12.z.object({
-  patientId: import_zod12.z.string(),
-  userRef: import_zod12.z.string().optional(),
-  photoUrl: import_zod12.z.string().nullable().optional(),
-  firstName: import_zod12.z.string().min(2),
-  lastName: import_zod12.z.string().min(2),
-  dateOfBirth: import_zod12.z.instanceof(import_firestore8.Timestamp).nullable(),
-  gender: import_zod12.z.nativeEnum(Gender),
-  email: import_zod12.z.string().email().optional(),
-  phoneNumber: import_zod12.z.string().optional(),
-  alternativePhoneNumber: import_zod12.z.string().optional(),
+var patientSensitiveInfoSchema = import_zod7.z.object({
+  patientId: import_zod7.z.string(),
+  userRef: import_zod7.z.string().optional(),
+  photoUrl: import_zod7.z.string().nullable().optional(),
+  firstName: import_zod7.z.string().min(2),
+  lastName: import_zod7.z.string().min(2),
+  dateOfBirth: import_zod7.z.instanceof(import_firestore7.Timestamp).nullable(),
+  gender: import_zod7.z.nativeEnum(Gender),
+  email: import_zod7.z.string().email().optional(),
+  phoneNumber: import_zod7.z.string().optional(),
+  alternativePhoneNumber: import_zod7.z.string().optional(),
   addressData: addressDataSchema.optional(),
-  emergencyContacts: import_zod12.z.array(emergencyContactSchema).optional(),
-  createdAt: import_zod12.z.instanceof(import_firestore8.Timestamp),
-  updatedAt: import_zod12.z.instanceof(import_firestore8.Timestamp)
+  emergencyContacts: import_zod7.z.array(emergencyContactSchema).optional(),
+  createdAt: import_zod7.z.instanceof(import_firestore7.Timestamp),
+  updatedAt: import_zod7.z.instanceof(import_firestore7.Timestamp)
 });
-var patientDoctorSchema = import_zod12.z.object({
-  userRef: import_zod12.z.string(),
-  assignedAt: import_zod12.z.instanceof(import_firestore8.Timestamp),
-  assignedBy: import_zod12.z.string().optional(),
-  isActive: import_zod12.z.boolean(),
-  notes: import_zod12.z.string().optional()
+var patientDoctorSchema = import_zod7.z.object({
+  userRef: import_zod7.z.string(),
+  assignedAt: import_zod7.z.instanceof(import_firestore7.Timestamp),
+  assignedBy: import_zod7.z.string().optional(),
+  isActive: import_zod7.z.boolean(),
+  notes: import_zod7.z.string().optional()
 });
-var patientClinicSchema = import_zod12.z.object({
-  clinicId: import_zod12.z.string(),
-  assignedAt: import_zod12.z.instanceof(import_firestore8.Timestamp),
-  assignedBy: import_zod12.z.string().optional(),
-  isActive: import_zod12.z.boolean(),
-  notes: import_zod12.z.string().optional()
+var patientClinicSchema = import_zod7.z.object({
+  clinicId: import_zod7.z.string(),
+  assignedAt: import_zod7.z.instanceof(import_firestore7.Timestamp),
+  assignedBy: import_zod7.z.string().optional(),
+  isActive: import_zod7.z.boolean(),
+  notes: import_zod7.z.string().optional()
 });
-var patientProfileSchema = import_zod12.z.object({
-  id: import_zod12.z.string(),
-  userRef: import_zod12.z.string().optional(),
-  displayName: import_zod12.z.string(),
+var patientProfileSchema = import_zod7.z.object({
+  id: import_zod7.z.string(),
+  userRef: import_zod7.z.string().optional(),
+  displayName: import_zod7.z.string(),
   gamification: gamificationSchema,
-  expoTokens: import_zod12.z.array(import_zod12.z.string()),
-  isActive: import_zod12.z.boolean(),
-  isVerified: import_zod12.z.boolean(),
-  isManual: import_zod12.z.boolean().default(false),
+  expoTokens: import_zod7.z.array(import_zod7.z.string()),
+  isActive: import_zod7.z.boolean(),
+  isVerified: import_zod7.z.boolean(),
+  isManual: import_zod7.z.boolean().default(false),
   // Default to false if missing
-  phoneNumber: import_zod12.z.string().nullable().optional(),
-  dateOfBirth: import_zod12.z.instanceof(import_firestore8.Timestamp).nullable().optional(),
-  doctors: import_zod12.z.array(patientDoctorSchema),
-  clinics: import_zod12.z.array(patientClinicSchema),
-  doctorIds: import_zod12.z.array(import_zod12.z.string()),
-  clinicIds: import_zod12.z.array(import_zod12.z.string()),
-  createdAt: import_zod12.z.instanceof(import_firestore8.Timestamp),
-  updatedAt: import_zod12.z.instanceof(import_firestore8.Timestamp)
+  phoneNumber: import_zod7.z.string().nullable().optional(),
+  dateOfBirth: import_zod7.z.instanceof(import_firestore7.Timestamp).nullable().optional(),
+  doctors: import_zod7.z.array(patientDoctorSchema),
+  clinics: import_zod7.z.array(patientClinicSchema),
+  doctorIds: import_zod7.z.array(import_zod7.z.string()),
+  clinicIds: import_zod7.z.array(import_zod7.z.string()),
+  createdAt: import_zod7.z.instanceof(import_firestore7.Timestamp),
+  updatedAt: import_zod7.z.instanceof(import_firestore7.Timestamp)
 });
-var createPatientProfileSchema = import_zod12.z.object({
-  userRef: import_zod12.z.string().optional(),
-  displayName: import_zod12.z.string(),
-  expoTokens: import_zod12.z.array(import_zod12.z.string()),
+var createPatientProfileSchema = import_zod7.z.object({
+  userRef: import_zod7.z.string().optional(),
+  displayName: import_zod7.z.string(),
+  expoTokens: import_zod7.z.array(import_zod7.z.string()),
   gamification: gamificationSchema.optional(),
-  isActive: import_zod12.z.boolean(),
-  isVerified: import_zod12.z.boolean(),
-  isManual: import_zod12.z.boolean().default(false),
-  doctors: import_zod12.z.array(patientDoctorSchema).optional(),
-  clinics: import_zod12.z.array(patientClinicSchema).optional(),
-  doctorIds: import_zod12.z.array(import_zod12.z.string()).optional(),
-  clinicIds: import_zod12.z.array(import_zod12.z.string()).optional()
+  isActive: import_zod7.z.boolean(),
+  isVerified: import_zod7.z.boolean(),
+  isManual: import_zod7.z.boolean().default(false),
+  doctors: import_zod7.z.array(patientDoctorSchema).optional(),
+  clinics: import_zod7.z.array(patientClinicSchema).optional(),
+  doctorIds: import_zod7.z.array(import_zod7.z.string()).optional(),
+  clinicIds: import_zod7.z.array(import_zod7.z.string()).optional()
 });
-var createPatientSensitiveInfoSchema = import_zod12.z.object({
-  patientId: import_zod12.z.string(),
-  userRef: import_zod12.z.string().optional(),
+var createPatientSensitiveInfoSchema = import_zod7.z.object({
+  patientId: import_zod7.z.string(),
+  userRef: import_zod7.z.string().optional(),
   photoUrl: mediaResourceSchema.nullable().optional(),
-  firstName: import_zod12.z.string().min(2),
-  lastName: import_zod12.z.string().min(2),
-  dateOfBirth: import_zod12.z.instanceof(import_firestore8.Timestamp).nullable(),
-  gender: import_zod12.z.nativeEnum(Gender),
-  email: import_zod12.z.string().email().optional(),
-  phoneNumber: import_zod12.z.string().optional(),
-  alternativePhoneNumber: import_zod12.z.string().optional(),
+  firstName: import_zod7.z.string().min(2),
+  lastName: import_zod7.z.string().min(2),
+  dateOfBirth: import_zod7.z.instanceof(import_firestore7.Timestamp).nullable(),
+  gender: import_zod7.z.nativeEnum(Gender),
+  email: import_zod7.z.string().email().optional(),
+  phoneNumber: import_zod7.z.string().optional(),
+  alternativePhoneNumber: import_zod7.z.string().optional(),
   addressData: addressDataSchema.optional(),
-  emergencyContacts: import_zod12.z.array(emergencyContactSchema).optional()
+  emergencyContacts: import_zod7.z.array(emergencyContactSchema).optional()
 });
-var createManualPatientSchema = import_zod12.z.object({
-  clinicId: import_zod12.z.string().min(1, "Clinic ID is required"),
-  firstName: import_zod12.z.string().min(2, "First name is required"),
-  lastName: import_zod12.z.string().min(2, "Last name is required"),
-  dateOfBirth: import_zod12.z.instanceof(import_firestore8.Timestamp).nullable(),
-  gender: import_zod12.z.nativeEnum(Gender),
-  phoneNumber: import_zod12.z.string().optional(),
-  email: import_zod12.z.string().email().optional(),
+var createManualPatientSchema = import_zod7.z.object({
+  clinicId: import_zod7.z.string().min(1, "Clinic ID is required"),
+  firstName: import_zod7.z.string().min(2, "First name is required"),
+  lastName: import_zod7.z.string().min(2, "Last name is required"),
+  dateOfBirth: import_zod7.z.instanceof(import_firestore7.Timestamp).nullable(),
+  gender: import_zod7.z.nativeEnum(Gender),
+  phoneNumber: import_zod7.z.string().optional(),
+  email: import_zod7.z.string().email().optional(),
   addressData: addressDataSchema.optional(),
-  notes: import_zod12.z.string().optional()
+  notes: import_zod7.z.string().optional()
 });
-var searchPatientsSchema = import_zod12.z.object({
-  clinicId: import_zod12.z.string().optional(),
-  practitionerId: import_zod12.z.string().optional()
+var searchPatientsSchema = import_zod7.z.object({
+  clinicId: import_zod7.z.string().optional(),
+  practitionerId: import_zod7.z.string().optional()
 }).refine((data) => data.clinicId || data.practitionerId, {
   message: "At least one of clinicId or practitionerId must be provided",
   path: []
   // Optional: specify a path like ['clinicId'] or ['practitionerId']
 });
-var requesterInfoSchema = import_zod12.z.object({
-  id: import_zod12.z.string(),
-  role: import_zod12.z.enum(["clinic_admin", "practitioner"]),
-  associatedClinicId: import_zod12.z.string().optional(),
-  associatedPractitionerId: import_zod12.z.string().optional()
+var requesterInfoSchema = import_zod7.z.object({
+  id: import_zod7.z.string(),
+  role: import_zod7.z.enum(["clinic_admin", "practitioner"]),
+  associatedClinicId: import_zod7.z.string().optional(),
+  associatedPractitionerId: import_zod7.z.string().optional()
 }).refine(
   (data) => {
     if (data.role === "clinic_admin") {
@@ -3761,33 +3257,33 @@ var requesterInfoSchema = import_zod12.z.object({
 );
 
 // src/services/patient/utils/sensitive.utils.ts
-var import_zod14 = require("zod");
+var import_zod11 = require("zod");
 
 // src/services/patient/utils/practitioner.utils.ts
-var import_firestore9 = require("firebase/firestore");
+var import_firestore8 = require("firebase/firestore");
 var getPatientsByPractitionerUtil = async (db, practitionerId, options) => {
   try {
     console.log(
       `[getPatientsByPractitionerUtil] Fetching patients for practitioner ID: ${practitionerId} with options:`,
       options
     );
-    const patientsCollection = (0, import_firestore9.collection)(db, PATIENTS_COLLECTION);
+    const patientsCollection = (0, import_firestore8.collection)(db, PATIENTS_COLLECTION);
     const constraints = [
-      (0, import_firestore9.where)("doctorIds", "array-contains", practitionerId)
+      (0, import_firestore8.where)("doctorIds", "array-contains", practitionerId)
     ];
-    let q = (0, import_firestore9.query)(patientsCollection, ...constraints);
+    let q = (0, import_firestore8.query)(patientsCollection, ...constraints);
     if (options == null ? void 0 : options.limit) {
-      q = (0, import_firestore9.query)(q, (0, import_firestore9.limit)(options.limit));
+      q = (0, import_firestore8.query)(q, (0, import_firestore8.limit)(options.limit));
     }
     if (options == null ? void 0 : options.startAfter) {
-      const startAfterDoc = await (0, import_firestore9.getDoc)(
-        (0, import_firestore9.doc)(db, PATIENTS_COLLECTION, options.startAfter)
+      const startAfterDoc = await (0, import_firestore8.getDoc)(
+        (0, import_firestore8.doc)(db, PATIENTS_COLLECTION, options.startAfter)
       );
       if (startAfterDoc.exists()) {
-        q = (0, import_firestore9.query)(q, (0, import_firestore9.startAfter)(startAfterDoc));
+        q = (0, import_firestore8.query)(q, (0, import_firestore8.startAfter)(startAfterDoc));
       }
     }
-    const patientsSnapshot = await (0, import_firestore9.getDocs)(q);
+    const patientsSnapshot = await (0, import_firestore8.getDocs)(q);
     const patients = [];
     patientsSnapshot.forEach((doc37) => {
       patients.push(doc37.data());
@@ -3820,7 +3316,7 @@ var getPatientsByPractitionerWithDetailsUtil = async (db, practitionerId, option
     const patientProfilesWithDetails = await Promise.all(
       patientProfiles.map(async (profile) => {
         try {
-          const sensitiveInfoDoc = await (0, import_firestore9.getDoc)(
+          const sensitiveInfoDoc = await (0, import_firestore8.getDoc)(
             getSensitiveInfoDocRef(db, profile.id)
           );
           const sensitiveInfo = sensitiveInfoDoc.exists() ? sensitiveInfoDoc.data() : void 0;
@@ -3856,13 +3352,13 @@ var getPractitionerProfileByUserRef = async (db, userRef) => {
     console.log(
       `[getPractitionerProfileByUserRef] Fetching practitioner with userRef: ${userRef}`
     );
-    const practitionersCollection = (0, import_firestore9.collection)(db, PRACTITIONERS_COLLECTION);
-    const q = (0, import_firestore9.query)(
+    const practitionersCollection = (0, import_firestore8.collection)(db, PRACTITIONERS_COLLECTION);
+    const q = (0, import_firestore8.query)(
       practitionersCollection,
-      (0, import_firestore9.where)("userRef", "==", userRef),
-      (0, import_firestore9.limit)(1)
+      (0, import_firestore8.where)("userRef", "==", userRef),
+      (0, import_firestore8.limit)(1)
     );
-    const querySnapshot = await (0, import_firestore9.getDocs)(q);
+    const querySnapshot = await (0, import_firestore8.getDocs)(q);
     if (querySnapshot.empty) {
       console.log(
         `[getPractitionerProfileByUserRef] No practitioner found with userRef: ${userRef}`
@@ -3884,40 +3380,237 @@ var getPractitionerProfileByUserRef = async (db, userRef) => {
       `Failed to retrieve practitioner by userRef: ${error instanceof Error ? error.message : String(error)}`
     );
   }
-};
+};
+
+// src/services/clinic/utils/admin.utils.ts
+var import_firestore10 = require("firebase/firestore");
+
+// src/validations/clinic.schema.ts
+var import_zod10 = require("zod");
+var import_firestore9 = require("firebase/firestore");
+
+// src/validations/reviews.schema.ts
+var import_zod8 = require("zod");
+var baseReviewSchema = import_zod8.z.object({
+  id: import_zod8.z.string().min(1),
+  patientId: import_zod8.z.string().min(1),
+  fullReviewId: import_zod8.z.string().min(1),
+  createdAt: import_zod8.z.date(),
+  updatedAt: import_zod8.z.date(),
+  comment: import_zod8.z.string().min(1).max(2e3),
+  isVerified: import_zod8.z.boolean(),
+  isPublished: import_zod8.z.boolean()
+});
+var baseReviewCreateSchema = import_zod8.z.object({
+  patientId: import_zod8.z.string().min(1),
+  comment: import_zod8.z.string().min(1).max(2e3),
+  isVerified: import_zod8.z.boolean().default(false),
+  isPublished: import_zod8.z.boolean().default(true)
+});
+var clinicReviewSchema = baseReviewSchema.extend({
+  clinicId: import_zod8.z.string().min(1),
+  cleanliness: import_zod8.z.number().min(1).max(5),
+  facilities: import_zod8.z.number().min(1).max(5),
+  staffFriendliness: import_zod8.z.number().min(1).max(5),
+  waitingTime: import_zod8.z.number().min(1).max(5),
+  accessibility: import_zod8.z.number().min(1).max(5),
+  overallRating: import_zod8.z.number().min(1).max(5),
+  wouldRecommend: import_zod8.z.boolean()
+});
+var createClinicReviewSchema = baseReviewCreateSchema.extend({
+  clinicId: import_zod8.z.string().min(1),
+  cleanliness: import_zod8.z.number().min(1).max(5),
+  facilities: import_zod8.z.number().min(1).max(5),
+  staffFriendliness: import_zod8.z.number().min(1).max(5),
+  waitingTime: import_zod8.z.number().min(1).max(5),
+  accessibility: import_zod8.z.number().min(1).max(5),
+  wouldRecommend: import_zod8.z.boolean()
+});
+var practitionerReviewSchema = baseReviewSchema.extend({
+  practitionerId: import_zod8.z.string().min(1),
+  knowledgeAndExpertise: import_zod8.z.number().min(1).max(5),
+  communicationSkills: import_zod8.z.number().min(1).max(5),
+  bedSideManner: import_zod8.z.number().min(1).max(5),
+  thoroughness: import_zod8.z.number().min(1).max(5),
+  trustworthiness: import_zod8.z.number().min(1).max(5),
+  overallRating: import_zod8.z.number().min(1).max(5),
+  wouldRecommend: import_zod8.z.boolean()
+});
+var createPractitionerReviewSchema = baseReviewCreateSchema.extend({
+  practitionerId: import_zod8.z.string().min(1),
+  knowledgeAndExpertise: import_zod8.z.number().min(1).max(5),
+  communicationSkills: import_zod8.z.number().min(1).max(5),
+  bedSideManner: import_zod8.z.number().min(1).max(5),
+  thoroughness: import_zod8.z.number().min(1).max(5),
+  trustworthiness: import_zod8.z.number().min(1).max(5),
+  wouldRecommend: import_zod8.z.boolean()
+});
+var procedureReviewSchema = baseReviewSchema.extend({
+  procedureId: import_zod8.z.string().min(1),
+  effectivenessOfTreatment: import_zod8.z.number().min(1).max(5),
+  outcomeExplanation: import_zod8.z.number().min(1).max(5),
+  painManagement: import_zod8.z.number().min(1).max(5),
+  followUpCare: import_zod8.z.number().min(1).max(5),
+  valueForMoney: import_zod8.z.number().min(1).max(5),
+  overallRating: import_zod8.z.number().min(1).max(5),
+  wouldRecommend: import_zod8.z.boolean()
+});
+var createProcedureReviewSchema = baseReviewCreateSchema.extend({
+  procedureId: import_zod8.z.string().min(1),
+  effectivenessOfTreatment: import_zod8.z.number().min(1).max(5),
+  outcomeExplanation: import_zod8.z.number().min(1).max(5),
+  painManagement: import_zod8.z.number().min(1).max(5),
+  followUpCare: import_zod8.z.number().min(1).max(5),
+  valueForMoney: import_zod8.z.number().min(1).max(5),
+  wouldRecommend: import_zod8.z.boolean()
+});
+var clinicReviewInfoSchema = import_zod8.z.object({
+  totalReviews: import_zod8.z.number().min(0),
+  averageRating: import_zod8.z.number().min(0).max(5),
+  cleanliness: import_zod8.z.number().min(0).max(5),
+  facilities: import_zod8.z.number().min(0).max(5),
+  staffFriendliness: import_zod8.z.number().min(0).max(5),
+  waitingTime: import_zod8.z.number().min(0).max(5),
+  accessibility: import_zod8.z.number().min(0).max(5),
+  recommendationPercentage: import_zod8.z.number().min(0).max(100)
+});
+var practitionerReviewInfoSchema = import_zod8.z.object({
+  totalReviews: import_zod8.z.number().min(0),
+  averageRating: import_zod8.z.number().min(0).max(5),
+  knowledgeAndExpertise: import_zod8.z.number().min(0).max(5),
+  communicationSkills: import_zod8.z.number().min(0).max(5),
+  bedSideManner: import_zod8.z.number().min(0).max(5),
+  thoroughness: import_zod8.z.number().min(0).max(5),
+  trustworthiness: import_zod8.z.number().min(0).max(5),
+  recommendationPercentage: import_zod8.z.number().min(0).max(100)
+});
+var procedureReviewInfoSchema = import_zod8.z.object({
+  totalReviews: import_zod8.z.number().min(0),
+  averageRating: import_zod8.z.number().min(0).max(5),
+  effectivenessOfTreatment: import_zod8.z.number().min(0).max(5),
+  outcomeExplanation: import_zod8.z.number().min(0).max(5),
+  painManagement: import_zod8.z.number().min(0).max(5),
+  followUpCare: import_zod8.z.number().min(0).max(5),
+  valueForMoney: import_zod8.z.number().min(0).max(5),
+  recommendationPercentage: import_zod8.z.number().min(0).max(100)
+});
+var reviewSchema = import_zod8.z.object({
+  id: import_zod8.z.string().min(1),
+  appointmentId: import_zod8.z.string().min(1),
+  patientId: import_zod8.z.string().min(1),
+  createdAt: import_zod8.z.date(),
+  updatedAt: import_zod8.z.date(),
+  clinicReview: clinicReviewSchema.optional(),
+  practitionerReview: practitionerReviewSchema.optional(),
+  procedureReview: procedureReviewSchema.optional(),
+  overallComment: import_zod8.z.string().min(1).max(2e3),
+  overallRating: import_zod8.z.number().min(1).max(5)
+});
+var createReviewSchema = import_zod8.z.object({
+  patientId: import_zod8.z.string().min(1),
+  clinicReview: createClinicReviewSchema.optional(),
+  practitionerReview: createPractitionerReviewSchema.optional(),
+  procedureReview: createProcedureReviewSchema.optional(),
+  overallComment: import_zod8.z.string().min(1).max(2e3)
+}).refine(
+  (data) => {
+    return data.clinicReview || data.practitionerReview || data.procedureReview;
+  },
+  {
+    message: "At least one review type (clinic, practitioner, or procedure) must be provided",
+    path: ["reviewType"]
+  }
+);
 
-// src/services/clinic/utils/admin.utils.ts
-var import_firestore11 = require("firebase/firestore");
+// src/validations/shared.schema.ts
+var import_zod9 = require("zod");
+
+// src/backoffice/types/static/procedure-family.types.ts
+var ProcedureFamily = /* @__PURE__ */ ((ProcedureFamily2) => {
+  ProcedureFamily2["AESTHETICS"] = "aesthetics";
+  ProcedureFamily2["SURGERY"] = "surgery";
+  return ProcedureFamily2;
+})(ProcedureFamily || {});
+
+// src/validations/shared.schema.ts
+var sharedClinicContactInfoSchema = import_zod9.z.object({
+  email: import_zod9.z.string().email(),
+  phoneNumber: import_zod9.z.string(),
+  alternativePhoneNumber: import_zod9.z.string().nullable().optional(),
+  website: import_zod9.z.string().nullable().optional()
+});
+var sharedClinicLocationSchema = import_zod9.z.object({
+  address: import_zod9.z.string(),
+  city: import_zod9.z.string(),
+  country: import_zod9.z.string(),
+  postalCode: import_zod9.z.string(),
+  latitude: import_zod9.z.number().min(-90).max(90),
+  longitude: import_zod9.z.number().min(-180).max(180),
+  geohash: import_zod9.z.string().nullable().optional()
+});
+var procedureSummaryInfoSchema = import_zod9.z.object({
+  id: import_zod9.z.string().min(1),
+  name: import_zod9.z.string().min(1),
+  description: import_zod9.z.string().optional(),
+  photo: import_zod9.z.string().optional(),
+  family: import_zod9.z.nativeEnum(ProcedureFamily),
+  categoryName: import_zod9.z.string(),
+  subcategoryName: import_zod9.z.string(),
+  technologyName: import_zod9.z.string(),
+  price: import_zod9.z.number().nonnegative(),
+  pricingMeasure: import_zod9.z.nativeEnum(PricingMeasure),
+  currency: import_zod9.z.nativeEnum(Currency),
+  duration: import_zod9.z.number().int().positive(),
+  clinicId: import_zod9.z.string().min(1),
+  clinicName: import_zod9.z.string().min(1),
+  practitionerId: import_zod9.z.string().min(1),
+  practitionerName: import_zod9.z.string().min(1)
+});
+var clinicInfoSchema = import_zod9.z.object({
+  id: import_zod9.z.string(),
+  featuredPhoto: import_zod9.z.string(),
+  name: import_zod9.z.string(),
+  description: import_zod9.z.string().nullable().optional(),
+  location: sharedClinicLocationSchema,
+  contactInfo: sharedClinicContactInfoSchema
+});
+var doctorInfoSchema = import_zod9.z.object({
+  id: import_zod9.z.string(),
+  name: import_zod9.z.string(),
+  description: import_zod9.z.string().nullable().optional(),
+  photo: import_zod9.z.string(),
+  rating: import_zod9.z.number().min(0).max(5),
+  services: import_zod9.z.array(import_zod9.z.string())
+  // List of procedure IDs practitioner offers
+});
 
 // src/validations/clinic.schema.ts
-var import_zod13 = require("zod");
-var import_firestore10 = require("firebase/firestore");
-var clinicContactInfoSchema = import_zod13.z.object({
-  email: import_zod13.z.string().email(),
-  phoneNumber: import_zod13.z.string(),
-  alternativePhoneNumber: import_zod13.z.string().nullable().optional(),
-  website: import_zod13.z.string().nullable().optional()
+var clinicContactInfoSchema = import_zod10.z.object({
+  email: import_zod10.z.string().email(),
+  phoneNumber: import_zod10.z.string(),
+  alternativePhoneNumber: import_zod10.z.string().nullable().optional(),
+  website: import_zod10.z.string().nullable().optional()
 });
-var clinicLocationSchema = import_zod13.z.object({
-  address: import_zod13.z.string(),
-  city: import_zod13.z.string(),
-  country: import_zod13.z.string(),
-  postalCode: import_zod13.z.string(),
-  latitude: import_zod13.z.number().min(-90).max(90),
-  longitude: import_zod13.z.number().min(-180).max(180),
-  geohash: import_zod13.z.string().nullable().optional()
+var clinicLocationSchema = import_zod10.z.object({
+  address: import_zod10.z.string(),
+  city: import_zod10.z.string(),
+  country: import_zod10.z.string(),
+  postalCode: import_zod10.z.string(),
+  latitude: import_zod10.z.number().min(-90).max(90),
+  longitude: import_zod10.z.number().min(-180).max(180),
+  geohash: import_zod10.z.string().nullable().optional()
 });
-var workingHoursTimeSchema = import_zod13.z.object({
-  open: import_zod13.z.string(),
-  close: import_zod13.z.string(),
-  breaks: import_zod13.z.array(
-    import_zod13.z.object({
-      start: import_zod13.z.string(),
-      end: import_zod13.z.string()
+var workingHoursTimeSchema = import_zod10.z.object({
+  open: import_zod10.z.string(),
+  close: import_zod10.z.string(),
+  breaks: import_zod10.z.array(
+    import_zod10.z.object({
+      start: import_zod10.z.string(),
+      end: import_zod10.z.string()
     })
   ).optional()
 });
-var workingHoursSchema = import_zod13.z.object({
+var workingHoursSchema = import_zod10.z.object({
   monday: workingHoursTimeSchema.nullable(),
   tuesday: workingHoursTimeSchema.nullable(),
   wednesday: workingHoursTimeSchema.nullable(),
@@ -3926,255 +3619,255 @@ var workingHoursSchema = import_zod13.z.object({
   saturday: workingHoursTimeSchema.nullable(),
   sunday: workingHoursTimeSchema.nullable()
 });
-var clinicTagsSchema = import_zod13.z.object({
-  tags: import_zod13.z.array(import_zod13.z.nativeEnum(ClinicTag))
+var clinicTagsSchema = import_zod10.z.object({
+  tags: import_zod10.z.array(import_zod10.z.nativeEnum(ClinicTag))
 });
-var contactPersonSchema = import_zod13.z.object({
-  firstName: import_zod13.z.string(),
-  lastName: import_zod13.z.string(),
-  title: import_zod13.z.string().nullable().optional(),
-  email: import_zod13.z.string().email(),
-  phoneNumber: import_zod13.z.string().nullable().optional()
+var contactPersonSchema = import_zod10.z.object({
+  firstName: import_zod10.z.string(),
+  lastName: import_zod10.z.string(),
+  title: import_zod10.z.string().nullable().optional(),
+  email: import_zod10.z.string().email(),
+  phoneNumber: import_zod10.z.string().nullable().optional()
 });
-var adminInfoSchema = import_zod13.z.object({
-  id: import_zod13.z.string(),
-  name: import_zod13.z.string(),
-  email: import_zod13.z.string().email()
+var adminInfoSchema = import_zod10.z.object({
+  id: import_zod10.z.string(),
+  name: import_zod10.z.string(),
+  email: import_zod10.z.string().email()
 });
-var clinicAdminSchema = import_zod13.z.object({
-  id: import_zod13.z.string(),
-  userRef: import_zod13.z.string(),
-  clinicGroupId: import_zod13.z.string(),
-  isGroupOwner: import_zod13.z.boolean(),
-  clinicsManaged: import_zod13.z.array(import_zod13.z.string()),
-  clinicsManagedInfo: import_zod13.z.array(clinicInfoSchema),
+var clinicAdminSchema = import_zod10.z.object({
+  id: import_zod10.z.string(),
+  userRef: import_zod10.z.string(),
+  clinicGroupId: import_zod10.z.string(),
+  isGroupOwner: import_zod10.z.boolean(),
+  clinicsManaged: import_zod10.z.array(import_zod10.z.string()),
+  clinicsManagedInfo: import_zod10.z.array(clinicInfoSchema),
   contactInfo: contactPersonSchema,
-  roleTitle: import_zod13.z.string(),
-  createdAt: import_zod13.z.instanceof(Date).or(import_zod13.z.instanceof(import_firestore10.Timestamp)),
-  updatedAt: import_zod13.z.instanceof(Date).or(import_zod13.z.instanceof(import_firestore10.Timestamp)),
-  isActive: import_zod13.z.boolean()
+  roleTitle: import_zod10.z.string(),
+  createdAt: import_zod10.z.instanceof(Date).or(import_zod10.z.instanceof(import_firestore9.Timestamp)),
+  updatedAt: import_zod10.z.instanceof(Date).or(import_zod10.z.instanceof(import_firestore9.Timestamp)),
+  isActive: import_zod10.z.boolean()
 });
-var adminTokenSchema = import_zod13.z.object({
-  id: import_zod13.z.string(),
-  token: import_zod13.z.string(),
-  email: import_zod13.z.string().email().optional().nullable(),
-  status: import_zod13.z.nativeEnum(AdminTokenStatus),
-  usedByUserRef: import_zod13.z.string().optional(),
-  createdAt: import_zod13.z.instanceof(Date).or(import_zod13.z.instanceof(import_firestore10.Timestamp)),
+var adminTokenSchema = import_zod10.z.object({
+  id: import_zod10.z.string(),
+  token: import_zod10.z.string(),
+  email: import_zod10.z.string().email().optional().nullable(),
+  status: import_zod10.z.nativeEnum(AdminTokenStatus),
+  usedByUserRef: import_zod10.z.string().optional(),
+  createdAt: import_zod10.z.instanceof(Date).or(import_zod10.z.instanceof(import_firestore9.Timestamp)),
   // Timestamp
-  expiresAt: import_zod13.z.instanceof(Date).or(import_zod13.z.instanceof(import_firestore10.Timestamp))
+  expiresAt: import_zod10.z.instanceof(Date).or(import_zod10.z.instanceof(import_firestore9.Timestamp))
   // Timestamp
 });
-var createAdminTokenSchema = import_zod13.z.object({
-  expiresInDays: import_zod13.z.number().min(1).max(30).optional(),
-  email: import_zod13.z.string().email().optional().nullable()
+var createAdminTokenSchema = import_zod10.z.object({
+  expiresInDays: import_zod10.z.number().min(1).max(30).optional(),
+  email: import_zod10.z.string().email().optional().nullable()
 });
-var clinicGroupSchema = import_zod13.z.object({
-  id: import_zod13.z.string(),
-  name: import_zod13.z.string(),
-  description: import_zod13.z.string().nullable().optional(),
+var clinicGroupSchema = import_zod10.z.object({
+  id: import_zod10.z.string(),
+  name: import_zod10.z.string(),
+  description: import_zod10.z.string().nullable().optional(),
   hqLocation: clinicLocationSchema,
   contactInfo: clinicContactInfoSchema,
   contactPerson: contactPersonSchema,
-  clinics: import_zod13.z.array(import_zod13.z.string()),
-  clinicsInfo: import_zod13.z.array(clinicInfoSchema),
-  admins: import_zod13.z.array(import_zod13.z.string()),
-  adminsInfo: import_zod13.z.array(adminInfoSchema),
-  adminTokens: import_zod13.z.array(adminTokenSchema),
-  ownerId: import_zod13.z.string().nullable(),
-  createdAt: import_zod13.z.instanceof(Date).or(import_zod13.z.instanceof(import_firestore10.Timestamp)),
+  clinics: import_zod10.z.array(import_zod10.z.string()),
+  clinicsInfo: import_zod10.z.array(clinicInfoSchema),
+  admins: import_zod10.z.array(import_zod10.z.string()),
+  adminsInfo: import_zod10.z.array(adminInfoSchema),
+  adminTokens: import_zod10.z.array(adminTokenSchema),
+  ownerId: import_zod10.z.string().nullable(),
+  createdAt: import_zod10.z.instanceof(Date).or(import_zod10.z.instanceof(import_firestore9.Timestamp)),
   // Timestamp
-  updatedAt: import_zod13.z.instanceof(Date).or(import_zod13.z.instanceof(import_firestore10.Timestamp)),
+  updatedAt: import_zod10.z.instanceof(Date).or(import_zod10.z.instanceof(import_firestore9.Timestamp)),
   // Timestamp
-  isActive: import_zod13.z.boolean(),
+  isActive: import_zod10.z.boolean(),
   logo: mediaResourceSchema.optional().nullable(),
-  practiceType: import_zod13.z.nativeEnum(PracticeType).optional(),
-  languages: import_zod13.z.array(import_zod13.z.nativeEnum(Language)).optional(),
-  subscriptionModel: import_zod13.z.nativeEnum(SubscriptionModel),
-  calendarSyncEnabled: import_zod13.z.boolean().optional(),
-  autoConfirmAppointments: import_zod13.z.boolean().optional(),
-  businessIdentificationNumber: import_zod13.z.string().optional().nullable(),
-  onboarding: import_zod13.z.object({
-    completed: import_zod13.z.boolean().optional().default(false),
-    step: import_zod13.z.number().optional().default(1)
+  practiceType: import_zod10.z.nativeEnum(PracticeType).optional(),
+  languages: import_zod10.z.array(import_zod10.z.nativeEnum(Language)).optional(),
+  subscriptionModel: import_zod10.z.nativeEnum(SubscriptionModel),
+  calendarSyncEnabled: import_zod10.z.boolean().optional(),
+  autoConfirmAppointments: import_zod10.z.boolean().optional(),
+  businessIdentificationNumber: import_zod10.z.string().optional().nullable(),
+  onboarding: import_zod10.z.object({
+    completed: import_zod10.z.boolean().optional().default(false),
+    step: import_zod10.z.number().optional().default(1)
   }).optional()
 });
-var clinicSchema = import_zod13.z.object({
-  id: import_zod13.z.string(),
-  clinicGroupId: import_zod13.z.string(),
-  name: import_zod13.z.string(),
-  description: import_zod13.z.string().nullable().optional(),
+var clinicSchema = import_zod10.z.object({
+  id: import_zod10.z.string(),
+  clinicGroupId: import_zod10.z.string(),
+  name: import_zod10.z.string(),
+  description: import_zod10.z.string().nullable().optional(),
   location: clinicLocationSchema,
   contactInfo: clinicContactInfoSchema,
   workingHours: workingHoursSchema,
-  tags: import_zod13.z.array(import_zod13.z.nativeEnum(ClinicTag)),
-  featuredPhotos: import_zod13.z.array(mediaResourceSchema),
+  tags: import_zod10.z.array(import_zod10.z.nativeEnum(ClinicTag)),
+  featuredPhotos: import_zod10.z.array(mediaResourceSchema),
   coverPhoto: mediaResourceSchema.nullable(),
-  photosWithTags: import_zod13.z.array(
-    import_zod13.z.object({
+  photosWithTags: import_zod10.z.array(
+    import_zod10.z.object({
       url: mediaResourceSchema,
-      tag: import_zod13.z.string()
+      tag: import_zod10.z.string()
     })
   ).optional(),
-  doctors: import_zod13.z.array(import_zod13.z.string()),
+  doctors: import_zod10.z.array(import_zod10.z.string()),
   // List of practitioner IDs
-  doctorsInfo: import_zod13.z.array(doctorInfoSchema),
+  doctorsInfo: import_zod10.z.array(doctorInfoSchema),
   // Aggregated doctor info
-  procedures: import_zod13.z.array(import_zod13.z.string()),
+  procedures: import_zod10.z.array(import_zod10.z.string()),
   // List of procedure IDs offered by clinic
-  proceduresInfo: import_zod13.z.array(procedureSummaryInfoSchema),
+  proceduresInfo: import_zod10.z.array(procedureSummaryInfoSchema),
   // Use the correct schema for aggregated procedure info
   reviewInfo: clinicReviewInfoSchema,
-  admins: import_zod13.z.array(import_zod13.z.string()),
-  createdAt: import_zod13.z.instanceof(Date).or(import_zod13.z.instanceof(import_firestore10.Timestamp)),
+  admins: import_zod10.z.array(import_zod10.z.string()),
+  createdAt: import_zod10.z.instanceof(Date).or(import_zod10.z.instanceof(import_firestore9.Timestamp)),
   // Timestamp
-  updatedAt: import_zod13.z.instanceof(Date).or(import_zod13.z.instanceof(import_firestore10.Timestamp)),
+  updatedAt: import_zod10.z.instanceof(Date).or(import_zod10.z.instanceof(import_firestore9.Timestamp)),
   // Timestamp
-  isActive: import_zod13.z.boolean(),
-  isVerified: import_zod13.z.boolean(),
+  isActive: import_zod10.z.boolean(),
+  isVerified: import_zod10.z.boolean(),
   logo: mediaResourceSchema.optional().nullable()
 });
-var createClinicAdminSchema = import_zod13.z.object({
-  userRef: import_zod13.z.string(),
-  clinicGroupId: import_zod13.z.string().optional(),
-  isGroupOwner: import_zod13.z.boolean(),
-  clinicsManaged: import_zod13.z.array(import_zod13.z.string()),
+var createClinicAdminSchema = import_zod10.z.object({
+  userRef: import_zod10.z.string(),
+  clinicGroupId: import_zod10.z.string().optional(),
+  isGroupOwner: import_zod10.z.boolean(),
+  clinicsManaged: import_zod10.z.array(import_zod10.z.string()),
   contactInfo: contactPersonSchema,
-  roleTitle: import_zod13.z.string(),
-  isActive: import_zod13.z.boolean()
+  roleTitle: import_zod10.z.string(),
+  isActive: import_zod10.z.boolean()
   // clinicsManagedInfo is aggregated, not provided on creation
 });
-var createClinicGroupSchema = import_zod13.z.object({
-  name: import_zod13.z.string(),
-  description: import_zod13.z.string().optional(),
+var createClinicGroupSchema = import_zod10.z.object({
+  name: import_zod10.z.string(),
+  description: import_zod10.z.string().optional(),
   hqLocation: clinicLocationSchema,
   contactInfo: clinicContactInfoSchema,
   contactPerson: contactPersonSchema,
-  ownerId: import_zod13.z.string().nullable(),
-  isActive: import_zod13.z.boolean(),
+  ownerId: import_zod10.z.string().nullable(),
+  isActive: import_zod10.z.boolean(),
   logo: mediaResourceSchema.optional().nullable(),
-  practiceType: import_zod13.z.nativeEnum(PracticeType).optional(),
-  languages: import_zod13.z.array(import_zod13.z.nativeEnum(Language)).optional(),
-  subscriptionModel: import_zod13.z.nativeEnum(SubscriptionModel).optional().default("no_subscription" /* NO_SUBSCRIPTION */),
-  calendarSyncEnabled: import_zod13.z.boolean().optional(),
-  autoConfirmAppointments: import_zod13.z.boolean().optional(),
-  businessIdentificationNumber: import_zod13.z.string().optional().nullable(),
-  onboarding: import_zod13.z.object({
-    completed: import_zod13.z.boolean().optional().default(false),
-    step: import_zod13.z.number().optional().default(1)
+  practiceType: import_zod10.z.nativeEnum(PracticeType).optional(),
+  languages: import_zod10.z.array(import_zod10.z.nativeEnum(Language)).optional(),
+  subscriptionModel: import_zod10.z.nativeEnum(SubscriptionModel).optional().default("no_subscription" /* NO_SUBSCRIPTION */),
+  calendarSyncEnabled: import_zod10.z.boolean().optional(),
+  autoConfirmAppointments: import_zod10.z.boolean().optional(),
+  businessIdentificationNumber: import_zod10.z.string().optional().nullable(),
+  onboarding: import_zod10.z.object({
+    completed: import_zod10.z.boolean().optional().default(false),
+    step: import_zod10.z.number().optional().default(1)
   }).optional()
   // clinics, clinicsInfo, admins, adminsInfo, adminTokens are managed internally
 });
-var createClinicSchema = import_zod13.z.object({
-  clinicGroupId: import_zod13.z.string(),
-  name: import_zod13.z.string(),
-  description: import_zod13.z.string().optional(),
+var createClinicSchema = import_zod10.z.object({
+  clinicGroupId: import_zod10.z.string(),
+  name: import_zod10.z.string(),
+  description: import_zod10.z.string().optional(),
   location: clinicLocationSchema,
   contactInfo: clinicContactInfoSchema,
   workingHours: workingHoursSchema,
-  tags: import_zod13.z.array(import_zod13.z.nativeEnum(ClinicTag)),
+  tags: import_zod10.z.array(import_zod10.z.nativeEnum(ClinicTag)),
   coverPhoto: mediaResourceSchema.nullable().optional(),
-  photosWithTags: import_zod13.z.array(
-    import_zod13.z.object({
+  photosWithTags: import_zod10.z.array(
+    import_zod10.z.object({
       url: mediaResourceSchema,
-      tag: import_zod13.z.string()
+      tag: import_zod10.z.string()
     })
   ).optional(),
-  doctors: import_zod13.z.array(import_zod13.z.string()).optional().default([]),
-  procedures: import_zod13.z.array(import_zod13.z.string()).optional().default([]),
-  proceduresInfo: import_zod13.z.array(procedureSummaryInfoSchema).optional(),
-  admins: import_zod13.z.array(import_zod13.z.string()),
-  isActive: import_zod13.z.boolean().optional().default(true),
-  isVerified: import_zod13.z.boolean().optional().default(false),
+  doctors: import_zod10.z.array(import_zod10.z.string()).optional().default([]),
+  procedures: import_zod10.z.array(import_zod10.z.string()).optional().default([]),
+  proceduresInfo: import_zod10.z.array(procedureSummaryInfoSchema).optional(),
+  admins: import_zod10.z.array(import_zod10.z.string()),
+  isActive: import_zod10.z.boolean().optional().default(true),
+  isVerified: import_zod10.z.boolean().optional().default(false),
   logo: mediaResourceSchema.optional().nullable(),
-  featuredPhotos: import_zod13.z.array(mediaResourceSchema).optional().default([])
+  featuredPhotos: import_zod10.z.array(mediaResourceSchema).optional().default([])
 });
-var createDefaultClinicGroupSchema = import_zod13.z.object({
-  name: import_zod13.z.string(),
-  ownerId: import_zod13.z.string().nullable(),
+var createDefaultClinicGroupSchema = import_zod10.z.object({
+  name: import_zod10.z.string(),
+  ownerId: import_zod10.z.string().nullable(),
   contactPerson: contactPersonSchema,
   contactInfo: clinicContactInfoSchema,
   hqLocation: clinicLocationSchema,
-  isActive: import_zod13.z.boolean(),
+  isActive: import_zod10.z.boolean(),
   logo: mediaResourceSchema.optional().nullable(),
-  practiceType: import_zod13.z.nativeEnum(PracticeType).optional(),
-  languages: import_zod13.z.array(import_zod13.z.nativeEnum(Language)).optional(),
-  subscriptionModel: import_zod13.z.nativeEnum(SubscriptionModel).optional().default("no_subscription" /* NO_SUBSCRIPTION */),
-  onboarding: import_zod13.z.object({
-    completed: import_zod13.z.boolean().optional().default(false),
-    step: import_zod13.z.number().optional().default(1)
+  practiceType: import_zod10.z.nativeEnum(PracticeType).optional(),
+  languages: import_zod10.z.array(import_zod10.z.nativeEnum(Language)).optional(),
+  subscriptionModel: import_zod10.z.nativeEnum(SubscriptionModel).optional().default("no_subscription" /* NO_SUBSCRIPTION */),
+  onboarding: import_zod10.z.object({
+    completed: import_zod10.z.boolean().optional().default(false),
+    step: import_zod10.z.number().optional().default(1)
   }).optional()
 });
-var clinicAdminSignupSchema = import_zod13.z.object({
-  email: import_zod13.z.string().email(),
-  password: import_zod13.z.string().min(8),
-  firstName: import_zod13.z.string(),
-  lastName: import_zod13.z.string(),
-  title: import_zod13.z.string(),
-  phoneNumber: import_zod13.z.string(),
-  isCreatingNewGroup: import_zod13.z.boolean(),
-  inviteToken: import_zod13.z.string().optional(),
-  clinicGroupData: import_zod13.z.object({
-    name: import_zod13.z.string(),
+var clinicAdminSignupSchema = import_zod10.z.object({
+  email: import_zod10.z.string().email(),
+  password: import_zod10.z.string().min(8),
+  firstName: import_zod10.z.string(),
+  lastName: import_zod10.z.string(),
+  title: import_zod10.z.string(),
+  phoneNumber: import_zod10.z.string(),
+  isCreatingNewGroup: import_zod10.z.boolean(),
+  inviteToken: import_zod10.z.string().optional(),
+  clinicGroupData: import_zod10.z.object({
+    name: import_zod10.z.string(),
     hqLocation: clinicLocationSchema,
     logo: mediaResourceSchema.optional(),
     contactInfo: clinicContactInfoSchema,
-    subscriptionModel: import_zod13.z.nativeEnum(SubscriptionModel).optional().default("no_subscription" /* NO_SUBSCRIPTION */)
+    subscriptionModel: import_zod10.z.nativeEnum(SubscriptionModel).optional().default("no_subscription" /* NO_SUBSCRIPTION */)
   }).optional()
 });
-var clinicGroupSetupSchema = import_zod13.z.object({
-  languages: import_zod13.z.array(import_zod13.z.nativeEnum(Language)),
-  practiceType: import_zod13.z.nativeEnum(PracticeType),
-  description: import_zod13.z.string(),
+var clinicGroupSetupSchema = import_zod10.z.object({
+  languages: import_zod10.z.array(import_zod10.z.nativeEnum(Language)),
+  practiceType: import_zod10.z.nativeEnum(PracticeType),
+  description: import_zod10.z.string(),
   logo: mediaResourceSchema,
-  calendarSyncEnabled: import_zod13.z.boolean(),
-  autoConfirmAppointments: import_zod13.z.boolean(),
-  businessIdentificationNumber: import_zod13.z.string().optional().nullable(),
-  onboarding: import_zod13.z.object({
-    completed: import_zod13.z.boolean().optional().default(false),
-    step: import_zod13.z.number().optional().default(1)
+  calendarSyncEnabled: import_zod10.z.boolean(),
+  autoConfirmAppointments: import_zod10.z.boolean(),
+  businessIdentificationNumber: import_zod10.z.string().optional().nullable(),
+  onboarding: import_zod10.z.object({
+    completed: import_zod10.z.boolean().optional().default(false),
+    step: import_zod10.z.number().optional().default(1)
   }).optional()
 });
-var clinicBranchSetupSchema = import_zod13.z.object({
-  name: import_zod13.z.string(),
+var clinicBranchSetupSchema = import_zod10.z.object({
+  name: import_zod10.z.string(),
   location: clinicLocationSchema,
-  description: import_zod13.z.string().optional(),
+  description: import_zod10.z.string().optional(),
   contactInfo: clinicContactInfoSchema,
   workingHours: workingHoursSchema,
-  tags: import_zod13.z.array(import_zod13.z.nativeEnum(ClinicTag)),
+  tags: import_zod10.z.array(import_zod10.z.nativeEnum(ClinicTag)),
   logo: mediaResourceSchema.optional(),
   coverPhoto: mediaResourceSchema.nullable().optional(),
-  photosWithTags: import_zod13.z.array(
-    import_zod13.z.object({
+  photosWithTags: import_zod10.z.array(
+    import_zod10.z.object({
       url: mediaResourceSchema,
-      tag: import_zod13.z.string()
+      tag: import_zod10.z.string()
     })
   ).optional(),
-  featuredPhotos: import_zod13.z.array(mediaResourceSchema).optional()
+  featuredPhotos: import_zod10.z.array(mediaResourceSchema).optional()
 });
 var updateClinicAdminSchema = createClinicAdminSchema.partial();
 var updateClinicGroupSchema = createClinicGroupSchema.partial();
-var updateClinicSchema = import_zod13.z.object({
-  name: import_zod13.z.string().optional(),
-  description: import_zod13.z.string().optional(),
+var updateClinicSchema = import_zod10.z.object({
+  name: import_zod10.z.string().optional(),
+  description: import_zod10.z.string().optional(),
   location: clinicLocationSchema.optional(),
   contactInfo: clinicContactInfoSchema.optional(),
   workingHours: workingHoursSchema.optional(),
-  tags: import_zod13.z.array(import_zod13.z.nativeEnum(ClinicTag)).optional(),
+  tags: import_zod10.z.array(import_zod10.z.nativeEnum(ClinicTag)).optional(),
   coverPhoto: mediaResourceSchema.nullable().optional(),
-  photosWithTags: import_zod13.z.array(
-    import_zod13.z.object({
+  photosWithTags: import_zod10.z.array(
+    import_zod10.z.object({
       url: mediaResourceSchema,
-      tag: import_zod13.z.string()
+      tag: import_zod10.z.string()
     })
   ).optional(),
-  doctors: import_zod13.z.array(import_zod13.z.string()).optional(),
-  procedures: import_zod13.z.array(import_zod13.z.string()).optional(),
-  proceduresInfo: import_zod13.z.array(procedureSummaryInfoSchema).optional(),
-  isActive: import_zod13.z.boolean().optional(),
-  isVerified: import_zod13.z.boolean().optional(),
+  doctors: import_zod10.z.array(import_zod10.z.string()).optional(),
+  procedures: import_zod10.z.array(import_zod10.z.string()).optional(),
+  proceduresInfo: import_zod10.z.array(procedureSummaryInfoSchema).optional(),
+  isActive: import_zod10.z.boolean().optional(),
+  isVerified: import_zod10.z.boolean().optional(),
   logo: mediaResourceSchema.optional().nullable(),
-  featuredPhotos: import_zod13.z.array(mediaResourceSchema).optional()
+  featuredPhotos: import_zod10.z.array(mediaResourceSchema).optional()
 });
 
 // src/services/clinic/utils/admin.utils.ts
@@ -4250,7 +3943,7 @@ async function createClinicAdmin(db, data, clinicGroupService) {
   }
   console.log("[CLINIC_ADMIN] Preparing admin data object");
   const adminData = {
-    id: (0, import_firestore11.doc)((0, import_firestore11.collection)(db, CLINIC_ADMINS_COLLECTION)).id,
+    id: (0, import_firestore10.doc)((0, import_firestore10.collection)(db, CLINIC_ADMINS_COLLECTION)).id,
     // Generate a new ID for the admin document
     userRef: validatedData.userRef,
     clinicGroupId: clinicGroupId || "",
@@ -4263,15 +3956,15 @@ async function createClinicAdmin(db, data, clinicGroupService) {
     contactInfo: validatedData.contactInfo,
     roleTitle: validatedData.roleTitle,
     isActive: validatedData.isActive,
-    createdAt: (0, import_firestore11.serverTimestamp)(),
-    updatedAt: (0, import_firestore11.serverTimestamp)()
+    createdAt: (0, import_firestore10.serverTimestamp)(),
+    updatedAt: (0, import_firestore10.serverTimestamp)()
   };
   console.log("[CLINIC_ADMIN] Validating complete admin object");
   try {
     clinicAdminSchema.parse({
       ...adminData,
-      createdAt: import_firestore11.Timestamp.now(),
-      updatedAt: import_firestore11.Timestamp.now()
+      createdAt: import_firestore10.Timestamp.now(),
+      updatedAt: import_firestore10.Timestamp.now()
     });
     console.log("[CLINIC_ADMIN] Admin object validation passed");
   } catch (schemaError) {
@@ -4285,7 +3978,7 @@ async function createClinicAdmin(db, data, clinicGroupService) {
     adminId: adminData.id
   });
   try {
-    await (0, import_firestore11.setDoc)((0, import_firestore11.doc)(db, CLINIC_ADMINS_COLLECTION, adminData.id), adminData);
+    await (0, import_firestore10.setDoc)((0, import_firestore10.doc)(db, CLINIC_ADMINS_COLLECTION, adminData.id), adminData);
     console.log("[CLINIC_ADMIN] Admin saved successfully");
   } catch (firestoreError) {
     console.error(
@@ -4334,30 +4027,30 @@ async function checkClinicGroupExists(db, groupId, clinicGroupService) {
   return !!group;
 }
 async function getClinicAdmin(db, adminId) {
-  const docRef = (0, import_firestore11.doc)(db, CLINIC_ADMINS_COLLECTION, adminId);
-  const docSnap = await (0, import_firestore11.getDoc)(docRef);
+  const docRef = (0, import_firestore10.doc)(db, CLINIC_ADMINS_COLLECTION, adminId);
+  const docSnap = await (0, import_firestore10.getDoc)(docRef);
   if (docSnap.exists()) {
     return docSnap.data();
   }
   return null;
 }
 async function getClinicAdminByUserRef(db, userRef) {
-  const q = (0, import_firestore11.query)(
-    (0, import_firestore11.collection)(db, CLINIC_ADMINS_COLLECTION),
-    (0, import_firestore11.where)("userRef", "==", userRef)
+  const q = (0, import_firestore10.query)(
+    (0, import_firestore10.collection)(db, CLINIC_ADMINS_COLLECTION),
+    (0, import_firestore10.where)("userRef", "==", userRef)
   );
-  const querySnapshot = await (0, import_firestore11.getDocs)(q);
+  const querySnapshot = await (0, import_firestore10.getDocs)(q);
   if (querySnapshot.empty) {
     return null;
   }
   return querySnapshot.docs[0].data();
 }
 async function getClinicAdminsByGroup(db, clinicGroupId) {
-  const q = (0, import_firestore11.query)(
-    (0, import_firestore11.collection)(db, CLINIC_ADMINS_COLLECTION),
-    (0, import_firestore11.where)("clinicGroupId", "==", clinicGroupId)
+  const q = (0, import_firestore10.query)(
+    (0, import_firestore10.collection)(db, CLINIC_ADMINS_COLLECTION),
+    (0, import_firestore10.where)("clinicGroupId", "==", clinicGroupId)
   );
-  const querySnapshot = await (0, import_firestore11.getDocs)(q);
+  const querySnapshot = await (0, import_firestore10.getDocs)(q);
   return querySnapshot.docs.map((doc37) => doc37.data());
 }
 async function updateClinicAdmin(db, adminId, data) {
@@ -4367,9 +4060,9 @@ async function updateClinicAdmin(db, adminId, data) {
   }
   const updatedData = {
     ...data,
-    updatedAt: (0, import_firestore11.serverTimestamp)()
+    updatedAt: (0, import_firestore10.serverTimestamp)()
   };
-  await (0, import_firestore11.updateDoc)((0, import_firestore11.doc)(db, CLINIC_ADMINS_COLLECTION, adminId), updatedData);
+  await (0, import_firestore10.updateDoc)((0, import_firestore10.doc)(db, CLINIC_ADMINS_COLLECTION, adminId), updatedData);
   const updatedAdmin = await getClinicAdmin(db, adminId);
   if (!updatedAdmin) {
     throw new Error("Failed to retrieve updated admin");
@@ -4381,7 +4074,7 @@ async function deleteClinicAdmin(db, adminId) {
   if (!admin2) {
     throw new Error("Clinic admin not found");
   }
-  await (0, import_firestore11.deleteDoc)((0, import_firestore11.doc)(db, CLINIC_ADMINS_COLLECTION, adminId));
+  await (0, import_firestore10.deleteDoc)((0, import_firestore10.doc)(db, CLINIC_ADMINS_COLLECTION, adminId));
 }
 async function addClinicToManaged(db, adminId, clinicId, requesterId, clinicService) {
   const admin2 = await getClinicAdmin(db, adminId);
@@ -4495,7 +4188,7 @@ async function syncOwnerClinics(db, adminId, clinicService, clinicGroupService)
 // src/services/patient/utils/sensitive.utils.ts
 var checkSensitiveAccessUtil = async (db, patientId, requesterId, requesterRoles) => {
   var _a;
-  const patientDoc = await (0, import_firestore12.getDoc)(getPatientDocRef(db, patientId));
+  const patientDoc = await (0, import_firestore11.getDoc)(getPatientDocRef(db, patientId));
   if (!patientDoc.exists()) {
     throw new Error("Patient profile not found");
   }
@@ -4562,7 +4255,7 @@ var createSensitiveInfoUtil = async (db, data, requesterId, requesterRoles, medi
       requesterRoles
     );
     const validatedData = createPatientSensitiveInfoSchema.parse(data);
-    const sensitiveDoc = await (0, import_firestore12.getDoc)(
+    const sensitiveDoc = await (0, import_firestore11.getDoc)(
       getSensitiveInfoDocRef(db, data.patientId)
     );
     if (sensitiveDoc.exists()) {
@@ -4581,17 +4274,17 @@ var createSensitiveInfoUtil = async (db, data, requesterId, requesterRoles, medi
     const sensitiveInfoData = {
       ...validatedData,
       photoUrl: processedPhotoUrl,
-      createdAt: (0, import_firestore12.serverTimestamp)(),
-      updatedAt: (0, import_firestore12.serverTimestamp)()
+      createdAt: (0, import_firestore11.serverTimestamp)(),
+      updatedAt: (0, import_firestore11.serverTimestamp)()
     };
-    await (0, import_firestore12.setDoc)(getSensitiveInfoDocRef(db, data.patientId), sensitiveInfoData);
-    const createdDoc = await (0, import_firestore12.getDoc)(getSensitiveInfoDocRef(db, data.patientId));
+    await (0, import_firestore11.setDoc)(getSensitiveInfoDocRef(db, data.patientId), sensitiveInfoData);
+    const createdDoc = await (0, import_firestore11.getDoc)(getSensitiveInfoDocRef(db, data.patientId));
     if (!createdDoc.exists()) {
       throw new Error("Failed to create sensitive information");
     }
     return createdDoc.data();
   } catch (error) {
-    if (error instanceof import_zod14.z.ZodError) {
+    if (error instanceof import_zod11.z.ZodError) {
       throw new Error("Invalid sensitive info data: " + error.message);
     }
     throw error;
@@ -4600,7 +4293,7 @@ var createSensitiveInfoUtil = async (db, data, requesterId, requesterRoles, medi
 var getSensitiveInfoUtil = async (db, patientId, requesterId, requesterRoles) => {
   await checkSensitiveAccessUtil(db, patientId, requesterId, requesterRoles);
   await initSensitiveInfoDocIfNotExists(db, patientId, requesterId);
-  const sensitiveDoc = await (0, import_firestore12.getDoc)(getSensitiveInfoDocRef(db, patientId));
+  const sensitiveDoc = await (0, import_firestore11.getDoc)(getSensitiveInfoDocRef(db, patientId));
   return sensitiveDoc.exists() ? sensitiveDoc.data() : null;
 };
 var updateSensitiveInfoUtil = async (db, patientId, data, requesterId, requesterRoles, mediaService) => {
@@ -4623,10 +4316,10 @@ var updateSensitiveInfoUtil = async (db, patientId, data, requesterId, requester
   const updateData = {
     ...data,
     photoUrl: processedPhotoUrl,
-    updatedAt: (0, import_firestore12.serverTimestamp)()
+    updatedAt: (0, import_firestore11.serverTimestamp)()
   };
-  await (0, import_firestore12.updateDoc)(getSensitiveInfoDocRef(db, patientId), updateData);
-  const updatedDoc = await (0, import_firestore12.getDoc)(getSensitiveInfoDocRef(db, patientId));
+  await (0, import_firestore11.updateDoc)(getSensitiveInfoDocRef(db, patientId), updateData);
+  const updatedDoc = await (0, import_firestore11.getDoc)(getSensitiveInfoDocRef(db, patientId));
   if (!updatedDoc.exists()) {
     throw new Error("Failed to retrieve updated sensitive information");
   }
@@ -4635,21 +4328,21 @@ var updateSensitiveInfoUtil = async (db, patientId, data, requesterId, requester
 
 // src/services/patient/utils/docs.utils.ts
 var getPatientDocRef = (db, patientId) => {
-  return (0, import_firestore13.doc)(db, PATIENTS_COLLECTION, patientId);
+  return (0, import_firestore12.doc)(db, PATIENTS_COLLECTION, patientId);
 };
 var getPatientDocRefByUserRef = async (db, userRef) => {
-  const patientsRef = (0, import_firestore13.collection)(db, PATIENTS_COLLECTION);
-  const q = (0, import_firestore13.query)(patientsRef, (0, import_firestore13.where)("userRef", "==", userRef));
-  const querySnapshot = await (0, import_firestore13.getDocs)(q);
+  const patientsRef = (0, import_firestore12.collection)(db, PATIENTS_COLLECTION);
+  const q = (0, import_firestore12.query)(patientsRef, (0, import_firestore12.where)("userRef", "==", userRef));
+  const querySnapshot = await (0, import_firestore12.getDocs)(q);
   if (querySnapshot.empty) {
     throw new Error("Patient profile not found");
   }
-  return (0, import_firestore13.doc)(db, PATIENTS_COLLECTION, querySnapshot.docs[0].id);
+  return (0, import_firestore12.doc)(db, PATIENTS_COLLECTION, querySnapshot.docs[0].id);
 };
 var getSensitiveInfoDocRef = (db, patientId) => {
   const path = `${PATIENTS_COLLECTION}/${patientId}/${PATIENT_SENSITIVE_INFO_COLLECTION}/${patientId}`;
   console.log(`[getSensitiveInfoDocRef] Creating reference with path: ${path}`);
-  return (0, import_firestore13.doc)(
+  return (0, import_firestore12.doc)(
     db,
     PATIENTS_COLLECTION,
     patientId,
@@ -4660,7 +4353,7 @@ var getSensitiveInfoDocRef = (db, patientId) => {
 var getLocationInfoDocRef = (db, patientId) => {
   const path = `${PATIENTS_COLLECTION}/${patientId}/${PATIENT_LOCATION_INFO_COLLECTION}/${patientId}`;
   console.log(`[getLocationInfoDocRef] Creating reference with path: ${path}`);
-  return (0, import_firestore13.doc)(
+  return (0, import_firestore12.doc)(
     db,
     PATIENTS_COLLECTION,
     patientId,
@@ -4671,7 +4364,7 @@ var getLocationInfoDocRef = (db, patientId) => {
 var getMedicalInfoDocRef = (db, patientId) => {
   const path = `${PATIENTS_COLLECTION}/${patientId}/${PATIENT_MEDICAL_INFO_COLLECTION}/${patientId}`;
   console.log(`[getMedicalInfoDocRef] Creating reference with path: ${path}`);
-  return (0, import_firestore13.doc)(
+  return (0, import_firestore12.doc)(
     db,
     PATIENTS_COLLECTION,
     patientId,
@@ -4688,7 +4381,7 @@ var initSensitiveInfoDocIfNotExists = async (db, patientId, userRef) => {
     console.log(
       `[initSensitiveInfoDocIfNotExists] Got document reference: ${sensitiveInfoRef.path}`
     );
-    const sensitiveDoc = await (0, import_firestore13.getDoc)(sensitiveInfoRef);
+    const sensitiveDoc = await (0, import_firestore12.getDoc)(sensitiveInfoRef);
     console.log(
       `[initSensitiveInfoDocIfNotExists] Document exists: ${sensitiveDoc.exists()}`
     );
@@ -4712,7 +4405,7 @@ var initSensitiveInfoDocIfNotExists = async (db, patientId, userRef) => {
         )
       );
       await createSensitiveInfoUtil(db, defaultSensitiveInfo, userRef);
-      const verifyDoc = await (0, import_firestore13.getDoc)(sensitiveInfoRef);
+      const verifyDoc = await (0, import_firestore12.getDoc)(sensitiveInfoRef);
       console.log(
         `[initSensitiveInfoDocIfNotExists] Verification - document exists: ${verifyDoc.exists()}`
       );
@@ -4729,8 +4422,8 @@ var initSensitiveInfoDocIfNotExists = async (db, patientId, userRef) => {
 };
 
 // src/services/patient/utils/location.utils.ts
-var import_firestore14 = require("firebase/firestore");
-var import_zod15 = require("zod");
+var import_firestore13 = require("firebase/firestore");
+var import_zod12 = require("zod");
 var import_geofire_common = require("geofire-common");
 var updatePatientLocationUtil = async (db, patientId, latitude, longitude) => {
   const locationData = {
@@ -4740,9 +4433,9 @@ var updatePatientLocationUtil = async (db, patientId, latitude, longitude) => {
   };
   const updateData = {
     locationData,
-    updatedAt: (0, import_firestore14.serverTimestamp)()
+    updatedAt: (0, import_firestore13.serverTimestamp)()
   };
-  await (0, import_firestore14.updateDoc)(getLocationInfoDocRef(db, patientId), updateData);
+  await (0, import_firestore13.updateDoc)(getLocationInfoDocRef(db, patientId), updateData);
 };
 var createLocationInfoUtil = async (db, data, requesterId) => {
   try {
@@ -4759,17 +4452,17 @@ var createLocationInfoUtil = async (db, data, requesterId) => {
           validatedData.locationData.longitude
         ])
       },
-      createdAt: (0, import_firestore14.serverTimestamp)(),
-      updatedAt: (0, import_firestore14.serverTimestamp)()
+      createdAt: (0, import_firestore13.serverTimestamp)(),
+      updatedAt: (0, import_firestore13.serverTimestamp)()
     };
-    await (0, import_firestore14.setDoc)(getLocationInfoDocRef(db, data.patientId), locationData);
-    const locationDoc = await (0, import_firestore14.getDoc)(getLocationInfoDocRef(db, data.patientId));
+    await (0, import_firestore13.setDoc)(getLocationInfoDocRef(db, data.patientId), locationData);
+    const locationDoc = await (0, import_firestore13.getDoc)(getLocationInfoDocRef(db, data.patientId));
     if (!locationDoc.exists()) {
       throw new Error("Failed to create location information");
     }
     return locationDoc.data();
   } catch (error) {
-    if (error instanceof import_zod15.z.ZodError) {
+    if (error instanceof import_zod12.z.ZodError) {
       throw new Error("Invalid location data: " + error.message);
     }
     throw error;
@@ -4779,7 +4472,7 @@ var getLocationInfoUtil = async (db, patientId, requesterId) => {
   if (patientId !== requesterId) {
     throw new Error("Unauthorized access to location information");
   }
-  const locationDoc = await (0, import_firestore14.getDoc)(getLocationInfoDocRef(db, patientId));
+  const locationDoc = await (0, import_firestore13.getDoc)(getLocationInfoDocRef(db, patientId));
   return locationDoc.exists() ? locationDoc.data() : null;
 };
 var updateLocationInfoUtil = async (db, patientId, data, requesterId) => {
@@ -4796,8 +4489,8 @@ var updateLocationInfoUtil = async (db, patientId, data, requesterId) => {
       ])
     };
   }
-  updateData.updatedAt = (0, import_firestore14.serverTimestamp)();
-  await (0, import_firestore14.updateDoc)(getLocationInfoDocRef(db, patientId), updateData);
+  updateData.updatedAt = (0, import_firestore13.serverTimestamp)();
+  await (0, import_firestore13.updateDoc)(getLocationInfoDocRef(db, patientId), updateData);
   const updatedInfo = await getLocationInfoUtil(db, patientId, requesterId);
   if (!updatedInfo) {
     throw new Error("Failed to retrieve updated location information");
@@ -4806,121 +4499,121 @@ var updateLocationInfoUtil = async (db, patientId, data, requesterId) => {
 };
 
 // src/services/patient/utils/medical-stuff.utils.ts
-var import_firestore15 = require("firebase/firestore");
+var import_firestore14 = require("firebase/firestore");
 var addDoctorUtil = async (db, patientId, doctorRef, assignedBy) => {
   var _a;
   const newDoctor = {
     userRef: doctorRef,
-    assignedAt: import_firestore15.Timestamp.now(),
+    assignedAt: import_firestore14.Timestamp.now(),
     assignedBy,
     isActive: true
   };
-  const patientDoc = await (0, import_firestore15.getDoc)(getPatientDocRef(db, patientId));
+  const patientDoc = await (0, import_firestore14.getDoc)(getPatientDocRef(db, patientId));
   if (!patientDoc.exists()) throw new Error("Patient profile not found");
   const patientData = patientDoc.data();
   const existingDoctorIndex = (_a = patientData.doctors) == null ? void 0 : _a.findIndex(
     (d) => d.userRef === doctorRef
   );
   const updates = {
-    updatedAt: (0, import_firestore15.serverTimestamp)(),
-    doctorIds: (0, import_firestore15.arrayUnion)(doctorRef)
+    updatedAt: (0, import_firestore14.serverTimestamp)(),
+    doctorIds: (0, import_firestore14.arrayUnion)(doctorRef)
   };
   if (existingDoctorIndex !== void 0 && existingDoctorIndex > -1) {
     const updatedDoctors = [...patientData.doctors];
     updatedDoctors[existingDoctorIndex] = {
       ...updatedDoctors[existingDoctorIndex],
       isActive: true,
-      assignedAt: import_firestore15.Timestamp.now(),
+      assignedAt: import_firestore14.Timestamp.now(),
       assignedBy
     };
     updates.doctors = updatedDoctors;
   } else {
-    updates.doctors = (0, import_firestore15.arrayUnion)(newDoctor);
+    updates.doctors = (0, import_firestore14.arrayUnion)(newDoctor);
   }
-  await (0, import_firestore15.updateDoc)(getPatientDocRef(db, patientId), updates);
+  await (0, import_firestore14.updateDoc)(getPatientDocRef(db, patientId), updates);
 };
 var removeDoctorUtil = async (db, patientId, doctorRef) => {
   var _a;
   const patientDocRef = getPatientDocRef(db, patientId);
-  const patientDoc = await (0, import_firestore15.getDoc)(patientDocRef);
+  const patientDoc = await (0, import_firestore14.getDoc)(patientDocRef);
   if (!patientDoc.exists()) throw new Error("Patient profile not found");
   const patientData = patientDoc.data();
   const updatedDoctors = ((_a = patientData.doctors) == null ? void 0 : _a.filter((doctor) => doctor.userRef !== doctorRef)) || [];
-  await (0, import_firestore15.updateDoc)(patientDocRef, {
+  await (0, import_firestore14.updateDoc)(patientDocRef, {
     doctors: updatedDoctors,
     // Set the filtered array
-    doctorIds: (0, import_firestore15.arrayRemove)(doctorRef),
+    doctorIds: (0, import_firestore14.arrayRemove)(doctorRef),
     // Remove ID from the denormalized list
-    updatedAt: (0, import_firestore15.serverTimestamp)()
+    updatedAt: (0, import_firestore14.serverTimestamp)()
   });
 };
 var addClinicUtil = async (db, patientId, clinicId, assignedBy) => {
   var _a;
   const newClinic = {
     clinicId,
-    assignedAt: import_firestore15.Timestamp.now(),
+    assignedAt: import_firestore14.Timestamp.now(),
     assignedBy,
     isActive: true
   };
-  const patientDoc = await (0, import_firestore15.getDoc)(getPatientDocRef(db, patientId));
+  const patientDoc = await (0, import_firestore14.getDoc)(getPatientDocRef(db, patientId));
   if (!patientDoc.exists()) throw new Error("Patient profile not found");
   const patientData = patientDoc.data();
   const existingClinicIndex = (_a = patientData.clinics) == null ? void 0 : _a.findIndex(
     (c) => c.clinicId === clinicId
   );
   const updates = {
-    updatedAt: (0, import_firestore15.serverTimestamp)(),
-    clinicIds: (0, import_firestore15.arrayUnion)(clinicId)
+    updatedAt: (0, import_firestore14.serverTimestamp)(),
+    clinicIds: (0, import_firestore14.arrayUnion)(clinicId)
   };
   if (existingClinicIndex !== void 0 && existingClinicIndex > -1) {
     const updatedClinics = [...patientData.clinics];
     updatedClinics[existingClinicIndex] = {
       ...updatedClinics[existingClinicIndex],
       isActive: true,
-      assignedAt: import_firestore15.Timestamp.now(),
+      assignedAt: import_firestore14.Timestamp.now(),
       assignedBy
     };
     updates.clinics = updatedClinics;
   } else {
-    updates.clinics = (0, import_firestore15.arrayUnion)(newClinic);
+    updates.clinics = (0, import_firestore14.arrayUnion)(newClinic);
   }
-  await (0, import_firestore15.updateDoc)(getPatientDocRef(db, patientId), updates);
+  await (0, import_firestore14.updateDoc)(getPatientDocRef(db, patientId), updates);
 };
 var removeClinicUtil = async (db, patientId, clinicId) => {
   var _a;
   const patientDocRef = getPatientDocRef(db, patientId);
-  const patientDoc = await (0, import_firestore15.getDoc)(patientDocRef);
+  const patientDoc = await (0, import_firestore14.getDoc)(patientDocRef);
   if (!patientDoc.exists()) throw new Error("Patient profile not found");
   const patientData = patientDoc.data();
   const updatedClinics = ((_a = patientData.clinics) == null ? void 0 : _a.filter((clinic) => clinic.clinicId !== clinicId)) || [];
-  await (0, import_firestore15.updateDoc)(patientDocRef, {
+  await (0, import_firestore14.updateDoc)(patientDocRef, {
     clinics: updatedClinics,
     // Set the filtered array
-    clinicIds: (0, import_firestore15.arrayRemove)(clinicId),
+    clinicIds: (0, import_firestore14.arrayRemove)(clinicId),
     // Remove ID from the denormalized list
-    updatedAt: (0, import_firestore15.serverTimestamp)()
+    updatedAt: (0, import_firestore14.serverTimestamp)()
   });
 };
 
 // src/services/patient/utils/medical.utils.ts
-var import_firestore16 = require("firebase/firestore");
+var import_firestore15 = require("firebase/firestore");
 var ensureMedicalInfoExists = async (db, patientId, requesterId) => {
   const medicalInfoRef = getMedicalInfoDocRef(db, patientId);
-  const medicalInfoDoc = await (0, import_firestore16.getDoc)(medicalInfoRef);
+  const medicalInfoDoc = await (0, import_firestore15.getDoc)(medicalInfoRef);
   if (!medicalInfoDoc.exists()) {
     const defaultData = {
       ...DEFAULT_MEDICAL_INFO,
       patientId,
-      lastUpdated: (0, import_firestore16.serverTimestamp)(),
+      lastUpdated: (0, import_firestore15.serverTimestamp)(),
       updatedBy: requesterId
       // Koristimo ID onoga ko zahteva akciju
     };
-    await (0, import_firestore16.setDoc)(medicalInfoRef, defaultData);
+    await (0, import_firestore15.setDoc)(medicalInfoRef, defaultData);
   }
 };
 var checkMedicalAccessUtil = async (db, patientId, requesterId, requesterRoles) => {
   var _a;
-  const patientDoc = await (0, import_firestore16.getDoc)(getPatientDocRef(db, patientId));
+  const patientDoc = await (0, import_firestore15.getDoc)(getPatientDocRef(db, patientId));
   if (!patientDoc.exists()) {
     throw new Error("Patient profile not found");
   }
@@ -4960,20 +4653,20 @@ var checkMedicalAccessUtil = async (db, patientId, requesterId, requesterRoles)
 var createMedicalInfoUtil = async (db, patientId, data, requesterId, requesterRoles) => {
   await checkMedicalAccessUtil(db, patientId, requesterId, requesterRoles);
   const validatedData = createPatientMedicalInfoSchema.parse(data);
-  await (0, import_firestore16.setDoc)(getMedicalInfoDocRef(db, patientId), {
+  await (0, import_firestore15.setDoc)(getMedicalInfoDocRef(db, patientId), {
     ...validatedData,
     patientId,
-    lastUpdated: (0, import_firestore16.serverTimestamp)(),
+    lastUpdated: (0, import_firestore15.serverTimestamp)(),
     updatedBy: requesterId
   });
 };
 var getMedicalInfoUtil = async (db, patientId, requesterId, requesterRoles) => {
   await checkMedicalAccessUtil(db, patientId, requesterId, requesterRoles);
   const docRef = getMedicalInfoDocRef(db, patientId);
-  const snapshot = await (0, import_firestore16.getDoc)(docRef);
+  const snapshot = await (0, import_firestore15.getDoc)(docRef);
   if (!snapshot.exists()) {
     await ensureMedicalInfoExists(db, patientId, requesterId);
-    const newSnapshot = await (0, import_firestore16.getDoc)(docRef);
+    const newSnapshot = await (0, import_firestore15.getDoc)(docRef);
     return patientMedicalInfoSchema.parse(newSnapshot.data());
   }
   return patientMedicalInfoSchema.parse(snapshot.data());
@@ -4982,9 +4675,9 @@ var updateVitalStatsUtil = async (db, patientId, data, requesterId, requesterRol
   await checkMedicalAccessUtil(db, patientId, requesterId, requesterRoles);
   await ensureMedicalInfoExists(db, patientId, requesterId);
   const validatedData = updateVitalStatsSchema.parse(data);
-  await (0, import_firestore16.updateDoc)(getMedicalInfoDocRef(db, patientId), {
+  await (0, import_firestore15.updateDoc)(getMedicalInfoDocRef(db, patientId), {
     vitalStats: validatedData,
-    lastUpdated: (0, import_firestore16.serverTimestamp)(),
+    lastUpdated: (0, import_firestore15.serverTimestamp)(),
     updatedBy: requesterId
   });
 };
@@ -4992,9 +4685,9 @@ var addAllergyUtil = async (db, patientId, data, requesterId, requesterRoles) =>
   await checkMedicalAccessUtil(db, patientId, requesterId, requesterRoles);
   await ensureMedicalInfoExists(db, patientId, requesterId);
   const validatedData = addAllergySchema.parse(data);
-  await (0, import_firestore16.updateDoc)(getMedicalInfoDocRef(db, patientId), {
-    allergies: (0, import_firestore16.arrayUnion)(validatedData),
-    lastUpdated: (0, import_firestore16.serverTimestamp)(),
+  await (0, import_firestore15.updateDoc)(getMedicalInfoDocRef(db, patientId), {
+    allergies: (0, import_firestore15.arrayUnion)(validatedData),
+    lastUpdated: (0, import_firestore15.serverTimestamp)(),
     updatedBy: requesterId
   });
 };
@@ -5002,7 +4695,7 @@ var updateAllergyUtil = async (db, patientId, data, requesterId, requesterRoles)
   await checkMedicalAccessUtil(db, patientId, requesterId, requesterRoles);
   const validatedData = updateAllergySchema.parse(data);
   const { allergyIndex, ...updateData } = validatedData;
-  const docSnapshot = await (0, import_firestore16.getDoc)(getMedicalInfoDocRef(db, patientId));
+  const docSnapshot = await (0, import_firestore15.getDoc)(getMedicalInfoDocRef(db, patientId));
   if (!docSnapshot.exists()) throw new Error("Medical info not found");
   const medicalInfo = patientMedicalInfoSchema.parse(docSnapshot.data());
   if (allergyIndex >= medicalInfo.allergies.length) {
@@ -5013,15 +4706,15 @@ var updateAllergyUtil = async (db, patientId, data, requesterId, requesterRoles)
     ...updatedAllergies[allergyIndex],
     ...updateData
   };
-  await (0, import_firestore16.updateDoc)(getMedicalInfoDocRef(db, patientId), {
+  await (0, import_firestore15.updateDoc)(getMedicalInfoDocRef(db, patientId), {
     allergies: updatedAllergies,
-    lastUpdated: (0, import_firestore16.serverTimestamp)(),
+    lastUpdated: (0, import_firestore15.serverTimestamp)(),
     updatedBy: requesterId
   });
 };
 var removeAllergyUtil = async (db, patientId, allergyIndex, requesterId, requesterRoles) => {
   await checkMedicalAccessUtil(db, patientId, requesterId, requesterRoles);
-  const doc37 = await (0, import_firestore16.getDoc)(getMedicalInfoDocRef(db, patientId));
+  const doc37 = await (0, import_firestore15.getDoc)(getMedicalInfoDocRef(db, patientId));
   if (!doc37.exists()) throw new Error("Medical info not found");
   const medicalInfo = doc37.data();
   if (allergyIndex >= medicalInfo.allergies.length) {
@@ -5030,9 +4723,9 @@ var removeAllergyUtil = async (db, patientId, allergyIndex, requesterId, request
   const updatedAllergies = medicalInfo.allergies.filter(
     (_, index) => index !== allergyIndex
   );
-  await (0, import_firestore16.updateDoc)(getMedicalInfoDocRef(db, patientId), {
+  await (0, import_firestore15.updateDoc)(getMedicalInfoDocRef(db, patientId), {
     allergies: updatedAllergies,
-    lastUpdated: (0, import_firestore16.serverTimestamp)(),
+    lastUpdated: (0, import_firestore15.serverTimestamp)(),
     updatedBy: requesterId
   });
 };
@@ -5040,9 +4733,9 @@ var addBlockingConditionUtil = async (db, patientId, data, requesterId, requeste
   await checkMedicalAccessUtil(db, patientId, requesterId, requesterRoles);
   await ensureMedicalInfoExists(db, patientId, requesterId);
   const validatedData = addBlockingConditionSchema.parse(data);
-  await (0, import_firestore16.updateDoc)(getMedicalInfoDocRef(db, patientId), {
-    blockingConditions: (0, import_firestore16.arrayUnion)(validatedData),
-    lastUpdated: (0, import_firestore16.serverTimestamp)(),
+  await (0, import_firestore15.updateDoc)(getMedicalInfoDocRef(db, patientId), {
+    blockingConditions: (0, import_firestore15.arrayUnion)(validatedData),
+    lastUpdated: (0, import_firestore15.serverTimestamp)(),
     updatedBy: requesterId
   });
 };
@@ -5050,7 +4743,7 @@ var updateBlockingConditionUtil = async (db, patientId, data, requesterId, reque
   await checkMedicalAccessUtil(db, patientId, requesterId, requesterRoles);
   const validatedData = updateBlockingConditionSchema.parse(data);
   const { conditionIndex, ...updateData } = validatedData;
-  const doc37 = await (0, import_firestore16.getDoc)(getMedicalInfoDocRef(db, patientId));
+  const doc37 = await (0, import_firestore15.getDoc)(getMedicalInfoDocRef(db, patientId));
   if (!doc37.exists()) throw new Error("Medical info not found");
   const medicalInfo = doc37.data();
   if (conditionIndex >= medicalInfo.blockingConditions.length) {
@@ -5061,15 +4754,15 @@ var updateBlockingConditionUtil = async (db, patientId, data, requesterId, reque
     ...updatedConditions[conditionIndex],
     ...updateData
   };
-  await (0, import_firestore16.updateDoc)(getMedicalInfoDocRef(db, patientId), {
+  await (0, import_firestore15.updateDoc)(getMedicalInfoDocRef(db, patientId), {
     blockingConditions: updatedConditions,
-    lastUpdated: (0, import_firestore16.serverTimestamp)(),
+    lastUpdated: (0, import_firestore15.serverTimestamp)(),
     updatedBy: requesterId
   });
 };
 var removeBlockingConditionUtil = async (db, patientId, conditionIndex, requesterId, requesterRoles) => {
   await checkMedicalAccessUtil(db, patientId, requesterId, requesterRoles);
-  const doc37 = await (0, import_firestore16.getDoc)(getMedicalInfoDocRef(db, patientId));
+  const doc37 = await (0, import_firestore15.getDoc)(getMedicalInfoDocRef(db, patientId));
   if (!doc37.exists()) throw new Error("Medical info not found");
   const medicalInfo = doc37.data();
   if (conditionIndex >= medicalInfo.blockingConditions.length) {
@@ -5078,9 +4771,9 @@ var removeBlockingConditionUtil = async (db, patientId, conditionIndex, requeste
   const updatedConditions = medicalInfo.blockingConditions.filter(
     (_, index) => index !== conditionIndex
   );
-  await (0, import_firestore16.updateDoc)(getMedicalInfoDocRef(db, patientId), {
+  await (0, import_firestore15.updateDoc)(getMedicalInfoDocRef(db, patientId), {
     blockingConditions: updatedConditions,
-    lastUpdated: (0, import_firestore16.serverTimestamp)(),
+    lastUpdated: (0, import_firestore15.serverTimestamp)(),
     updatedBy: requesterId
   });
 };
@@ -5088,9 +4781,9 @@ var addContraindicationUtil = async (db, patientId, data, requesterId, requester
   await checkMedicalAccessUtil(db, patientId, requesterId, requesterRoles);
   await ensureMedicalInfoExists(db, patientId, requesterId);
   const validatedData = addContraindicationSchema.parse(data);
-  await (0, import_firestore16.updateDoc)(getMedicalInfoDocRef(db, patientId), {
-    contraindications: (0, import_firestore16.arrayUnion)(validatedData),
-    lastUpdated: (0, import_firestore16.serverTimestamp)(),
+  await (0, import_firestore15.updateDoc)(getMedicalInfoDocRef(db, patientId), {
+    contraindications: (0, import_firestore15.arrayUnion)(validatedData),
+    lastUpdated: (0, import_firestore15.serverTimestamp)(),
     updatedBy: requesterId
   });
 };
@@ -5098,7 +4791,7 @@ var updateContraindicationUtil = async (db, patientId, data, requesterId, reques
   await checkMedicalAccessUtil(db, patientId, requesterId, requesterRoles);
   const validatedData = updateContraindicationSchema.parse(data);
   const { contraindicationIndex, ...updateData } = validatedData;
-  const doc37 = await (0, import_firestore16.getDoc)(getMedicalInfoDocRef(db, patientId));
+  const doc37 = await (0, import_firestore15.getDoc)(getMedicalInfoDocRef(db, patientId));
   if (!doc37.exists()) throw new Error("Medical info not found");
   const medicalInfo = doc37.data();
   if (contraindicationIndex >= medicalInfo.contraindications.length) {
@@ -5109,15 +4802,15 @@ var updateContraindicationUtil = async (db, patientId, data, requesterId, reques
     ...updatedContraindications[contraindicationIndex],
     ...updateData
   };
-  await (0, import_firestore16.updateDoc)(getMedicalInfoDocRef(db, patientId), {
+  await (0, import_firestore15.updateDoc)(getMedicalInfoDocRef(db, patientId), {
     contraindications: updatedContraindications,
-    lastUpdated: (0, import_firestore16.serverTimestamp)(),
+    lastUpdated: (0, import_firestore15.serverTimestamp)(),
     updatedBy: requesterId
   });
 };
 var removeContraindicationUtil = async (db, patientId, contraindicationIndex, requesterId, requesterRoles) => {
   await checkMedicalAccessUtil(db, patientId, requesterId, requesterRoles);
-  const doc37 = await (0, import_firestore16.getDoc)(getMedicalInfoDocRef(db, patientId));
+  const doc37 = await (0, import_firestore15.getDoc)(getMedicalInfoDocRef(db, patientId));
   if (!doc37.exists()) throw new Error("Medical info not found");
   const medicalInfo = doc37.data();
   if (contraindicationIndex >= medicalInfo.contraindications.length) {
@@ -5126,9 +4819,9 @@ var removeContraindicationUtil = async (db, patientId, contraindicationIndex, re
   const updatedContraindications = medicalInfo.contraindications.filter(
     (_, index) => index !== contraindicationIndex
   );
-  await (0, import_firestore16.updateDoc)(getMedicalInfoDocRef(db, patientId), {
+  await (0, import_firestore15.updateDoc)(getMedicalInfoDocRef(db, patientId), {
     contraindications: updatedContraindications,
-    lastUpdated: (0, import_firestore16.serverTimestamp)(),
+    lastUpdated: (0, import_firestore15.serverTimestamp)(),
     updatedBy: requesterId
   });
 };
@@ -5136,9 +4829,9 @@ var addMedicationUtil = async (db, patientId, data, requesterId, requesterRoles)
   await checkMedicalAccessUtil(db, patientId, requesterId, requesterRoles);
   await ensureMedicalInfoExists(db, patientId, requesterId);
   const validatedData = addMedicationSchema.parse(data);
-  await (0, import_firestore16.updateDoc)(getMedicalInfoDocRef(db, patientId), {
-    currentMedications: (0, import_firestore16.arrayUnion)(validatedData),
-    lastUpdated: (0, import_firestore16.serverTimestamp)(),
+  await (0, import_firestore15.updateDoc)(getMedicalInfoDocRef(db, patientId), {
+    currentMedications: (0, import_firestore15.arrayUnion)(validatedData),
+    lastUpdated: (0, import_firestore15.serverTimestamp)(),
     updatedBy: requesterId
   });
 };
@@ -5146,7 +4839,7 @@ var updateMedicationUtil = async (db, patientId, data, requesterId, requesterRol
   await checkMedicalAccessUtil(db, patientId, requesterId, requesterRoles);
   const validatedData = updateMedicationSchema.parse(data);
   const { medicationIndex, ...updateData } = validatedData;
-  const doc37 = await (0, import_firestore16.getDoc)(getMedicalInfoDocRef(db, patientId));
+  const doc37 = await (0, import_firestore15.getDoc)(getMedicalInfoDocRef(db, patientId));
   if (!doc37.exists()) throw new Error("Medical info not found");
   const medicalInfo = doc37.data();
   if (medicationIndex >= medicalInfo.currentMedications.length) {
@@ -5157,15 +4850,15 @@ var updateMedicationUtil = async (db, patientId, data, requesterId, requesterRol
     ...updatedMedications[medicationIndex],
     ...updateData
   };
-  await (0, import_firestore16.updateDoc)(getMedicalInfoDocRef(db, patientId), {
+  await (0, import_firestore15.updateDoc)(getMedicalInfoDocRef(db, patientId), {
     currentMedications: updatedMedications,
-    lastUpdated: (0, import_firestore16.serverTimestamp)(),
+    lastUpdated: (0, import_firestore15.serverTimestamp)(),
     updatedBy: requesterId
   });
 };
 var removeMedicationUtil = async (db, patientId, medicationIndex, requesterId, requesterRoles) => {
   await checkMedicalAccessUtil(db, patientId, requesterId, requesterRoles);
-  const doc37 = await (0, import_firestore16.getDoc)(getMedicalInfoDocRef(db, patientId));
+  const doc37 = await (0, import_firestore15.getDoc)(getMedicalInfoDocRef(db, patientId));
   if (!doc37.exists()) throw new Error("Medical info not found");
   const medicalInfo = doc37.data();
   if (medicationIndex >= medicalInfo.currentMedications.length) {
@@ -5174,16 +4867,16 @@ var removeMedicationUtil = async (db, patientId, medicationIndex, requesterId, r
   const updatedMedications = medicalInfo.currentMedications.filter(
     (_, index) => index !== medicationIndex
   );
-  await (0, import_firestore16.updateDoc)(getMedicalInfoDocRef(db, patientId), {
+  await (0, import_firestore15.updateDoc)(getMedicalInfoDocRef(db, patientId), {
     currentMedications: updatedMedications,
-    lastUpdated: (0, import_firestore16.serverTimestamp)(),
+    lastUpdated: (0, import_firestore15.serverTimestamp)(),
     updatedBy: requesterId
   });
 };
 
 // src/services/patient/utils/profile.utils.ts
-var import_firestore17 = require("firebase/firestore");
-var import_zod16 = require("zod");
+var import_firestore16 = require("firebase/firestore");
+var import_zod13 = require("zod");
 var createPatientProfileUtil = async (db, data, generateId2) => {
   var _a, _b;
   try {
@@ -5212,15 +4905,15 @@ var createPatientProfileUtil = async (db, data, generateId2) => {
       clinics: validatedData.clinics || [],
       doctorIds: ((_a = validatedData.doctors) == null ? void 0 : _a.map((d) => d.userRef)) || [],
       clinicIds: ((_b = validatedData.clinics) == null ? void 0 : _b.map((c) => c.clinicId)) || [],
-      createdAt: (0, import_firestore17.serverTimestamp)(),
-      updatedAt: (0, import_firestore17.serverTimestamp)()
+      createdAt: (0, import_firestore16.serverTimestamp)(),
+      updatedAt: (0, import_firestore16.serverTimestamp)()
     };
     patientProfileSchema.parse({
       ...patientData,
-      createdAt: import_firestore17.Timestamp.now(),
-      updatedAt: import_firestore17.Timestamp.now()
+      createdAt: import_firestore16.Timestamp.now(),
+      updatedAt: import_firestore16.Timestamp.now()
     });
-    await (0, import_firestore17.setDoc)(getPatientDocRef(db, patientId), patientData);
+    await (0, import_firestore16.setDoc)(getPatientDocRef(db, patientId), patientData);
     console.log(`[createPatientProfileUtil] Creating sensitive info document`);
     let sensitiveInfoSuccess = false;
     try {
@@ -5270,7 +4963,7 @@ var createPatientProfileUtil = async (db, data, generateId2) => {
       }
     }
     console.log(`[createPatientProfileUtil] Verifying patient document exists`);
-    const patientDoc = await (0, import_firestore17.getDoc)(getPatientDocRef(db, patientId));
+    const patientDoc = await (0, import_firestore16.getDoc)(getPatientDocRef(db, patientId));
     if (!patientDoc.exists()) {
       console.error(
         `[createPatientProfileUtil] Patient document not found after creation`
@@ -5286,51 +4979,51 @@ var createPatientProfileUtil = async (db, data, generateId2) => {
       `[createPatientProfileUtil] Error in patient profile creation:`,
       error
     );
-    if (error instanceof import_zod16.z.ZodError) {
+    if (error instanceof import_zod13.z.ZodError) {
       throw new Error("Invalid patient data: " + error.message);
     }
     throw error;
   }
 };
 var getPatientProfileUtil = async (db, patientId) => {
-  const patientDoc = await (0, import_firestore17.getDoc)(getPatientDocRef(db, patientId));
+  const patientDoc = await (0, import_firestore16.getDoc)(getPatientDocRef(db, patientId));
   return patientDoc.exists() ? patientDoc.data() : null;
 };
 var getPatientProfileByUserRefUtil = async (db, userRef) => {
   try {
     const docRef = await getPatientDocRefByUserRef(db, userRef);
-    const patientDoc = await (0, import_firestore17.getDoc)(docRef);
+    const patientDoc = await (0, import_firestore16.getDoc)(docRef);
     return patientDoc.exists() ? patientDoc.data() : null;
   } catch (error) {
     return null;
   }
 };
 var addExpoTokenUtil = async (db, patientId, token) => {
-  await (0, import_firestore17.updateDoc)(getPatientDocRef(db, patientId), {
-    expoTokens: (0, import_firestore17.arrayUnion)(token),
-    updatedAt: (0, import_firestore17.serverTimestamp)()
+  await (0, import_firestore16.updateDoc)(getPatientDocRef(db, patientId), {
+    expoTokens: (0, import_firestore16.arrayUnion)(token),
+    updatedAt: (0, import_firestore16.serverTimestamp)()
   });
 };
 var removeExpoTokenUtil = async (db, patientId, token) => {
-  await (0, import_firestore17.updateDoc)(getPatientDocRef(db, patientId), {
-    expoTokens: (0, import_firestore17.arrayRemove)(token),
-    updatedAt: (0, import_firestore17.serverTimestamp)()
+  await (0, import_firestore16.updateDoc)(getPatientDocRef(db, patientId), {
+    expoTokens: (0, import_firestore16.arrayRemove)(token),
+    updatedAt: (0, import_firestore16.serverTimestamp)()
   });
 };
 var addPointsUtil = async (db, patientId, points) => {
-  await (0, import_firestore17.updateDoc)(getPatientDocRef(db, patientId), {
-    "gamification.points": (0, import_firestore17.increment)(points),
-    updatedAt: (0, import_firestore17.serverTimestamp)()
+  await (0, import_firestore16.updateDoc)(getPatientDocRef(db, patientId), {
+    "gamification.points": (0, import_firestore16.increment)(points),
+    updatedAt: (0, import_firestore16.serverTimestamp)()
   });
 };
 var updatePatientProfileUtil = async (db, patientId, data) => {
   try {
     const updateData = {
       ...data,
-      updatedAt: (0, import_firestore17.serverTimestamp)()
+      updatedAt: (0, import_firestore16.serverTimestamp)()
     };
-    await (0, import_firestore17.updateDoc)(getPatientDocRef(db, patientId), updateData);
-    const updatedDoc = await (0, import_firestore17.getDoc)(getPatientDocRef(db, patientId));
+    await (0, import_firestore16.updateDoc)(getPatientDocRef(db, patientId), updateData);
+    const updatedDoc = await (0, import_firestore16.getDoc)(getPatientDocRef(db, patientId));
     if (!updatedDoc.exists()) {
       throw new Error("Patient profile not found after update");
     }
@@ -5343,7 +5036,7 @@ var updatePatientProfileUtil = async (db, patientId, data) => {
 var updatePatientProfileByUserRefUtil = async (db, userRef, data) => {
   try {
     const docRef = await getPatientDocRefByUserRef(db, userRef);
-    const patientDoc = await (0, import_firestore17.getDoc)(docRef);
+    const patientDoc = await (0, import_firestore16.getDoc)(docRef);
     if (!patientDoc.exists()) {
       throw new Error("Patient profile not found");
     }
@@ -5372,14 +5065,14 @@ var testCreateSubDocuments = async (db, patientId, userRef) => {
       photoUrl: "",
       firstName: "Name",
       lastName: "Surname",
-      dateOfBirth: import_firestore17.Timestamp.now(),
+      dateOfBirth: import_firestore16.Timestamp.now(),
       gender: "prefer_not_to_say" /* PREFER_NOT_TO_SAY */,
       email: "test@example.com",
       phoneNumber: "",
-      createdAt: import_firestore17.Timestamp.now(),
-      updatedAt: import_firestore17.Timestamp.now()
+      createdAt: import_firestore16.Timestamp.now(),
+      updatedAt: import_firestore16.Timestamp.now()
     };
-    await (0, import_firestore17.setDoc)(sensitiveInfoRef, defaultSensitiveInfo);
+    await (0, import_firestore16.setDoc)(sensitiveInfoRef, defaultSensitiveInfo);
     console.log(
       `[testCreateSubDocuments] Sensitive info document created directly`
     );
@@ -5391,10 +5084,10 @@ var testCreateSubDocuments = async (db, patientId, userRef) => {
     const defaultMedicalInfo = {
       ...DEFAULT_MEDICAL_INFO,
       patientId,
-      lastUpdated: import_firestore17.Timestamp.now(),
+      lastUpdated: import_firestore16.Timestamp.now(),
       updatedBy: userRef
     };
-    await (0, import_firestore17.setDoc)(medicalInfoRef, defaultMedicalInfo);
+    await (0, import_firestore16.setDoc)(medicalInfoRef, defaultMedicalInfo);
     console.log(
       `[testCreateSubDocuments] Medical info document created directly`
     );
@@ -5408,7 +5101,7 @@ var searchPatientsUtil = async (db, params, requester) => {
   searchPatientsSchema.parse(params);
   requesterInfoSchema.parse(requester);
   const constraints = [];
-  const patientsCollectionRef = (0, import_firestore17.collection)(db, PATIENTS_COLLECTION);
+  const patientsCollectionRef = (0, import_firestore16.collection)(db, PATIENTS_COLLECTION);
   if (requester.role === "clinic_admin") {
     if (!requester.associatedClinicId) {
       throw new Error(
@@ -5422,11 +5115,11 @@ var searchPatientsUtil = async (db, params, requester) => {
       return [];
     }
     constraints.push(
-      (0, import_firestore17.where)("clinicIds", "array-contains", requester.associatedClinicId)
+      (0, import_firestore16.where)("clinicIds", "array-contains", requester.associatedClinicId)
     );
     if (params.practitionerId) {
       constraints.push(
-        (0, import_firestore17.where)("doctorIds", "array-contains", params.practitionerId)
+        (0, import_firestore16.where)("doctorIds", "array-contains", params.practitionerId)
       );
     }
   } else if (requester.role === "practitioner") {
@@ -5442,17 +5135,17 @@ var searchPatientsUtil = async (db, params, requester) => {
       return [];
     }
     constraints.push(
-      (0, import_firestore17.where)("doctorIds", "array-contains", requester.associatedPractitionerId)
+      (0, import_firestore16.where)("doctorIds", "array-contains", requester.associatedPractitionerId)
     );
     if (params.clinicId) {
-      constraints.push((0, import_firestore17.where)("clinicIds", "array-contains", params.clinicId));
+      constraints.push((0, import_firestore16.where)("clinicIds", "array-contains", params.clinicId));
     }
   } else {
     throw new Error("Invalid requester role.");
   }
   try {
-    const finalQuery = (0, import_firestore17.query)(patientsCollectionRef, ...constraints);
-    const querySnapshot = await (0, import_firestore17.getDocs)(finalQuery);
+    const finalQuery = (0, import_firestore16.query)(patientsCollectionRef, ...constraints);
+    const querySnapshot = await (0, import_firestore16.getDocs)(finalQuery);
     const patients = querySnapshot.docs.map(
       (doc37) => doc37.data()
     );
@@ -5471,20 +5164,20 @@ var getAllPatientsUtil = async (db, options) => {
       `[getAllPatientsUtil] Fetching patients with options:`,
       options
     );
-    const patientsCollection = (0, import_firestore17.collection)(db, PATIENTS_COLLECTION);
-    let q = (0, import_firestore17.query)(patientsCollection);
+    const patientsCollection = (0, import_firestore16.collection)(db, PATIENTS_COLLECTION);
+    let q = (0, import_firestore16.query)(patientsCollection);
     if (options == null ? void 0 : options.limit) {
-      q = (0, import_firestore17.query)(q, (0, import_firestore17.limit)(options.limit));
+      q = (0, import_firestore16.query)(q, (0, import_firestore16.limit)(options.limit));
     }
     if (options == null ? void 0 : options.startAfter) {
-      const startAfterDoc = await (0, import_firestore17.getDoc)(
-        (0, import_firestore17.doc)(db, PATIENTS_COLLECTION, options.startAfter)
+      const startAfterDoc = await (0, import_firestore16.getDoc)(
+        (0, import_firestore16.doc)(db, PATIENTS_COLLECTION, options.startAfter)
       );
       if (startAfterDoc.exists()) {
-        q = (0, import_firestore17.query)(q, (0, import_firestore17.startAfter)(startAfterDoc));
+        q = (0, import_firestore16.query)(q, (0, import_firestore16.startAfter)(startAfterDoc));
       }
     }
-    const patientsSnapshot = await (0, import_firestore17.getDocs)(q);
+    const patientsSnapshot = await (0, import_firestore16.getDocs)(q);
     const patients = [];
     patientsSnapshot.forEach((doc37) => {
       patients.push(doc37.data());
@@ -5500,31 +5193,31 @@ var getAllPatientsUtil = async (db, options) => {
 };
 
 // src/services/patient/utils/token.utils.ts
-var import_firestore18 = require("firebase/firestore");
+var import_firestore17 = require("firebase/firestore");
 
 // src/validations/patient/token.schema.ts
-var import_zod17 = require("zod");
-var patientTokenSchema = import_zod17.z.object({
-  id: import_zod17.z.string().min(1, "Token ID is required"),
-  token: import_zod17.z.string().min(1, "Token string is required"),
-  patientId: import_zod17.z.string().min(1, "Patient ID is required"),
-  email: import_zod17.z.string().email("Invalid email format"),
-  clinicId: import_zod17.z.string().min(1, "Clinic ID is required"),
-  status: import_zod17.z.nativeEnum(PatientTokenStatus),
-  createdBy: import_zod17.z.string().min(1, "Creator ID is required"),
-  createdAt: import_zod17.z.any(),
+var import_zod14 = require("zod");
+var patientTokenSchema = import_zod14.z.object({
+  id: import_zod14.z.string().min(1, "Token ID is required"),
+  token: import_zod14.z.string().min(1, "Token string is required"),
+  patientId: import_zod14.z.string().min(1, "Patient ID is required"),
+  email: import_zod14.z.string().email("Invalid email format"),
+  clinicId: import_zod14.z.string().min(1, "Clinic ID is required"),
+  status: import_zod14.z.nativeEnum(PatientTokenStatus),
+  createdBy: import_zod14.z.string().min(1, "Creator ID is required"),
+  createdAt: import_zod14.z.any(),
   // Assuming Timestamp validated elsewhere
-  expiresAt: import_zod17.z.any(),
+  expiresAt: import_zod14.z.any(),
   // Assuming Timestamp validated elsewhere
-  usedBy: import_zod17.z.string().optional(),
-  usedAt: import_zod17.z.any().optional()
+  usedBy: import_zod14.z.string().optional(),
+  usedAt: import_zod14.z.any().optional()
   // Assuming Timestamp validated elsewhere
 });
-var createPatientTokenSchema = import_zod17.z.object({
-  patientId: import_zod17.z.string().min(1, "Patient ID is required"),
-  clinicId: import_zod17.z.string().min(1, "Clinic ID is required"),
-  email: import_zod17.z.string().email("Invalid email format"),
-  expiresAt: import_zod17.z.date().optional()
+var createPatientTokenSchema = import_zod14.z.object({
+  patientId: import_zod14.z.string().min(1, "Patient ID is required"),
+  clinicId: import_zod14.z.string().min(1, "Clinic ID is required"),
+  email: import_zod14.z.string().email("Invalid email format"),
+  expiresAt: import_zod14.z.date().optional()
 });
 
 // src/services/patient/utils/token.utils.ts
@@ -5532,7 +5225,7 @@ var createPatientTokenUtil = async (db, data, createdBy, generateId2) => {
   var _a;
   const validatedData = createPatientTokenSchema.parse(data);
   const patientRef = getPatientDocRef(db, validatedData.patientId);
-  const patientDoc = await (0, import_firestore18.getDoc)(patientRef);
+  const patientDoc = await (0, import_firestore17.getDoc)(patientRef);
   if (!patientDoc.exists() || !((_a = patientDoc.data()) == null ? void 0 : _a.isManual)) {
     throw new Error(
       "Patient profile not found or is not a manually created profile."
@@ -5548,36 +5241,36 @@ var createPatientTokenUtil = async (db, data, createdBy, generateId2) => {
     clinicId: validatedData.clinicId,
     status: "active" /* ACTIVE */,
     createdBy,
-    createdAt: import_firestore18.Timestamp.now(),
-    expiresAt: import_firestore18.Timestamp.fromDate(expiration)
+    createdAt: import_firestore17.Timestamp.now(),
+    expiresAt: import_firestore17.Timestamp.fromDate(expiration)
   };
   patientTokenSchema.parse(token);
-  const tokenRef = (0, import_firestore18.doc)(
+  const tokenRef = (0, import_firestore17.doc)(
     db,
     PATIENTS_COLLECTION,
     validatedData.patientId,
     INVITE_TOKENS_COLLECTION,
     token.id
   );
-  await (0, import_firestore18.setDoc)(tokenRef, token);
+  await (0, import_firestore17.setDoc)(tokenRef, token);
   return token;
 };
 var validatePatientTokenUtil = async (db, tokenString) => {
-  const patientsRef = (0, import_firestore18.collection)(db, PATIENTS_COLLECTION);
-  const patientsSnapshot = await (0, import_firestore18.getDocs)(patientsRef);
+  const patientsRef = (0, import_firestore17.collection)(db, PATIENTS_COLLECTION);
+  const patientsSnapshot = await (0, import_firestore17.getDocs)(patientsRef);
   for (const patientDoc of patientsSnapshot.docs) {
-    const tokensRef = (0, import_firestore18.collection)(
+    const tokensRef = (0, import_firestore17.collection)(
       db,
       patientDoc.ref.path,
       INVITE_TOKENS_COLLECTION
     );
-    const q = (0, import_firestore18.query)(
+    const q = (0, import_firestore17.query)(
       tokensRef,
-      (0, import_firestore18.where)("token", "==", tokenString),
-      (0, import_firestore18.where)("status", "==", "active" /* ACTIVE */),
-      (0, import_firestore18.where)("expiresAt", ">", import_firestore18.Timestamp.now())
+      (0, import_firestore17.where)("token", "==", tokenString),
+      (0, import_firestore17.where)("status", "==", "active" /* ACTIVE */),
+      (0, import_firestore17.where)("expiresAt", ">", import_firestore17.Timestamp.now())
     );
-    const tokenSnapshot = await (0, import_firestore18.getDocs)(q);
+    const tokenSnapshot = await (0, import_firestore17.getDocs)(q);
     if (!tokenSnapshot.empty) {
       return tokenSnapshot.docs[0].data();
     }
@@ -5585,45 +5278,45 @@ var validatePatientTokenUtil = async (db, tokenString) => {
   return null;
 };
 var markPatientTokenAsUsedUtil = async (db, tokenId, patientId, userId) => {
-  const tokenRef = (0, import_firestore18.doc)(
+  const tokenRef = (0, import_firestore17.doc)(
     db,
     PATIENTS_COLLECTION,
     patientId,
     INVITE_TOKENS_COLLECTION,
     tokenId
   );
-  await (0, import_firestore18.updateDoc)(tokenRef, {
+  await (0, import_firestore17.updateDoc)(tokenRef, {
     status: "used" /* USED */,
     usedBy: userId,
-    usedAt: import_firestore18.Timestamp.now()
+    usedAt: import_firestore17.Timestamp.now()
   });
 };
 var getActiveInviteTokensByClinicUtil = async (db, clinicId) => {
-  const tokensQuery = (0, import_firestore18.query)(
-    (0, import_firestore18.collectionGroup)(db, INVITE_TOKENS_COLLECTION),
-    (0, import_firestore18.where)("clinicId", "==", clinicId),
-    (0, import_firestore18.where)("status", "==", "active" /* ACTIVE */),
-    (0, import_firestore18.where)("expiresAt", ">", import_firestore18.Timestamp.now())
+  const tokensQuery = (0, import_firestore17.query)(
+    (0, import_firestore17.collectionGroup)(db, INVITE_TOKENS_COLLECTION),
+    (0, import_firestore17.where)("clinicId", "==", clinicId),
+    (0, import_firestore17.where)("status", "==", "active" /* ACTIVE */),
+    (0, import_firestore17.where)("expiresAt", ">", import_firestore17.Timestamp.now())
   );
-  const querySnapshot = await (0, import_firestore18.getDocs)(tokensQuery);
+  const querySnapshot = await (0, import_firestore17.getDocs)(tokensQuery);
   if (querySnapshot.empty) {
     return [];
   }
   return querySnapshot.docs.map((doc37) => doc37.data());
 };
 var getActiveInviteTokensByPatientUtil = async (db, patientId) => {
-  const tokensRef = (0, import_firestore18.collection)(
+  const tokensRef = (0, import_firestore17.collection)(
     db,
     PATIENTS_COLLECTION,
     patientId,
     INVITE_TOKENS_COLLECTION
   );
-  const q = (0, import_firestore18.query)(
+  const q = (0, import_firestore17.query)(
     tokensRef,
-    (0, import_firestore18.where)("status", "==", "active" /* ACTIVE */),
-    (0, import_firestore18.where)("expiresAt", ">", import_firestore18.Timestamp.now())
+    (0, import_firestore17.where)("status", "==", "active" /* ACTIVE */),
+    (0, import_firestore17.where)("expiresAt", ">", import_firestore17.Timestamp.now())
   );
-  const querySnapshot = await (0, import_firestore18.getDocs)(q);
+  const querySnapshot = await (0, import_firestore17.getDocs)(q);
   if (querySnapshot.empty) {
     return [];
   }
@@ -5663,8 +5356,8 @@ var PatientService = class extends BaseService {
       );
     }
     const patientId = this.generateId();
-    const batch = (0, import_firestore19.writeBatch)(this.db);
-    const now = import_firestore20.Timestamp.now();
+    const batch = (0, import_firestore18.writeBatch)(this.db);
+    const now = import_firestore19.Timestamp.now();
     const patientProfileRef = getPatientDocRef(this.db, patientId);
     const newProfile = {
       id: patientId,
@@ -5989,8 +5682,8 @@ var PatientService = class extends BaseService {
     if (!this.auth.currentUser) {
       throw new Error("No authenticated user");
     }
-    const userDoc = await (0, import_firestore19.getDoc)(
-      (0, import_firestore19.doc)(this.db, "users", this.auth.currentUser.uid)
+    const userDoc = await (0, import_firestore18.getDoc)(
+      (0, import_firestore18.doc)(this.db, "users", this.auth.currentUser.uid)
     );
     if (!userDoc.exists()) {
       throw new Error("User not found");
@@ -6001,7 +5694,7 @@ var PatientService = class extends BaseService {
    * Briše profil pacijenta i sve povezane subkolekcije
    */
   async deletePatientProfile(patientId) {
-    const batch = (0, import_firestore19.writeBatch)(this.db);
+    const batch = (0, import_firestore18.writeBatch)(this.db);
     batch.delete(getSensitiveInfoDocRef(this.db, patientId));
     batch.delete(getLocationInfoDocRef(this.db, patientId));
     batch.delete(getMedicalInfoDocRef(this.db, patientId));
@@ -6044,9 +5737,9 @@ var PatientService = class extends BaseService {
       "patient_profile_photos",
       file instanceof File ? file.name : `profile_photo_${patientId}`
     );
-    await (0, import_firestore19.updateDoc)(getSensitiveInfoDocRef(this.db, patientId), {
+    await (0, import_firestore18.updateDoc)(getSensitiveInfoDocRef(this.db, patientId), {
       photoUrl: mediaMetadata.url,
-      updatedAt: (0, import_firestore19.serverTimestamp)()
+      updatedAt: (0, import_firestore18.serverTimestamp)()
     });
     return mediaMetadata.url;
   }
@@ -6109,9 +5802,9 @@ var PatientService = class extends BaseService {
           error
         );
       }
-      await (0, import_firestore19.updateDoc)(getSensitiveInfoDocRef(this.db, patientId), {
+      await (0, import_firestore18.updateDoc)(getSensitiveInfoDocRef(this.db, patientId), {
         photoUrl: null,
-        updatedAt: (0, import_firestore19.serverTimestamp)()
+        updatedAt: (0, import_firestore18.serverTimestamp)()
       });
     }
   }
@@ -6412,7 +6105,169 @@ var ClinicAdminService = class extends BaseService {
 
 // src/services/practitioner/practitioner.service.ts
 var import_firestore21 = require("firebase/firestore");
-var import_zod18 = require("zod");
+
+// src/validations/practitioner.schema.ts
+var import_zod15 = require("zod");
+var import_firestore20 = require("firebase/firestore");
+
+// src/backoffice/types/static/certification.types.ts
+var CertificationLevel = /* @__PURE__ */ ((CertificationLevel2) => {
+  CertificationLevel2["AESTHETICIAN"] = "aesthetician";
+  CertificationLevel2["NURSE_ASSISTANT"] = "nurse_assistant";
+  CertificationLevel2["NURSE"] = "nurse";
+  CertificationLevel2["NURSE_PRACTITIONER"] = "nurse_practitioner";
+  CertificationLevel2["PHYSICIAN_ASSISTANT"] = "physician_assistant";
+  CertificationLevel2["DOCTOR"] = "doctor";
+  CertificationLevel2["SPECIALIST"] = "specialist";
+  CertificationLevel2["PLASTIC_SURGEON"] = "plastic_surgeon";
+  return CertificationLevel2;
+})(CertificationLevel || {});
+var CertificationSpecialty = /* @__PURE__ */ ((CertificationSpecialty3) => {
+  CertificationSpecialty3["LASER"] = "laser";
+  CertificationSpecialty3["INJECTABLES"] = "injectables";
+  CertificationSpecialty3["CHEMICAL_PEELS"] = "chemical_peels";
+  CertificationSpecialty3["MICRODERMABRASION"] = "microdermabrasion";
+  CertificationSpecialty3["BODY_CONTOURING"] = "body_contouring";
+  CertificationSpecialty3["SKIN_CARE"] = "skin_care";
+  CertificationSpecialty3["WOUND_CARE"] = "wound_care";
+  CertificationSpecialty3["ANESTHESIA"] = "anesthesia";
+  return CertificationSpecialty3;
+})(CertificationSpecialty || {});
+
+// src/validations/practitioner.schema.ts
+var practitionerBasicInfoSchema = import_zod15.z.object({
+  firstName: import_zod15.z.string().min(2).max(50),
+  lastName: import_zod15.z.string().min(2).max(50),
+  title: import_zod15.z.string().min(2).max(100),
+  email: import_zod15.z.string().email(),
+  phoneNumber: import_zod15.z.string().regex(/^\+?[1-9]\d{1,14}$/, "Invalid phone number").nullable(),
+  dateOfBirth: import_zod15.z.instanceof(import_firestore20.Timestamp).or(import_zod15.z.date()).nullable(),
+  gender: import_zod15.z.enum(["male", "female", "other"]),
+  profileImageUrl: mediaResourceSchema.optional().nullable(),
+  bio: import_zod15.z.string().max(1e3).optional(),
+  languages: import_zod15.z.array(import_zod15.z.string()).min(1)
+});
+var practitionerCertificationSchema = import_zod15.z.object({
+  level: import_zod15.z.nativeEnum(CertificationLevel),
+  specialties: import_zod15.z.array(import_zod15.z.nativeEnum(CertificationSpecialty)),
+  licenseNumber: import_zod15.z.string().min(3).max(50),
+  issuingAuthority: import_zod15.z.string().min(2).max(100),
+  issueDate: import_zod15.z.instanceof(import_firestore20.Timestamp).or(import_zod15.z.date()),
+  expiryDate: import_zod15.z.instanceof(import_firestore20.Timestamp).or(import_zod15.z.date()).optional().nullable(),
+  verificationStatus: import_zod15.z.enum(["pending", "verified", "rejected"])
+});
+var timeSlotSchema = import_zod15.z.object({
+  start: import_zod15.z.string().regex(/^([01]\d|2[0-3]):([0-5]\d)$/, "Invalid time format"),
+  end: import_zod15.z.string().regex(/^([01]\d|2[0-3]):([0-5]\d)$/, "Invalid time format")
+}).nullable();
+var practitionerWorkingHoursSchema = import_zod15.z.object({
+  practitionerId: import_zod15.z.string().min(1),
+  clinicId: import_zod15.z.string().min(1),
+  monday: timeSlotSchema,
+  tuesday: timeSlotSchema,
+  wednesday: timeSlotSchema,
+  thursday: timeSlotSchema,
+  friday: timeSlotSchema,
+  saturday: timeSlotSchema,
+  sunday: timeSlotSchema,
+  createdAt: import_zod15.z.instanceof(import_firestore20.Timestamp).or(import_zod15.z.date()),
+  updatedAt: import_zod15.z.instanceof(import_firestore20.Timestamp).or(import_zod15.z.date())
+});
+var practitionerClinicWorkingHoursSchema = import_zod15.z.object({
+  clinicId: import_zod15.z.string().min(1),
+  workingHours: import_zod15.z.object({
+    monday: timeSlotSchema,
+    tuesday: timeSlotSchema,
+    wednesday: timeSlotSchema,
+    thursday: timeSlotSchema,
+    friday: timeSlotSchema,
+    saturday: timeSlotSchema,
+    sunday: timeSlotSchema
+  }),
+  isActive: import_zod15.z.boolean(),
+  createdAt: import_zod15.z.instanceof(import_firestore20.Timestamp).or(import_zod15.z.date()),
+  updatedAt: import_zod15.z.instanceof(import_firestore20.Timestamp).or(import_zod15.z.date())
+});
+var practitionerSchema = import_zod15.z.object({
+  id: import_zod15.z.string().min(1),
+  userRef: import_zod15.z.string().min(1),
+  basicInfo: practitionerBasicInfoSchema,
+  certification: practitionerCertificationSchema,
+  clinics: import_zod15.z.array(import_zod15.z.string()),
+  clinicWorkingHours: import_zod15.z.array(practitionerClinicWorkingHoursSchema),
+  clinicsInfo: import_zod15.z.array(clinicInfoSchema),
+  procedures: import_zod15.z.array(import_zod15.z.string()),
+  freeConsultations: import_zod15.z.record(import_zod15.z.string(), import_zod15.z.string()).optional().nullable(),
+  proceduresInfo: import_zod15.z.array(procedureSummaryInfoSchema),
+  reviewInfo: practitionerReviewInfoSchema,
+  isActive: import_zod15.z.boolean(),
+  isVerified: import_zod15.z.boolean(),
+  status: import_zod15.z.nativeEnum(PractitionerStatus),
+  createdAt: import_zod15.z.instanceof(import_firestore20.Timestamp).or(import_zod15.z.date()),
+  updatedAt: import_zod15.z.instanceof(import_firestore20.Timestamp).or(import_zod15.z.date())
+});
+var createPractitionerSchema = import_zod15.z.object({
+  userRef: import_zod15.z.string().min(1),
+  basicInfo: practitionerBasicInfoSchema,
+  certification: practitionerCertificationSchema,
+  clinics: import_zod15.z.array(import_zod15.z.string()).optional(),
+  clinicWorkingHours: import_zod15.z.array(practitionerClinicWorkingHoursSchema).optional(),
+  clinicsInfo: import_zod15.z.array(clinicInfoSchema).optional(),
+  freeConsultations: import_zod15.z.record(import_zod15.z.string(), import_zod15.z.string()).optional().nullable(),
+  proceduresInfo: import_zod15.z.array(procedureSummaryInfoSchema).optional(),
+  isActive: import_zod15.z.boolean(),
+  isVerified: import_zod15.z.boolean(),
+  status: import_zod15.z.nativeEnum(PractitionerStatus).optional()
+});
+var createDraftPractitionerSchema = import_zod15.z.object({
+  basicInfo: practitionerBasicInfoSchema,
+  certification: practitionerCertificationSchema,
+  clinics: import_zod15.z.array(import_zod15.z.string()).optional(),
+  clinicWorkingHours: import_zod15.z.array(practitionerClinicWorkingHoursSchema).optional(),
+  clinicsInfo: import_zod15.z.array(clinicInfoSchema).optional(),
+  freeConsultations: import_zod15.z.record(import_zod15.z.string(), import_zod15.z.string()).optional().nullable(),
+  proceduresInfo: import_zod15.z.array(procedureSummaryInfoSchema).optional(),
+  isActive: import_zod15.z.boolean().optional().default(false),
+  isVerified: import_zod15.z.boolean().optional().default(false)
+});
+var practitionerTokenSchema = import_zod15.z.object({
+  id: import_zod15.z.string().min(1),
+  token: import_zod15.z.string().min(6),
+  practitionerId: import_zod15.z.string().min(1),
+  email: import_zod15.z.string().email(),
+  clinicId: import_zod15.z.string().min(1),
+  status: import_zod15.z.nativeEnum(PractitionerTokenStatus),
+  createdBy: import_zod15.z.string().min(1),
+  createdAt: import_zod15.z.instanceof(import_firestore20.Timestamp).or(import_zod15.z.date()),
+  expiresAt: import_zod15.z.instanceof(import_firestore20.Timestamp).or(import_zod15.z.date()),
+  usedBy: import_zod15.z.string().optional(),
+  usedAt: import_zod15.z.instanceof(import_firestore20.Timestamp).or(import_zod15.z.date()).optional()
+});
+var createPractitionerTokenSchema = import_zod15.z.object({
+  practitionerId: import_zod15.z.string().min(1),
+  email: import_zod15.z.string().email(),
+  clinicId: import_zod15.z.string().min(1),
+  expiresAt: import_zod15.z.date().optional()
+});
+var practitionerSignupSchema = import_zod15.z.object({
+  email: import_zod15.z.string().email(),
+  password: import_zod15.z.string().min(8),
+  firstName: import_zod15.z.string().min(2).max(50).optional(),
+  lastName: import_zod15.z.string().min(2).max(50).optional(),
+  token: import_zod15.z.string().optional(),
+  profileData: import_zod15.z.object({
+    basicInfo: import_zod15.z.object({
+      phoneNumber: import_zod15.z.string().optional(),
+      profileImageUrl: mediaResourceSchema.optional(),
+      gender: import_zod15.z.enum(["male", "female", "other"]).optional(),
+      bio: import_zod15.z.string().optional()
+    }).optional(),
+    certification: import_zod15.z.any().optional()
+  }).optional()
+});
+
+// src/services/practitioner/practitioner.service.ts
+var import_zod16 = require("zod");
 var import_geofire_common2 = require("geofire-common");
 var PractitionerService = class extends BaseService {
   constructor(db, auth, app, clinicService, procedureService) {
@@ -6542,7 +6397,7 @@ var PractitionerService = class extends BaseService {
       }
       return createdPractitioner;
     } catch (error) {
-      if (error instanceof import_zod18.z.ZodError) {
+      if (error instanceof import_zod16.z.ZodError) {
         throw new Error(`Invalid practitioner data: ${error.message}`);
       }
       console.error("Error creating practitioner:", error);
@@ -6658,7 +6513,7 @@ var PractitionerService = class extends BaseService {
       await (0, import_firestore21.setDoc)((0, import_firestore21.doc)(this.db, tokenPath), token);
       return { practitioner: savedPractitioner, token };
     } catch (error) {
-      if (error instanceof import_zod18.z.ZodError) {
+      if (error instanceof import_zod16.z.ZodError) {
         throw new Error("Invalid practitioner data: " + error.message);
       }
       throw error;
@@ -6711,7 +6566,7 @@ var PractitionerService = class extends BaseService {
       await (0, import_firestore21.setDoc)((0, import_firestore21.doc)(this.db, tokenPath), token);
       return token;
     } catch (error) {
-      if (error instanceof import_zod18.z.ZodError) {
+      if (error instanceof import_zod16.z.ZodError) {
         throw new Error("Invalid token data: " + error.message);
       }
       throw error;
@@ -6905,7 +6760,7 @@ var PractitionerService = class extends BaseService {
       }
       return updatedPractitioner;
     } catch (error) {
-      if (error instanceof import_zod18.z.ZodError) {
+      if (error instanceof import_zod16.z.ZodError) {
         throw new Error(`Invalid practitioner update data: ${error.message}`);
       }
       console.error(`Error updating practitioner ${practitionerId}:`, error);
@@ -7688,7 +7543,7 @@ var UserService = class extends BaseService {
       });
       return this.getUserById(uid);
     } catch (error) {
-      if (error instanceof import_zod19.z.ZodError) {
+      if (error instanceof import_zod17.z.ZodError) {
         throw USER_ERRORS.VALIDATION_ERROR;
       }
       throw error;
@@ -7775,7 +7630,7 @@ var UserService = class extends BaseService {
 // src/services/clinic/utils/clinic-group.utils.ts
 var import_firestore23 = require("firebase/firestore");
 var import_geofire_common3 = require("geofire-common");
-var import_zod20 = require("zod");
+var import_zod18 = require("zod");
 
 // src/services/clinic/utils/photos.utils.ts
 var import_storage3 = require("firebase/storage");
@@ -7973,7 +7828,7 @@ async function createClinicGroup(db, data, ownerId, isDefault = false, clinicAdm
     });
     return groupData;
   } catch (error) {
-    if (error instanceof import_zod20.z.ZodError) {
+    if (error instanceof import_zod18.z.ZodError) {
       console.error(
         "[CLINIC_GROUP] Zod validation error:",
         JSON.stringify(error.errors, null, 2)
@@ -8420,12 +8275,12 @@ var ClinicGroupService = class extends BaseService {
 // src/services/clinic/clinic.service.ts
 var import_firestore27 = require("firebase/firestore");
 var import_geofire_common7 = require("geofire-common");
-var import_zod22 = require("zod");
+var import_zod20 = require("zod");
 
 // src/services/clinic/utils/clinic.utils.ts
 var import_firestore24 = require("firebase/firestore");
 var import_geofire_common4 = require("geofire-common");
-var import_zod21 = require("zod");
+var import_zod19 = require("zod");
 async function getClinic(db, clinicId) {
   const docRef = (0, import_firestore24.doc)(db, CLINICS_COLLECTION, clinicId);
   const docSnap = await (0, import_firestore24.getDoc)(docRef);
@@ -9189,7 +9044,7 @@ var ClinicService = class extends BaseService {
       if (!savedClinic) throw new Error("Failed to retrieve created clinic");
       return savedClinic;
     } catch (error) {
-      if (error instanceof import_zod22.z.ZodError) {
+      if (error instanceof import_zod20.z.ZodError) {
         throw new Error("Invalid clinic data: " + error.message);
       }
       console.error("Error creating clinic:", error);
@@ -9269,7 +9124,7 @@ var ClinicService = class extends BaseService {
       if (!updatedClinic) throw new Error("Failed to retrieve updated clinic");
       return updatedClinic;
     } catch (error) {
-      if (error instanceof import_zod22.z.ZodError) {
+      if (error instanceof import_zod20.z.ZodError) {
         throw new Error("Invalid clinic update data: " + error.message);
       }
       console.error(`Error updating clinic ${clinicId}:`, error);
@@ -9432,6 +9287,125 @@ var ClinicService = class extends BaseService {
   }
 };
 
+// src/services/auth/utils/firebase.utils.ts
+var import_auth5 = require("firebase/auth");
+var checkEmailExists = async (auth, email) => {
+  try {
+    const methods = await (0, import_auth5.fetchSignInMethodsForEmail)(auth, email);
+    return methods.length > 0;
+  } catch (error) {
+    console.warn(
+      "[FIREBASE] Could not check email existence, allowing signup to proceed:",
+      error
+    );
+    return false;
+  }
+};
+var cleanupFirebaseUser = async (firebaseUser) => {
+  try {
+    console.log("[FIREBASE] Cleaning up Firebase user", {
+      uid: firebaseUser.uid
+    });
+    await firebaseUser.delete();
+    console.log("[FIREBASE] Firebase user cleanup successful");
+  } catch (cleanupError) {
+    console.error("[FIREBASE] Failed to cleanup Firebase user:", cleanupError);
+  }
+};
+
+// src/services/auth/utils/error.utils.ts
+var import_zod21 = require("zod");
+var handleFirebaseError = (error) => {
+  const firebaseError = error;
+  switch (firebaseError.code) {
+    case "auth/email-already-in-use" /* EMAIL_ALREADY_IN_USE */:
+      return AUTH_ERRORS.EMAIL_ALREADY_EXISTS;
+    case "auth/weak-password":
+      return new Error(
+        "Password is too weak. Please choose a stronger password."
+      );
+    case "auth/invalid-email":
+      return new Error("Please enter a valid email address.");
+    case "auth/network-request-failed":
+      return new Error(
+        "Network error. Please check your internet connection and try again."
+      );
+    default:
+      return new Error(
+        `Account creation failed: ${firebaseError.message || "Unknown error"}`
+      );
+  }
+};
+var handleSignupError = (error) => {
+  if (error instanceof import_zod21.z.ZodError) {
+    const errorMessages = error.errors.map((e) => `${e.path.join(".")}: ${e.message}`).join(", ");
+    return new Error(`Validation failed: ${errorMessages}`);
+  }
+  if (error.code && error.code.startsWith("auth/")) {
+    return handleFirebaseError(error);
+  }
+  if (error.message && error.message.includes("token")) {
+    return new Error("Invalid or expired invitation token");
+  }
+  if (error.message && error.message.includes("validation")) {
+    return new Error(`Invalid practitioner data: ${error.message}`);
+  }
+  return new Error(
+    `Registration failed: ${error.message || "Unknown error occurred"}`
+  );
+};
+
+// src/services/auth/utils/practitioner.utils.ts
+var import_zod22 = require("zod");
+var profileDataSchema = import_zod22.z.object({
+  basicInfo: practitionerBasicInfoSchema.partial().optional(),
+  certification: practitionerCertificationSchema.partial().optional()
+}).partial();
+var buildPractitionerData = (data, userRef) => {
+  var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m;
+  const basicInfo = {
+    firstName: data.firstName || "Name",
+    lastName: data.lastName || "Surname",
+    email: data.email,
+    phoneNumber: ((_b = (_a = data.profileData) == null ? void 0 : _a.basicInfo) == null ? void 0 : _b.phoneNumber) || null,
+    profileImageUrl: ((_d = (_c = data.profileData) == null ? void 0 : _c.basicInfo) == null ? void 0 : _d.profileImageUrl) || "",
+    gender: ((_f = (_e = data.profileData) == null ? void 0 : _e.basicInfo) == null ? void 0 : _f.gender) || "other",
+    bio: ((_h = (_g = data.profileData) == null ? void 0 : _g.basicInfo) == null ? void 0 : _h.bio) || "",
+    title: "Practitioner",
+    dateOfBirth: ((_j = (_i = data.profileData) == null ? void 0 : _i.basicInfo) == null ? void 0 : _j.dateOfBirth) || /* @__PURE__ */ new Date(),
+    languages: ((_l = (_k = data.profileData) == null ? void 0 : _k.basicInfo) == null ? void 0 : _l.languages) || ["English"]
+  };
+  const certification = ((_m = data.profileData) == null ? void 0 : _m.certification) || {
+    level: "aesthetician" /* AESTHETICIAN */,
+    specialties: [],
+    licenseNumber: "Pending",
+    issuingAuthority: "Pending",
+    issueDate: /* @__PURE__ */ new Date(),
+    verificationStatus: "pending"
+  };
+  return {
+    userRef,
+    basicInfo,
+    certification,
+    status: "active" /* ACTIVE */,
+    isActive: true,
+    isVerified: false
+  };
+};
+var validatePractitionerProfileData = async (profileData) => {
+  try {
+    await profileDataSchema.parseAsync(profileData);
+  } catch (error) {
+    if (error instanceof import_zod22.z.ZodError) {
+      const errorMessages = error.errors.map((e) => `${e.path.join(".")}: ${e.message}`).join(", ");
+      throw new Error(
+        `Practitioner profile validation failed: ${errorMessages}`
+      );
+    }
+    throw error;
+  }
+};
+
 // src/services/auth/auth.service.ts
 var AuthService = class extends BaseService {
   constructor(db, auth, app, userService) {
@@ -17246,11 +17220,8 @@ var ProductService = class extends BaseService {
   beforeAfterPerZoneSchema,
   billingPerZoneSchema,
   blockingConditionSchema,
-  buildPractitionerData,
   calendarEventSchema,
   calendarEventTimeSchema,
-  checkEmailExists,
-  cleanupFirebaseUser,
   clinicAdminOptionsSchema,
   clinicAdminSchema,
   clinicAdminSignupSchema,
@@ -17298,7 +17269,6 @@ var ProductService = class extends BaseService {
   documentTemplateSchema,
   emailSchema,
   emergencyContactSchema,
-  extractErrorMessage,
   filledDocumentSchema,
   filledDocumentStatusSchema,
   finalBillingSchema,
@@ -17310,10 +17280,7 @@ var ProductService = class extends BaseService {
   getFirebaseFunctions,
   getFirebaseInstance,
   getFirebaseStorage,
-  handleFirebaseError,
-  handleSignupError,
   initializeFirebase,
-  isPractitionerDataComplete,
   linkedFormInfoSchema,
   locationDataSchema,
   mediaResourceSchema,
@@ -17385,7 +17352,6 @@ var ProductService = class extends BaseService {
   userRoleSchema,
   userRolesSchema,
   userSchema,
-  validatePractitionerProfileData,
   vitalStatsSchema,
   workingHoursSchema
 });