@blackcode_sa/metaestetics-api 1.7.18 → 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) {
@@ -5589,1246 +5948,948 @@ async function removeAdminFromGroup(db, groupId, adminId, app) {
   if (group.ownerId === adminId) {
     throw new Error("Cannot remove the owner from the group");
   }
-  if (!group.admins.includes(adminId)) {
-    return;
-  }
-  await updateClinicGroup(
-    db,
-    groupId,
-    {
-      admins: group.admins.filter((id) => id !== adminId)
-    },
-    app
-  );
-}
-async function deactivateClinicGroup(db, groupId, app) {
-  const group = await getClinicGroup(db, groupId);
-  if (!group) {
-    throw new Error("Clinic group not found");
-  }
-  await updateClinicGroup(
-    db,
-    groupId,
-    {
-      isActive: false
-    },
-    app
-  );
-}
-async function createAdminToken(db, groupId, creatorAdminId, app, data) {
-  const group = await getClinicGroup(db, groupId);
-  if (!group) {
-    throw new Error("Clinic group not found");
-  }
-  if (!group.admins.includes(creatorAdminId)) {
-    throw new Error("Admin does not belong to this clinic group");
-  }
-  const now = import_firestore18.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(
-    now.seconds + expiresInDays * 24 * 60 * 60,
-    now.nanoseconds
-  );
-  const token = {
-    id: generateId(),
-    token: generateId(),
-    status: "active" /* ACTIVE */,
-    email,
-    createdAt: now,
-    expiresAt
-  };
-  await updateClinicGroup(
-    db,
-    groupId,
-    {
-      adminTokens: [...group.adminTokens, token]
-    },
-    app
-  );
-  return token;
-}
-async function verifyAndUseAdminToken(db, groupId, token, userRef, app) {
-  const group = await getClinicGroup(db, groupId);
-  if (!group) {
-    throw new Error("Clinic group not found");
-  }
-  const adminToken = group.adminTokens.find((t) => t.token === token);
-  if (!adminToken) {
-    throw new Error("Admin token not found");
-  }
-  if (adminToken.status !== "active" /* ACTIVE */) {
-    throw new Error("Admin token is not active");
-  }
-  const now = import_firestore18.Timestamp.now();
-  if (adminToken.expiresAt.seconds < now.seconds) {
-    const updatedTokens2 = group.adminTokens.map(
-      (t) => t.id === adminToken.id ? { ...t, status: "expired" /* EXPIRED */ } : t
-    );
-    await updateClinicGroup(
-      db,
-      groupId,
-      {
-        adminTokens: updatedTokens2
-      },
-      app
-    );
-    throw new Error("Admin token has expired");
+  if (!group.admins.includes(adminId)) {
+    return;
   }
-  const updatedTokens = group.adminTokens.map(
-    (t) => t.id === adminToken.id ? {
-      ...t,
-      status: "used" /* USED */,
-      usedByUserRef: userRef
-    } : t
-  );
   await updateClinicGroup(
     db,
     groupId,
     {
-      adminTokens: updatedTokens
+      admins: group.admins.filter((id) => id !== adminId)
     },
     app
   );
-  return true;
 }
-async function deleteAdminToken(db, groupId, tokenId, adminId, app) {
+async function deactivateClinicGroup(db, groupId, app) {
   const group = await getClinicGroup(db, groupId);
   if (!group) {
     throw new Error("Clinic group not found");
   }
-  if (!group.admins.includes(adminId)) {
-    throw new Error("Admin does not belong to this clinic group");
-  }
-  const updatedTokens = group.adminTokens.filter((t) => t.id !== tokenId);
   await updateClinicGroup(
     db,
     groupId,
     {
-      adminTokens: updatedTokens
+      isActive: false
     },
     app
   );
 }
-async function getActiveAdminTokens(db, groupId, adminId, app) {
+async function createAdminToken(db, groupId, creatorAdminId, app, data) {
   const group = await getClinicGroup(db, groupId);
   if (!group) {
     throw new Error("Clinic group not found");
   }
-  if (!group.admins.includes(adminId)) {
+  if (!group.admins.includes(creatorAdminId)) {
     throw new Error("Admin does not belong to this clinic group");
   }
-  return group.adminTokens.filter((t) => t.status === "active" /* ACTIVE */);
+  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_firestore20.Timestamp(
+    now.seconds + expiresInDays * 24 * 60 * 60,
+    now.nanoseconds
+  );
+  const token = {
+    id: generateId(),
+    token: generateId(),
+    status: "active" /* ACTIVE */,
+    email,
+    createdAt: now,
+    expiresAt
+  };
+  await updateClinicGroup(
+    db,
+    groupId,
+    {
+      adminTokens: [...group.adminTokens, token]
+    },
+    app
+  );
+  return token;
 }
-
-// src/services/clinic/clinic-group.service.ts
-var ClinicGroupService = class extends BaseService {
-  constructor(db, auth, app, clinicAdminService) {
-    super(db, auth, app);
-    this.clinicAdminService = clinicAdminService;
-  }
-  /**
-   * Kreira novu grupaciju klinika
-   */
-  async createClinicGroup(data, ownerId, isDefault = false) {
-    return createClinicGroup(
-      this.db,
-      data,
-      ownerId,
-      isDefault,
-      this.clinicAdminService,
-      this.app
-    );
-  }
-  /**
-   * Dohvata grupaciju klinika po ID-u
-   */
-  async getClinicGroup(groupId) {
-    return getClinicGroup(this.db, groupId);
-  }
-  /**
-   * Dohvata sve aktivne grupacije klinika
-   */
-  async getAllActiveGroups() {
-    return getAllActiveGroups(this.db);
-  }
-  /**
-   * Ažurira grupaciju klinika
-   */
-  async updateClinicGroup(groupId, data) {
-    return updateClinicGroup(this.db, groupId, data, this.app);
-  }
-  /**
-   * Dodaje admina u grupaciju
-   */
-  async addAdminToGroup(groupId, adminId) {
-    return addAdminToGroup(
-      this.db,
-      groupId,
-      adminId,
-      this.app
-    );
-  }
-  /**
-   * Uklanja admina iz grupacije
-   */
-  async removeAdminFromGroup(groupId, adminId) {
-    return removeAdminFromGroup(
-      this.db,
-      groupId,
-      adminId,
-      this.app
-    );
-  }
-  /**
-   * Deaktivira grupaciju klinika
-   */
-  async deactivateClinicGroup(groupId) {
-    return deactivateClinicGroup(this.db, groupId, this.app);
-  }
-  /**
-   * Sets up additional clinic group information after initial creation
-   *
-   * @param groupId - The ID of the clinic group to set up
-   * @param setupData - The setup data for the clinic group
-   * @returns The updated clinic group
-   */
-  async setupClinicGroup(groupId, setupData) {
-    console.log("[CLINIC_GROUP] Setting up clinic group", { groupId });
-    const clinicGroup = await this.getClinicGroup(groupId);
-    if (!clinicGroup) {
-      console.error("[CLINIC_GROUP] Clinic group not found", { groupId });
-      throw new Error(`Clinic group with ID ${groupId} not found`);
-    }
-    let logoUrl = setupData.logo;
-    if (logoUrl && typeof logoUrl === "string" && logoUrl.startsWith("data:")) {
-      console.log("[CLINIC_GROUP] Processing logo in setupClinicGroup");
-      try {
-        const uploadedLogoUrl = await uploadPhoto(
-          logoUrl,
-          "clinic-groups",
-          groupId,
-          "logo",
-          this.app
-        );
-        console.log("[CLINIC_GROUP] Logo processed in setupClinicGroup", {
-          uploadedLogoUrl
-        });
-        if (uploadedLogoUrl !== null) {
-          logoUrl = uploadedLogoUrl;
-        }
-      } catch (error) {
-        console.error(
-          "[CLINIC_GROUP] Error processing logo in setupClinicGroup:",
-          error
-        );
-      }
-    }
-    const updateData = {
-      languages: setupData.languages,
-      practiceType: setupData.practiceType,
-      description: setupData.description,
-      logo: logoUrl,
-      calendarSyncEnabled: setupData.calendarSyncEnabled,
-      autoConfirmAppointments: setupData.autoConfirmAppointments,
-      businessIdentificationNumber: setupData.businessIdentificationNumber
-    };
-    console.log("[CLINIC_GROUP] Updating clinic group with setup data");
-    return this.updateClinicGroup(groupId, updateData);
-  }
-  /**
-   * Kreira admin token za grupaciju
-   */
-  async createAdminToken(groupId, creatorAdminId, data) {
-    return createAdminToken(
-      this.db,
-      groupId,
-      creatorAdminId,
-      this.app,
-      data
-    );
-  }
-  /**
-   * Verifikuje i koristi admin token
-   */
-  async verifyAndUseAdminToken(groupId, token, userRef) {
-    return verifyAndUseAdminToken(
-      this.db,
-      groupId,
-      token,
-      userRef,
-      this.app
-    );
-  }
-  /**
-   * Briše admin token
-   */
-  async deleteAdminToken(groupId, tokenId, adminId) {
-    return deleteAdminToken(
-      this.db,
-      groupId,
-      tokenId,
-      adminId,
-      this.app
-    );
-  }
-  /**
-   * Dohvata aktivne admin tokene
-   */
-  async getActiveAdminTokens(groupId, adminId) {
-    return getActiveAdminTokens(
-      this.db,
-      groupId,
-      adminId,
-      this.app
-    );
-  }
-  // TODO: Add a method to get all admin tokens for a clinic group (not just active ones)
-  // TODO: Refactor admin token methods not to add tokens to the clinicGroup document,
-  // but to add them to a subcollection called adminTokens that belongs to a specific clinicGroup document
-  // TODO: Add granular control over admin permissions, e.g. only allow admins to manage certain clinics to tokens directly
-  // TODO: Generally refactor admin tokens and invites, also create cloud function to send invites and send updates when sombody uses the token
-  /**
-   * Updates the onboarding status for a clinic group
-   *
-   * @param groupId - The ID of the clinic group to update
-   * @param onboardingData - The onboarding data to update
-   * @returns The updated clinic group
-   */
-  async setOnboarding(groupId, onboardingData) {
-    console.log("[CLINIC_GROUP] Updating onboarding status", {
-      groupId,
-      onboardingData
-    });
-    return this.updateClinicGroup(groupId, {
-      onboarding: onboardingData
-    });
-  }
-  /**
-   * Sets the current onboarding step for a clinic group
-   *
-   * @param groupId - The ID of the clinic group to update
-   * @param step - The current onboarding step number
-   * @returns The updated clinic group
-   */
-  async setOnboardingStep(groupId, step) {
-    console.log("[CLINIC_GROUP] Setting onboarding step", { groupId, step });
-    return this.setOnboarding(groupId, { step, completed: false });
+async function verifyAndUseAdminToken(db, groupId, token, userRef, app) {
+  const group = await getClinicGroup(db, groupId);
+  if (!group) {
+    throw new Error("Clinic group not found");
   }
-  /**
-   * Marks the onboarding process as completed for a clinic group
-   *
-   * @param groupId - The ID of the clinic group to update
-   * @returns The updated clinic group
-   */
-  async completeOnboarding(groupId) {
-    console.log("[CLINIC_GROUP] Completing onboarding", { groupId });
-    return this.setOnboarding(groupId, { completed: true });
+  const adminToken = group.adminTokens.find((t) => t.token === token);
+  if (!adminToken) {
+    throw new Error("Admin token not found");
   }
-};
-
-// src/services/clinic/clinic.service.ts
-var import_firestore24 = require("firebase/firestore");
-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_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);
-  if (docSnap.exists()) {
-    return docSnap.data();
+  if (adminToken.status !== "active" /* ACTIVE */) {
+    throw new Error("Admin token is not active");
   }
-  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 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
+    );
+    await updateClinicGroup(
+      db,
+      groupId,
+      {
+        adminTokens: updatedTokens2
+      },
+      app
+    );
+    throw new Error("Admin token has expired");
+  }
+  const updatedTokens = group.adminTokens.map(
+    (t) => t.id === adminToken.id ? {
+      ...t,
+      status: "used" /* USED */,
+      usedByUserRef: userRef
+    } : t
   );
-  const querySnapshot = await (0, import_firestore19.getDocs)(q);
-  return querySnapshot.docs.map((doc34) => doc34.data());
+  await updateClinicGroup(
+    db,
+    groupId,
+    {
+      adminTokens: updatedTokens
+    },
+    app
+  );
+  return true;
 }
-async function updateClinic(db, clinicId, data, adminId, clinicAdminService, app) {
-  console.log("[CLINIC] Starting clinic update", { clinicId, adminId });
-  const clinic = await getClinic(db, clinicId);
-  if (!clinic) {
-    console.error("[CLINIC] Clinic not found", { clinicId });
-    throw new Error("Clinic not found");
+async function deleteAdminToken(db, groupId, tokenId, adminId, app) {
+  const group = await getClinicGroup(db, groupId);
+  if (!group) {
+    throw new Error("Clinic group not found");
   }
-  try {
-    console.log("[CLINIC] Checking admin permissions");
-    const admin = await clinicAdminService.getClinicAdmin(adminId);
-    if (!admin) {
-      console.error("[CLINIC] Admin not found", { adminId });
-      throw new Error("Admin not found");
-    }
-    const hasPermission = admin.isGroupOwner && admin.clinicGroupId === clinic.clinicGroupId || admin.clinicsManaged.includes(clinicId) && clinic.admins && clinic.admins.includes(adminId);
-    if (!hasPermission) {
-      console.error(
-        "[CLINIC] Admin does not have permission to update this clinic",
-        {
-          adminId,
-          clinicId,
-          isGroupOwner: admin.isGroupOwner,
-          clinicsManaged: admin.clinicsManaged,
-          isClinicAdmin: clinic.admins && clinic.admins.includes(adminId)
-        }
-      );
-      throw new Error("Admin does not have permission to update this clinic");
-    }
-    console.log("[CLINIC] Admin permissions verified");
-  } catch (adminError) {
-    console.error("[CLINIC] Error verifying admin permissions:", adminError);
-    throw adminError;
+  if (!group.admins.includes(adminId)) {
+    throw new Error("Admin does not belong to this clinic group");
   }
-  let updatedData = { ...data };
-  if (data.logo && typeof data.logo === "string" && data.logo.startsWith("data:")) {
-    console.log("[CLINIC] Processing logo update");
-    try {
-      const logoUrl = await uploadPhoto(
-        data.logo,
-        "clinics",
-        clinicId,
-        "logo",
-        app
-      );
-      console.log("[CLINIC] Logo update processed", { logoUrl });
-      if (logoUrl !== null) {
-        updatedData.logo = logoUrl;
-      }
-    } catch (logoError) {
-      console.error("[CLINIC] Error processing logo update:", logoError);
-    }
+  const updatedTokens = group.adminTokens.filter((t) => t.id !== tokenId);
+  await updateClinicGroup(
+    db,
+    groupId,
+    {
+      adminTokens: updatedTokens
+    },
+    app
+  );
+}
+async function getActiveAdminTokens(db, groupId, adminId, app) {
+  const group = await getClinicGroup(db, groupId);
+  if (!group) {
+    throw new Error("Clinic group not found");
   }
-  if (data.coverPhoto) {
-    console.log("[CLINIC] Processing cover photo update");
-    try {
-      if (typeof data.coverPhoto === "string" && data.coverPhoto.startsWith("data:")) {
-        const uploadedPhoto = await uploadPhoto(
-          data.coverPhoto,
-          "clinics",
-          clinicId,
-          "cover",
-          app
-        );
-        if (uploadedPhoto) {
-          updatedData.coverPhoto = uploadedPhoto;
-        }
-      } else {
-        updatedData.coverPhoto = data.coverPhoto;
-      }
-      console.log("[CLINIC] Cover photo update processed");
-    } catch (photoError) {
-      console.error(
-        "[CLINIC] Error processing cover photo update:",
-        photoError
-      );
-      if (typeof data.coverPhoto === "string" && !data.coverPhoto.startsWith("data:")) {
-        updatedData.coverPhoto = data.coverPhoto;
-      }
-    }
+  if (!group.admins.includes(adminId)) {
+    throw new Error("Admin does not belong to this clinic group");
   }
-  if (data.featuredPhotos && data.featuredPhotos.length > 0) {
-    console.log("[CLINIC] Processing featured photos update");
-    try {
-      const dataUrlPhotos = data.featuredPhotos.filter(
-        (photo) => typeof photo === "string" && photo.startsWith("data:")
-      );
-      const existingPhotos = data.featuredPhotos.filter(
-        (photo) => typeof photo === "string" && !photo.startsWith("data:")
-      );
-      if (dataUrlPhotos.length > 0) {
-        const uploadedPhotos = await uploadMultiplePhotos(
-          dataUrlPhotos,
-          "clinics",
-          clinicId,
-          "featured",
-          app
-        );
-        console.log("[CLINIC] Featured photos update processed", {
-          count: uploadedPhotos.length
-        });
-        updatedData.featuredPhotos = [...existingPhotos, ...uploadedPhotos];
-      } else {
-        updatedData.featuredPhotos = existingPhotos;
-      }
-    } catch (featuredError) {
-      console.error(
-        "[CLINIC] Error processing featured photos update:",
-        featuredError
-      );
-      updatedData.featuredPhotos = data.featuredPhotos.filter(
-        (photo) => typeof photo === "string" && !photo.startsWith("data:")
-      );
-    }
+  return group.adminTokens.filter((t) => t.status === "active" /* ACTIVE */);
+}
+
+// src/services/clinic/clinic-group.service.ts
+var ClinicGroupService = class extends BaseService {
+  constructor(db, auth, app, clinicAdminService) {
+    super(db, auth, app);
+    this.clinicAdminService = clinicAdminService;
   }
-  if (data.photosWithTags && data.photosWithTags.length > 0) {
-    console.log("[CLINIC] Processing photos with tags update");
-    try {
-      const updatedPhotosWithTags = [];
-      for (const photoWithTag of data.photosWithTags) {
-        if (photoWithTag.url && photoWithTag.url.startsWith("data:")) {
-          const uploadedUrl = await uploadPhoto(
-            photoWithTag.url,
-            "clinics",
-            clinicId,
-            `tagged-${photoWithTag.tag}`,
-            app
-          );
-          if (uploadedUrl) {
-            updatedPhotosWithTags.push({
-              url: uploadedUrl,
-              tag: photoWithTag.tag
-            });
-          }
-        } else {
-          updatedPhotosWithTags.push(photoWithTag);
-        }
-      }
-      updatedData.photosWithTags = updatedPhotosWithTags;
-      console.log("[CLINIC] Photos with tags update processed", {
-        count: updatedPhotosWithTags.length
-      });
-    } catch (tagsError) {
-      console.error(
-        "[CLINIC] Error processing photos with tags update:",
-        tagsError
-      );
-      updatedData.photosWithTags = data.photosWithTags.filter(
-        (photo) => !photo.url.startsWith("data:")
-      );
-    }
+  /**
+   * Kreira novu grupaciju klinika
+   */
+  async createClinicGroup(data, ownerId, isDefault = false) {
+    return createClinicGroup(
+      this.db,
+      data,
+      ownerId,
+      isDefault,
+      this.clinicAdminService,
+      this.app
+    );
   }
-  updatedData = {
-    ...updatedData,
-    updatedAt: import_firestore19.Timestamp.now()
-  };
-  console.log("[CLINIC] Updating clinic in Firestore");
-  try {
-    await (0, import_firestore19.updateDoc)((0, import_firestore19.doc)(db, CLINICS_COLLECTION, clinicId), updatedData);
-    console.log("[CLINIC] Clinic updated successfully");
-  } catch (updateError) {
-    console.error("[CLINIC] Error updating clinic in Firestore:", updateError);
-    throw updateError;
+  /**
+   * Dohvata grupaciju klinika po ID-u
+   */
+  async getClinicGroup(groupId) {
+    return getClinicGroup(this.db, groupId);
   }
-  const updatedClinic = await getClinic(db, clinicId);
-  if (!updatedClinic) {
-    console.error("[CLINIC] Failed to retrieve updated clinic");
-    throw new Error("Failed to retrieve updated clinic");
+  /**
+   * Dohvata sve aktivne grupacije klinika
+   */
+  async getAllActiveGroups() {
+    return getAllActiveGroups(this.db);
   }
-  console.log("[CLINIC] Clinic update completed successfully");
-  return updatedClinic;
-}
-async function getClinicsByAdmin(db, adminId, options = {}, clinicAdminService, clinicGroupService) {
-  const admin = await clinicAdminService.getClinicAdmin(adminId);
-  if (!admin) {
-    throw new Error("Admin not found");
+  /**
+   * Ažurira grupaciju klinika
+   */
+  async updateClinicGroup(groupId, data) {
+    return updateClinicGroup(this.db, groupId, data, this.app);
   }
-  let clinicIds = [...admin.clinicsManaged];
-  if (admin.isGroupOwner && options.includeGroupClinics) {
-    const group = await clinicGroupService.getClinicGroup(admin.clinicGroupId);
-    if (group) {
-      clinicIds = [.../* @__PURE__ */ new Set([...clinicIds, ...group.clinics])];
-    }
+  /**
+   * Dodaje admina u grupaciju
+   */
+  async addAdminToGroup(groupId, adminId) {
+    return addAdminToGroup(
+      this.db,
+      groupId,
+      adminId,
+      this.app
+    );
   }
-  if (clinicIds.length === 0) {
-    return [];
+  /**
+   * Uklanja admina iz grupacije
+   */
+  async removeAdminFromGroup(groupId, adminId) {
+    return removeAdminFromGroup(
+      this.db,
+      groupId,
+      adminId,
+      this.app
+    );
   }
-  const constraints = [(0, import_firestore19.where)("id", "in", clinicIds)];
-  if (options.isActive !== void 0) {
-    constraints.push((0, import_firestore19.where)("isActive", "==", options.isActive));
+  /**
+   * Deaktivira grupaciju klinika
+   */
+  async deactivateClinicGroup(groupId) {
+    return deactivateClinicGroup(this.db, groupId, this.app);
   }
-  const q = (0, import_firestore19.query)((0, import_firestore19.collection)(db, CLINICS_COLLECTION), ...constraints);
-  const querySnapshot = await (0, import_firestore19.getDocs)(q);
-  return querySnapshot.docs.map((doc34) => doc34.data());
-}
-async function getActiveClinicsByAdmin(db, adminId, clinicAdminService, clinicGroupService) {
-  return getClinicsByAdmin(
-    db,
-    adminId,
-    { isActive: true },
-    clinicAdminService,
-    clinicGroupService
-  );
-}
-async function getClinicById(db, clinicId) {
-  try {
-    const clinicRef = (0, import_firestore19.doc)(db, CLINICS_COLLECTION, clinicId);
-    const clinicSnapshot = await (0, import_firestore19.getDoc)(clinicRef);
-    if (!clinicSnapshot.exists()) {
-      return null;
+  /**
+   * Sets up additional clinic group information after initial creation
+   *
+   * @param groupId - The ID of the clinic group to set up
+   * @param setupData - The setup data for the clinic group
+   * @returns The updated clinic group
+   */
+  async setupClinicGroup(groupId, setupData) {
+    console.log("[CLINIC_GROUP] Setting up clinic group", { groupId });
+    const clinicGroup = await this.getClinicGroup(groupId);
+    if (!clinicGroup) {
+      console.error("[CLINIC_GROUP] Clinic group not found", { groupId });
+      throw new Error(`Clinic group with ID ${groupId} not found`);
     }
-    const clinicData = clinicSnapshot.data();
-    return {
-      ...clinicData,
-      id: clinicSnapshot.id
-    };
-  } catch (error) {
-    console.error("[CLINIC_UTILS] Error getting clinic by ID:", error);
-    throw error;
-  }
-}
-async function getAllClinics(db, pagination, lastDoc) {
-  try {
-    const clinicsCollection = (0, import_firestore19.collection)(db, CLINICS_COLLECTION);
-    let clinicsQuery = (0, import_firestore19.query)(clinicsCollection);
-    if (pagination && pagination > 0) {
-      if (lastDoc) {
-        clinicsQuery = (0, import_firestore19.query)(
-          clinicsCollection,
-          (0, import_firestore19.startAfter)(lastDoc),
-          (0, import_firestore19.limit)(pagination)
+    let logoUrl = setupData.logo;
+    if (logoUrl && typeof logoUrl === "string" && logoUrl.startsWith("data:")) {
+      console.log("[CLINIC_GROUP] Processing logo in setupClinicGroup");
+      try {
+        const uploadedLogoUrl = await uploadPhoto(
+          logoUrl,
+          "clinic-groups",
+          groupId,
+          "logo",
+          this.app
+        );
+        console.log("[CLINIC_GROUP] Logo processed in setupClinicGroup", {
+          uploadedLogoUrl
+        });
+        if (uploadedLogoUrl !== null) {
+          logoUrl = uploadedLogoUrl;
+        }
+      } catch (error) {
+        console.error(
+          "[CLINIC_GROUP] Error processing logo in setupClinicGroup:",
+          error
         );
-      } else {
-        clinicsQuery = (0, import_firestore19.query)(clinicsCollection, (0, import_firestore19.limit)(pagination));
       }
     }
-    const clinicsSnapshot = await (0, import_firestore19.getDocs)(clinicsQuery);
-    const lastVisible = clinicsSnapshot.docs[clinicsSnapshot.docs.length - 1];
-    const clinics = clinicsSnapshot.docs.map((doc34) => {
-      const data = doc34.data();
-      return {
-        ...data,
-        id: doc34.id
-      };
-    });
-    return {
-      clinics,
-      lastDoc: lastVisible
+    const updateData = {
+      languages: setupData.languages,
+      practiceType: setupData.practiceType,
+      description: setupData.description,
+      logo: logoUrl,
+      calendarSyncEnabled: setupData.calendarSyncEnabled,
+      autoConfirmAppointments: setupData.autoConfirmAppointments,
+      businessIdentificationNumber: setupData.businessIdentificationNumber
     };
-  } catch (error) {
-    console.error("[CLINIC_UTILS] Error getting all clinics:", error);
-    throw error;
+    console.log("[CLINIC_GROUP] Updating clinic group with setup data");
+    return this.updateClinicGroup(groupId, updateData);
   }
-}
-async function getAllClinicsInRange(db, center, rangeInKm, pagination, lastDoc) {
-  const bounds = (0, import_geofire_common4.geohashQueryBounds)(
-    [center.latitude, center.longitude],
-    rangeInKm * 1e3
-  );
-  const matchingClinics = [];
-  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)
-    ];
-    const q = (0, import_firestore19.query)((0, import_firestore19.collection)(db, CLINICS_COLLECTION), ...constraints);
-    const querySnapshot = await (0, import_firestore19.getDocs)(q);
-    for (const doc34 of querySnapshot.docs) {
-      const clinic = doc34.data();
-      const distance = (0, import_geofire_common4.distanceBetween)(
-        [center.latitude, center.longitude],
-        [clinic.location.latitude, clinic.location.longitude]
-      );
-      const distanceInKm = distance / 1e3;
-      if (distanceInKm <= rangeInKm) {
-        matchingClinics.push({
-          ...clinic,
-          distance: distanceInKm
-        });
-      }
-    }
+  /**
+   * Kreira admin token za grupaciju
+   */
+  async createAdminToken(groupId, creatorAdminId, data) {
+    return createAdminToken(
+      this.db,
+      groupId,
+      creatorAdminId,
+      this.app,
+      data
+    );
   }
-  matchingClinics.sort((a, b) => a.distance - b.distance);
-  if (pagination && pagination > 0) {
-    let result = matchingClinics;
-    if (lastDoc && matchingClinics.length > 0) {
-      const lastIndex = matchingClinics.findIndex(
-        (clinic) => clinic.id === lastDoc.id
-      );
-      if (lastIndex !== -1) {
-        result = matchingClinics.slice(lastIndex + 1);
-      }
-    }
-    const paginatedClinics = result.slice(0, pagination);
-    const newLastDoc = paginatedClinics.length > 0 ? paginatedClinics[paginatedClinics.length - 1] : null;
-    return {
-      clinics: paginatedClinics,
-      lastDoc: newLastDoc
-    };
+  /**
+   * Verifikuje i koristi admin token
+   */
+  async verifyAndUseAdminToken(groupId, token, userRef) {
+    return verifyAndUseAdminToken(
+      this.db,
+      groupId,
+      token,
+      userRef,
+      this.app
+    );
   }
-  return {
-    clinics: matchingClinics,
-    lastDoc: null
-  };
-}
-
-// src/services/clinic/utils/tag.utils.ts
-async function addTags(db, clinicId, adminId, newTags, clinicAdminService, app) {
-  const clinic = await getClinic(db, clinicId);
-  if (!clinic) {
-    throw new Error("Clinic not found");
+  /**
+   * Briše admin token
+   */
+  async deleteAdminToken(groupId, tokenId, adminId) {
+    return deleteAdminToken(
+      this.db,
+      groupId,
+      tokenId,
+      adminId,
+      this.app
+    );
+  }
+  /**
+   * Dohvata aktivne admin tokene
+   */
+  async getActiveAdminTokens(groupId, adminId) {
+    return getActiveAdminTokens(
+      this.db,
+      groupId,
+      adminId,
+      this.app
+    );
+  }
+  // TODO: Add a method to get all admin tokens for a clinic group (not just active ones)
+  // TODO: Refactor admin token methods not to add tokens to the clinicGroup document,
+  // but to add them to a subcollection called adminTokens that belongs to a specific clinicGroup document
+  // TODO: Add granular control over admin permissions, e.g. only allow admins to manage certain clinics to tokens directly
+  // TODO: Generally refactor admin tokens and invites, also create cloud function to send invites and send updates when sombody uses the token
+  /**
+   * Updates the onboarding status for a clinic group
+   *
+   * @param groupId - The ID of the clinic group to update
+   * @param onboardingData - The onboarding data to update
+   * @returns The updated clinic group
+   */
+  async setOnboarding(groupId, onboardingData) {
+    console.log("[CLINIC_GROUP] Updating onboarding status", {
+      groupId,
+      onboardingData
+    });
+    return this.updateClinicGroup(groupId, {
+      onboarding: onboardingData
+    });
   }
-  const admin = await clinicAdminService.getClinicAdmin(adminId);
-  if (!admin) {
-    throw new Error("Admin not found");
+  /**
+   * Sets the current onboarding step for a clinic group
+   *
+   * @param groupId - The ID of the clinic group to update
+   * @param step - The current onboarding step number
+   * @returns The updated clinic group
+   */
+  async setOnboardingStep(groupId, step) {
+    console.log("[CLINIC_GROUP] Setting onboarding step", { groupId, step });
+    return this.setOnboarding(groupId, { step, completed: false });
   }
-  const hasPermission = admin.isGroupOwner && admin.clinicGroupId === clinic.clinicGroupId || admin.clinicsManaged.includes(clinicId) && clinic.admins && clinic.admins.includes(adminId);
-  if (!hasPermission) {
-    throw new Error("Admin does not have permission to update this clinic");
+  /**
+   * Marks the onboarding process as completed for a clinic group
+   *
+   * @param groupId - The ID of the clinic group to update
+   * @returns The updated clinic group
+   */
+  async completeOnboarding(groupId) {
+    console.log("[CLINIC_GROUP] Completing onboarding", { groupId });
+    return this.setOnboarding(groupId, { completed: true });
   }
-  const updatedTags = [.../* @__PURE__ */ new Set([...clinic.tags, ...newTags.tags || []])];
-  return updateClinic(
-    db,
-    clinicId,
-    {
-      tags: updatedTags
-    },
-    adminId,
-    clinicAdminService,
-    app
+};
+
+// src/services/clinic/clinic.service.ts
+var import_firestore24 = require("firebase/firestore");
+var import_geofire_common7 = require("geofire-common");
+var import_zod19 = require("zod");
+
+// src/services/clinic/utils/clinic.utils.ts
+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_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_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_firestore21.getDocs)(q);
+  return querySnapshot.docs.map((doc34) => doc34.data());
 }
-async function removeTags(db, clinicId, adminId, tagsToRemove, clinicAdminService, app) {
+async function updateClinic(db, clinicId, data, adminId, clinicAdminService, app) {
+  console.log("[CLINIC] Starting clinic update", { clinicId, adminId });
   const clinic = await getClinic(db, clinicId);
   if (!clinic) {
+    console.error("[CLINIC] Clinic not found", { clinicId });
     throw new Error("Clinic not found");
   }
-  const admin = await clinicAdminService.getClinicAdmin(adminId);
-  if (!admin) {
-    throw new Error("Admin not found");
-  }
-  const hasPermission = admin.isGroupOwner && admin.clinicGroupId === clinic.clinicGroupId || admin.clinicsManaged.includes(clinicId) && clinic.admins && clinic.admins.includes(adminId);
-  if (!hasPermission) {
-    throw new Error("Admin does not have permission to update this clinic");
-  }
-  const updatedTags = clinic.tags.filter(
-    (tag) => !tagsToRemove.tags || !tagsToRemove.tags.includes(tag)
-  );
-  return updateClinic(
-    db,
-    clinicId,
-    {
-      tags: updatedTags
-    },
-    adminId,
-    clinicAdminService,
-    app
-  );
-}
-
-// src/services/clinic/utils/search.utils.ts
-var import_firestore20 = require("firebase/firestore");
-var import_geofire_common5 = require("geofire-common");
-async function findClinicsInRadius(db, center, radiusInKm, filters) {
-  const bounds = (0, import_geofire_common5.geohashQueryBounds)(
-    [center.latitude, center.longitude],
-    radiusInKm * 1e3
-  );
-  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)
-    ];
-    if (filters == null ? void 0 : filters.services) {
-      constraints.push(
-        (0, import_firestore20.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));
+  try {
+    console.log("[CLINIC] Checking admin permissions");
+    const admin = await clinicAdminService.getClinicAdmin(adminId);
+    if (!admin) {
+      console.error("[CLINIC] Admin not found", { adminId });
+      throw new Error("Admin not found");
     }
-    const q = (0, import_firestore20.query)((0, import_firestore20.collection)(db, CLINICS_COLLECTION), ...constraints);
-    const querySnapshot = await (0, import_firestore20.getDocs)(q);
-    for (const doc34 of querySnapshot.docs) {
-      const clinic = doc34.data();
-      const distance = (0, import_geofire_common5.distanceBetween)(
-        [center.latitude, center.longitude],
-        [clinic.location.latitude, clinic.location.longitude]
+    const hasPermission = admin.isGroupOwner && admin.clinicGroupId === clinic.clinicGroupId || admin.clinicsManaged.includes(clinicId) && clinic.admins && clinic.admins.includes(adminId);
+    if (!hasPermission) {
+      console.error(
+        "[CLINIC] Admin does not have permission to update this clinic",
+        {
+          adminId,
+          clinicId,
+          isGroupOwner: admin.isGroupOwner,
+          clinicsManaged: admin.clinicsManaged,
+          isClinicAdmin: clinic.admins && clinic.admins.includes(adminId)
+        }
       );
-      const distanceInKm = distance / 1e3;
-      if (distanceInKm <= radiusInKm) {
-        matchingDocs.push(clinic);
-      }
+      throw new Error("Admin does not have permission to update this clinic");
     }
+    console.log("[CLINIC] Admin permissions verified");
+  } catch (adminError) {
+    console.error("[CLINIC] Error verifying admin permissions:", adminError);
+    throw adminError;
   }
-  return matchingDocs.sort((a, b) => {
-    const distanceA = (0, import_geofire_common5.distanceBetween)(
-      [center.latitude, center.longitude],
-      [a.location.latitude, a.location.longitude]
-    );
-    const distanceB = (0, import_geofire_common5.distanceBetween)(
-      [center.latitude, center.longitude],
-      [b.location.latitude, b.location.longitude]
-    );
-    return distanceA - distanceB;
-  });
-}
-
-// src/services/clinic/utils/filter.utils.ts
-var import_firestore21 = require("firebase/firestore");
-var import_geofire_common6 = require("geofire-common");
-async function getClinicsByFilters(db, filters) {
-  console.log(
-    "[FILTER_UTILS] Starting clinic filtering with criteria:",
-    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));
-  } else {
-    constraints.push((0, import_firestore21.where)("isActive", "==", true));
-  }
-  if (filters.tags && filters.tags.length > 0) {
-    constraints.push((0, import_firestore21.where)("tags", "array-contains", filters.tags[0]));
-  }
-  if (filters.procedureTechnology) {
-    constraints.push(
-      (0, import_firestore21.where)("servicesInfo.technology", "==", filters.procedureTechnology)
-    );
-  } else if (filters.procedureSubcategory) {
-    constraints.push(
-      (0, import_firestore21.where)("servicesInfo.subCategory", "==", filters.procedureSubcategory)
-    );
-  } else if (filters.procedureCategory) {
-    constraints.push(
-      (0, import_firestore21.where)("servicesInfo.category", "==", filters.procedureCategory)
-    );
-  } else if (filters.procedureFamily) {
-    constraints.push(
-      (0, import_firestore21.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));
-  } else if (filters.pagination && filters.pagination > 0) {
-    constraints.push((0, import_firestore21.limit)(filters.pagination));
-  }
-  constraints.push((0, import_firestore21.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`
+  let updatedData = { ...data };
+  if (data.logo && typeof data.logo === "string" && data.logo.startsWith("data:")) {
+    console.log("[CLINIC] Processing logo update");
+    try {
+      const logoUrl = await uploadPhoto(
+        data.logo,
+        "clinics",
+        clinicId,
+        "logo",
+        app
       );
-      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("[CLINIC] Logo update processed", { logoUrl });
+      if (logoUrl !== null) {
+        updatedData.logo = logoUrl;
       }
+    } catch (logoError) {
+      console.error("[CLINIC] Error processing logo update:", logoError);
     }
-    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 (data.coverPhoto) {
+    console.log("[CLINIC] Processing cover photo update");
+    try {
+      if (typeof data.coverPhoto === "string" && data.coverPhoto.startsWith("data:")) {
+        const uploadedPhoto = await uploadPhoto(
+          data.coverPhoto,
+          "clinics",
+          clinicId,
+          "cover",
+          app
         );
-        if (lastDocIndex !== -1) {
-          startIndex = lastDocIndex + 1;
+        if (uploadedPhoto) {
+          updatedData.coverPhoto = uploadedPhoto;
         }
+      } else {
+        updatedData.coverPhoto = data.coverPhoto;
       }
-      const paginatedClinics = filteredClinics.slice(
-        startIndex,
-        startIndex + filters.pagination
+      console.log("[CLINIC] Cover photo update processed");
+    } catch (photoError) {
+      console.error(
+        "[CLINIC] Error processing cover photo update:",
+        photoError
       );
-      lastVisibleDoc = paginatedClinics.length > 0 ? paginatedClinics[paginatedClinics.length - 1] : null;
-      clinicsResult = paginatedClinics;
-    } else {
-      clinicsResult = filteredClinics;
+      if (typeof data.coverPhoto === "string" && !data.coverPhoto.startsWith("data:")) {
+        updatedData.coverPhoto = data.coverPhoto;
+      }
     }
-  } 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]
+  }
+  if (data.featuredPhotos && data.featuredPhotos.length > 0) {
+    console.log("[CLINIC] Processing featured photos update");
+    try {
+      const dataUrlPhotos = data.featuredPhotos.filter(
+        (photo) => typeof photo === "string" && photo.startsWith("data:")
+      );
+      const existingPhotos = data.featuredPhotos.filter(
+        (photo) => typeof photo === "string" && !photo.startsWith("data:")
+      );
+      if (dataUrlPhotos.length > 0) {
+        const uploadedPhotos = await uploadMultiplePhotos(
+          dataUrlPhotos,
+          "clinics",
+          clinicId,
+          "featured",
+          app
         );
-        clinicsWithDistance.push({
-          ...clinic,
-          distance: distance / 1e3
-          // Convert to kilometers
+        console.log("[CLINIC] Featured photos update processed", {
+          count: uploadedPhotos.length
         });
-      });
-      filteredClinics = clinicsWithDistance;
-      filteredClinics.sort(
-        (a, b) => a.distance - b.distance
+        updatedData.featuredPhotos = [...existingPhotos, ...uploadedPhotos];
+      } else {
+        updatedData.featuredPhotos = existingPhotos;
+      }
+    } catch (featuredError) {
+      console.error(
+        "[CLINIC] Error processing featured photos update:",
+        featuredError
+      );
+      updatedData.featuredPhotos = data.featuredPhotos.filter(
+        (photo) => typeof photo === "string" && !photo.startsWith("data:")
       );
     }
-    if (filters.tags && filters.tags.length > 1) {
-      filteredClinics = filteredClinics.filter((clinic) => {
-        return filters.tags.every((tag) => clinic.tags.includes(tag));
+  }
+  if (data.photosWithTags && data.photosWithTags.length > 0) {
+    console.log("[CLINIC] Processing photos with tags update");
+    try {
+      const updatedPhotosWithTags = [];
+      for (const photoWithTag of data.photosWithTags) {
+        if (photoWithTag.url && photoWithTag.url.startsWith("data:")) {
+          const uploadedUrl = await uploadPhoto(
+            photoWithTag.url,
+            "clinics",
+            clinicId,
+            `tagged-${photoWithTag.tag}`,
+            app
+          );
+          if (uploadedUrl) {
+            updatedPhotosWithTags.push({
+              url: uploadedUrl,
+              tag: photoWithTag.tag
+            });
+          }
+        } else {
+          updatedPhotosWithTags.push(photoWithTag);
+        }
+      }
+      updatedData.photosWithTags = updatedPhotosWithTags;
+      console.log("[CLINIC] Photos with tags update processed", {
+        count: updatedPhotosWithTags.length
       });
-    }
-    if (filters.minRating !== void 0) {
-      filteredClinics = filteredClinics.filter(
-        (clinic) => clinic.reviewInfo.averageRating >= filters.minRating
+    } catch (tagsError) {
+      console.error(
+        "[CLINIC] Error processing photos with tags update:",
+        tagsError
       );
-    }
-    if (filters.maxRating !== void 0) {
-      filteredClinics = filteredClinics.filter(
-        (clinic) => clinic.reviewInfo.averageRating <= filters.maxRating
+      updatedData.photosWithTags = data.photosWithTags.filter(
+        (photo) => !photo.url.startsWith("data:")
       );
     }
-    lastVisibleDoc = querySnapshot.docs.length > 0 ? querySnapshot.docs[querySnapshot.docs.length - 1] : null;
-    clinicsResult = filteredClinics;
   }
-  return {
-    clinics: clinicsResult,
-    lastDoc: lastVisibleDoc
+  updatedData = {
+    ...updatedData,
+    updatedAt: import_firestore21.Timestamp.now()
   };
+  console.log("[CLINIC] Updating clinic in Firestore");
+  try {
+    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);
+    throw updateError;
+  }
+  const updatedClinic = await getClinic(db, clinicId);
+  if (!updatedClinic) {
+    console.error("[CLINIC] Failed to retrieve updated clinic");
+    throw new Error("Failed to retrieve updated clinic");
+  }
+  console.log("[CLINIC] Clinic update completed successfully");
+  return updatedClinic;
 }
-
-// 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);
+async function getClinicsByAdmin(db, adminId, options = {}, clinicAdminService, clinicGroupService) {
+  const admin = await clinicAdminService.getClinicAdmin(adminId);
+  if (!admin) {
+    throw new Error("Admin not found");
   }
-  /**
-   * 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;
+  let clinicIds = [...admin.clinicsManaged];
+  if (admin.isGroupOwner && options.includeGroupClinics) {
+    const group = await clinicGroupService.getClinicGroup(admin.clinicGroupId);
+    if (group) {
+      clinicIds = [.../* @__PURE__ */ new Set([...clinicIds, ...group.clinics])];
     }
   }
-  /**
-   * 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();
+  if (clinicIds.length === 0) {
+    return [];
+  }
+  const constraints = [(0, import_firestore21.where)("id", "in", clinicIds)];
+  if (options.isActive !== void 0) {
+    constraints.push((0, import_firestore21.where)("isActive", "==", options.isActive));
+  }
+  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) {
+  return getClinicsByAdmin(
+    db,
+    adminId,
+    { isActive: true },
+    clinicAdminService,
+    clinicGroupService
+  );
+}
+async function getClinicById(db, clinicId) {
+  try {
+    const clinicRef = (0, import_firestore21.doc)(db, CLINICS_COLLECTION, clinicId);
+    const clinicSnapshot = await (0, import_firestore21.getDoc)(clinicRef);
+    if (!clinicSnapshot.exists()) {
+      return null;
     }
-    console.log("[MediaService] No metadata found for ID:", mediaId);
-    return null;
+    const clinicData = clinicSnapshot.data();
+    return {
+      ...clinicData,
+      id: clinicSnapshot.id
+    };
+  } catch (error) {
+    console.error("[CLINIC_UTILS] Error getting clinic by ID:", error);
+    throw error;
   }
-  /**
-   * 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)
-    );
-    try {
-      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;
+}
+async function getAllClinics(db, pagination, lastDoc) {
+  try {
+    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_firestore21.query)(
+          clinicsCollection,
+          (0, import_firestore21.startAfter)(lastDoc),
+          (0, import_firestore21.limit)(pagination)
+        );
+      } else {
+        clinicsQuery = (0, import_firestore21.query)(clinicsCollection, (0, import_firestore21.limit)(pagination));
       }
-      console.log("[MediaService] No metadata found for URL:", url);
-      return null;
-    } catch (error) {
-      console.error("[MediaService] Error fetching metadata by URL:", error);
-      throw error;
     }
+    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();
+      return {
+        ...data,
+        id: doc34.id
+      };
+    });
+    return {
+      clinics,
+      lastDoc: lastVisible
+    };
+  } catch (error) {
+    console.error("[CLINIC_UTILS] Error getting all clinics:", 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.`
+}
+async function getAllClinicsInRange(db, center, rangeInKm, pagination, lastDoc) {
+  const bounds = (0, import_geofire_common4.geohashQueryBounds)(
+    [center.latitude, center.longitude],
+    rangeInKm * 1e3
+  );
+  const matchingClinics = [];
+  let lastDocSnapshot = null;
+  for (const b of bounds) {
+    const constraints = [
+      (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_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)(
+        [center.latitude, center.longitude],
+        [clinic.location.latitude, clinic.location.longitude]
       );
-      return;
+      const distanceInKm = distance / 1e3;
+      if (distanceInKm <= rangeInKm) {
+        matchingClinics.push({
+          ...clinic,
+          distance: distanceInKm
+        });
+      }
     }
-    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}`
+  }
+  matchingClinics.sort((a, b) => a.distance - b.distance);
+  if (pagination && pagination > 0) {
+    let result = matchingClinics;
+    if (lastDoc && matchingClinics.length > 0) {
+      const lastIndex = matchingClinics.findIndex(
+        (clinic) => clinic.id === lastDoc.id
       );
-    } catch (error) {
-      console.error(`[MediaService] Error deleting media ${mediaId}:`, error);
-      throw error;
+      if (lastIndex !== -1) {
+        result = matchingClinics.slice(lastIndex + 1);
+      }
     }
+    const paginatedClinics = result.slice(0, pagination);
+    const newLastDoc = paginatedClinics.length > 0 ? paginatedClinics[paginatedClinics.length - 1] : null;
+    return {
+      clinics: paginatedClinics,
+      lastDoc: newLastDoc
+    };
   }
-  /**
-   * 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.`
+  return {
+    clinics: matchingClinics,
+    lastDoc: null
+  };
+}
+
+// src/services/clinic/utils/tag.utils.ts
+async function addTags(db, clinicId, adminId, newTags, clinicAdminService, app) {
+  const clinic = await getClinic(db, clinicId);
+  if (!clinic) {
+    throw new Error("Clinic not found");
+  }
+  const admin = await clinicAdminService.getClinicAdmin(adminId);
+  if (!admin) {
+    throw new Error("Admin not found");
+  }
+  const hasPermission = admin.isGroupOwner && admin.clinicGroupId === clinic.clinicGroupId || admin.clinicsManaged.includes(clinicId) && clinic.admins && clinic.admins.includes(adminId);
+  if (!hasPermission) {
+    throw new Error("Admin does not have permission to update this clinic");
+  }
+  const updatedTags = [.../* @__PURE__ */ new Set([...clinic.tags, ...newTags.tags || []])];
+  return updateClinic(
+    db,
+    clinicId,
+    {
+      tags: updatedTags
+    },
+    adminId,
+    clinicAdminService,
+    app
+  );
+}
+async function removeTags(db, clinicId, adminId, tagsToRemove, clinicAdminService, app) {
+  const clinic = await getClinic(db, clinicId);
+  if (!clinic) {
+    throw new Error("Clinic not found");
+  }
+  const admin = await clinicAdminService.getClinicAdmin(adminId);
+  if (!admin) {
+    throw new Error("Admin not found");
+  }
+  const hasPermission = admin.isGroupOwner && admin.clinicGroupId === clinic.clinicGroupId || admin.clinicsManaged.includes(clinicId) && clinic.admins && clinic.admins.includes(adminId);
+  if (!hasPermission) {
+    throw new Error("Admin does not have permission to update this clinic");
+  }
+  const updatedTags = clinic.tags.filter(
+    (tag) => !tagsToRemove.tags || !tagsToRemove.tags.includes(tag)
+  );
+  return updateClinic(
+    db,
+    clinicId,
+    {
+      tags: updatedTags
+    },
+    adminId,
+    clinicAdminService,
+    app
+  );
+}
+
+// src/services/clinic/utils/search.utils.ts
+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)(
+    [center.latitude, center.longitude],
+    radiusInKm * 1e3
+  );
+  const matchingDocs = [];
+  for (const b of bounds) {
+    const constraints = [
+      (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_firestore22.where)("services", "array-contains-any", filters.services)
       );
-      return null;
     }
-    if (metadata.accessLevel === newAccessLevel) {
-      console.log(
-        `[MediaService] Media ID ${mediaId} already has access level ${newAccessLevel}. Updating timestamp only.`
+    if ((filters == null ? void 0 : filters.tags) && filters.tags.length > 0) {
+      constraints.push((0, import_firestore22.where)("tags", "array-contains-any", filters.tags));
+    }
+    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)(
+        [center.latitude, center.longitude],
+        [clinic.location.latitude, clinic.location.longitude]
       );
-      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
-        );
-        throw error;
+      const distanceInKm = distance / 1e3;
+      if (distanceInKm <= radiusInKm) {
+        matchingDocs.push(clinic);
       }
     }
-    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}`
+  }
+  return matchingDocs.sort((a, b) => {
+    const distanceA = (0, import_geofire_common5.distanceBetween)(
+      [center.latitude, center.longitude],
+      [a.location.latitude, a.location.longitude]
     );
-    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);
+    const distanceB = (0, import_geofire_common5.distanceBetween)(
+      [center.latitude, center.longitude],
+      [b.location.latitude, b.location.longitude]
+    );
+    return distanceA - distanceB;
+  });
+}
+
+// src/services/clinic/utils/filter.utils.ts
+var import_firestore23 = require("firebase/firestore");
+var import_geofire_common6 = require("geofire-common");
+async function getClinicsByFilters(db, filters) {
+  console.log(
+    "[FILTER_UTILS] Starting clinic filtering with criteria:",
+    filters
+  );
+  const isGeoQuery = filters.center && filters.radiusInKm && filters.radiusInKm > 0;
+  const constraints = [];
+  if (filters.isActive !== void 0) {
+    constraints.push((0, import_firestore23.where)("isActive", "==", filters.isActive));
+  } else {
+    constraints.push((0, import_firestore23.where)("isActive", "==", true));
+  }
+  if (filters.tags && filters.tags.length > 0) {
+    constraints.push((0, import_firestore23.where)("tags", "array-contains", filters.tags[0]));
+  }
+  if (filters.procedureTechnology) {
+    constraints.push(
+      (0, import_firestore23.where)("servicesInfo.technology", "==", filters.procedureTechnology)
+    );
+  } else if (filters.procedureSubcategory) {
+    constraints.push(
+      (0, import_firestore23.where)("servicesInfo.subCategory", "==", filters.procedureSubcategory)
+    );
+  } else if (filters.procedureCategory) {
+    constraints.push(
+      (0, import_firestore23.where)("servicesInfo.category", "==", filters.procedureCategory)
+    );
+  } else if (filters.procedureFamily) {
+    constraints.push(
+      (0, import_firestore23.where)("servicesInfo.procedureFamily", "==", filters.procedureFamily)
+    );
+  }
+  if (filters.pagination && filters.pagination > 0 && filters.lastDoc) {
+    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_firestore23.limit)(filters.pagination));
+  }
+  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_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);
       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
-        );
-      }
-      return { ...metadata, ...updateData };
-    } catch (error) {
-      console.error(
-        `[MediaService] Error updating media access level and moving file for ${mediaId}:`,
-        error
+        `[FILTER_UTILS] Found ${querySnapshot.docs.length} clinics in geo bound`
       );
-      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.`
+      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]
         );
-        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
-          );
+        const distanceInKm = distance / 1e3;
+        if (distanceInKm <= radiusInKm) {
+          matchingClinics.push({
+            ...clinic,
+            distance: distanceInKm
+          });
         }
       }
-      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));
+    let filteredClinics = matchingClinics;
+    if (filters.tags && filters.tags.length > 1) {
+      filteredClinics = filteredClinics.filter((clinic) => {
+        return filters.tags.every((tag) => clinic.tags.includes(tag));
+      });
     }
-    if (accessLevel) {
-      qConstraints.push((0, import_firestore23.where)("accessLevel", "==", accessLevel));
+    if (filters.minRating !== void 0) {
+      filteredClinics = filteredClinics.filter(
+        (clinic) => clinic.reviewInfo.averageRating >= filters.minRating
+      );
     }
-    qConstraints.push((0, import_firestore23.orderBy)("createdAt", "desc"));
-    if (count) {
-      qConstraints.push((0, import_firestore23.limit)(count));
+    if (filters.maxRating !== void 0) {
+      filteredClinics = filteredClinics.filter(
+        (clinic) => clinic.reviewInfo.averageRating <= filters.maxRating
+      );
     }
-    if (startAfterId) {
-      const startAfterDoc = await this.getMediaMetadata(startAfterId);
-      if (startAfterDoc) {
+    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;
     }
-    const finalQuery = (0, import_firestore23.query)(
-      (0, import_firestore23.collection)(this.db, MEDIA_METADATA_COLLECTION),
-      ...qConstraints
+  } 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(
+      `[FILTER_UTILS] Found ${querySnapshot.docs.length} clinics with regular query`
     );
-    try {
-      const querySnapshot = await (0, import_firestore23.getDocs)(finalQuery);
-      const mediaList = querySnapshot.docs.map(
-        (doc34) => doc34.data()
+    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
       );
-      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.tags && filters.tags.length > 1) {
+      filteredClinics = filteredClinics.filter((clinic) => {
+        return filters.tags.every((tag) => clinic.tags.includes(tag));
+      });
     }
-    console.log(`[MediaService] URL not found for media ID: ${mediaId}`);
-    return null;
+    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/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 || []
       };
@@ -9627,37 +9690,30 @@ var FilledDocumentService = class extends BaseService {
     return { documents: [], lastDoc: null };
   }
   /**
-   * Upload a file and associate it with a filled document field.
-   * @param appointmentId - ID of the appointment.
-   * @param formId - ID of the filled document.
-   * @param isUserForm - Boolean indicating if it's a user form or doctor form.
-   * @param file - The file to upload.
-   * @param fieldId - The ID of the field in the document to associate with this file.
-   * @param accessLevel - Access level for the file, defaults to PRIVATE.
-   * @returns The updated filled document with file information.
+   * Upload a file for a filled document field without updating the document.
+   * This method only handles the upload and returns the file value to be used by the UI.
+   *
+   * @param appointmentId - ID of the appointment
+   * @param formId - ID of the filled document
+   * @param isUserForm - Boolean indicating if it's a user form or doctor form
+   * @param file - The file to upload
+   * @returns The file value object to be stored in the document
    */
-  async uploadFileForFilledDocument(appointmentId, formId, isUserForm, file, fieldId, accessLevel = "private" /* PRIVATE */) {
+  async uploadFileForFilledDocument(appointmentId, formId, isUserForm, file) {
     console.log(
-      `[FilledDocumentService] Uploading file for field ${fieldId} in form ${formId}`
-    );
-    const existingDoc = await this.getFilledDocumentFromAppointmentById(
-      appointmentId,
-      formId,
-      isUserForm
+      `[FilledDocumentService] Uploading file for form ${formId} in appointment ${appointmentId}`
     );
-    if (!existingDoc) {
-      throw new Error(
-        `Filled document with ID ${formId} not found in appointment ${appointmentId}`
-      );
-    }
-    const ownerId = existingDoc.patientId;
-    const collectionName = isUserForm ? "patient_forms_files" : "doctor_forms_files";
+    const fileId = this.generateId();
+    const formType = isUserForm ? "user-form" : "doctor-form";
+    const collectionName = `${formType}/${formId}`;
+    const accessLevel = "confidential" /* CONFIDENTIAL */;
     const mediaMetadata = await this.mediaService.uploadMedia(
       file,
-      ownerId,
+      appointmentId,
+      // Using appointmentId as ownerId
       accessLevel,
       collectionName,
-      file instanceof File ? file.name : `${fieldId}_file`
+      file instanceof File ? file.name : `file_${fileId}`
     );
     const fileValue = {
       mediaId: mediaMetadata.id,
@@ -9667,118 +9723,49 @@ var FilledDocumentService = class extends BaseService {
       size: mediaMetadata.size,
       uploadedAt: Date.now()
     };
-    const values = {
-      [fieldId]: fileValue
-    };
-    return this.updateFilledDocumentInAppointment(
-      appointmentId,
-      formId,
-      isUserForm,
-      values
-    );
+    return fileValue;
   }
   /**
-   * Upload a signature image for a filled document field.
+   * Upload a signature image for a filled document.
    * This is a specialized version of uploadFileForFilledDocument specifically for signatures.
-   * @param appointmentId - ID of the appointment.
-   * @param formId - ID of the filled document.
-   * @param isUserForm - Boolean indicating if it's a user form or doctor form.
-   * @param signatureBlob - The signature image as a Blob.
-   * @param fieldId - The ID of the signature field in the document.
-   * @returns The updated filled document with signature information.
+   *
+   * @param appointmentId - ID of the appointment
+   * @param formId - ID of the filled document
+   * @param isUserForm - Boolean indicating if it's a user form or doctor form
+   * @param signatureBlob - The signature image as a Blob
+   * @returns The file value object to be stored in the document
    */
-  async uploadSignatureForFilledDocument(appointmentId, formId, isUserForm, signatureBlob, fieldId) {
+  async uploadSignatureForFilledDocument(appointmentId, formId, isUserForm, signatureBlob) {
     console.log(
-      `[FilledDocumentService] Uploading signature for field ${fieldId} in form ${formId}`
+      `[FilledDocumentService] Uploading signature for form ${formId}`
     );
+    const signatureId = this.generateId();
     const signatureFile = new File(
       [signatureBlob],
-      `signature_${fieldId}.png`,
-      {
-        type: "image/png"
-      }
+      `signature_${signatureId}.png`,
+      { type: "image/png" }
     );
     return this.uploadFileForFilledDocument(
       appointmentId,
       formId,
       isUserForm,
-      signatureFile,
-      fieldId,
-      "confidential" /* CONFIDENTIAL */
-      // Signatures should be confidential
-    );
-  }
-  /**
-   * Remove a file from a filled document field.
-   * This will both update the document and delete the media file.
-   * @param appointmentId - ID of the appointment.
-   * @param formId - ID of the filled document.
-   * @param isUserForm - Boolean indicating if it's a user form or doctor form.
-   * @param fieldId - The ID of the field containing the file.
-   * @returns The updated filled document with the file removed.
-   */
-  async removeFileFromFilledDocument(appointmentId, formId, isUserForm, fieldId) {
-    var _a;
-    console.log(
-      `[FilledDocumentService] Removing file from field ${fieldId} in form ${formId}`
-    );
-    const existingDoc = await this.getFilledDocumentFromAppointmentById(
-      appointmentId,
-      formId,
-      isUserForm
-    );
-    if (!existingDoc) {
-      throw new Error(
-        `Filled document with ID ${formId} not found in appointment ${appointmentId}`
-      );
-    }
-    const fileValue = (_a = existingDoc.values) == null ? void 0 : _a[fieldId];
-    if (fileValue && fileValue.mediaId) {
-      try {
-        await this.mediaService.deleteMedia(fileValue.mediaId);
-      } catch (error) {
-        console.error(
-          `[FilledDocumentService] Error deleting media ${fileValue.mediaId}:`,
-          error
-        );
-      }
-    }
-    const values = {
-      [fieldId]: null
-    };
-    return this.updateFilledDocumentInAppointment(
-      appointmentId,
-      formId,
-      isUserForm,
-      values
+      signatureFile
     );
   }
   /**
-   * Get the download URL for a file in a filled document.
-   * @param appointmentId - ID of the appointment.
-   * @param formId - ID of the filled document.
-   * @param isUserForm - Boolean indicating if it's a user form or doctor form.
-   * @param fieldId - The ID of the field containing the file.
-   * @returns The download URL for the file, or null if not found.
+   * Delete a file using its mediaId.
+   *
+   * @param mediaId - ID of the media to delete
+   * @returns Promise resolving when the deletion is complete
    */
-  async getFileUrlFromFilledDocument(appointmentId, formId, isUserForm, fieldId) {
-    var _a;
+  async deleteFile(mediaId) {
     console.log(
-      `[FilledDocumentService] Getting file URL for field ${fieldId} in form ${formId}`
-    );
-    const doc34 = await this.getFilledDocumentFromAppointmentById(
-      appointmentId,
-      formId,
-      isUserForm
+      `[FilledDocumentService] Deleting file with mediaId ${mediaId}`
     );
-    if (!doc34) {
-      return null;
+    if (!mediaId) {
+      throw new Error("MediaId is required to delete a file");
     }
-    const fileValue = (_a = doc34.values) == null ? void 0 : _a[fieldId];
-    if (fileValue && fileValue.url) {
-      return fileValue.url;
-    }
-    return null;
+    await this.mediaService.deleteMedia(mediaId);
   }
 };