@blackcode_sa/metaestetics-api 1.7.19 → 1.7.20

package/dist/index.js

@@ -1096,7 +1096,7 @@ var BaseService = class {
 };
 
 // src/services/user.service.ts
-var import_firestore17 = require("firebase/firestore");
+var import_firestore19 = require("firebase/firestore");
 
 // src/errors/user.errors.ts
 var USER_ERRORS = {
@@ -3322,7 +3322,7 @@ var doctorInfoSchema = import_zod11.z.object({
 // src/validations/media.schema.ts
 var import_zod12 = require("zod");
 var mediaResourceSchema = import_zod12.z.union([
-  import_zod12.z.string(),
+  import_zod12.z.string().url(),
   import_zod12.z.instanceof(File),
   import_zod12.z.instanceof(Blob)
 ]);
@@ -4060,732 +4060,1091 @@ var ClinicAdminService = class extends BaseService {
 };
 
 // src/services/practitioner/practitioner.service.ts
-var import_firestore16 = require("firebase/firestore");
+var import_firestore18 = require("firebase/firestore");
 
-// src/validations/practitioner.schema.ts
-var import_zod14 = require("zod");
+// src/services/media/media.service.ts
 var import_firestore15 = 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_zod14.z.object({
-  firstName: import_zod14.z.string().min(2).max(50),
-  lastName: import_zod14.z.string().min(2).max(50),
-  title: import_zod14.z.string().min(2).max(100),
-  email: import_zod14.z.string().email(),
-  phoneNumber: import_zod14.z.string().regex(/^\+?[1-9]\d{1,14}$/, "Invalid phone number"),
-  dateOfBirth: import_zod14.z.instanceof(import_firestore15.Timestamp).or(import_zod14.z.date()),
-  gender: import_zod14.z.enum(["male", "female", "other"]),
-  profileImageUrl: import_zod14.z.string().url().optional(),
-  bio: import_zod14.z.string().max(1e3).optional(),
-  languages: import_zod14.z.array(import_zod14.z.string()).min(1)
-});
-var practitionerCertificationSchema = import_zod14.z.object({
-  level: import_zod14.z.nativeEnum(CertificationLevel),
-  specialties: import_zod14.z.array(import_zod14.z.nativeEnum(CertificationSpecialty)),
-  licenseNumber: import_zod14.z.string().min(3).max(50),
-  issuingAuthority: import_zod14.z.string().min(2).max(100),
-  issueDate: import_zod14.z.instanceof(import_firestore15.Timestamp).or(import_zod14.z.date()),
-  expiryDate: import_zod14.z.instanceof(import_firestore15.Timestamp).or(import_zod14.z.date()).optional(),
-  verificationStatus: import_zod14.z.enum(["pending", "verified", "rejected"])
-});
-var timeSlotSchema = import_zod14.z.object({
-  start: import_zod14.z.string().regex(/^([01]\d|2[0-3]):([0-5]\d)$/, "Invalid time format"),
-  end: import_zod14.z.string().regex(/^([01]\d|2[0-3]):([0-5]\d)$/, "Invalid time format")
-}).nullable();
-var practitionerWorkingHoursSchema = import_zod14.z.object({
-  practitionerId: import_zod14.z.string().min(1),
-  clinicId: import_zod14.z.string().min(1),
-  monday: timeSlotSchema,
-  tuesday: timeSlotSchema,
-  wednesday: timeSlotSchema,
-  thursday: timeSlotSchema,
-  friday: timeSlotSchema,
-  saturday: timeSlotSchema,
-  sunday: timeSlotSchema,
-  createdAt: import_zod14.z.instanceof(import_firestore15.Timestamp).or(import_zod14.z.date()),
-  updatedAt: import_zod14.z.instanceof(import_firestore15.Timestamp).or(import_zod14.z.date())
-});
-var practitionerClinicWorkingHoursSchema = import_zod14.z.object({
-  clinicId: import_zod14.z.string().min(1),
-  workingHours: import_zod14.z.object({
-    monday: timeSlotSchema,
-    tuesday: timeSlotSchema,
-    wednesday: timeSlotSchema,
-    thursday: timeSlotSchema,
-    friday: timeSlotSchema,
-    saturday: timeSlotSchema,
-    sunday: timeSlotSchema
-  }),
-  isActive: import_zod14.z.boolean(),
-  createdAt: import_zod14.z.instanceof(import_firestore15.Timestamp).or(import_zod14.z.date()),
-  updatedAt: import_zod14.z.instanceof(import_firestore15.Timestamp).or(import_zod14.z.date())
-});
-var practitionerSchema = import_zod14.z.object({
-  id: import_zod14.z.string().min(1),
-  userRef: import_zod14.z.string().min(1),
-  basicInfo: practitionerBasicInfoSchema,
-  certification: practitionerCertificationSchema,
-  clinics: import_zod14.z.array(import_zod14.z.string()),
-  clinicWorkingHours: import_zod14.z.array(practitionerClinicWorkingHoursSchema),
-  clinicsInfo: import_zod14.z.array(clinicInfoSchema),
-  procedures: import_zod14.z.array(import_zod14.z.string()),
-  proceduresInfo: import_zod14.z.array(procedureSummaryInfoSchema),
-  reviewInfo: practitionerReviewInfoSchema,
-  isActive: import_zod14.z.boolean(),
-  isVerified: import_zod14.z.boolean(),
-  status: import_zod14.z.nativeEnum(PractitionerStatus),
-  createdAt: import_zod14.z.instanceof(import_firestore15.Timestamp).or(import_zod14.z.date()),
-  updatedAt: import_zod14.z.instanceof(import_firestore15.Timestamp).or(import_zod14.z.date())
-});
-var createPractitionerSchema = import_zod14.z.object({
-  userRef: import_zod14.z.string().min(1),
-  basicInfo: practitionerBasicInfoSchema,
-  certification: practitionerCertificationSchema,
-  clinics: import_zod14.z.array(import_zod14.z.string()).optional(),
-  clinicWorkingHours: import_zod14.z.array(practitionerClinicWorkingHoursSchema).optional(),
-  clinicsInfo: import_zod14.z.array(clinicInfoSchema).optional(),
-  proceduresInfo: import_zod14.z.array(procedureSummaryInfoSchema).optional(),
-  isActive: import_zod14.z.boolean(),
-  isVerified: import_zod14.z.boolean(),
-  status: import_zod14.z.nativeEnum(PractitionerStatus).optional()
-});
-var createDraftPractitionerSchema = import_zod14.z.object({
-  basicInfo: practitionerBasicInfoSchema,
-  certification: practitionerCertificationSchema,
-  clinics: import_zod14.z.array(import_zod14.z.string()).optional(),
-  clinicWorkingHours: import_zod14.z.array(practitionerClinicWorkingHoursSchema).optional(),
-  clinicsInfo: import_zod14.z.array(clinicInfoSchema).optional(),
-  proceduresInfo: import_zod14.z.array(procedureSummaryInfoSchema).optional(),
-  isActive: import_zod14.z.boolean().optional().default(false),
-  isVerified: import_zod14.z.boolean().optional().default(false)
-});
-var practitionerTokenSchema = import_zod14.z.object({
-  id: import_zod14.z.string().min(1),
-  token: import_zod14.z.string().min(6),
-  practitionerId: import_zod14.z.string().min(1),
-  email: import_zod14.z.string().email(),
-  clinicId: import_zod14.z.string().min(1),
-  status: import_zod14.z.nativeEnum(PractitionerTokenStatus),
-  createdBy: import_zod14.z.string().min(1),
-  createdAt: import_zod14.z.instanceof(import_firestore15.Timestamp).or(import_zod14.z.date()),
-  expiresAt: import_zod14.z.instanceof(import_firestore15.Timestamp).or(import_zod14.z.date()),
-  usedBy: import_zod14.z.string().optional(),
-  usedAt: import_zod14.z.instanceof(import_firestore15.Timestamp).or(import_zod14.z.date()).optional()
-});
-var createPractitionerTokenSchema = import_zod14.z.object({
-  practitionerId: import_zod14.z.string().min(1),
-  email: import_zod14.z.string().email(),
-  clinicId: import_zod14.z.string().min(1),
-  expiresAt: import_zod14.z.date().optional()
-});
-var practitionerSignupSchema = import_zod14.z.object({
-  email: import_zod14.z.string().email(),
-  password: import_zod14.z.string().min(8),
-  firstName: import_zod14.z.string().min(2).max(50).optional(),
-  lastName: import_zod14.z.string().min(2).max(50).optional(),
-  token: import_zod14.z.string().optional(),
-  profileData: import_zod14.z.object({
-    basicInfo: import_zod14.z.object({
-      phoneNumber: import_zod14.z.string().optional(),
-      profileImageUrl: import_zod14.z.string().optional(),
-      gender: import_zod14.z.enum(["male", "female", "other"]).optional(),
-      bio: import_zod14.z.string().optional()
-    }).optional(),
-    certification: import_zod14.z.any().optional()
-  }).optional()
-});
-
-// src/services/practitioner/practitioner.service.ts
-var import_zod15 = require("zod");
-var import_geofire_common2 = require("geofire-common");
-var PractitionerService = class extends BaseService {
-  constructor(db, auth, app, clinicService) {
+var import_storage4 = require("firebase/storage");
+var import_firestore16 = require("firebase/firestore");
+var MediaAccessLevel = /* @__PURE__ */ ((MediaAccessLevel2) => {
+  MediaAccessLevel2["PUBLIC"] = "public";
+  MediaAccessLevel2["PRIVATE"] = "private";
+  MediaAccessLevel2["CONFIDENTIAL"] = "confidential";
+  return MediaAccessLevel2;
+})(MediaAccessLevel || {});
+var MEDIA_METADATA_COLLECTION = "media_metadata";
+var MediaService = class extends BaseService {
+  constructor(db, auth, app) {
     super(db, auth, app);
-    this.clinicService = clinicService;
-  }
-  getClinicService() {
-    if (!this.clinicService) {
-      throw new Error("Clinic service not initialized!");
-    }
-    return this.clinicService;
-  }
-  setClinicService(clinicService) {
-    this.clinicService = clinicService;
   }
   /**
-   * Creates a new practitioner
+   * Upload a media file, store its metadata, and return the metadata including the URL.
+   * @param file - The file to upload.
+   * @param ownerId - ID of the owner (user, patient, clinic, etc.).
+   * @param accessLevel - Access level (public, private, confidential).
+   * @param collectionName - The logical collection name this media belongs to (e.g., 'patient_profile_pictures', 'clinic_logos').
+   * @param originalFileName - Optional: the original name of the file, if not using file.name.
+   * @returns Promise with the media metadata.
    */
-  async createPractitioner(data) {
+  async uploadMedia(file, ownerId, accessLevel, collectionName, originalFileName) {
+    const mediaId = this.generateId();
+    const fileNameToUse = originalFileName || (file instanceof File ? file.name : file.toString());
+    const uniqueFileName = `${mediaId}-${fileNameToUse}`;
+    const filePath = `media/${accessLevel}/${ownerId}/${collectionName}/${uniqueFileName}`;
+    console.log(`[MediaService] Uploading file to: ${filePath}`);
+    const storageRef = (0, import_storage4.ref)(this.storage, filePath);
     try {
-      const validData = createPractitionerSchema.parse(data);
-      const practitionerId = this.generateId();
-      const reviewInfo = {
-        totalReviews: 0,
-        averageRating: 0,
-        knowledgeAndExpertise: 0,
-        communicationSkills: 0,
-        bedSideManner: 0,
-        thoroughness: 0,
-        trustworthiness: 0,
-        recommendationPercentage: 0
-      };
-      const practitioner = {
-        id: practitionerId,
-        userRef: validData.userRef,
-        basicInfo: validData.basicInfo,
-        certification: validData.certification,
-        clinics: validData.clinics || [],
-        clinicWorkingHours: validData.clinicWorkingHours || [],
-        clinicsInfo: [],
-        procedures: [],
-        proceduresInfo: [],
-        reviewInfo,
-        isActive: validData.isActive !== void 0 ? validData.isActive : true,
-        isVerified: validData.isVerified !== void 0 ? validData.isVerified : false,
-        status: validData.status || "active" /* ACTIVE */,
-        createdAt: (0, import_firestore16.serverTimestamp)(),
-        updatedAt: (0, import_firestore16.serverTimestamp)()
-      };
-      practitionerSchema.parse({
-        ...practitioner,
-        createdAt: import_firestore16.Timestamp.now(),
-        updatedAt: import_firestore16.Timestamp.now()
+      const uploadResult = await (0, import_storage4.uploadBytes)(storageRef, file, {
+        contentType: file.type
       });
-      const practitionerRef = (0, import_firestore16.doc)(
-        this.db,
-        PRACTITIONERS_COLLECTION,
-        practitionerId
-      );
-      await (0, import_firestore16.setDoc)(practitionerRef, practitioner);
-      const createdPractitioner = await this.getPractitioner(practitionerId);
-      if (!createdPractitioner) {
-        throw new Error(
-          `Failed to retrieve created practitioner ${practitionerId}`
-        );
-      }
-      return createdPractitioner;
+      console.log("[MediaService] File uploaded successfully", uploadResult);
+      const downloadURL = await (0, import_storage4.getDownloadURL)(uploadResult.ref);
+      console.log("[MediaService] Got download URL:", downloadURL);
+      const metadata = {
+        id: mediaId,
+        name: fileNameToUse,
+        url: downloadURL,
+        contentType: file.type,
+        size: file.size,
+        createdAt: import_firestore15.Timestamp.now(),
+        accessLevel,
+        ownerId,
+        collectionName,
+        path: filePath
+      };
+      const metadataDocRef = (0, import_firestore16.doc)(this.db, MEDIA_METADATA_COLLECTION, mediaId);
+      await (0, import_firestore16.setDoc)(metadataDocRef, metadata);
+      console.log("[MediaService] Metadata stored in Firestore:", mediaId);
+      return metadata;
     } catch (error) {
-      if (error instanceof import_zod15.z.ZodError) {
-        throw new Error(`Invalid practitioner data: ${error.message}`);
-      }
-      console.error("Error creating practitioner:", error);
+      console.error("[MediaService] Error during media upload:", error);
       throw error;
     }
   }
   /**
-   * Kreira novi draft profil zdravstvenog radnika bez povezanog korisnika
-   * Koristi se od strane administratora klinike za kreiranje profila i kasnije pozivanje
-   * @param data Podaci za kreiranje draft profila
-   * @param createdBy ID administratora koji kreira profil
-   * @param clinicId ID klinike za koju se kreira profil
-   * @returns Objekt koji sadrži kreirani draft profil i token za registraciju
-   */
-  async createDraftPractitioner(data, createdBy, clinicId) {
+   * Get media metadata from Firestore by its ID.
+   * @param mediaId - ID of the media.
+   * @returns Promise with the media metadata or null if not found.
+   */
+  async getMediaMetadata(mediaId) {
+    console.log(`[MediaService] Getting media metadata for ID: ${mediaId}`);
+    const docRef = (0, import_firestore16.doc)(this.db, MEDIA_METADATA_COLLECTION, mediaId);
+    const docSnap = await (0, import_firestore16.getDoc)(docRef);
+    if (docSnap.exists()) {
+      console.log("[MediaService] Metadata found:", docSnap.data());
+      return docSnap.data();
+    }
+    console.log("[MediaService] No metadata found for ID:", mediaId);
+    return null;
+  }
+  /**
+   * Get media metadata from Firestore by its public URL.
+   * @param url - The public URL of the media file.
+   * @returns Promise with the media metadata or null if not found.
+   */
+  async getMediaMetadataByUrl(url) {
+    console.log(`[MediaService] Getting media metadata by URL: ${url}`);
+    const q = (0, import_firestore16.query)(
+      (0, import_firestore16.collection)(this.db, MEDIA_METADATA_COLLECTION),
+      (0, import_firestore16.where)("url", "==", url),
+      (0, import_firestore16.limit)(1)
+    );
     try {
-      const validatedData = createDraftPractitionerSchema.parse(data);
-      const clinic = await this.getClinicService().getClinic(clinicId);
-      if (!clinic) {
-        throw new Error(`Clinic ${clinicId} not found`);
-      }
-      const clinicsToAdd = /* @__PURE__ */ new Set([clinicId]);
-      if (data.clinics && data.clinics.length > 0) {
-        for (const cId of data.clinics) {
-          if (cId !== clinicId) {
-            const otherClinic = await this.getClinicService().getClinic(cId);
-            if (!otherClinic) {
-              throw new Error(`Clinic ${cId} not found`);
-            }
-          }
-          clinicsToAdd.add(cId);
-        }
-      }
-      const clinics = Array.from(clinicsToAdd);
-      const defaultReviewInfo = {
-        totalReviews: 0,
-        averageRating: 0,
-        knowledgeAndExpertise: 0,
-        communicationSkills: 0,
-        bedSideManner: 0,
-        thoroughness: 0,
-        trustworthiness: 0,
-        recommendationPercentage: 0
-      };
-      const practitionerId = this.generateId();
-      const clinicsInfo = [];
-      for (const cId of clinics) {
-        const clinicData = await this.getClinicService().getClinic(cId);
-        if (clinicData) {
-          clinicsInfo.push({
-            id: clinicData.id,
-            name: clinicData.name,
-            location: clinicData.location,
-            contactInfo: clinicData.contactInfo,
-            // Make sure we're using the right property for featuredPhoto
-            featuredPhoto: clinicData.featuredPhotos && clinicData.featuredPhotos.length > 0 ? typeof clinicData.featuredPhotos[0] === "string" ? clinicData.featuredPhotos[0] : "" : (typeof clinicData.coverPhoto === "string" ? clinicData.coverPhoto : "") || "",
-            description: clinicData.description || null
-          });
-        }
-      }
-      const finalClinicsInfo = validatedData.clinicsInfo && validatedData.clinicsInfo.length > 0 ? validatedData.clinicsInfo : clinicsInfo;
-      const proceduresInfo = [];
-      const practitionerData = {
-        id: practitionerId,
-        userRef: "",
-        // Prazno - biće popunjeno kada korisnik kreira nalog
-        basicInfo: validatedData.basicInfo,
-        certification: validatedData.certification,
-        clinics,
-        clinicWorkingHours: validatedData.clinicWorkingHours || [],
-        clinicsInfo: finalClinicsInfo,
-        procedures: [],
-        proceduresInfo,
-        reviewInfo: defaultReviewInfo,
-        isActive: validatedData.isActive !== void 0 ? validatedData.isActive : false,
-        isVerified: validatedData.isVerified !== void 0 ? validatedData.isVerified : false,
-        status: "draft" /* DRAFT */,
-        createdAt: (0, import_firestore16.serverTimestamp)(),
-        updatedAt: (0, import_firestore16.serverTimestamp)()
-      };
-      practitionerSchema.parse({
-        ...practitionerData,
-        userRef: "temp-for-validation",
-        createdAt: import_firestore16.Timestamp.now(),
-        updatedAt: import_firestore16.Timestamp.now()
-      });
-      await (0, import_firestore16.setDoc)(
-        (0, import_firestore16.doc)(this.db, PRACTITIONERS_COLLECTION, practitionerData.id),
-        practitionerData
-      );
-      const savedPractitioner = await this.getPractitioner(practitionerData.id);
-      if (!savedPractitioner) {
-        throw new Error("Failed to create draft practitioner profile");
+      const querySnapshot = await (0, import_firestore16.getDocs)(q);
+      if (!querySnapshot.empty) {
+        const metadata = querySnapshot.docs[0].data();
+        console.log("[MediaService] Metadata found by URL:", metadata);
+        return metadata;
       }
-      const tokenString = this.generateId().slice(0, 6).toUpperCase();
-      const expiration = new Date(Date.now() + 7 * 24 * 60 * 60 * 1e3);
-      const token = {
-        id: this.generateId(),
-        token: tokenString,
-        practitionerId,
-        email: practitionerData.basicInfo.email,
-        clinicId,
-        status: "active" /* ACTIVE */,
-        createdBy,
-        createdAt: import_firestore16.Timestamp.now(),
-        expiresAt: import_firestore16.Timestamp.fromDate(expiration)
-      };
-      practitionerTokenSchema.parse(token);
-      const tokenPath = `${PRACTITIONERS_COLLECTION}/${practitionerId}/${REGISTER_TOKENS_COLLECTION}/${token.id}`;
-      await (0, import_firestore16.setDoc)((0, import_firestore16.doc)(this.db, tokenPath), token);
-      return { practitioner: savedPractitioner, token };
+      console.log("[MediaService] No metadata found for URL:", url);
+      return null;
     } catch (error) {
-      if (error instanceof import_zod15.z.ZodError) {
-        throw new Error("Invalid practitioner data: " + error.message);
-      }
+      console.error("[MediaService] Error fetching metadata by URL:", error);
       throw error;
     }
   }
   /**
-   * Creates a token for inviting practitioner to claim their profile
-   * @param data Data for creating token
-   * @param createdBy ID of the user creating the token
-   * @returns Created token
+   * Delete media from storage and remove metadata from Firestore.
+   * @param mediaId - ID of the media to delete.
    */
-  async createPractitionerToken(data, createdBy) {
-    try {
-      const validatedData = createPractitionerTokenSchema.parse(data);
-      const practitioner = await this.getPractitioner(
-        validatedData.practitionerId
+  async deleteMedia(mediaId) {
+    console.log(`[MediaService] Deleting media with ID: ${mediaId}`);
+    const metadata = await this.getMediaMetadata(mediaId);
+    if (!metadata) {
+      console.warn(
+        `[MediaService] Metadata not found for media ID ${mediaId}. Cannot delete.`
       );
-      if (!practitioner) {
-        throw new Error("Practitioner not found");
-      }
-      if (practitioner.status !== "draft" /* DRAFT */) {
-        throw new Error(
-          "Can only create tokens for practitioners in DRAFT status"
-        );
-      }
-      const clinic = await this.getClinicService().getClinic(
-        validatedData.clinicId
+      return;
+    }
+    const storageFileRef = (0, import_storage4.ref)(this.storage, metadata.path);
+    try {
+      await (0, import_storage4.deleteObject)(storageFileRef);
+      console.log(`[MediaService] File deleted from Storage: ${metadata.path}`);
+      const metadataDocRef = (0, import_firestore16.doc)(this.db, MEDIA_METADATA_COLLECTION, mediaId);
+      await (0, import_firestore16.deleteDoc)(metadataDocRef);
+      console.log(
+        `[MediaService] Metadata deleted from Firestore for ID: ${mediaId}`
       );
-      if (!clinic) {
-        throw new Error(`Clinic ${validatedData.clinicId} not found`);
-      }
-      if (!practitioner.clinics.includes(validatedData.clinicId)) {
-        throw new Error("Practitioner is not associated with this clinic");
-      }
-      const expiration = validatedData.expiresAt || new Date(Date.now() + 7 * 24 * 60 * 60 * 1e3);
-      const tokenString = this.generateId().slice(0, 6).toUpperCase();
-      const token = {
-        id: this.generateId(),
-        token: tokenString,
-        practitionerId: validatedData.practitionerId,
-        email: validatedData.email,
-        clinicId: validatedData.clinicId,
-        status: "active" /* ACTIVE */,
-        createdBy,
-        createdAt: import_firestore16.Timestamp.now(),
-        expiresAt: import_firestore16.Timestamp.fromDate(expiration)
-      };
-      practitionerTokenSchema.parse(token);
-      const tokenPath = `${PRACTITIONERS_COLLECTION}/${validatedData.practitionerId}/${REGISTER_TOKENS_COLLECTION}/${token.id}`;
-      await (0, import_firestore16.setDoc)((0, import_firestore16.doc)(this.db, tokenPath), token);
-      return token;
     } catch (error) {
-      if (error instanceof import_zod15.z.ZodError) {
-        throw new Error("Invalid token data: " + error.message);
-      }
+      console.error(`[MediaService] Error deleting media ${mediaId}:`, error);
       throw error;
     }
   }
   /**
-   * Gets active tokens for a practitioner
-   * @param practitionerId ID of the practitioner
-   * @returns Array of active tokens
+   * Update media access level. This involves moving the file in Firebase Storage
+   * to a new path reflecting the new access level, and updating its metadata.
+   * @param mediaId - ID of the media to update.
+   * @param newAccessLevel - New access level.
+   * @returns Promise with the updated media metadata, or null if metadata not found.
    */
-  async getPractitionerActiveTokens(practitionerId) {
-    const tokensRef = (0, import_firestore16.collection)(
-      this.db,
-      `${PRACTITIONERS_COLLECTION}/${practitionerId}/${REGISTER_TOKENS_COLLECTION}`
-    );
-    const q = (0, import_firestore16.query)(
-      tokensRef,
-      (0, import_firestore16.where)("status", "==", "active" /* ACTIVE */),
-      (0, import_firestore16.where)("expiresAt", ">", import_firestore16.Timestamp.now())
+  async updateMediaAccessLevel(mediaId, newAccessLevel) {
+    var _a;
+    console.log(
+      `[MediaService] Attempting to update access level for media ID: ${mediaId} to ${newAccessLevel}`
     );
-    const querySnapshot = await (0, import_firestore16.getDocs)(q);
-    return querySnapshot.docs.map((doc34) => doc34.data());
-  }
-  /**
-   * Gets a token by its string value and validates it
-   * @param tokenString The token string to find
-   * @returns The token if found and valid, null otherwise
-   */
-  async validateToken(tokenString) {
-    const practitionersRef = (0, import_firestore16.collection)(this.db, PRACTITIONERS_COLLECTION);
-    const practitionersSnapshot = await (0, import_firestore16.getDocs)(practitionersRef);
-    for (const practitionerDoc of practitionersSnapshot.docs) {
-      const practitionerId = practitionerDoc.id;
-      const tokensRef = (0, import_firestore16.collection)(
-        this.db,
-        `${PRACTITIONERS_COLLECTION}/${practitionerId}/${REGISTER_TOKENS_COLLECTION}`
+    const metadata = await this.getMediaMetadata(mediaId);
+    if (!metadata) {
+      console.warn(
+        `[MediaService] Metadata not found for media ID ${mediaId}. Cannot update access level.`
       );
+      return null;
+    }
+    if (metadata.accessLevel === newAccessLevel) {
       console.log(
-        `[PRACTITIONER] Validating token for practitioner ${practitionerId}`,
-        {
-          tokenString,
-          timestamp: import_firestore16.Timestamp.now().toDate()
-        }
-      );
-      const q = (0, import_firestore16.query)(
-        tokensRef,
-        (0, import_firestore16.where)("token", "==", tokenString),
-        (0, import_firestore16.where)("status", "==", "active" /* ACTIVE */),
-        (0, import_firestore16.where)("expiresAt", ">", import_firestore16.Timestamp.now())
+        `[MediaService] Media ID ${mediaId} already has access level ${newAccessLevel}. Updating timestamp only.`
       );
+      const metadataDocRef = (0, import_firestore16.doc)(this.db, MEDIA_METADATA_COLLECTION, mediaId);
       try {
-        const tokenSnapshot = await (0, import_firestore16.getDocs)(q);
-        console.log(
-          `[PRACTITIONER] Token query results for practitioner ${practitionerId}`,
-          {
-            found: !tokenSnapshot.empty,
-            count: tokenSnapshot.size
-          }
-        );
-        if (!tokenSnapshot.empty) {
-          const tokenData = tokenSnapshot.docs[0].data();
-          console.log(`[PRACTITIONER] Valid token found`, {
-            tokenId: tokenData.id,
-            expiresAt: tokenData.expiresAt.toDate()
-          });
-          return tokenData;
-        }
+        await (0, import_firestore16.updateDoc)(metadataDocRef, { updatedAt: import_firestore15.Timestamp.now() });
+        return { ...metadata, updatedAt: import_firestore15.Timestamp.now() };
       } catch (error) {
         console.error(
-          `[PRACTITIONER] Error validating token for practitioner ${practitionerId}:`,
+          `[MediaService] Error updating timestamp for media ID ${mediaId}:`,
           error
         );
         throw error;
       }
     }
-    return null;
-  }
-  /**
-   * Marks a token as used
-   * @param tokenId ID of the token
-   * @param practitionerId ID of the practitioner
-   * @param userId ID of the user using the token
-   */
-  async markTokenAsUsed(tokenId, practitionerId, userId) {
-    const tokenRef = (0, import_firestore16.doc)(
-      this.db,
-      `${PRACTITIONERS_COLLECTION}/${practitionerId}/${REGISTER_TOKENS_COLLECTION}/${tokenId}`
+    const oldStoragePath = metadata.path;
+    const fileNamePart = `${metadata.id}-${metadata.name}`;
+    const newStoragePath = `media/${newAccessLevel}/${metadata.ownerId}/${metadata.collectionName}/${fileNamePart}`;
+    console.log(
+      `[MediaService] Moving file for ${mediaId} from ${oldStoragePath} to ${newStoragePath}`
     );
-    await (0, import_firestore16.updateDoc)(tokenRef, {
-      status: "used" /* USED */,
-      usedBy: userId,
-      usedAt: import_firestore16.Timestamp.now()
-    });
-  }
-  /**
-   * Dohvata zdravstvenog radnika po ID-u
-   */
-  async getPractitioner(practitionerId) {
-    const practitionerDoc = await (0, import_firestore16.getDoc)(
-      (0, import_firestore16.doc)(this.db, PRACTITIONERS_COLLECTION, practitionerId)
-    );
-    if (!practitionerDoc.exists()) {
-      return null;
-    }
-    return practitionerDoc.data();
-  }
-  /**
-   * Dohvata zdravstvenog radnika po User ID-u
-   */
-  async getPractitionerByUserRef(userRef) {
-    const q = (0, import_firestore16.query)(
-      (0, import_firestore16.collection)(this.db, PRACTITIONERS_COLLECTION),
-      (0, import_firestore16.where)("userRef", "==", userRef)
-    );
-    const querySnapshot = await (0, import_firestore16.getDocs)(q);
-    if (querySnapshot.empty) {
-      return null;
-    }
-    return querySnapshot.docs[0].data();
-  }
-  /**
-   * Dohvata sve zdravstvene radnike za određenu kliniku sa statusom ACTIVE
-   */
-  async getPractitionersByClinic(clinicId) {
-    const q = (0, import_firestore16.query)(
-      (0, import_firestore16.collection)(this.db, PRACTITIONERS_COLLECTION),
-      (0, import_firestore16.where)("clinics", "array-contains", clinicId),
-      (0, import_firestore16.where)("isActive", "==", true),
-      (0, import_firestore16.where)("status", "==", "active" /* ACTIVE */)
-    );
-    const querySnapshot = await (0, import_firestore16.getDocs)(q);
-    return querySnapshot.docs.map((doc34) => doc34.data());
-  }
-  /**
-   * Dohvata sve zdravstvene radnike za određenu kliniku
-   */
-  async getAllPractitionersByClinic(clinicId) {
-    const q = (0, import_firestore16.query)(
-      (0, import_firestore16.collection)(this.db, PRACTITIONERS_COLLECTION),
-      (0, import_firestore16.where)("clinics", "array-contains", clinicId),
-      (0, import_firestore16.where)("isActive", "==", true)
-    );
-    const querySnapshot = await (0, import_firestore16.getDocs)(q);
-    return querySnapshot.docs.map((doc34) => doc34.data());
-  }
-  /**
-   * Dohvata sve draft zdravstvene radnike za određenu kliniku sa statusom DRAFT
-   */
-  async getDraftPractitionersByClinic(clinicId) {
-    const q = (0, import_firestore16.query)(
-      (0, import_firestore16.collection)(this.db, PRACTITIONERS_COLLECTION),
-      (0, import_firestore16.where)("clinics", "array-contains", clinicId),
-      (0, import_firestore16.where)("status", "==", "draft" /* DRAFT */)
-    );
-    const querySnapshot = await (0, import_firestore16.getDocs)(q);
-    return querySnapshot.docs.map((doc34) => doc34.data());
-  }
-  /**
-   * Updates a practitioner
-   */
-  async updatePractitioner(practitionerId, data) {
+    const oldStorageFileRef = (0, import_storage4.ref)(this.storage, oldStoragePath);
+    const newStorageFileRef = (0, import_storage4.ref)(this.storage, newStoragePath);
     try {
-      const validData = data;
-      const practitionerRef = (0, import_firestore16.doc)(
-        this.db,
-        PRACTITIONERS_COLLECTION,
-        practitionerId
+      console.log(`[MediaService] Downloading bytes from ${oldStoragePath}`);
+      const fileBytes = await (0, import_storage4.getBytes)(oldStorageFileRef);
+      console.log(
+        `[MediaService] Successfully downloaded ${fileBytes.byteLength} bytes from ${oldStoragePath}`
+      );
+      console.log(`[MediaService] Uploading bytes to ${newStoragePath}`);
+      await (0, import_storage4.uploadBytes)(newStorageFileRef, fileBytes, {
+        contentType: metadata.contentType
+      });
+      console.log(
+        `[MediaService] Successfully uploaded bytes to ${newStoragePath}`
+      );
+      const newDownloadURL = await (0, import_storage4.getDownloadURL)(newStorageFileRef);
+      console.log(
+        `[MediaService] Got new download URL for ${newStoragePath}: ${newDownloadURL}`
       );
-      const practitionerDoc = await (0, import_firestore16.getDoc)(practitionerRef);
-      if (!practitionerDoc.exists()) {
-        throw new Error(`Practitioner ${practitionerId} not found`);
-      }
-      const currentPractitioner = practitionerDoc.data();
       const updateData = {
-        ...validData,
-        updatedAt: (0, import_firestore16.serverTimestamp)()
+        accessLevel: newAccessLevel,
+        path: newStoragePath,
+        url: newDownloadURL,
+        updatedAt: import_firestore15.Timestamp.now()
       };
-      await (0, import_firestore16.updateDoc)(practitionerRef, updateData);
-      const updatedPractitioner = await this.getPractitioner(practitionerId);
-      if (!updatedPractitioner) {
-        throw new Error(
-          `Failed to retrieve updated practitioner ${practitionerId}`
-        );
-      }
-      return updatedPractitioner;
-    } catch (error) {
-      if (error instanceof import_zod15.z.ZodError) {
-        throw new Error(`Invalid practitioner update data: ${error.message}`);
-      }
-      console.error(`Error updating practitioner ${practitionerId}:`, error);
-      throw error;
-    }
-  }
-  /**
-   * Adds a clinic to a practitioner
-   */
-  async addClinic(practitionerId, clinicId) {
-    var _a;
-    try {
-      const practitionerRef = (0, import_firestore16.doc)(
-        this.db,
-        PRACTITIONERS_COLLECTION,
-        practitionerId
+      const metadataDocRef = (0, import_firestore16.doc)(this.db, MEDIA_METADATA_COLLECTION, mediaId);
+      console.log(
+        `[MediaService] Updating Firestore metadata for ${mediaId} with new data:`,
+        updateData
       );
-      const practitionerDoc = await (0, import_firestore16.getDoc)(practitionerRef);
-      if (!practitionerDoc.exists()) {
-        throw new Error(`Practitioner ${practitionerId} not found`);
-      }
-      const practitioner = practitionerDoc.data();
-      if ((_a = practitioner.clinics) == null ? void 0 : _a.includes(clinicId)) {
+      await (0, import_firestore16.updateDoc)(metadataDocRef, updateData);
+      console.log(
+        `[MediaService] Successfully updated Firestore metadata for ${mediaId}`
+      );
+      try {
+        console.log(`[MediaService] Deleting old file from ${oldStoragePath}`);
+        await (0, import_storage4.deleteObject)(oldStorageFileRef);
         console.log(
-          `Clinic ${clinicId} already added to practitioner ${practitionerId}`
+          `[MediaService] Successfully deleted old file from ${oldStoragePath}`
+        );
+      } catch (deleteError) {
+        console.error(
+          `[MediaService] Failed to delete old file from ${oldStoragePath} for media ID ${mediaId}. This file is now orphaned. Error:`,
+          deleteError
         );
-        return;
       }
-      await (0, import_firestore16.updateDoc)(practitionerRef, {
-        clinics: (0, import_firestore16.arrayUnion)(clinicId),
-        updatedAt: (0, import_firestore16.serverTimestamp)()
-      });
+      return { ...metadata, ...updateData };
     } catch (error) {
       console.error(
-        `Error adding clinic ${clinicId} to practitioner ${practitionerId}:`,
+        `[MediaService] Error updating media access level and moving file for ${mediaId}:`,
         error
       );
+      if (newStorageFileRef && error.code !== "storage/object-not-found" && ((_a = error.message) == null ? void 0 : _a.includes("uploadBytes"))) {
+        console.warn(
+          `[MediaService] Attempting to delete partially uploaded file at ${newStoragePath} due to error.`
+        );
+        try {
+          await (0, import_storage4.deleteObject)(newStorageFileRef);
+          console.warn(
+            `[MediaService] Cleaned up partially uploaded file at ${newStoragePath}.`
+          );
+        } catch (cleanupError) {
+          console.error(
+            `[MediaService] Failed to cleanup partially uploaded file at ${newStoragePath}:`,
+            cleanupError
+          );
+        }
+      }
       throw error;
     }
   }
   /**
-   * Removes a clinic from a practitioner
+   * List all media for an owner, optionally filtered by collection and access level.
+   * @param ownerId - ID of the owner.
+   * @param collectionName - Optional: Filter by collection name.
+   * @param accessLevel - Optional: Filter by access level.
+   * @param count - Optional: Number of items to fetch.
+   * @param startAfterId - Optional: ID of the document to start after (for pagination).
    */
-  async removeClinic(practitionerId, clinicId) {
+  async listMedia(ownerId, collectionName, accessLevel, count, startAfterId) {
+    console.log(`[MediaService] Listing media for owner: ${ownerId}`);
+    let qConstraints = [(0, import_firestore16.where)("ownerId", "==", ownerId)];
+    if (collectionName) {
+      qConstraints.push((0, import_firestore16.where)("collectionName", "==", collectionName));
+    }
+    if (accessLevel) {
+      qConstraints.push((0, import_firestore16.where)("accessLevel", "==", accessLevel));
+    }
+    qConstraints.push((0, import_firestore16.orderBy)("createdAt", "desc"));
+    if (count) {
+      qConstraints.push((0, import_firestore16.limit)(count));
+    }
+    if (startAfterId) {
+      const startAfterDoc = await this.getMediaMetadata(startAfterId);
+      if (startAfterDoc) {
+      }
+    }
+    const finalQuery = (0, import_firestore16.query)(
+      (0, import_firestore16.collection)(this.db, MEDIA_METADATA_COLLECTION),
+      ...qConstraints
+    );
     try {
-      const practitionerRef = (0, import_firestore16.doc)(
-        this.db,
-        PRACTITIONERS_COLLECTION,
-        practitionerId
+      const querySnapshot = await (0, import_firestore16.getDocs)(finalQuery);
+      const mediaList = querySnapshot.docs.map(
+        (doc34) => doc34.data()
       );
-      const practitionerDoc = await (0, import_firestore16.getDoc)(practitionerRef);
-      if (!practitionerDoc.exists()) {
-        throw new Error(`Practitioner ${practitionerId} not found`);
-      }
-      await (0, import_firestore16.updateDoc)(practitionerRef, {
-        clinics: (0, import_firestore16.arrayRemove)(clinicId),
-        updatedAt: (0, import_firestore16.serverTimestamp)()
-      });
+      console.log(`[MediaService] Found ${mediaList.length} media items.`);
+      return mediaList;
     } catch (error) {
-      console.error(
-        `Error removing clinic ${clinicId} from practitioner ${practitionerId}:`,
-        error
-      );
+      console.error("[MediaService] Error listing media:", error);
       throw error;
     }
   }
   /**
-   * Deaktivira profil zdravstvenog radnika
-   */
-  async deactivatePractitioner(practitionerId) {
-    await this.updatePractitioner(practitionerId, {
-      isActive: false
-    });
-  }
-  /**
-   * Aktivira profil zdravstvenog radnika
-   */
-  async activatePractitioner(practitionerId) {
-    await this.updatePractitioner(practitionerId, {
-      isActive: true
-    });
-  }
-  /**
-   * Briše profil zdravstvenog radnika
+   * Get download URL for media. (Convenience, as URL is in metadata)
+   * @param mediaId - ID of the media.
    */
-  async deletePractitioner(practitionerId) {
-    const practitioner = await this.getPractitioner(practitionerId);
-    if (!practitioner) {
-      throw new Error("Practitioner not found");
+  async getMediaDownloadUrl(mediaId) {
+    console.log(`[MediaService] Getting download URL for media ID: ${mediaId}`);
+    const metadata = await this.getMediaMetadata(mediaId);
+    if (metadata && metadata.url) {
+      console.log(`[MediaService] URL found: ${metadata.url}`);
+      return metadata.url;
     }
-    await (0, import_firestore16.deleteDoc)((0, import_firestore16.doc)(this.db, PRACTITIONERS_COLLECTION, practitionerId));
+    console.log(`[MediaService] URL not found for media ID: ${mediaId}`);
+    return null;
   }
-  /**
-   * Validates a registration token and claims the associated draft practitioner profile
-   * @param tokenString The token provided by the practitioner
-   * @param userId The ID of the user claiming the profile
-   * @returns The claimed practitioner profile or null if token is invalid
-   */
-  async validateTokenAndClaimProfile(tokenString, userId) {
-    console.log("[PRACTITIONER] Validating token for claiming profile", {
-      tokenString,
-      userId
-    });
-    const token = await this.validateToken(tokenString);
-    if (!token) {
-      console.log(
-        "[PRACTITIONER] Token validation failed - token not found or not valid",
-        {
-          tokenString
-        }
-      );
-      return null;
-    }
-    console.log("[PRACTITIONER] Token successfully validated", {
-      tokenId: token.id,
-      practitionerId: token.practitionerId
-    });
-    const practitioner = await this.getPractitioner(token.practitionerId);
-    if (!practitioner) {
-      console.log("[PRACTITIONER] Practitioner not found", {
-        practitionerId: token.practitionerId
-      });
-      return null;
-    }
-    if (practitioner.status !== "draft" /* DRAFT */) {
-      console.log("[PRACTITIONER] Practitioner status is not DRAFT", {
-        practitionerId: practitioner.id,
-        status: practitioner.status
-      });
-      throw new Error("This practitioner profile has already been claimed");
-    }
-    const existingPractitioner = await this.getPractitionerByUserRef(userId);
-    if (existingPractitioner) {
-      throw new Error("User already has a practitioner profile");
-    }
-    const updatedPractitioner = await this.updatePractitioner(practitioner.id, {
-      userRef: userId,
-      status: "active" /* ACTIVE */
-    });
-    await this.markTokenAsUsed(token.id, token.practitionerId, userId);
-    console.log("[PRACTITIONER] Profile claimed successfully", {
-      practitionerId: updatedPractitioner.id,
-      userId
+};
+
+// src/validations/practitioner.schema.ts
+var import_zod14 = require("zod");
+var import_firestore17 = 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_zod14.z.object({
+  firstName: import_zod14.z.string().min(2).max(50),
+  lastName: import_zod14.z.string().min(2).max(50),
+  title: import_zod14.z.string().min(2).max(100),
+  email: import_zod14.z.string().email(),
+  phoneNumber: import_zod14.z.string().regex(/^\+?[1-9]\d{1,14}$/, "Invalid phone number"),
+  dateOfBirth: import_zod14.z.instanceof(import_firestore17.Timestamp).or(import_zod14.z.date()),
+  gender: import_zod14.z.enum(["male", "female", "other"]),
+  profileImageUrl: mediaResourceSchema.optional(),
+  bio: import_zod14.z.string().max(1e3).optional(),
+  languages: import_zod14.z.array(import_zod14.z.string()).min(1)
+});
+var practitionerCertificationSchema = import_zod14.z.object({
+  level: import_zod14.z.nativeEnum(CertificationLevel),
+  specialties: import_zod14.z.array(import_zod14.z.nativeEnum(CertificationSpecialty)),
+  licenseNumber: import_zod14.z.string().min(3).max(50),
+  issuingAuthority: import_zod14.z.string().min(2).max(100),
+  issueDate: import_zod14.z.instanceof(import_firestore17.Timestamp).or(import_zod14.z.date()),
+  expiryDate: import_zod14.z.instanceof(import_firestore17.Timestamp).or(import_zod14.z.date()).optional(),
+  verificationStatus: import_zod14.z.enum(["pending", "verified", "rejected"])
+});
+var timeSlotSchema = import_zod14.z.object({
+  start: import_zod14.z.string().regex(/^([01]\d|2[0-3]):([0-5]\d)$/, "Invalid time format"),
+  end: import_zod14.z.string().regex(/^([01]\d|2[0-3]):([0-5]\d)$/, "Invalid time format")
+}).nullable();
+var practitionerWorkingHoursSchema = import_zod14.z.object({
+  practitionerId: import_zod14.z.string().min(1),
+  clinicId: import_zod14.z.string().min(1),
+  monday: timeSlotSchema,
+  tuesday: timeSlotSchema,
+  wednesday: timeSlotSchema,
+  thursday: timeSlotSchema,
+  friday: timeSlotSchema,
+  saturday: timeSlotSchema,
+  sunday: timeSlotSchema,
+  createdAt: import_zod14.z.instanceof(import_firestore17.Timestamp).or(import_zod14.z.date()),
+  updatedAt: import_zod14.z.instanceof(import_firestore17.Timestamp).or(import_zod14.z.date())
+});
+var practitionerClinicWorkingHoursSchema = import_zod14.z.object({
+  clinicId: import_zod14.z.string().min(1),
+  workingHours: import_zod14.z.object({
+    monday: timeSlotSchema,
+    tuesday: timeSlotSchema,
+    wednesday: timeSlotSchema,
+    thursday: timeSlotSchema,
+    friday: timeSlotSchema,
+    saturday: timeSlotSchema,
+    sunday: timeSlotSchema
+  }),
+  isActive: import_zod14.z.boolean(),
+  createdAt: import_zod14.z.instanceof(import_firestore17.Timestamp).or(import_zod14.z.date()),
+  updatedAt: import_zod14.z.instanceof(import_firestore17.Timestamp).or(import_zod14.z.date())
+});
+var practitionerSchema = import_zod14.z.object({
+  id: import_zod14.z.string().min(1),
+  userRef: import_zod14.z.string().min(1),
+  basicInfo: practitionerBasicInfoSchema,
+  certification: practitionerCertificationSchema,
+  clinics: import_zod14.z.array(import_zod14.z.string()),
+  clinicWorkingHours: import_zod14.z.array(practitionerClinicWorkingHoursSchema),
+  clinicsInfo: import_zod14.z.array(clinicInfoSchema),
+  procedures: import_zod14.z.array(import_zod14.z.string()),
+  proceduresInfo: import_zod14.z.array(procedureSummaryInfoSchema),
+  reviewInfo: practitionerReviewInfoSchema,
+  isActive: import_zod14.z.boolean(),
+  isVerified: import_zod14.z.boolean(),
+  status: import_zod14.z.nativeEnum(PractitionerStatus),
+  createdAt: import_zod14.z.instanceof(import_firestore17.Timestamp).or(import_zod14.z.date()),
+  updatedAt: import_zod14.z.instanceof(import_firestore17.Timestamp).or(import_zod14.z.date())
+});
+var createPractitionerSchema = import_zod14.z.object({
+  userRef: import_zod14.z.string().min(1),
+  basicInfo: practitionerBasicInfoSchema,
+  certification: practitionerCertificationSchema,
+  clinics: import_zod14.z.array(import_zod14.z.string()).optional(),
+  clinicWorkingHours: import_zod14.z.array(practitionerClinicWorkingHoursSchema).optional(),
+  clinicsInfo: import_zod14.z.array(clinicInfoSchema).optional(),
+  proceduresInfo: import_zod14.z.array(procedureSummaryInfoSchema).optional(),
+  isActive: import_zod14.z.boolean(),
+  isVerified: import_zod14.z.boolean(),
+  status: import_zod14.z.nativeEnum(PractitionerStatus).optional()
+});
+var createDraftPractitionerSchema = import_zod14.z.object({
+  basicInfo: practitionerBasicInfoSchema,
+  certification: practitionerCertificationSchema,
+  clinics: import_zod14.z.array(import_zod14.z.string()).optional(),
+  clinicWorkingHours: import_zod14.z.array(practitionerClinicWorkingHoursSchema).optional(),
+  clinicsInfo: import_zod14.z.array(clinicInfoSchema).optional(),
+  proceduresInfo: import_zod14.z.array(procedureSummaryInfoSchema).optional(),
+  isActive: import_zod14.z.boolean().optional().default(false),
+  isVerified: import_zod14.z.boolean().optional().default(false)
+});
+var practitionerTokenSchema = import_zod14.z.object({
+  id: import_zod14.z.string().min(1),
+  token: import_zod14.z.string().min(6),
+  practitionerId: import_zod14.z.string().min(1),
+  email: import_zod14.z.string().email(),
+  clinicId: import_zod14.z.string().min(1),
+  status: import_zod14.z.nativeEnum(PractitionerTokenStatus),
+  createdBy: import_zod14.z.string().min(1),
+  createdAt: import_zod14.z.instanceof(import_firestore17.Timestamp).or(import_zod14.z.date()),
+  expiresAt: import_zod14.z.instanceof(import_firestore17.Timestamp).or(import_zod14.z.date()),
+  usedBy: import_zod14.z.string().optional(),
+  usedAt: import_zod14.z.instanceof(import_firestore17.Timestamp).or(import_zod14.z.date()).optional()
+});
+var createPractitionerTokenSchema = import_zod14.z.object({
+  practitionerId: import_zod14.z.string().min(1),
+  email: import_zod14.z.string().email(),
+  clinicId: import_zod14.z.string().min(1),
+  expiresAt: import_zod14.z.date().optional()
+});
+var practitionerSignupSchema = import_zod14.z.object({
+  email: import_zod14.z.string().email(),
+  password: import_zod14.z.string().min(8),
+  firstName: import_zod14.z.string().min(2).max(50).optional(),
+  lastName: import_zod14.z.string().min(2).max(50).optional(),
+  token: import_zod14.z.string().optional(),
+  profileData: import_zod14.z.object({
+    basicInfo: import_zod14.z.object({
+      phoneNumber: import_zod14.z.string().optional(),
+      profileImageUrl: mediaResourceSchema.optional(),
+      gender: import_zod14.z.enum(["male", "female", "other"]).optional(),
+      bio: import_zod14.z.string().optional()
+    }).optional(),
+    certification: import_zod14.z.any().optional()
+  }).optional()
+});
+
+// src/services/practitioner/practitioner.service.ts
+var import_zod15 = require("zod");
+var import_geofire_common2 = require("geofire-common");
+var PractitionerService = class extends BaseService {
+  constructor(db, auth, app, clinicService) {
+    super(db, auth, app);
+    this.clinicService = clinicService;
+    this.mediaService = new MediaService(db, auth, app);
+  }
+  getClinicService() {
+    if (!this.clinicService) {
+      throw new Error("Clinic service not initialized!");
+    }
+    return this.clinicService;
+  }
+  setClinicService(clinicService) {
+    this.clinicService = clinicService;
+  }
+  /**
+   * Handles profile photo upload for practitioners
+   * @param profilePhoto - MediaResource (File, Blob, or URL string)
+   * @param practitionerId - ID of the practitioner
+   * @returns URL string of the uploaded or existing photo
+   */
+  async handleProfilePhotoUpload(profilePhoto, practitionerId) {
+    if (!profilePhoto) {
+      return void 0;
+    }
+    if (typeof profilePhoto === "string") {
+      return profilePhoto;
+    }
+    if (profilePhoto instanceof File || profilePhoto instanceof Blob) {
+      console.log(
+        `[PractitionerService] Uploading profile photo for practitioner ${practitionerId}`
+      );
+      const mediaMetadata = await this.mediaService.uploadMedia(
+        profilePhoto,
+        practitionerId,
+        // Using practitionerId as ownerId
+        "public" /* PUBLIC */,
+        // Profile photos should be public
+        "practitioner_profile_photos",
+        profilePhoto instanceof File ? profilePhoto.name : `profile_photo_${practitionerId}`
+      );
+      return mediaMetadata.url;
+    }
+    return void 0;
+  }
+  /**
+   * Processes BasicPractitionerInfo to handle profile photo uploads
+   * @param basicInfo - The basic info containing potential MediaResource profile photo
+   * @param practitionerId - ID of the practitioner
+   * @returns Processed basic info with URL string for profileImageUrl
+   */
+  async processBasicInfo(basicInfo, practitionerId) {
+    const processedBasicInfo = { ...basicInfo };
+    if (basicInfo.profileImageUrl) {
+      const uploadedUrl = await this.handleProfilePhotoUpload(
+        basicInfo.profileImageUrl,
+        practitionerId
+      );
+      processedBasicInfo.profileImageUrl = uploadedUrl;
+    }
+    return processedBasicInfo;
+  }
+  /**
+   * Creates a new practitioner
+   */
+  async createPractitioner(data) {
+    try {
+      const validData = createPractitionerSchema.parse(data);
+      const practitionerId = this.generateId();
+      const reviewInfo = {
+        totalReviews: 0,
+        averageRating: 0,
+        knowledgeAndExpertise: 0,
+        communicationSkills: 0,
+        bedSideManner: 0,
+        thoroughness: 0,
+        trustworthiness: 0,
+        recommendationPercentage: 0
+      };
+      const practitioner = {
+        id: practitionerId,
+        userRef: validData.userRef,
+        basicInfo: await this.processBasicInfo(
+          validData.basicInfo,
+          practitionerId
+        ),
+        certification: validData.certification,
+        clinics: validData.clinics || [],
+        clinicWorkingHours: validData.clinicWorkingHours || [],
+        clinicsInfo: [],
+        procedures: [],
+        proceduresInfo: [],
+        reviewInfo,
+        isActive: validData.isActive !== void 0 ? validData.isActive : true,
+        isVerified: validData.isVerified !== void 0 ? validData.isVerified : false,
+        status: validData.status || "active" /* ACTIVE */,
+        createdAt: (0, import_firestore18.serverTimestamp)(),
+        updatedAt: (0, import_firestore18.serverTimestamp)()
+      };
+      practitionerSchema.parse({
+        ...practitioner,
+        createdAt: import_firestore18.Timestamp.now(),
+        updatedAt: import_firestore18.Timestamp.now()
+      });
+      const practitionerRef = (0, import_firestore18.doc)(
+        this.db,
+        PRACTITIONERS_COLLECTION,
+        practitionerId
+      );
+      await (0, import_firestore18.setDoc)(practitionerRef, practitioner);
+      const createdPractitioner = await this.getPractitioner(practitionerId);
+      if (!createdPractitioner) {
+        throw new Error(
+          `Failed to retrieve created practitioner ${practitionerId}`
+        );
+      }
+      return createdPractitioner;
+    } catch (error) {
+      if (error instanceof import_zod15.z.ZodError) {
+        throw new Error(`Invalid practitioner data: ${error.message}`);
+      }
+      console.error("Error creating practitioner:", error);
+      throw error;
+    }
+  }
+  /**
+   * Kreira novi draft profil zdravstvenog radnika bez povezanog korisnika
+   * Koristi se od strane administratora klinike za kreiranje profila i kasnije pozivanje
+   * @param data Podaci za kreiranje draft profila
+   * @param createdBy ID administratora koji kreira profil
+   * @param clinicId ID klinike za koju se kreira profil
+   * @returns Objekt koji sadrži kreirani draft profil i token za registraciju
+   */
+  async createDraftPractitioner(data, createdBy, clinicId) {
+    try {
+      const validatedData = createDraftPractitionerSchema.parse(data);
+      const clinic = await this.getClinicService().getClinic(clinicId);
+      if (!clinic) {
+        throw new Error(`Clinic ${clinicId} not found`);
+      }
+      const clinicsToAdd = /* @__PURE__ */ new Set([clinicId]);
+      if (data.clinics && data.clinics.length > 0) {
+        for (const cId of data.clinics) {
+          if (cId !== clinicId) {
+            const otherClinic = await this.getClinicService().getClinic(cId);
+            if (!otherClinic) {
+              throw new Error(`Clinic ${cId} not found`);
+            }
+          }
+          clinicsToAdd.add(cId);
+        }
+      }
+      const clinics = Array.from(clinicsToAdd);
+      const defaultReviewInfo = {
+        totalReviews: 0,
+        averageRating: 0,
+        knowledgeAndExpertise: 0,
+        communicationSkills: 0,
+        bedSideManner: 0,
+        thoroughness: 0,
+        trustworthiness: 0,
+        recommendationPercentage: 0
+      };
+      const practitionerId = this.generateId();
+      const clinicsInfo = [];
+      for (const cId of clinics) {
+        const clinicData = await this.getClinicService().getClinic(cId);
+        if (clinicData) {
+          clinicsInfo.push({
+            id: clinicData.id,
+            name: clinicData.name,
+            location: clinicData.location,
+            contactInfo: clinicData.contactInfo,
+            // Make sure we're using the right property for featuredPhoto
+            featuredPhoto: clinicData.featuredPhotos && clinicData.featuredPhotos.length > 0 ? typeof clinicData.featuredPhotos[0] === "string" ? clinicData.featuredPhotos[0] : "" : (typeof clinicData.coverPhoto === "string" ? clinicData.coverPhoto : "") || "",
+            description: clinicData.description || null
+          });
+        }
+      }
+      const finalClinicsInfo = validatedData.clinicsInfo && validatedData.clinicsInfo.length > 0 ? validatedData.clinicsInfo : clinicsInfo;
+      const proceduresInfo = [];
+      const practitionerData = {
+        id: practitionerId,
+        userRef: "",
+        // Prazno - biće popunjeno kada korisnik kreira nalog
+        basicInfo: await this.processBasicInfo(
+          validatedData.basicInfo,
+          practitionerId
+        ),
+        certification: validatedData.certification,
+        clinics,
+        clinicWorkingHours: validatedData.clinicWorkingHours || [],
+        clinicsInfo: finalClinicsInfo,
+        procedures: [],
+        proceduresInfo,
+        reviewInfo: defaultReviewInfo,
+        isActive: validatedData.isActive !== void 0 ? validatedData.isActive : false,
+        isVerified: validatedData.isVerified !== void 0 ? validatedData.isVerified : false,
+        status: "draft" /* DRAFT */,
+        createdAt: (0, import_firestore18.serverTimestamp)(),
+        updatedAt: (0, import_firestore18.serverTimestamp)()
+      };
+      practitionerSchema.parse({
+        ...practitionerData,
+        userRef: "temp-for-validation",
+        createdAt: import_firestore18.Timestamp.now(),
+        updatedAt: import_firestore18.Timestamp.now()
+      });
+      await (0, import_firestore18.setDoc)(
+        (0, import_firestore18.doc)(this.db, PRACTITIONERS_COLLECTION, practitionerData.id),
+        practitionerData
+      );
+      const savedPractitioner = await this.getPractitioner(practitionerData.id);
+      if (!savedPractitioner) {
+        throw new Error("Failed to create draft practitioner profile");
+      }
+      const tokenString = this.generateId().slice(0, 6).toUpperCase();
+      const expiration = new Date(Date.now() + 7 * 24 * 60 * 60 * 1e3);
+      const token = {
+        id: this.generateId(),
+        token: tokenString,
+        practitionerId,
+        email: practitionerData.basicInfo.email,
+        clinicId,
+        status: "active" /* ACTIVE */,
+        createdBy,
+        createdAt: import_firestore18.Timestamp.now(),
+        expiresAt: import_firestore18.Timestamp.fromDate(expiration)
+      };
+      practitionerTokenSchema.parse(token);
+      const tokenPath = `${PRACTITIONERS_COLLECTION}/${practitionerId}/${REGISTER_TOKENS_COLLECTION}/${token.id}`;
+      await (0, import_firestore18.setDoc)((0, import_firestore18.doc)(this.db, tokenPath), token);
+      return { practitioner: savedPractitioner, token };
+    } catch (error) {
+      if (error instanceof import_zod15.z.ZodError) {
+        throw new Error("Invalid practitioner data: " + error.message);
+      }
+      throw error;
+    }
+  }
+  /**
+   * Creates a token for inviting practitioner to claim their profile
+   * @param data Data for creating token
+   * @param createdBy ID of the user creating the token
+   * @returns Created token
+   */
+  async createPractitionerToken(data, createdBy) {
+    try {
+      const validatedData = createPractitionerTokenSchema.parse(data);
+      const practitioner = await this.getPractitioner(
+        validatedData.practitionerId
+      );
+      if (!practitioner) {
+        throw new Error("Practitioner not found");
+      }
+      if (practitioner.status !== "draft" /* DRAFT */) {
+        throw new Error(
+          "Can only create tokens for practitioners in DRAFT status"
+        );
+      }
+      const clinic = await this.getClinicService().getClinic(
+        validatedData.clinicId
+      );
+      if (!clinic) {
+        throw new Error(`Clinic ${validatedData.clinicId} not found`);
+      }
+      if (!practitioner.clinics.includes(validatedData.clinicId)) {
+        throw new Error("Practitioner is not associated with this clinic");
+      }
+      const expiration = validatedData.expiresAt || new Date(Date.now() + 7 * 24 * 60 * 60 * 1e3);
+      const tokenString = this.generateId().slice(0, 6).toUpperCase();
+      const token = {
+        id: this.generateId(),
+        token: tokenString,
+        practitionerId: validatedData.practitionerId,
+        email: validatedData.email,
+        clinicId: validatedData.clinicId,
+        status: "active" /* ACTIVE */,
+        createdBy,
+        createdAt: import_firestore18.Timestamp.now(),
+        expiresAt: import_firestore18.Timestamp.fromDate(expiration)
+      };
+      practitionerTokenSchema.parse(token);
+      const tokenPath = `${PRACTITIONERS_COLLECTION}/${validatedData.practitionerId}/${REGISTER_TOKENS_COLLECTION}/${token.id}`;
+      await (0, import_firestore18.setDoc)((0, import_firestore18.doc)(this.db, tokenPath), token);
+      return token;
+    } catch (error) {
+      if (error instanceof import_zod15.z.ZodError) {
+        throw new Error("Invalid token data: " + error.message);
+      }
+      throw error;
+    }
+  }
+  /**
+   * Gets active tokens for a practitioner
+   * @param practitionerId ID of the practitioner
+   * @returns Array of active tokens
+   */
+  async getPractitionerActiveTokens(practitionerId) {
+    const tokensRef = (0, import_firestore18.collection)(
+      this.db,
+      `${PRACTITIONERS_COLLECTION}/${practitionerId}/${REGISTER_TOKENS_COLLECTION}`
+    );
+    const q = (0, import_firestore18.query)(
+      tokensRef,
+      (0, import_firestore18.where)("status", "==", "active" /* ACTIVE */),
+      (0, import_firestore18.where)("expiresAt", ">", import_firestore18.Timestamp.now())
+    );
+    const querySnapshot = await (0, import_firestore18.getDocs)(q);
+    return querySnapshot.docs.map((doc34) => doc34.data());
+  }
+  /**
+   * Gets a token by its string value and validates it
+   * @param tokenString The token string to find
+   * @returns The token if found and valid, null otherwise
+   */
+  async validateToken(tokenString) {
+    const practitionersRef = (0, import_firestore18.collection)(this.db, PRACTITIONERS_COLLECTION);
+    const practitionersSnapshot = await (0, import_firestore18.getDocs)(practitionersRef);
+    for (const practitionerDoc of practitionersSnapshot.docs) {
+      const practitionerId = practitionerDoc.id;
+      const tokensRef = (0, import_firestore18.collection)(
+        this.db,
+        `${PRACTITIONERS_COLLECTION}/${practitionerId}/${REGISTER_TOKENS_COLLECTION}`
+      );
+      console.log(
+        `[PRACTITIONER] Validating token for practitioner ${practitionerId}`,
+        {
+          tokenString,
+          timestamp: import_firestore18.Timestamp.now().toDate()
+        }
+      );
+      const q = (0, import_firestore18.query)(
+        tokensRef,
+        (0, import_firestore18.where)("token", "==", tokenString),
+        (0, import_firestore18.where)("status", "==", "active" /* ACTIVE */),
+        (0, import_firestore18.where)("expiresAt", ">", import_firestore18.Timestamp.now())
+      );
+      try {
+        const tokenSnapshot = await (0, import_firestore18.getDocs)(q);
+        console.log(
+          `[PRACTITIONER] Token query results for practitioner ${practitionerId}`,
+          {
+            found: !tokenSnapshot.empty,
+            count: tokenSnapshot.size
+          }
+        );
+        if (!tokenSnapshot.empty) {
+          const tokenData = tokenSnapshot.docs[0].data();
+          console.log(`[PRACTITIONER] Valid token found`, {
+            tokenId: tokenData.id,
+            expiresAt: tokenData.expiresAt.toDate()
+          });
+          return tokenData;
+        }
+      } catch (error) {
+        console.error(
+          `[PRACTITIONER] Error validating token for practitioner ${practitionerId}:`,
+          error
+        );
+        throw error;
+      }
+    }
+    return null;
+  }
+  /**
+   * Marks a token as used
+   * @param tokenId ID of the token
+   * @param practitionerId ID of the practitioner
+   * @param userId ID of the user using the token
+   */
+  async markTokenAsUsed(tokenId, practitionerId, userId) {
+    const tokenRef = (0, import_firestore18.doc)(
+      this.db,
+      `${PRACTITIONERS_COLLECTION}/${practitionerId}/${REGISTER_TOKENS_COLLECTION}/${tokenId}`
+    );
+    await (0, import_firestore18.updateDoc)(tokenRef, {
+      status: "used" /* USED */,
+      usedBy: userId,
+      usedAt: import_firestore18.Timestamp.now()
+    });
+  }
+  /**
+   * Dohvata zdravstvenog radnika po ID-u
+   */
+  async getPractitioner(practitionerId) {
+    const practitionerDoc = await (0, import_firestore18.getDoc)(
+      (0, import_firestore18.doc)(this.db, PRACTITIONERS_COLLECTION, practitionerId)
+    );
+    if (!practitionerDoc.exists()) {
+      return null;
+    }
+    return practitionerDoc.data();
+  }
+  /**
+   * Dohvata zdravstvenog radnika po User ID-u
+   */
+  async getPractitionerByUserRef(userRef) {
+    const q = (0, import_firestore18.query)(
+      (0, import_firestore18.collection)(this.db, PRACTITIONERS_COLLECTION),
+      (0, import_firestore18.where)("userRef", "==", userRef)
+    );
+    const querySnapshot = await (0, import_firestore18.getDocs)(q);
+    if (querySnapshot.empty) {
+      return null;
+    }
+    return querySnapshot.docs[0].data();
+  }
+  /**
+   * Dohvata sve zdravstvene radnike za određenu kliniku sa statusom ACTIVE
+   */
+  async getPractitionersByClinic(clinicId) {
+    const q = (0, import_firestore18.query)(
+      (0, import_firestore18.collection)(this.db, PRACTITIONERS_COLLECTION),
+      (0, import_firestore18.where)("clinics", "array-contains", clinicId),
+      (0, import_firestore18.where)("isActive", "==", true),
+      (0, import_firestore18.where)("status", "==", "active" /* ACTIVE */)
+    );
+    const querySnapshot = await (0, import_firestore18.getDocs)(q);
+    return querySnapshot.docs.map((doc34) => doc34.data());
+  }
+  /**
+   * Dohvata sve zdravstvene radnike za određenu kliniku
+   */
+  async getAllPractitionersByClinic(clinicId) {
+    const q = (0, import_firestore18.query)(
+      (0, import_firestore18.collection)(this.db, PRACTITIONERS_COLLECTION),
+      (0, import_firestore18.where)("clinics", "array-contains", clinicId),
+      (0, import_firestore18.where)("isActive", "==", true)
+    );
+    const querySnapshot = await (0, import_firestore18.getDocs)(q);
+    return querySnapshot.docs.map((doc34) => doc34.data());
+  }
+  /**
+   * Dohvata sve draft zdravstvene radnike za određenu kliniku sa statusom DRAFT
+   */
+  async getDraftPractitionersByClinic(clinicId) {
+    const q = (0, import_firestore18.query)(
+      (0, import_firestore18.collection)(this.db, PRACTITIONERS_COLLECTION),
+      (0, import_firestore18.where)("clinics", "array-contains", clinicId),
+      (0, import_firestore18.where)("status", "==", "draft" /* DRAFT */)
+    );
+    const querySnapshot = await (0, import_firestore18.getDocs)(q);
+    return querySnapshot.docs.map((doc34) => doc34.data());
+  }
+  /**
+   * Updates a practitioner
+   */
+  async updatePractitioner(practitionerId, data) {
+    try {
+      const validData = data;
+      const practitionerRef = (0, import_firestore18.doc)(
+        this.db,
+        PRACTITIONERS_COLLECTION,
+        practitionerId
+      );
+      const practitionerDoc = await (0, import_firestore18.getDoc)(practitionerRef);
+      if (!practitionerDoc.exists()) {
+        throw new Error(`Practitioner ${practitionerId} not found`);
+      }
+      const currentPractitioner = practitionerDoc.data();
+      let processedData = { ...validData };
+      if (validData.basicInfo) {
+        processedData.basicInfo = await this.processBasicInfo(
+          validData.basicInfo,
+          practitionerId
+        );
+      }
+      const updateData = {
+        ...processedData,
+        updatedAt: (0, import_firestore18.serverTimestamp)()
+      };
+      await (0, import_firestore18.updateDoc)(practitionerRef, updateData);
+      const updatedPractitioner = await this.getPractitioner(practitionerId);
+      if (!updatedPractitioner) {
+        throw new Error(
+          `Failed to retrieve updated practitioner ${practitionerId}`
+        );
+      }
+      return updatedPractitioner;
+    } catch (error) {
+      if (error instanceof import_zod15.z.ZodError) {
+        throw new Error(`Invalid practitioner update data: ${error.message}`);
+      }
+      console.error(`Error updating practitioner ${practitionerId}:`, error);
+      throw error;
+    }
+  }
+  /**
+   * Adds a clinic to a practitioner
+   */
+  async addClinic(practitionerId, clinicId) {
+    var _a;
+    try {
+      const practitionerRef = (0, import_firestore18.doc)(
+        this.db,
+        PRACTITIONERS_COLLECTION,
+        practitionerId
+      );
+      const practitionerDoc = await (0, import_firestore18.getDoc)(practitionerRef);
+      if (!practitionerDoc.exists()) {
+        throw new Error(`Practitioner ${practitionerId} not found`);
+      }
+      const practitioner = practitionerDoc.data();
+      if ((_a = practitioner.clinics) == null ? void 0 : _a.includes(clinicId)) {
+        console.log(
+          `Clinic ${clinicId} already added to practitioner ${practitionerId}`
+        );
+        return;
+      }
+      await (0, import_firestore18.updateDoc)(practitionerRef, {
+        clinics: (0, import_firestore18.arrayUnion)(clinicId),
+        updatedAt: (0, import_firestore18.serverTimestamp)()
+      });
+    } catch (error) {
+      console.error(
+        `Error adding clinic ${clinicId} to practitioner ${practitionerId}:`,
+        error
+      );
+      throw error;
+    }
+  }
+  /**
+   * Removes a clinic from a practitioner
+   */
+  async removeClinic(practitionerId, clinicId) {
+    try {
+      const practitionerRef = (0, import_firestore18.doc)(
+        this.db,
+        PRACTITIONERS_COLLECTION,
+        practitionerId
+      );
+      const practitionerDoc = await (0, import_firestore18.getDoc)(practitionerRef);
+      if (!practitionerDoc.exists()) {
+        throw new Error(`Practitioner ${practitionerId} not found`);
+      }
+      await (0, import_firestore18.updateDoc)(practitionerRef, {
+        clinics: (0, import_firestore18.arrayRemove)(clinicId),
+        updatedAt: (0, import_firestore18.serverTimestamp)()
+      });
+    } catch (error) {
+      console.error(
+        `Error removing clinic ${clinicId} from practitioner ${practitionerId}:`,
+        error
+      );
+      throw error;
+    }
+  }
+  /**
+   * Deaktivira profil zdravstvenog radnika
+   */
+  async deactivatePractitioner(practitionerId) {
+    await this.updatePractitioner(practitionerId, {
+      isActive: false
+    });
+  }
+  /**
+   * Aktivira profil zdravstvenog radnika
+   */
+  async activatePractitioner(practitionerId) {
+    await this.updatePractitioner(practitionerId, {
+      isActive: true
+    });
+  }
+  /**
+   * Briše profil zdravstvenog radnika
+   */
+  async deletePractitioner(practitionerId) {
+    const practitioner = await this.getPractitioner(practitionerId);
+    if (!practitioner) {
+      throw new Error("Practitioner not found");
+    }
+    await (0, import_firestore18.deleteDoc)((0, import_firestore18.doc)(this.db, PRACTITIONERS_COLLECTION, practitionerId));
+  }
+  /**
+   * Validates a registration token and claims the associated draft practitioner profile
+   * @param tokenString The token provided by the practitioner
+   * @param userId The ID of the user claiming the profile
+   * @returns The claimed practitioner profile or null if token is invalid
+   */
+  async validateTokenAndClaimProfile(tokenString, userId) {
+    console.log("[PRACTITIONER] Validating token for claiming profile", {
+      tokenString,
+      userId
+    });
+    const token = await this.validateToken(tokenString);
+    if (!token) {
+      console.log(
+        "[PRACTITIONER] Token validation failed - token not found or not valid",
+        {
+          tokenString
+        }
+      );
+      return null;
+    }
+    console.log("[PRACTITIONER] Token successfully validated", {
+      tokenId: token.id,
+      practitionerId: token.practitionerId
+    });
+    const practitioner = await this.getPractitioner(token.practitionerId);
+    if (!practitioner) {
+      console.log("[PRACTITIONER] Practitioner not found", {
+        practitionerId: token.practitionerId
+      });
+      return null;
+    }
+    if (practitioner.status !== "draft" /* DRAFT */) {
+      console.log("[PRACTITIONER] Practitioner status is not DRAFT", {
+        practitionerId: practitioner.id,
+        status: practitioner.status
+      });
+      throw new Error("This practitioner profile has already been claimed");
+    }
+    const existingPractitioner = await this.getPractitionerByUserRef(userId);
+    if (existingPractitioner) {
+      throw new Error("User already has a practitioner profile");
+    }
+    const updatedPractitioner = await this.updatePractitioner(practitioner.id, {
+      userRef: userId,
+      status: "active" /* ACTIVE */
+    });
+    await this.markTokenAsUsed(token.id, token.practitionerId, userId);
+    console.log("[PRACTITIONER] Profile claimed successfully", {
+      practitionerId: updatedPractitioner.id,
+      userId
     });
     return updatedPractitioner;
   }
@@ -4802,21 +5161,21 @@ var PractitionerService = class extends BaseService {
     try {
       const constraints = [];
       if (!(options == null ? void 0 : options.includeDraftPractitioners)) {
-        constraints.push((0, import_firestore16.where)("status", "==", "active" /* ACTIVE */));
+        constraints.push((0, import_firestore18.where)("status", "==", "active" /* ACTIVE */));
       }
-      constraints.push((0, import_firestore16.orderBy)("basicInfo.lastName", "asc"));
-      constraints.push((0, import_firestore16.orderBy)("basicInfo.firstName", "asc"));
+      constraints.push((0, import_firestore18.orderBy)("basicInfo.lastName", "asc"));
+      constraints.push((0, import_firestore18.orderBy)("basicInfo.firstName", "asc"));
       if ((options == null ? void 0 : options.pagination) && options.pagination > 0) {
         if (options.lastDoc) {
-          constraints.push((0, import_firestore16.startAfter)(options.lastDoc));
+          constraints.push((0, import_firestore18.startAfter)(options.lastDoc));
         }
-        constraints.push((0, import_firestore16.limit)(options.pagination));
+        constraints.push((0, import_firestore18.limit)(options.pagination));
       }
-      const q = (0, import_firestore16.query)(
-        (0, import_firestore16.collection)(this.db, PRACTITIONERS_COLLECTION),
+      const q = (0, import_firestore18.query)(
+        (0, import_firestore18.collection)(this.db, PRACTITIONERS_COLLECTION),
         ...constraints
       );
-      const querySnapshot = await (0, import_firestore16.getDocs)(q);
+      const querySnapshot = await (0, import_firestore18.getDocs)(q);
       const practitioners = querySnapshot.docs.map(
         (doc34) => doc34.data()
       );
@@ -4861,31 +5220,31 @@ var PractitionerService = class extends BaseService {
       );
       const constraints = [];
       if (!filters.includeDraftPractitioners) {
-        constraints.push((0, import_firestore16.where)("status", "==", "active" /* ACTIVE */));
+        constraints.push((0, import_firestore18.where)("status", "==", "active" /* ACTIVE */));
       }
-      constraints.push((0, import_firestore16.where)("isActive", "==", true));
+      constraints.push((0, import_firestore18.where)("isActive", "==", true));
       if (filters.certifications && filters.certifications.length > 0) {
         constraints.push(
-          (0, import_firestore16.where)(
+          (0, import_firestore18.where)(
             "certification.certifications",
             "array-contains-any",
             filters.certifications
           )
         );
       }
-      constraints.push((0, import_firestore16.orderBy)("basicInfo.lastName", "asc"));
-      constraints.push((0, import_firestore16.orderBy)("basicInfo.firstName", "asc"));
+      constraints.push((0, import_firestore18.orderBy)("basicInfo.lastName", "asc"));
+      constraints.push((0, import_firestore18.orderBy)("basicInfo.firstName", "asc"));
       if (filters.pagination && filters.pagination > 0) {
         if (filters.lastDoc) {
-          constraints.push((0, import_firestore16.startAfter)(filters.lastDoc));
+          constraints.push((0, import_firestore18.startAfter)(filters.lastDoc));
         }
-        constraints.push((0, import_firestore16.limit)(filters.pagination));
+        constraints.push((0, import_firestore18.limit)(filters.pagination));
       }
-      const q = (0, import_firestore16.query)(
-        (0, import_firestore16.collection)(this.db, PRACTITIONERS_COLLECTION),
+      const q = (0, import_firestore18.query)(
+        (0, import_firestore18.collection)(this.db, PRACTITIONERS_COLLECTION),
         ...constraints
       );
-      const querySnapshot = await (0, import_firestore16.getDocs)(q);
+      const querySnapshot = await (0, import_firestore18.getDocs)(q);
       console.log(
         `[PRACTITIONER_SERVICE] Found ${querySnapshot.docs.length} practitioners with base query`
       );
@@ -5007,11 +5366,11 @@ var UserService = class extends BaseService {
       email: firebaseUser.email,
       roles: roles.length > 0 ? roles : ["patient" /* PATIENT */],
       isAnonymous: firebaseUser.isAnonymous,
-      createdAt: (0, import_firestore17.serverTimestamp)(),
-      updatedAt: (0, import_firestore17.serverTimestamp)(),
-      lastLoginAt: (0, import_firestore17.serverTimestamp)()
+      createdAt: (0, import_firestore19.serverTimestamp)(),
+      updatedAt: (0, import_firestore19.serverTimestamp)(),
+      lastLoginAt: (0, import_firestore19.serverTimestamp)()
     };
-    await (0, import_firestore17.setDoc)((0, import_firestore17.doc)(this.db, USERS_COLLECTION, userData.uid), userData);
+    await (0, import_firestore19.setDoc)((0, import_firestore19.doc)(this.db, USERS_COLLECTION, userData.uid), userData);
     if (options == null ? void 0 : options.skipProfileCreation) {
       return this.getUserById(userData.uid);
     }
@@ -5020,7 +5379,7 @@ var UserService = class extends BaseService {
       roles,
       options
     );
-    await (0, import_firestore17.updateDoc)((0, import_firestore17.doc)(this.db, USERS_COLLECTION, userData.uid), profiles);
+    await (0, import_firestore19.updateDoc)((0, import_firestore19.doc)(this.db, USERS_COLLECTION, userData.uid), profiles);
     return this.getUserById(userData.uid);
   }
   /**
@@ -5098,7 +5457,7 @@ var UserService = class extends BaseService {
               email: "",
               phoneNumber: "",
               title: "",
-              dateOfBirth: import_firestore17.Timestamp.now(),
+              dateOfBirth: import_firestore19.Timestamp.now(),
               gender: "other",
               languages: ["Serbian"]
             },
@@ -5107,7 +5466,7 @@ var UserService = class extends BaseService {
               specialties: [],
               licenseNumber: "",
               issuingAuthority: "",
-              issueDate: import_firestore17.Timestamp.now(),
+              issueDate: import_firestore19.Timestamp.now(),
               verificationStatus: "pending"
             },
             isActive: true,
@@ -5123,7 +5482,7 @@ var UserService = class extends BaseService {
    * Dohvata korisnika po ID-u
    */
   async getUserById(uid) {
-    const userDoc = await (0, import_firestore17.getDoc)((0, import_firestore17.doc)(this.db, USERS_COLLECTION, uid));
+    const userDoc = await (0, import_firestore19.getDoc)((0, import_firestore19.doc)(this.db, USERS_COLLECTION, uid));
     if (!userDoc.exists()) {
       throw USER_ERRORS.NOT_FOUND;
     }
@@ -5134,19 +5493,19 @@ var UserService = class extends BaseService {
    * Dohvata korisnika po email-u
    */
   async getUserByEmail(email) {
-    const usersRef = (0, import_firestore17.collection)(this.db, USERS_COLLECTION);
-    const q = (0, import_firestore17.query)(usersRef, (0, import_firestore17.where)("email", "==", email));
-    const querySnapshot = await (0, import_firestore17.getDocs)(q);
+    const usersRef = (0, import_firestore19.collection)(this.db, USERS_COLLECTION);
+    const q = (0, import_firestore19.query)(usersRef, (0, import_firestore19.where)("email", "==", email));
+    const querySnapshot = await (0, import_firestore19.getDocs)(q);
     if (querySnapshot.empty) return null;
     const userData = querySnapshot.docs[0].data();
     return userSchema.parse(userData);
   }
   async getUsersByRole(role) {
     const constraints = [
-      (0, import_firestore17.where)("roles", "array-contains", role)
+      (0, import_firestore19.where)("roles", "array-contains", role)
     ];
-    const q = (0, import_firestore17.query)((0, import_firestore17.collection)(this.db, USERS_COLLECTION), ...constraints);
-    const querySnapshot = await (0, import_firestore17.getDocs)(q);
+    const q = (0, import_firestore19.query)((0, import_firestore19.collection)(this.db, USERS_COLLECTION), ...constraints);
+    const querySnapshot = await (0, import_firestore19.getDocs)(q);
     const users = querySnapshot.docs.map((doc34) => doc34.data());
     return Promise.all(users.map((userData) => userSchema.parse(userData)));
   }
@@ -5154,33 +5513,33 @@ var UserService = class extends BaseService {
    * Ažurira timestamp poslednjeg logovanja
    */
   async updateUserLoginTimestamp(uid) {
-    const userRef = (0, import_firestore17.doc)(this.db, USERS_COLLECTION, uid);
-    const userDoc = await (0, import_firestore17.getDoc)(userRef);
+    const userRef = (0, import_firestore19.doc)(this.db, USERS_COLLECTION, uid);
+    const userDoc = await (0, import_firestore19.getDoc)(userRef);
     if (!userDoc.exists()) {
       throw AUTH_ERRORS.USER_NOT_FOUND;
     }
-    await (0, import_firestore17.updateDoc)(userRef, {
-      lastLoginAt: (0, import_firestore17.serverTimestamp)(),
-      updatedAt: (0, import_firestore17.serverTimestamp)()
+    await (0, import_firestore19.updateDoc)(userRef, {
+      lastLoginAt: (0, import_firestore19.serverTimestamp)(),
+      updatedAt: (0, import_firestore19.serverTimestamp)()
     });
     return this.getUserById(uid);
   }
   async upgradeAnonymousUser(uid, email) {
-    const userRef = (0, import_firestore17.doc)(this.db, USERS_COLLECTION, uid);
-    const userDoc = await (0, import_firestore17.getDoc)(userRef);
+    const userRef = (0, import_firestore19.doc)(this.db, USERS_COLLECTION, uid);
+    const userDoc = await (0, import_firestore19.getDoc)(userRef);
     if (!userDoc.exists()) {
       throw USER_ERRORS.NOT_FOUND;
     }
-    await (0, import_firestore17.updateDoc)(userRef, {
+    await (0, import_firestore19.updateDoc)(userRef, {
       email,
       isAnonymous: false,
-      updatedAt: (0, import_firestore17.serverTimestamp)()
+      updatedAt: (0, import_firestore19.serverTimestamp)()
     });
     return this.getUserById(uid);
   }
   async updateUser(uid, updates) {
-    const userRef = (0, import_firestore17.doc)(this.db, USERS_COLLECTION, uid);
-    const userDoc = await (0, import_firestore17.getDoc)(userRef);
+    const userRef = (0, import_firestore19.doc)(this.db, USERS_COLLECTION, uid);
+    const userDoc = await (0, import_firestore19.getDoc)(userRef);
     if (!userDoc.exists()) {
       throw USER_ERRORS.NOT_FOUND;
     }
@@ -5189,12 +5548,12 @@ var UserService = class extends BaseService {
       const updatedUser = {
         ...currentUser,
         ...updates,
-        updatedAt: (0, import_firestore17.serverTimestamp)()
+        updatedAt: (0, import_firestore19.serverTimestamp)()
       };
       userSchema.parse(updatedUser);
-      await (0, import_firestore17.updateDoc)(userRef, {
+      await (0, import_firestore19.updateDoc)(userRef, {
         ...updates,
-        updatedAt: (0, import_firestore17.serverTimestamp)()
+        updatedAt: (0, import_firestore19.serverTimestamp)()
       });
       return this.getUserById(uid);
     } catch (error) {
@@ -5211,10 +5570,10 @@ var UserService = class extends BaseService {
     const user = await this.getUserById(uid);
     if (user.roles.includes(role)) return;
     const profiles = await this.createProfilesForRoles(uid, [role], options);
-    await (0, import_firestore17.updateDoc)((0, import_firestore17.doc)(this.db, USERS_COLLECTION, uid), {
+    await (0, import_firestore19.updateDoc)((0, import_firestore19.doc)(this.db, USERS_COLLECTION, uid), {
       roles: [...user.roles, role],
       ...profiles,
-      updatedAt: (0, import_firestore17.serverTimestamp)()
+      updatedAt: (0, import_firestore19.serverTimestamp)()
     });
   }
   /**
@@ -5246,15 +5605,15 @@ var UserService = class extends BaseService {
         }
         break;
     }
-    await (0, import_firestore17.updateDoc)((0, import_firestore17.doc)(this.db, USERS_COLLECTION, uid), {
+    await (0, import_firestore19.updateDoc)((0, import_firestore19.doc)(this.db, USERS_COLLECTION, uid), {
       roles: user.roles.filter((r) => r !== role),
-      updatedAt: (0, import_firestore17.serverTimestamp)()
+      updatedAt: (0, import_firestore19.serverTimestamp)()
     });
   }
   // Delete operations
   async deleteUser(uid) {
-    const userRef = (0, import_firestore17.doc)(this.db, USERS_COLLECTION, uid);
-    const userDoc = await (0, import_firestore17.getDoc)(userRef);
+    const userRef = (0, import_firestore19.doc)(this.db, USERS_COLLECTION, uid);
+    const userDoc = await (0, import_firestore19.getDoc)(userRef);
     if (!userDoc.exists()) {
       throw USER_ERRORS.NOT_FOUND;
     }
@@ -5275,7 +5634,7 @@ var UserService = class extends BaseService {
           userData.adminProfile
         );
       }
-      await (0, import_firestore17.deleteDoc)(userRef);
+      await (0, import_firestore19.deleteDoc)(userRef);
     } catch (error) {
       throw error;
     }
@@ -5283,12 +5642,12 @@ var UserService = class extends BaseService {
 };
 
 // src/services/clinic/utils/clinic-group.utils.ts
-var import_firestore18 = require("firebase/firestore");
+var import_firestore20 = require("firebase/firestore");
 var import_geofire_common3 = require("geofire-common");
 var import_zod17 = require("zod");
 
 // src/services/clinic/utils/photos.utils.ts
-var import_storage4 = require("firebase/storage");
+var import_storage5 = require("firebase/storage");
 async function uploadPhoto(photo, entityType, entityId, photoType, app, fileName) {
   if (!photo || typeof photo !== "string" || !photo.startsWith("data:")) {
     return photo;
@@ -5297,9 +5656,9 @@ async function uploadPhoto(photo, entityType, entityId, photoType, app, fileName
     console.log(
       `[PHOTO_UTILS] Uploading ${photoType} for ${entityType}/${entityId}`
     );
-    const storage = (0, import_storage4.getStorage)(app);
+    const storage = (0, import_storage5.getStorage)(app);
     const storageFileName = fileName || `${photoType}-${Date.now()}`;
-    const storageRef = (0, import_storage4.ref)(
+    const storageRef = (0, import_storage5.ref)(
       storage,
       `${entityType}/${entityId}/${storageFileName}`
     );
@@ -5311,8 +5670,8 @@ async function uploadPhoto(photo, entityType, entityId, photoType, app, fileName
       byteArrays.push(byteCharacters.charCodeAt(i));
     }
     const blob = new Blob([new Uint8Array(byteArrays)], { type: contentType });
-    await (0, import_storage4.uploadBytes)(storageRef, blob, { contentType });
-    const downloadUrl = await (0, import_storage4.getDownloadURL)(storageRef);
+    await (0, import_storage5.uploadBytes)(storageRef, blob, { contentType });
+    const downloadUrl = await (0, import_storage5.getDownloadURL)(storageRef);
     console.log(`[PHOTO_UTILS] ${photoType} uploaded successfully`, {
       downloadUrl
     });
@@ -5400,9 +5759,9 @@ async function createClinicGroup(db, data, ownerId, isDefault = false, clinicAdm
       throw geohashError;
     }
   }
-  const now = import_firestore18.Timestamp.now();
+  const now = import_firestore20.Timestamp.now();
   console.log("[CLINIC_GROUP] Preparing clinic group data object");
-  const groupId = (0, import_firestore18.doc)((0, import_firestore18.collection)(db, CLINIC_GROUPS_COLLECTION)).id;
+  const groupId = (0, import_firestore20.doc)((0, import_firestore20.collection)(db, CLINIC_GROUPS_COLLECTION)).id;
   console.log("[CLINIC_GROUP] Logo value:", {
     logoValue: validatedData.logo,
     logoType: validatedData.logo === null ? "null" : typeof validatedData.logo
@@ -5452,7 +5811,7 @@ async function createClinicGroup(db, data, ownerId, isDefault = false, clinicAdm
       groupId: groupData.id
     });
     try {
-      await (0, import_firestore18.setDoc)((0, import_firestore18.doc)(db, CLINIC_GROUPS_COLLECTION, groupData.id), groupData);
+      await (0, import_firestore20.setDoc)((0, import_firestore20.doc)(db, CLINIC_GROUPS_COLLECTION, groupData.id), groupData);
       console.log("[CLINIC_GROUP] Clinic group saved successfully");
     } catch (firestoreError) {
       console.error(
@@ -5498,19 +5857,19 @@ async function createClinicGroup(db, data, ownerId, isDefault = false, clinicAdm
   }
 }
 async function getClinicGroup(db, groupId) {
-  const docRef = (0, import_firestore18.doc)(db, CLINIC_GROUPS_COLLECTION, groupId);
-  const docSnap = await (0, import_firestore18.getDoc)(docRef);
+  const docRef = (0, import_firestore20.doc)(db, CLINIC_GROUPS_COLLECTION, groupId);
+  const docSnap = await (0, import_firestore20.getDoc)(docRef);
   if (docSnap.exists()) {
     return docSnap.data();
   }
   return null;
 }
 async function getAllActiveGroups(db) {
-  const q = (0, import_firestore18.query)(
-    (0, import_firestore18.collection)(db, CLINIC_GROUPS_COLLECTION),
-    (0, import_firestore18.where)("isActive", "==", true)
+  const q = (0, import_firestore20.query)(
+    (0, import_firestore20.collection)(db, CLINIC_GROUPS_COLLECTION),
+    (0, import_firestore20.where)("isActive", "==", true)
   );
-  const querySnapshot = await (0, import_firestore18.getDocs)(q);
+  const querySnapshot = await (0, import_firestore20.getDocs)(q);
   return querySnapshot.docs.map((doc34) => doc34.data());
 }
 async function updateClinicGroup(db, groupId, data, app) {
@@ -5539,10 +5898,10 @@ async function updateClinicGroup(db, groupId, data, app) {
   }
   updatedData = {
     ...updatedData,
-    updatedAt: import_firestore18.Timestamp.now()
+    updatedAt: import_firestore20.Timestamp.now()
   };
   console.log("[CLINIC_GROUP] Updating clinic group in Firestore");
-  await (0, import_firestore18.updateDoc)((0, import_firestore18.doc)(db, CLINIC_GROUPS_COLLECTION, groupId), updatedData);
+  await (0, import_firestore20.updateDoc)((0, import_firestore20.doc)(db, CLINIC_GROUPS_COLLECTION, groupId), updatedData);
   console.log("[CLINIC_GROUP] Clinic group updated successfully");
   const updatedGroup = await getClinicGroup(db, groupId);
   if (!updatedGroup) {
@@ -5623,10 +5982,10 @@ async function createAdminToken(db, groupId, creatorAdminId, app, data) {
   if (!group.admins.includes(creatorAdminId)) {
     throw new Error("Admin does not belong to this clinic group");
   }
-  const now = import_firestore18.Timestamp.now();
+  const now = import_firestore20.Timestamp.now();
   const expiresInDays = (data == null ? void 0 : data.expiresInDays) || 7;
   const email = (data == null ? void 0 : data.email) || null;
-  const expiresAt = new import_firestore18.Timestamp(
+  const expiresAt = new import_firestore20.Timestamp(
     now.seconds + expiresInDays * 24 * 60 * 60,
     now.nanoseconds
   );
@@ -5660,7 +6019,7 @@ async function verifyAndUseAdminToken(db, groupId, token, userRef, app) {
   if (adminToken.status !== "active" /* ACTIVE */) {
     throw new Error("Admin token is not active");
   }
-  const now = import_firestore18.Timestamp.now();
+  const now = import_firestore20.Timestamp.now();
   if (adminToken.expiresAt.seconds < now.seconds) {
     const updatedTokens2 = group.adminTokens.map(
       (t) => t.id === adminToken.id ? { ...t, status: "expired" /* EXPIRED */ } : t
@@ -5933,24 +6292,24 @@ var import_geofire_common7 = require("geofire-common");
 var import_zod19 = require("zod");
 
 // src/services/clinic/utils/clinic.utils.ts
-var import_firestore19 = require("firebase/firestore");
+var import_firestore21 = require("firebase/firestore");
 var import_geofire_common4 = require("geofire-common");
 var import_zod18 = require("zod");
 async function getClinic(db, clinicId) {
-  const docRef = (0, import_firestore19.doc)(db, CLINICS_COLLECTION, clinicId);
-  const docSnap = await (0, import_firestore19.getDoc)(docRef);
+  const docRef = (0, import_firestore21.doc)(db, CLINICS_COLLECTION, clinicId);
+  const docSnap = await (0, import_firestore21.getDoc)(docRef);
   if (docSnap.exists()) {
     return docSnap.data();
   }
   return null;
 }
 async function getClinicsByGroup(db, groupId) {
-  const q = (0, import_firestore19.query)(
-    (0, import_firestore19.collection)(db, CLINICS_COLLECTION),
-    (0, import_firestore19.where)("clinicGroupId", "==", groupId),
-    (0, import_firestore19.where)("isActive", "==", true)
+  const q = (0, import_firestore21.query)(
+    (0, import_firestore21.collection)(db, CLINICS_COLLECTION),
+    (0, import_firestore21.where)("clinicGroupId", "==", groupId),
+    (0, import_firestore21.where)("isActive", "==", true)
   );
-  const querySnapshot = await (0, import_firestore19.getDocs)(q);
+  const querySnapshot = await (0, import_firestore21.getDocs)(q);
   return querySnapshot.docs.map((doc34) => doc34.data());
 }
 async function updateClinic(db, clinicId, data, adminId, clinicAdminService, app) {
@@ -6106,11 +6465,11 @@ async function updateClinic(db, clinicId, data, adminId, clinicAdminService, app
   }
   updatedData = {
     ...updatedData,
-    updatedAt: import_firestore19.Timestamp.now()
+    updatedAt: import_firestore21.Timestamp.now()
   };
   console.log("[CLINIC] Updating clinic in Firestore");
   try {
-    await (0, import_firestore19.updateDoc)((0, import_firestore19.doc)(db, CLINICS_COLLECTION, clinicId), updatedData);
+    await (0, import_firestore21.updateDoc)((0, import_firestore21.doc)(db, CLINICS_COLLECTION, clinicId), updatedData);
     console.log("[CLINIC] Clinic updated successfully");
   } catch (updateError) {
     console.error("[CLINIC] Error updating clinic in Firestore:", updateError);
@@ -6139,12 +6498,12 @@ async function getClinicsByAdmin(db, adminId, options = {}, clinicAdminService,
   if (clinicIds.length === 0) {
     return [];
   }
-  const constraints = [(0, import_firestore19.where)("id", "in", clinicIds)];
+  const constraints = [(0, import_firestore21.where)("id", "in", clinicIds)];
   if (options.isActive !== void 0) {
-    constraints.push((0, import_firestore19.where)("isActive", "==", options.isActive));
+    constraints.push((0, import_firestore21.where)("isActive", "==", options.isActive));
   }
-  const q = (0, import_firestore19.query)((0, import_firestore19.collection)(db, CLINICS_COLLECTION), ...constraints);
-  const querySnapshot = await (0, import_firestore19.getDocs)(q);
+  const q = (0, import_firestore21.query)((0, import_firestore21.collection)(db, CLINICS_COLLECTION), ...constraints);
+  const querySnapshot = await (0, import_firestore21.getDocs)(q);
   return querySnapshot.docs.map((doc34) => doc34.data());
 }
 async function getActiveClinicsByAdmin(db, adminId, clinicAdminService, clinicGroupService) {
@@ -6158,8 +6517,8 @@ async function getActiveClinicsByAdmin(db, adminId, clinicAdminService, clinicGr
 }
 async function getClinicById(db, clinicId) {
   try {
-    const clinicRef = (0, import_firestore19.doc)(db, CLINICS_COLLECTION, clinicId);
-    const clinicSnapshot = await (0, import_firestore19.getDoc)(clinicRef);
+    const clinicRef = (0, import_firestore21.doc)(db, CLINICS_COLLECTION, clinicId);
+    const clinicSnapshot = await (0, import_firestore21.getDoc)(clinicRef);
     if (!clinicSnapshot.exists()) {
       return null;
     }
@@ -6175,20 +6534,20 @@ async function getClinicById(db, clinicId) {
 }
 async function getAllClinics(db, pagination, lastDoc) {
   try {
-    const clinicsCollection = (0, import_firestore19.collection)(db, CLINICS_COLLECTION);
-    let clinicsQuery = (0, import_firestore19.query)(clinicsCollection);
+    const clinicsCollection = (0, import_firestore21.collection)(db, CLINICS_COLLECTION);
+    let clinicsQuery = (0, import_firestore21.query)(clinicsCollection);
     if (pagination && pagination > 0) {
       if (lastDoc) {
-        clinicsQuery = (0, import_firestore19.query)(
+        clinicsQuery = (0, import_firestore21.query)(
           clinicsCollection,
-          (0, import_firestore19.startAfter)(lastDoc),
-          (0, import_firestore19.limit)(pagination)
+          (0, import_firestore21.startAfter)(lastDoc),
+          (0, import_firestore21.limit)(pagination)
         );
       } else {
-        clinicsQuery = (0, import_firestore19.query)(clinicsCollection, (0, import_firestore19.limit)(pagination));
+        clinicsQuery = (0, import_firestore21.query)(clinicsCollection, (0, import_firestore21.limit)(pagination));
       }
     }
-    const clinicsSnapshot = await (0, import_firestore19.getDocs)(clinicsQuery);
+    const clinicsSnapshot = await (0, import_firestore21.getDocs)(clinicsQuery);
     const lastVisible = clinicsSnapshot.docs[clinicsSnapshot.docs.length - 1];
     const clinics = clinicsSnapshot.docs.map((doc34) => {
       const data = doc34.data();
@@ -6215,12 +6574,12 @@ async function getAllClinicsInRange(db, center, rangeInKm, pagination, lastDoc)
   let lastDocSnapshot = null;
   for (const b of bounds) {
     const constraints = [
-      (0, import_firestore19.where)("location.geohash", ">=", b[0]),
-      (0, import_firestore19.where)("location.geohash", "<=", b[1]),
-      (0, import_firestore19.where)("isActive", "==", true)
+      (0, import_firestore21.where)("location.geohash", ">=", b[0]),
+      (0, import_firestore21.where)("location.geohash", "<=", b[1]),
+      (0, import_firestore21.where)("isActive", "==", true)
     ];
-    const q = (0, import_firestore19.query)((0, import_firestore19.collection)(db, CLINICS_COLLECTION), ...constraints);
-    const querySnapshot = await (0, import_firestore19.getDocs)(q);
+    const q = (0, import_firestore21.query)((0, import_firestore21.collection)(db, CLINICS_COLLECTION), ...constraints);
+    const querySnapshot = await (0, import_firestore21.getDocs)(q);
     for (const doc34 of querySnapshot.docs) {
       const clinic = doc34.data();
       const distance = (0, import_geofire_common4.distanceBetween)(
@@ -6315,7 +6674,7 @@ async function removeTags(db, clinicId, adminId, tagsToRemove, clinicAdminServic
 }
 
 // src/services/clinic/utils/search.utils.ts
-var import_firestore20 = require("firebase/firestore");
+var import_firestore22 = require("firebase/firestore");
 var import_geofire_common5 = require("geofire-common");
 async function findClinicsInRadius(db, center, radiusInKm, filters) {
   const bounds = (0, import_geofire_common5.geohashQueryBounds)(
@@ -6325,20 +6684,20 @@ async function findClinicsInRadius(db, center, radiusInKm, filters) {
   const matchingDocs = [];
   for (const b of bounds) {
     const constraints = [
-      (0, import_firestore20.where)("location.geohash", ">=", b[0]),
-      (0, import_firestore20.where)("location.geohash", "<=", b[1]),
-      (0, import_firestore20.where)("isActive", "==", true)
+      (0, import_firestore22.where)("location.geohash", ">=", b[0]),
+      (0, import_firestore22.where)("location.geohash", "<=", b[1]),
+      (0, import_firestore22.where)("isActive", "==", true)
     ];
     if (filters == null ? void 0 : filters.services) {
       constraints.push(
-        (0, import_firestore20.where)("services", "array-contains-any", filters.services)
+        (0, import_firestore22.where)("services", "array-contains-any", filters.services)
       );
     }
     if ((filters == null ? void 0 : filters.tags) && filters.tags.length > 0) {
-      constraints.push((0, import_firestore20.where)("tags", "array-contains-any", filters.tags));
+      constraints.push((0, import_firestore22.where)("tags", "array-contains-any", filters.tags));
     }
-    const q = (0, import_firestore20.query)((0, import_firestore20.collection)(db, CLINICS_COLLECTION), ...constraints);
-    const querySnapshot = await (0, import_firestore20.getDocs)(q);
+    const q = (0, import_firestore22.query)((0, import_firestore22.collection)(db, CLINICS_COLLECTION), ...constraints);
+    const querySnapshot = await (0, import_firestore22.getDocs)(q);
     for (const doc34 of querySnapshot.docs) {
       const clinic = doc34.data();
       const distance = (0, import_geofire_common5.distanceBetween)(
@@ -6365,7 +6724,7 @@ async function findClinicsInRadius(db, center, radiusInKm, filters) {
 }
 
 // src/services/clinic/utils/filter.utils.ts
-var import_firestore21 = require("firebase/firestore");
+var import_firestore23 = require("firebase/firestore");
 var import_geofire_common6 = require("geofire-common");
 async function getClinicsByFilters(db, filters) {
   console.log(
@@ -6375,460 +6734,162 @@ async function getClinicsByFilters(db, filters) {
   const isGeoQuery = filters.center && filters.radiusInKm && filters.radiusInKm > 0;
   const constraints = [];
   if (filters.isActive !== void 0) {
-    constraints.push((0, import_firestore21.where)("isActive", "==", filters.isActive));
+    constraints.push((0, import_firestore23.where)("isActive", "==", filters.isActive));
   } else {
-    constraints.push((0, import_firestore21.where)("isActive", "==", true));
+    constraints.push((0, import_firestore23.where)("isActive", "==", true));
   }
   if (filters.tags && filters.tags.length > 0) {
-    constraints.push((0, import_firestore21.where)("tags", "array-contains", filters.tags[0]));
+    constraints.push((0, import_firestore23.where)("tags", "array-contains", filters.tags[0]));
   }
   if (filters.procedureTechnology) {
     constraints.push(
-      (0, import_firestore21.where)("servicesInfo.technology", "==", filters.procedureTechnology)
+      (0, import_firestore23.where)("servicesInfo.technology", "==", filters.procedureTechnology)
     );
   } else if (filters.procedureSubcategory) {
     constraints.push(
-      (0, import_firestore21.where)("servicesInfo.subCategory", "==", filters.procedureSubcategory)
+      (0, import_firestore23.where)("servicesInfo.subCategory", "==", filters.procedureSubcategory)
     );
   } else if (filters.procedureCategory) {
     constraints.push(
-      (0, import_firestore21.where)("servicesInfo.category", "==", filters.procedureCategory)
+      (0, import_firestore23.where)("servicesInfo.category", "==", filters.procedureCategory)
     );
   } else if (filters.procedureFamily) {
     constraints.push(
-      (0, import_firestore21.where)("servicesInfo.procedureFamily", "==", filters.procedureFamily)
+      (0, import_firestore23.where)("servicesInfo.procedureFamily", "==", filters.procedureFamily)
     );
   }
   if (filters.pagination && filters.pagination > 0 && filters.lastDoc) {
-    constraints.push((0, import_firestore21.startAfter)(filters.lastDoc));
-    constraints.push((0, import_firestore21.limit)(filters.pagination));
+    constraints.push((0, import_firestore23.startAfter)(filters.lastDoc));
+    constraints.push((0, import_firestore23.limit)(filters.pagination));
   } else if (filters.pagination && filters.pagination > 0) {
-    constraints.push((0, import_firestore21.limit)(filters.pagination));
+    constraints.push((0, import_firestore23.limit)(filters.pagination));
   }
-  constraints.push((0, import_firestore21.orderBy)("location.geohash"));
+  constraints.push((0, import_firestore23.orderBy)("location.geohash"));
   let clinicsResult = [];
   let lastVisibleDoc = null;
   if (isGeoQuery) {
     const center = filters.center;
     const radiusInKm = filters.radiusInKm;
     const bounds = (0, import_geofire_common6.geohashQueryBounds)(
-      [center.latitude, center.longitude],
-      radiusInKm * 1e3
-      // Convert to meters
-    );
-    const matchingClinics = [];
-    for (const bound of bounds) {
-      const geoConstraints = [
-        ...constraints,
-        (0, import_firestore21.where)("location.geohash", ">=", bound[0]),
-        (0, import_firestore21.where)("location.geohash", "<=", bound[1])
-      ];
-      const q = (0, import_firestore21.query)((0, import_firestore21.collection)(db, CLINICS_COLLECTION), ...geoConstraints);
-      const querySnapshot = await (0, import_firestore21.getDocs)(q);
-      console.log(
-        `[FILTER_UTILS] Found ${querySnapshot.docs.length} clinics in geo bound`
-      );
-      for (const doc34 of querySnapshot.docs) {
-        const clinic = { ...doc34.data(), id: doc34.id };
-        const distance = (0, import_geofire_common6.distanceBetween)(
-          [center.latitude, center.longitude],
-          [clinic.location.latitude, clinic.location.longitude]
-        );
-        const distanceInKm = distance / 1e3;
-        if (distanceInKm <= radiusInKm) {
-          matchingClinics.push({
-            ...clinic,
-            distance: distanceInKm
-          });
-        }
-      }
-    }
-    let filteredClinics = matchingClinics;
-    if (filters.tags && filters.tags.length > 1) {
-      filteredClinics = filteredClinics.filter((clinic) => {
-        return filters.tags.every((tag) => clinic.tags.includes(tag));
-      });
-    }
-    if (filters.minRating !== void 0) {
-      filteredClinics = filteredClinics.filter(
-        (clinic) => clinic.reviewInfo.averageRating >= filters.minRating
-      );
-    }
-    if (filters.maxRating !== void 0) {
-      filteredClinics = filteredClinics.filter(
-        (clinic) => clinic.reviewInfo.averageRating <= filters.maxRating
-      );
-    }
-    filteredClinics.sort((a, b) => a.distance - b.distance);
-    if (filters.pagination && filters.pagination > 0) {
-      let startIndex = 0;
-      if (filters.lastDoc) {
-        const lastDocIndex = filteredClinics.findIndex(
-          (clinic) => clinic.id === filters.lastDoc.id
-        );
-        if (lastDocIndex !== -1) {
-          startIndex = lastDocIndex + 1;
-        }
-      }
-      const paginatedClinics = filteredClinics.slice(
-        startIndex,
-        startIndex + filters.pagination
-      );
-      lastVisibleDoc = paginatedClinics.length > 0 ? paginatedClinics[paginatedClinics.length - 1] : null;
-      clinicsResult = paginatedClinics;
-    } else {
-      clinicsResult = filteredClinics;
-    }
-  } else {
-    const q = (0, import_firestore21.query)((0, import_firestore21.collection)(db, CLINICS_COLLECTION), ...constraints);
-    const querySnapshot = await (0, import_firestore21.getDocs)(q);
-    console.log(
-      `[FILTER_UTILS] Found ${querySnapshot.docs.length} clinics with regular query`
-    );
-    const clinics = querySnapshot.docs.map((doc34) => {
-      return { ...doc34.data(), id: doc34.id };
-    });
-    let filteredClinics = clinics;
-    if (filters.center) {
-      const center = filters.center;
-      const clinicsWithDistance = [];
-      filteredClinics.forEach((clinic) => {
-        const distance = (0, import_geofire_common6.distanceBetween)(
-          [center.latitude, center.longitude],
-          [clinic.location.latitude, clinic.location.longitude]
-        );
-        clinicsWithDistance.push({
-          ...clinic,
-          distance: distance / 1e3
-          // Convert to kilometers
-        });
-      });
-      filteredClinics = clinicsWithDistance;
-      filteredClinics.sort(
-        (a, b) => a.distance - b.distance
-      );
-    }
-    if (filters.tags && filters.tags.length > 1) {
-      filteredClinics = filteredClinics.filter((clinic) => {
-        return filters.tags.every((tag) => clinic.tags.includes(tag));
-      });
-    }
-    if (filters.minRating !== void 0) {
-      filteredClinics = filteredClinics.filter(
-        (clinic) => clinic.reviewInfo.averageRating >= filters.minRating
-      );
-    }
-    if (filters.maxRating !== void 0) {
-      filteredClinics = filteredClinics.filter(
-        (clinic) => clinic.reviewInfo.averageRating <= filters.maxRating
-      );
-    }
-    lastVisibleDoc = querySnapshot.docs.length > 0 ? querySnapshot.docs[querySnapshot.docs.length - 1] : null;
-    clinicsResult = filteredClinics;
-  }
-  return {
-    clinics: clinicsResult,
-    lastDoc: lastVisibleDoc
-  };
-}
-
-// src/services/media/media.service.ts
-var import_firestore22 = require("firebase/firestore");
-var import_storage5 = require("firebase/storage");
-var import_firestore23 = require("firebase/firestore");
-var MediaAccessLevel = /* @__PURE__ */ ((MediaAccessLevel2) => {
-  MediaAccessLevel2["PUBLIC"] = "public";
-  MediaAccessLevel2["PRIVATE"] = "private";
-  MediaAccessLevel2["CONFIDENTIAL"] = "confidential";
-  return MediaAccessLevel2;
-})(MediaAccessLevel || {});
-var MEDIA_METADATA_COLLECTION = "media_metadata";
-var MediaService = class extends BaseService {
-  constructor(db, auth, app) {
-    super(db, auth, app);
-  }
-  /**
-   * Upload a media file, store its metadata, and return the metadata including the URL.
-   * @param file - The file to upload.
-   * @param ownerId - ID of the owner (user, patient, clinic, etc.).
-   * @param accessLevel - Access level (public, private, confidential).
-   * @param collectionName - The logical collection name this media belongs to (e.g., 'patient_profile_pictures', 'clinic_logos').
-   * @param originalFileName - Optional: the original name of the file, if not using file.name.
-   * @returns Promise with the media metadata.
-   */
-  async uploadMedia(file, ownerId, accessLevel, collectionName, originalFileName) {
-    const mediaId = this.generateId();
-    const fileNameToUse = originalFileName || (file instanceof File ? file.name : file.toString());
-    const uniqueFileName = `${mediaId}-${fileNameToUse}`;
-    const filePath = `media/${accessLevel}/${ownerId}/${collectionName}/${uniqueFileName}`;
-    console.log(`[MediaService] Uploading file to: ${filePath}`);
-    const storageRef = (0, import_storage5.ref)(this.storage, filePath);
-    try {
-      const uploadResult = await (0, import_storage5.uploadBytes)(storageRef, file, {
-        contentType: file.type
-      });
-      console.log("[MediaService] File uploaded successfully", uploadResult);
-      const downloadURL = await (0, import_storage5.getDownloadURL)(uploadResult.ref);
-      console.log("[MediaService] Got download URL:", downloadURL);
-      const metadata = {
-        id: mediaId,
-        name: fileNameToUse,
-        url: downloadURL,
-        contentType: file.type,
-        size: file.size,
-        createdAt: import_firestore22.Timestamp.now(),
-        accessLevel,
-        ownerId,
-        collectionName,
-        path: filePath
-      };
-      const metadataDocRef = (0, import_firestore23.doc)(this.db, MEDIA_METADATA_COLLECTION, mediaId);
-      await (0, import_firestore23.setDoc)(metadataDocRef, metadata);
-      console.log("[MediaService] Metadata stored in Firestore:", mediaId);
-      return metadata;
-    } catch (error) {
-      console.error("[MediaService] Error during media upload:", error);
-      throw error;
-    }
-  }
-  /**
-   * Get media metadata from Firestore by its ID.
-   * @param mediaId - ID of the media.
-   * @returns Promise with the media metadata or null if not found.
-   */
-  async getMediaMetadata(mediaId) {
-    console.log(`[MediaService] Getting media metadata for ID: ${mediaId}`);
-    const docRef = (0, import_firestore23.doc)(this.db, MEDIA_METADATA_COLLECTION, mediaId);
-    const docSnap = await (0, import_firestore23.getDoc)(docRef);
-    if (docSnap.exists()) {
-      console.log("[MediaService] Metadata found:", docSnap.data());
-      return docSnap.data();
-    }
-    console.log("[MediaService] No metadata found for ID:", mediaId);
-    return null;
-  }
-  /**
-   * Get media metadata from Firestore by its public URL.
-   * @param url - The public URL of the media file.
-   * @returns Promise with the media metadata or null if not found.
-   */
-  async getMediaMetadataByUrl(url) {
-    console.log(`[MediaService] Getting media metadata by URL: ${url}`);
-    const q = (0, import_firestore23.query)(
-      (0, import_firestore23.collection)(this.db, MEDIA_METADATA_COLLECTION),
-      (0, import_firestore23.where)("url", "==", url),
-      (0, import_firestore23.limit)(1)
+      [center.latitude, center.longitude],
+      radiusInKm * 1e3
+      // Convert to meters
     );
-    try {
+    const matchingClinics = [];
+    for (const bound of bounds) {
+      const geoConstraints = [
+        ...constraints,
+        (0, import_firestore23.where)("location.geohash", ">=", bound[0]),
+        (0, import_firestore23.where)("location.geohash", "<=", bound[1])
+      ];
+      const q = (0, import_firestore23.query)((0, import_firestore23.collection)(db, CLINICS_COLLECTION), ...geoConstraints);
       const querySnapshot = await (0, import_firestore23.getDocs)(q);
-      if (!querySnapshot.empty) {
-        const metadata = querySnapshot.docs[0].data();
-        console.log("[MediaService] Metadata found by URL:", metadata);
-        return metadata;
+      console.log(
+        `[FILTER_UTILS] Found ${querySnapshot.docs.length} clinics in geo bound`
+      );
+      for (const doc34 of querySnapshot.docs) {
+        const clinic = { ...doc34.data(), id: doc34.id };
+        const distance = (0, import_geofire_common6.distanceBetween)(
+          [center.latitude, center.longitude],
+          [clinic.location.latitude, clinic.location.longitude]
+        );
+        const distanceInKm = distance / 1e3;
+        if (distanceInKm <= radiusInKm) {
+          matchingClinics.push({
+            ...clinic,
+            distance: distanceInKm
+          });
+        }
       }
-      console.log("[MediaService] No metadata found for URL:", url);
-      return null;
-    } catch (error) {
-      console.error("[MediaService] Error fetching metadata by URL:", error);
-      throw error;
     }
-  }
-  /**
-   * Delete media from storage and remove metadata from Firestore.
-   * @param mediaId - ID of the media to delete.
-   */
-  async deleteMedia(mediaId) {
-    console.log(`[MediaService] Deleting media with ID: ${mediaId}`);
-    const metadata = await this.getMediaMetadata(mediaId);
-    if (!metadata) {
-      console.warn(
-        `[MediaService] Metadata not found for media ID ${mediaId}. Cannot delete.`
-      );
-      return;
+    let filteredClinics = matchingClinics;
+    if (filters.tags && filters.tags.length > 1) {
+      filteredClinics = filteredClinics.filter((clinic) => {
+        return filters.tags.every((tag) => clinic.tags.includes(tag));
+      });
     }
-    const storageFileRef = (0, import_storage5.ref)(this.storage, metadata.path);
-    try {
-      await (0, import_storage5.deleteObject)(storageFileRef);
-      console.log(`[MediaService] File deleted from Storage: ${metadata.path}`);
-      const metadataDocRef = (0, import_firestore23.doc)(this.db, MEDIA_METADATA_COLLECTION, mediaId);
-      await (0, import_firestore23.deleteDoc)(metadataDocRef);
-      console.log(
-        `[MediaService] Metadata deleted from Firestore for ID: ${mediaId}`
+    if (filters.minRating !== void 0) {
+      filteredClinics = filteredClinics.filter(
+        (clinic) => clinic.reviewInfo.averageRating >= filters.minRating
       );
-    } catch (error) {
-      console.error(`[MediaService] Error deleting media ${mediaId}:`, error);
-      throw error;
     }
-  }
-  /**
-   * Update media access level. This involves moving the file in Firebase Storage
-   * to a new path reflecting the new access level, and updating its metadata.
-   * @param mediaId - ID of the media to update.
-   * @param newAccessLevel - New access level.
-   * @returns Promise with the updated media metadata, or null if metadata not found.
-   */
-  async updateMediaAccessLevel(mediaId, newAccessLevel) {
-    var _a;
-    console.log(
-      `[MediaService] Attempting to update access level for media ID: ${mediaId} to ${newAccessLevel}`
-    );
-    const metadata = await this.getMediaMetadata(mediaId);
-    if (!metadata) {
-      console.warn(
-        `[MediaService] Metadata not found for media ID ${mediaId}. Cannot update access level.`
+    if (filters.maxRating !== void 0) {
+      filteredClinics = filteredClinics.filter(
+        (clinic) => clinic.reviewInfo.averageRating <= filters.maxRating
       );
-      return null;
     }
-    if (metadata.accessLevel === newAccessLevel) {
-      console.log(
-        `[MediaService] Media ID ${mediaId} already has access level ${newAccessLevel}. Updating timestamp only.`
-      );
-      const metadataDocRef = (0, import_firestore23.doc)(this.db, MEDIA_METADATA_COLLECTION, mediaId);
-      try {
-        await (0, import_firestore23.updateDoc)(metadataDocRef, { updatedAt: import_firestore22.Timestamp.now() });
-        return { ...metadata, updatedAt: import_firestore22.Timestamp.now() };
-      } catch (error) {
-        console.error(
-          `[MediaService] Error updating timestamp for media ID ${mediaId}:`,
-          error
+    filteredClinics.sort((a, b) => a.distance - b.distance);
+    if (filters.pagination && filters.pagination > 0) {
+      let startIndex = 0;
+      if (filters.lastDoc) {
+        const lastDocIndex = filteredClinics.findIndex(
+          (clinic) => clinic.id === filters.lastDoc.id
         );
-        throw error;
+        if (lastDocIndex !== -1) {
+          startIndex = lastDocIndex + 1;
+        }
       }
+      const paginatedClinics = filteredClinics.slice(
+        startIndex,
+        startIndex + filters.pagination
+      );
+      lastVisibleDoc = paginatedClinics.length > 0 ? paginatedClinics[paginatedClinics.length - 1] : null;
+      clinicsResult = paginatedClinics;
+    } else {
+      clinicsResult = filteredClinics;
     }
-    const oldStoragePath = metadata.path;
-    const fileNamePart = `${metadata.id}-${metadata.name}`;
-    const newStoragePath = `media/${newAccessLevel}/${metadata.ownerId}/${metadata.collectionName}/${fileNamePart}`;
+  } else {
+    const q = (0, import_firestore23.query)((0, import_firestore23.collection)(db, CLINICS_COLLECTION), ...constraints);
+    const querySnapshot = await (0, import_firestore23.getDocs)(q);
     console.log(
-      `[MediaService] Moving file for ${mediaId} from ${oldStoragePath} to ${newStoragePath}`
+      `[FILTER_UTILS] Found ${querySnapshot.docs.length} clinics with regular query`
     );
-    const oldStorageFileRef = (0, import_storage5.ref)(this.storage, oldStoragePath);
-    const newStorageFileRef = (0, import_storage5.ref)(this.storage, newStoragePath);
-    try {
-      console.log(`[MediaService] Downloading bytes from ${oldStoragePath}`);
-      const fileBytes = await (0, import_storage5.getBytes)(oldStorageFileRef);
-      console.log(
-        `[MediaService] Successfully downloaded ${fileBytes.byteLength} bytes from ${oldStoragePath}`
-      );
-      console.log(`[MediaService] Uploading bytes to ${newStoragePath}`);
-      await (0, import_storage5.uploadBytes)(newStorageFileRef, fileBytes, {
-        contentType: metadata.contentType
-      });
-      console.log(
-        `[MediaService] Successfully uploaded bytes to ${newStoragePath}`
-      );
-      const newDownloadURL = await (0, import_storage5.getDownloadURL)(newStorageFileRef);
-      console.log(
-        `[MediaService] Got new download URL for ${newStoragePath}: ${newDownloadURL}`
-      );
-      const updateData = {
-        accessLevel: newAccessLevel,
-        path: newStoragePath,
-        url: newDownloadURL,
-        updatedAt: import_firestore22.Timestamp.now()
-      };
-      const metadataDocRef = (0, import_firestore23.doc)(this.db, MEDIA_METADATA_COLLECTION, mediaId);
-      console.log(
-        `[MediaService] Updating Firestore metadata for ${mediaId} with new data:`,
-        updateData
-      );
-      await (0, import_firestore23.updateDoc)(metadataDocRef, updateData);
-      console.log(
-        `[MediaService] Successfully updated Firestore metadata for ${mediaId}`
-      );
-      try {
-        console.log(`[MediaService] Deleting old file from ${oldStoragePath}`);
-        await (0, import_storage5.deleteObject)(oldStorageFileRef);
-        console.log(
-          `[MediaService] Successfully deleted old file from ${oldStoragePath}`
-        );
-      } catch (deleteError) {
-        console.error(
-          `[MediaService] Failed to delete old file from ${oldStoragePath} for media ID ${mediaId}. This file is now orphaned. Error:`,
-          deleteError
+    const clinics = querySnapshot.docs.map((doc34) => {
+      return { ...doc34.data(), id: doc34.id };
+    });
+    let filteredClinics = clinics;
+    if (filters.center) {
+      const center = filters.center;
+      const clinicsWithDistance = [];
+      filteredClinics.forEach((clinic) => {
+        const distance = (0, import_geofire_common6.distanceBetween)(
+          [center.latitude, center.longitude],
+          [clinic.location.latitude, clinic.location.longitude]
         );
-      }
-      return { ...metadata, ...updateData };
-    } catch (error) {
-      console.error(
-        `[MediaService] Error updating media access level and moving file for ${mediaId}:`,
-        error
+        clinicsWithDistance.push({
+          ...clinic,
+          distance: distance / 1e3
+          // Convert to kilometers
+        });
+      });
+      filteredClinics = clinicsWithDistance;
+      filteredClinics.sort(
+        (a, b) => a.distance - b.distance
       );
-      if (newStorageFileRef && error.code !== "storage/object-not-found" && ((_a = error.message) == null ? void 0 : _a.includes("uploadBytes"))) {
-        console.warn(
-          `[MediaService] Attempting to delete partially uploaded file at ${newStoragePath} due to error.`
-        );
-        try {
-          await (0, import_storage5.deleteObject)(newStorageFileRef);
-          console.warn(
-            `[MediaService] Cleaned up partially uploaded file at ${newStoragePath}.`
-          );
-        } catch (cleanupError) {
-          console.error(
-            `[MediaService] Failed to cleanup partially uploaded file at ${newStoragePath}:`,
-            cleanupError
-          );
-        }
-      }
-      throw error;
-    }
-  }
-  /**
-   * List all media for an owner, optionally filtered by collection and access level.
-   * @param ownerId - ID of the owner.
-   * @param collectionName - Optional: Filter by collection name.
-   * @param accessLevel - Optional: Filter by access level.
-   * @param count - Optional: Number of items to fetch.
-   * @param startAfterId - Optional: ID of the document to start after (for pagination).
-   */
-  async listMedia(ownerId, collectionName, accessLevel, count, startAfterId) {
-    console.log(`[MediaService] Listing media for owner: ${ownerId}`);
-    let qConstraints = [(0, import_firestore23.where)("ownerId", "==", ownerId)];
-    if (collectionName) {
-      qConstraints.push((0, import_firestore23.where)("collectionName", "==", collectionName));
-    }
-    if (accessLevel) {
-      qConstraints.push((0, import_firestore23.where)("accessLevel", "==", accessLevel));
     }
-    qConstraints.push((0, import_firestore23.orderBy)("createdAt", "desc"));
-    if (count) {
-      qConstraints.push((0, import_firestore23.limit)(count));
-    }
-    if (startAfterId) {
-      const startAfterDoc = await this.getMediaMetadata(startAfterId);
-      if (startAfterDoc) {
-      }
+    if (filters.tags && filters.tags.length > 1) {
+      filteredClinics = filteredClinics.filter((clinic) => {
+        return filters.tags.every((tag) => clinic.tags.includes(tag));
+      });
     }
-    const finalQuery = (0, import_firestore23.query)(
-      (0, import_firestore23.collection)(this.db, MEDIA_METADATA_COLLECTION),
-      ...qConstraints
-    );
-    try {
-      const querySnapshot = await (0, import_firestore23.getDocs)(finalQuery);
-      const mediaList = querySnapshot.docs.map(
-        (doc34) => doc34.data()
+    if (filters.minRating !== void 0) {
+      filteredClinics = filteredClinics.filter(
+        (clinic) => clinic.reviewInfo.averageRating >= filters.minRating
       );
-      console.log(`[MediaService] Found ${mediaList.length} media items.`);
-      return mediaList;
-    } catch (error) {
-      console.error("[MediaService] Error listing media:", error);
-      throw error;
     }
-  }
-  /**
-   * Get download URL for media. (Convenience, as URL is in metadata)
-   * @param mediaId - ID of the media.
-   */
-  async getMediaDownloadUrl(mediaId) {
-    console.log(`[MediaService] Getting download URL for media ID: ${mediaId}`);
-    const metadata = await this.getMediaMetadata(mediaId);
-    if (metadata && metadata.url) {
-      console.log(`[MediaService] URL found: ${metadata.url}`);
-      return metadata.url;
+    if (filters.maxRating !== void 0) {
+      filteredClinics = filteredClinics.filter(
+        (clinic) => clinic.reviewInfo.averageRating <= filters.maxRating
+      );
     }
-    console.log(`[MediaService] URL not found for media ID: ${mediaId}`);
-    return null;
+    lastVisibleDoc = querySnapshot.docs.length > 0 ? querySnapshot.docs[querySnapshot.docs.length - 1] : null;
+    clinicsResult = filteredClinics;
   }
-};
+  return {
+    clinics: clinicsResult,
+    lastDoc: lastVisibleDoc
+  };
+}
 
 // src/services/clinic/clinic.service.ts
 var ClinicService = class extends BaseService {
@@ -8533,7 +8594,8 @@ var ProcedureService = class extends BaseService {
       id: practitionerSnapshot.id,
       name: `${practitioner.basicInfo.firstName} ${practitioner.basicInfo.lastName}`,
       description: practitioner.basicInfo.bio || "",
-      photo: practitioner.basicInfo.profileImageUrl || "",
+      photo: typeof practitioner.basicInfo.profileImageUrl === "string" ? practitioner.basicInfo.profileImageUrl : "",
+      // Default to empty string if not a processed URL
       rating: ((_a = practitioner.reviewInfo) == null ? void 0 : _a.averageRating) || 0,
       services: practitioner.procedures || []
     };
@@ -8667,7 +8729,8 @@ var ProcedureService = class extends BaseService {
         id: newPractitioner.id,
         name: `${newPractitioner.basicInfo.firstName} ${newPractitioner.basicInfo.lastName}`,
         description: newPractitioner.basicInfo.bio || "",
-        photo: newPractitioner.basicInfo.profileImageUrl || "",
+        photo: typeof newPractitioner.basicInfo.profileImageUrl === "string" ? newPractitioner.basicInfo.profileImageUrl : "",
+        // Default to empty string if not a processed URL
         rating: ((_a = newPractitioner.reviewInfo) == null ? void 0 : _a.averageRating) || 0,
         services: newPractitioner.procedures || []
       };