@blackcode_sa/metaestetics-api 1.11.2 → 1.12.0

package/dist/backoffice/index.js

@@ -32,6 +32,7 @@ __export(index_exports, {
   CertificationLevel: () => CertificationLevel,
   CertificationSpecialty: () => CertificationSpecialty,
   CircularReferenceError: () => CircularReferenceError,
+  ConstantsService: () => ConstantsService,
   Contraindication: () => Contraindication,
   ContraindicationError: () => ContraindicationError,
   Currency: () => Currency,
@@ -79,6 +80,7 @@ __export(index_exports, {
   certificationLevelSchema: () => certificationLevelSchema,
   certificationRequirementSchema: () => certificationRequirementSchema,
   certificationSpecialtySchema: () => certificationSpecialtySchema,
+  contraindicationDynamicSchema: () => contraindicationDynamicSchema,
   contraindicationSchemaBackoffice: () => contraindicationSchemaBackoffice,
   createDocumentTemplateSchema: () => createDocumentTemplateSchema,
   documentElementSchema: () => documentElementSchema,
@@ -95,6 +97,7 @@ __export(index_exports, {
   technologyUpdateSchema: () => technologyUpdateSchema,
   timeUnitSchemaBackoffice: () => timeUnitSchemaBackoffice,
   timeframeSchema: () => timeframeSchema,
+  treatmentBenefitDynamicSchema: () => treatmentBenefitDynamicSchema,
   treatmentBenefitSchemaBackoffice: () => treatmentBenefitSchemaBackoffice,
   updateDocumentTemplateSchema: () => updateDocumentTemplateSchema
 });
@@ -109,11 +112,13 @@ var BRANDS_COLLECTION = "brands";
 // src/services/base.service.ts
 var import_storage = require("firebase/storage");
 var BaseService = class {
-  constructor(db, auth, app) {
+  constructor(db, auth, app, storage) {
     this.db = db;
     this.auth = auth;
     this.app = app;
-    this.storage = (0, import_storage.getStorage)(app);
+    if (app) {
+      this.storage = storage || (0, import_storage.getStorage)(app);
+    }
   }
   /**
    * Generiše jedinstveni ID za dokumente
@@ -146,6 +151,7 @@ var BrandService = class extends BaseService {
     const now = /* @__PURE__ */ new Date();
     const newBrand = {
       ...brand,
+      name_lowercase: brand.name.toLowerCase(),
       createdAt: now,
       updatedAt: now,
       isActive: true
@@ -154,15 +160,69 @@ var BrandService = class extends BaseService {
     return { id: docRef.id, ...newBrand };
   }
   /**
-   * Gets all active brands
+   * Gets a paginated list of active brands, optionally filtered by name.
+   * @param rowsPerPage - The number of brands to fetch.
+   * @param searchTerm - An optional string to filter brand names by (starts-with search).
+   * @param lastVisible - An optional document snapshot to use as a cursor for pagination.
    */
-  async getAll() {
-    const q = (0, import_firestore.query)(this.getBrandsRef(), (0, import_firestore.where)("isActive", "==", true));
+  async getAll(rowsPerPage, searchTerm, lastVisible) {
+    const constraints = [
+      (0, import_firestore.where)("isActive", "==", true),
+      (0, import_firestore.orderBy)("name_lowercase")
+    ];
+    if (searchTerm) {
+      const lowercasedSearchTerm = searchTerm.toLowerCase();
+      constraints.push((0, import_firestore.where)("name_lowercase", ">=", lowercasedSearchTerm));
+      constraints.push(
+        (0, import_firestore.where)("name_lowercase", "<=", lowercasedSearchTerm + "\uF8FF")
+      );
+    }
+    if (lastVisible) {
+      constraints.push((0, import_firestore.startAfter)(lastVisible));
+    }
+    constraints.push((0, import_firestore.limit)(rowsPerPage));
+    const q = (0, import_firestore.query)(this.getBrandsRef(), ...constraints);
+    const snapshot = await (0, import_firestore.getDocs)(q);
+    const brands = snapshot.docs.map(
+      (doc11) => ({
+        id: doc11.id,
+        ...doc11.data()
+      })
+    );
+    const newLastVisible = snapshot.docs[snapshot.docs.length - 1];
+    return { brands, lastVisible: newLastVisible };
+  }
+  /**
+   * Gets the total count of active brands, optionally filtered by name.
+   * @param searchTerm - An optional string to filter brand names by (starts-with search).
+   */
+  async getBrandsCount(searchTerm) {
+    const constraints = [(0, import_firestore.where)("isActive", "==", true)];
+    if (searchTerm) {
+      const lowercasedSearchTerm = searchTerm.toLowerCase();
+      constraints.push((0, import_firestore.where)("name_lowercase", ">=", lowercasedSearchTerm));
+      constraints.push(
+        (0, import_firestore.where)("name_lowercase", "<=", lowercasedSearchTerm + "\uF8FF")
+      );
+    }
+    const q = (0, import_firestore.query)(this.getBrandsRef(), ...constraints);
+    const snapshot = await (0, import_firestore.getCountFromServer)(q);
+    return snapshot.data().count;
+  }
+  /**
+   * Gets all active brands for filter dropdowns (not paginated).
+   */
+  async getAllForFilter() {
+    const q = (0, import_firestore.query)(
+      this.getBrandsRef(),
+      (0, import_firestore.where)("isActive", "==", true),
+      (0, import_firestore.orderBy)("name")
+    );
     const snapshot = await (0, import_firestore.getDocs)(q);
     return snapshot.docs.map(
-      (doc10) => ({
-        id: doc10.id,
-        ...doc10.data()
+      (doc11) => ({
+        id: doc11.id,
+        ...doc11.data()
       })
     );
   }
@@ -174,6 +234,9 @@ var BrandService = class extends BaseService {
       ...brand,
       updatedAt: /* @__PURE__ */ new Date()
     };
+    if (brand.name) {
+      updateData.name_lowercase = brand.name.toLowerCase();
+    }
     const docRef = (0, import_firestore.doc)(this.getBrandsRef(), brandId);
     await (0, import_firestore.updateDoc)(docRef, updateData);
     return this.getById(brandId);
@@ -206,6 +269,13 @@ var import_firestore2 = require("firebase/firestore");
 // src/backoffice/types/category.types.ts
 var CATEGORIES_COLLECTION = "backoffice_categories";
 
+// src/backoffice/types/static/procedure-family.types.ts
+var ProcedureFamily = /* @__PURE__ */ ((ProcedureFamily2) => {
+  ProcedureFamily2["AESTHETICS"] = "aesthetics";
+  ProcedureFamily2["SURGERY"] = "surgery";
+  return ProcedureFamily2;
+})(ProcedureFamily || {});
+
 // src/backoffice/services/category.service.ts
 var CategoryService = class extends BaseService {
   /**
@@ -231,37 +301,87 @@ var CategoryService = class extends BaseService {
     return { id: docRef.id, ...newCategory };
   }
   /**
-   * Vraća sve aktivne kategorije
-   * @returns Lista aktivnih kategorija
+   * Returns counts of categories for each family.
+   * @param active - Whether to count active or inactive categories.
+   * @returns A record mapping family to category count.
    */
-  async getAll() {
+  async getCategoryCounts(active = true) {
+    const counts = {};
+    const families = Object.values(ProcedureFamily);
+    for (const family of families) {
+      const q = (0, import_firestore2.query)(
+        this.categoriesRef,
+        (0, import_firestore2.where)("family", "==", family),
+        (0, import_firestore2.where)("isActive", "==", active)
+      );
+      const snapshot = await (0, import_firestore2.getCountFromServer)(q);
+      counts[family] = snapshot.data().count;
+    }
+    return counts;
+  }
+  /**
+   * Vraća sve kategorije za potrebe filtera (bez paginacije)
+   * @returns Lista svih aktivnih kategorija
+   */
+  async getAllForFilter() {
     const q = (0, import_firestore2.query)(this.categoriesRef, (0, import_firestore2.where)("isActive", "==", true));
     const snapshot = await (0, import_firestore2.getDocs)(q);
     return snapshot.docs.map(
-      (doc10) => ({
-        id: doc10.id,
-        ...doc10.data()
+      (doc11) => ({
+        id: doc11.id,
+        ...doc11.data()
       })
     );
   }
   /**
-   * Vraća sve aktivne kategorije za određenu familiju procedura
+   * Vraća sve kategorije sa paginacijom
+   * @param options - Pagination and filter options
+   * @returns Lista kategorija i poslednji vidljiv dokument
+   */
+  async getAll(options = {}) {
+    const { active = true, limit: queryLimit = 10, lastVisible } = options;
+    const constraints = [
+      (0, import_firestore2.where)("isActive", "==", active),
+      (0, import_firestore2.orderBy)("name"),
+      queryLimit ? (0, import_firestore2.limit)(queryLimit) : void 0,
+      lastVisible ? (0, import_firestore2.startAfter)(lastVisible) : void 0
+    ].filter((c) => !!c);
+    const q = (0, import_firestore2.query)(this.categoriesRef, ...constraints);
+    const snapshot = await (0, import_firestore2.getDocs)(q);
+    const categories = snapshot.docs.map(
+      (doc11) => ({
+        id: doc11.id,
+        ...doc11.data()
+      })
+    );
+    const newLastVisible = snapshot.docs[snapshot.docs.length - 1];
+    return { categories, lastVisible: newLastVisible };
+  }
+  /**
+   * Vraća sve aktivne kategorije za određenu familiju procedura sa paginacijom
    * @param family - Familija procedura (aesthetics/surgery)
+   * @param options - Pagination options
    * @returns Lista kategorija koje pripadaju traženoj familiji
    */
-  async getAllByFamily(family) {
-    const q = (0, import_firestore2.query)(
-      this.categoriesRef,
+  async getAllByFamily(family, options = {}) {
+    const { active = true, limit: queryLimit = 10, lastVisible } = options;
+    const constraints = [
       (0, import_firestore2.where)("family", "==", family),
-      (0, import_firestore2.where)("isActive", "==", true)
-    );
+      (0, import_firestore2.where)("isActive", "==", active),
+      (0, import_firestore2.orderBy)("name"),
+      queryLimit ? (0, import_firestore2.limit)(queryLimit) : void 0,
+      lastVisible ? (0, import_firestore2.startAfter)(lastVisible) : void 0
+    ].filter((c) => !!c);
+    const q = (0, import_firestore2.query)(this.categoriesRef, ...constraints);
     const snapshot = await (0, import_firestore2.getDocs)(q);
-    return snapshot.docs.map(
-      (doc10) => ({
-        id: doc10.id,
-        ...doc10.data()
+    const categories = snapshot.docs.map(
+      (doc11) => ({
+        id: doc11.id,
+        ...doc11.data()
       })
     );
+    const newLastVisible = snapshot.docs[snapshot.docs.length - 1];
+    return { categories, lastVisible: newLastVisible };
   }
   /**
    * Ažurira postojeću kategoriju
@@ -285,6 +405,13 @@ var CategoryService = class extends BaseService {
   async delete(id) {
     await this.update(id, { isActive: false });
   }
+  /**
+   * Reactivates a category by setting its isActive flag to true.
+   * @param id - The ID of the category to reactivate.
+   */
+  async reactivate(id) {
+    await this.update(id, { isActive: true });
+  }
   /**
    * Vraća kategoriju po ID-u
    * @param id - ID tražene kategorije
@@ -536,9 +663,10 @@ var updateFilledDocumentDataSchema = import_zod.z.object({
 });
 
 // src/services/documentation-templates/documentation-template.service.ts
+var import_firestore4 = require("firebase/firestore");
 var DocumentationTemplateService = class extends BaseService {
-  constructor() {
-    super(...arguments);
+  constructor(...args) {
+    super(...args);
     this.collectionRef = (0, import_firestore3.collection)(
       this.db,
       DOCUMENTATION_TEMPLATES_COLLECTION
@@ -690,8 +818,8 @@ var DocumentationTemplateService = class extends BaseService {
     const q = (0, import_firestore3.query)(versionsCollectionRef, (0, import_firestore3.orderBy)("version", "desc"));
     const querySnapshot = await (0, import_firestore3.getDocs)(q);
     const versions = [];
-    querySnapshot.forEach((doc10) => {
-      versions.push(doc10.data());
+    querySnapshot.forEach((doc11) => {
+      versions.push(doc11.data());
     });
     return versions;
   }
@@ -722,15 +850,97 @@ var DocumentationTemplateService = class extends BaseService {
     const querySnapshot = await (0, import_firestore3.getDocs)(q);
     const templates = [];
     let lastVisible = null;
-    querySnapshot.forEach((doc10) => {
-      templates.push(doc10.data());
-      lastVisible = doc10;
+    querySnapshot.forEach((doc11) => {
+      templates.push(doc11.data());
+      lastVisible = doc11;
     });
     return {
       templates,
       lastDoc: lastVisible
     };
   }
+  /**
+   * Get all active templates with optional filters and pagination.
+   * @param options - Options for filtering and pagination.
+   * @returns A promise that resolves to the templates and the last visible document.
+   */
+  async getTemplates(options) {
+    const {
+      pageSize = 20,
+      lastDoc,
+      isUserForm,
+      isRequired,
+      sortingOrder
+    } = options;
+    const constraints = [
+      (0, import_firestore3.where)("isActive", "==", true),
+      (0, import_firestore3.orderBy)("sortingOrder", "asc"),
+      (0, import_firestore3.orderBy)("title", "asc"),
+      (0, import_firestore3.limit)(pageSize)
+    ];
+    if (isUserForm !== void 0) {
+      constraints.push((0, import_firestore3.where)("isUserForm", "==", isUserForm));
+    }
+    if (isRequired !== void 0) {
+      constraints.push((0, import_firestore3.where)("isRequired", "==", isRequired));
+    }
+    if (sortingOrder !== void 0) {
+      constraints.push((0, import_firestore3.where)("sortingOrder", "==", sortingOrder));
+    }
+    if (lastDoc) {
+      constraints.push((0, import_firestore3.startAfter)(lastDoc));
+    }
+    const q = (0, import_firestore3.query)(this.collectionRef, ...constraints.filter((c) => c));
+    const querySnapshot = await (0, import_firestore3.getDocs)(q);
+    const templates = [];
+    let lastVisible = null;
+    querySnapshot.forEach((doc11) => {
+      templates.push(doc11.data());
+      lastVisible = doc11;
+    });
+    return {
+      templates,
+      lastDoc: lastVisible
+    };
+  }
+  /**
+   * Get the total count of active templates with optional filters.
+   * @param options - Options for filtering.
+   * @returns A promise that resolves to the total count of templates.
+   */
+  async getTemplatesCount(options) {
+    const { isUserForm, isRequired, sortingOrder } = options;
+    const constraints = [(0, import_firestore3.where)("isActive", "==", true)];
+    if (isUserForm !== void 0) {
+      constraints.push((0, import_firestore3.where)("isUserForm", "==", isUserForm));
+    }
+    if (isRequired !== void 0) {
+      constraints.push((0, import_firestore3.where)("isRequired", "==", isRequired));
+    }
+    if (sortingOrder !== void 0) {
+      constraints.push((0, import_firestore3.where)("sortingOrder", "==", sortingOrder));
+    }
+    const q = (0, import_firestore3.query)(this.collectionRef, ...constraints.filter((c) => c));
+    const snapshot = await (0, import_firestore4.getCountFromServer)(q);
+    return snapshot.data().count;
+  }
+  /**
+   * Get all active templates without pagination for filtering purposes.
+   * @returns A promise that resolves to an array of all active templates.
+   */
+  async getAllActiveTemplates() {
+    const q = (0, import_firestore3.query)(
+      this.collectionRef,
+      (0, import_firestore3.where)("isActive", "==", true),
+      (0, import_firestore3.orderBy)("title", "asc")
+    );
+    const querySnapshot = await (0, import_firestore3.getDocs)(q);
+    const templates = [];
+    querySnapshot.forEach((doc11) => {
+      templates.push(doc11.data());
+    });
+    return templates;
+  }
   /**
    * Get templates by tags
    * @param tags - Tags to filter by
@@ -752,9 +962,9 @@ var DocumentationTemplateService = class extends BaseService {
     const querySnapshot = await (0, import_firestore3.getDocs)(q);
     const templates = [];
     let lastVisible = null;
-    querySnapshot.forEach((doc10) => {
-      templates.push(doc10.data());
-      lastVisible = doc10;
+    querySnapshot.forEach((doc11) => {
+      templates.push(doc11.data());
+      lastVisible = doc11;
     });
     return {
       templates,
@@ -781,9 +991,9 @@ var DocumentationTemplateService = class extends BaseService {
     const querySnapshot = await (0, import_firestore3.getDocs)(q);
     const templates = [];
     let lastVisible = null;
-    querySnapshot.forEach((doc10) => {
-      templates.push(doc10.data());
-      lastVisible = doc10;
+    querySnapshot.forEach((doc11) => {
+      templates.push(doc11.data());
+      lastVisible = doc11;
     });
     return {
       templates,
@@ -809,20 +1019,20 @@ var DocumentationTemplateService = class extends BaseService {
     }
     const querySnapshot = await (0, import_firestore3.getDocs)(q);
     const templates = [];
-    querySnapshot.forEach((doc10) => {
-      templates.push(doc10.data());
+    querySnapshot.forEach((doc11) => {
+      templates.push(doc11.data());
     });
     return templates;
   }
 };
 
 // src/services/documentation-templates/filled-document.service.ts
-var import_firestore6 = require("firebase/firestore");
+var import_firestore7 = require("firebase/firestore");
 
 // src/services/media/media.service.ts
-var import_firestore4 = require("firebase/firestore");
-var import_storage2 = require("firebase/storage");
 var import_firestore5 = require("firebase/firestore");
+var import_storage2 = require("firebase/storage");
+var import_firestore6 = require("firebase/firestore");
 
 // src/backoffice/services/documentation-template.service.ts
 var DocumentationTemplateServiceBackoffice = class {
@@ -832,8 +1042,8 @@ var DocumentationTemplateServiceBackoffice = class {
    * @param auth - Firebase Auth instance
    * @param app - Firebase App instance
    */
-  constructor(db, auth, app) {
-    this.apiService = new DocumentationTemplateService(db, auth, app);
+  constructor(...args) {
+    this.apiService = new DocumentationTemplateService(...args);
   }
   /**
    * Create a new document template
@@ -878,6 +1088,40 @@ var DocumentationTemplateServiceBackoffice = class {
   async getActiveTemplates(pageSize = 20, lastDoc) {
     return this.apiService.getActiveTemplates(pageSize, lastDoc);
   }
+  /**
+   * Get all active templates with optional filters and pagination.
+   * @param options - Options for filtering and pagination.
+   * @returns A promise that resolves to the templates and the last visible document.
+   */
+  async getTemplates(options) {
+    return this.apiService.getTemplates(options);
+  }
+  /**
+   * Get the total count of active templates with optional filters.
+   * @param options - Options for filtering.
+   * @returns A promise that resolves to the total count of templates.
+   */
+  async getTemplatesCount(options) {
+    return this.apiService.getTemplatesCount(options);
+  }
+  /**
+   * Get all active templates without pagination for filtering purposes.
+   * @returns A promise that resolves to an array of all active templates.
+   */
+  async getAllActiveTemplates() {
+    return this.apiService.getAllActiveTemplates();
+  }
+  /**
+   * Searches for active templates by title.
+   * @param title - The title to search for.
+   * @returns A list of templates that match the search criteria.
+   */
+  async search(title) {
+    const { templates } = await this.apiService.getActiveTemplates(1e3);
+    return templates.filter(
+      (t) => t.title.toLowerCase().includes(title.toLowerCase())
+    );
+  }
   /**
    * Get templates by tags
    * @param tags - Tags to filter by
@@ -918,7 +1162,7 @@ var DocumentationTemplateServiceBackoffice = class {
 };
 
 // src/backoffice/services/product.service.ts
-var import_firestore7 = require("firebase/firestore");
+var import_firestore8 = require("firebase/firestore");
 
 // src/backoffice/types/product.types.ts
 var PRODUCTS_COLLECTION = "products";
@@ -934,7 +1178,7 @@ var ProductService = class extends BaseService {
    * @returns Firestore collection reference
    */
   getProductsRef(technologyId) {
-    return (0, import_firestore7.collection)(
+    return (0, import_firestore8.collection)(
       this.db,
       TECHNOLOGIES_COLLECTION,
       technologyId,
@@ -954,47 +1198,129 @@ var ProductService = class extends BaseService {
       updatedAt: now,
       isActive: true
     };
-    const productRef = await (0, import_firestore7.addDoc)(
+    const productRef = await (0, import_firestore8.addDoc)(
       this.getProductsRef(technologyId),
       newProduct
     );
     return { id: productRef.id, ...newProduct };
   }
   /**
-   * Gets all products for a technology
+   * Gets a paginated list of all products, with optional filters.
+   * This uses a collectionGroup query to search across all technologies.
    */
-  async getAllByTechnology(technologyId) {
-    const q = (0, import_firestore7.query)(
-      this.getProductsRef(technologyId),
-      (0, import_firestore7.where)("isActive", "==", true)
+  async getAll(options) {
+    const {
+      rowsPerPage,
+      lastVisible,
+      categoryId,
+      subcategoryId,
+      technologyId
+    } = options;
+    const constraints = [
+      (0, import_firestore8.where)("isActive", "==", true),
+      (0, import_firestore8.orderBy)("name")
+    ];
+    if (categoryId) {
+      constraints.push((0, import_firestore8.where)("categoryId", "==", categoryId));
+    }
+    if (subcategoryId) {
+      constraints.push((0, import_firestore8.where)("subcategoryId", "==", subcategoryId));
+    }
+    if (technologyId) {
+      constraints.push((0, import_firestore8.where)("technologyId", "==", technologyId));
+    }
+    if (lastVisible) {
+      constraints.push((0, import_firestore8.startAfter)(lastVisible));
+    }
+    constraints.push((0, import_firestore8.limit)(rowsPerPage));
+    const q = (0, import_firestore8.query)(
+      (0, import_firestore8.collectionGroup)(this.db, PRODUCTS_COLLECTION),
+      ...constraints
     );
-    const snapshot = await (0, import_firestore7.getDocs)(q);
-    return snapshot.docs.map(
-      (doc10) => ({
-        id: doc10.id,
-        ...doc10.data()
+    const snapshot = await (0, import_firestore8.getDocs)(q);
+    const products = snapshot.docs.map(
+      (doc11) => ({
+        id: doc11.id,
+        ...doc11.data()
       })
     );
+    const newLastVisible = snapshot.docs[snapshot.docs.length - 1];
+    return { products, lastVisible: newLastVisible };
+  }
+  /**
+   * Gets the total count of active products, with optional filters.
+   */
+  async getProductsCount(options) {
+    const { categoryId, subcategoryId, technologyId } = options;
+    const constraints = [(0, import_firestore8.where)("isActive", "==", true)];
+    if (categoryId) {
+      constraints.push((0, import_firestore8.where)("categoryId", "==", categoryId));
+    }
+    if (subcategoryId) {
+      constraints.push((0, import_firestore8.where)("subcategoryId", "==", subcategoryId));
+    }
+    if (technologyId) {
+      constraints.push((0, import_firestore8.where)("technologyId", "==", technologyId));
+    }
+    const q = (0, import_firestore8.query)(
+      (0, import_firestore8.collectionGroup)(this.db, PRODUCTS_COLLECTION),
+      ...constraints
+    );
+    const snapshot = await (0, import_firestore8.getCountFromServer)(q);
+    return snapshot.data().count;
+  }
+  /**
+   * Gets counts of active products grouped by category, subcategory, and technology.
+   * This uses a single collectionGroup query for efficiency.
+   */
+  async getProductCounts() {
+    const q = (0, import_firestore8.query)(
+      (0, import_firestore8.collectionGroup)(this.db, PRODUCTS_COLLECTION),
+      (0, import_firestore8.where)("isActive", "==", true)
+    );
+    const snapshot = await (0, import_firestore8.getDocs)(q);
+    const counts = {
+      byCategory: {},
+      bySubcategory: {},
+      byTechnology: {}
+    };
+    if (snapshot.empty) {
+      return counts;
+    }
+    snapshot.docs.forEach((doc11) => {
+      const product = doc11.data();
+      const { categoryId, subcategoryId, technologyId } = product;
+      if (categoryId) {
+        counts.byCategory[categoryId] = (counts.byCategory[categoryId] || 0) + 1;
+      }
+      if (subcategoryId) {
+        counts.bySubcategory[subcategoryId] = (counts.bySubcategory[subcategoryId] || 0) + 1;
+      }
+      if (technologyId) {
+        counts.byTechnology[technologyId] = (counts.byTechnology[technologyId] || 0) + 1;
+      }
+    });
+    return counts;
   }
   /**
    * Gets all products for a brand by filtering through all technologies
    */
   async getAllByBrand(brandId) {
-    const allTechnologiesRef = (0, import_firestore7.collection)(this.db, TECHNOLOGIES_COLLECTION);
-    const technologiesSnapshot = await (0, import_firestore7.getDocs)(allTechnologiesRef);
+    const allTechnologiesRef = (0, import_firestore8.collection)(this.db, TECHNOLOGIES_COLLECTION);
+    const technologiesSnapshot = await (0, import_firestore8.getDocs)(allTechnologiesRef);
     const products = [];
     for (const techDoc of technologiesSnapshot.docs) {
-      const q = (0, import_firestore7.query)(
+      const q = (0, import_firestore8.query)(
         this.getProductsRef(techDoc.id),
-        (0, import_firestore7.where)("brandId", "==", brandId),
-        (0, import_firestore7.where)("isActive", "==", true)
+        (0, import_firestore8.where)("brandId", "==", brandId),
+        (0, import_firestore8.where)("isActive", "==", true)
       );
-      const snapshot = await (0, import_firestore7.getDocs)(q);
+      const snapshot = await (0, import_firestore8.getDocs)(q);
       products.push(
         ...snapshot.docs.map(
-          (doc10) => ({
-            id: doc10.id,
-            ...doc10.data()
+          (doc11) => ({
+            id: doc11.id,
+            ...doc11.data()
           })
         )
       );
@@ -1009,8 +1335,8 @@ var ProductService = class extends BaseService {
       ...product,
       updatedAt: /* @__PURE__ */ new Date()
     };
-    const docRef = (0, import_firestore7.doc)(this.getProductsRef(technologyId), productId);
-    await (0, import_firestore7.updateDoc)(docRef, updateData);
+    const docRef = (0, import_firestore8.doc)(this.getProductsRef(technologyId), productId);
+    await (0, import_firestore8.updateDoc)(docRef, updateData);
     return this.getById(technologyId, productId);
   }
   /**
@@ -1025,8 +1351,8 @@ var ProductService = class extends BaseService {
    * Gets a product by ID
    */
   async getById(technologyId, productId) {
-    const docRef = (0, import_firestore7.doc)(this.getProductsRef(technologyId), productId);
-    const docSnap = await (0, import_firestore7.getDoc)(docRef);
+    const docRef = (0, import_firestore8.doc)(this.getProductsRef(technologyId), productId);
+    const docSnap = await (0, import_firestore8.getDoc)(docRef);
     if (!docSnap.exists()) return null;
     return {
       id: docSnap.id,
@@ -1036,7 +1362,7 @@ var ProductService = class extends BaseService {
 };
 
 // src/backoffice/services/requirement.service.ts
-var import_firestore8 = require("firebase/firestore");
+var import_firestore9 = require("firebase/firestore");
 
 // src/backoffice/types/requirement.types.ts
 var TimeUnit = /* @__PURE__ */ ((TimeUnit2) => {
@@ -1057,7 +1383,7 @@ var RequirementService = class extends BaseService {
    * Referenca na Firestore kolekciju zahteva
    */
   get requirementsRef() {
-    return (0, import_firestore8.collection)(this.db, REQUIREMENTS_COLLECTION);
+    return (0, import_firestore9.collection)(this.db, REQUIREMENTS_COLLECTION);
   }
   /**
    * Kreira novi globalni zahtev
@@ -1072,7 +1398,7 @@ var RequirementService = class extends BaseService {
       updatedAt: now,
       isActive: true
     };
-    const docRef = await (0, import_firestore8.addDoc)(this.requirementsRef, newRequirement);
+    const docRef = await (0, import_firestore9.addDoc)(this.requirementsRef, newRequirement);
     return { id: docRef.id, ...newRequirement };
   }
   /**
@@ -1080,12 +1406,12 @@ var RequirementService = class extends BaseService {
    * @returns Lista aktivnih zahteva
    */
   async getAll() {
-    const q = (0, import_firestore8.query)(this.requirementsRef, (0, import_firestore8.where)("isActive", "==", true));
-    const snapshot = await (0, import_firestore8.getDocs)(q);
+    const q = (0, import_firestore9.query)(this.requirementsRef, (0, import_firestore9.where)("isActive", "==", true));
+    const snapshot = await (0, import_firestore9.getDocs)(q);
     return snapshot.docs.map(
-      (doc10) => ({
-        id: doc10.id,
-        ...doc10.data()
+      (doc11) => ({
+        id: doc11.id,
+        ...doc11.data()
       })
     );
   }
@@ -1095,19 +1421,31 @@ var RequirementService = class extends BaseService {
    * @returns Lista zahteva određenog tipa
    */
   async getAllByType(type) {
-    const q = (0, import_firestore8.query)(
+    const q = (0, import_firestore9.query)(
       this.requirementsRef,
-      (0, import_firestore8.where)("type", "==", type),
-      (0, import_firestore8.where)("isActive", "==", true)
+      (0, import_firestore9.where)("type", "==", type),
+      (0, import_firestore9.where)("isActive", "==", true)
     );
-    const snapshot = await (0, import_firestore8.getDocs)(q);
+    const snapshot = await (0, import_firestore9.getDocs)(q);
     return snapshot.docs.map(
-      (doc10) => ({
-        id: doc10.id,
-        ...doc10.data()
+      (doc11) => ({
+        id: doc11.id,
+        ...doc11.data()
       })
     );
   }
+  /**
+   * Searches for requirements by name.
+   * @param name - The name to search for.
+   * @param type - The type of requirement (pre/post).
+   * @returns A list of requirements that match the search criteria.
+   */
+  async search(name, type) {
+    const requirements = await this.getAllByType(type);
+    return requirements.filter(
+      (r) => r.name.toLowerCase().includes(name.toLowerCase())
+    );
+  }
   /**
    * Ažurira postojeći zahtev
    * @param id - ID zahteva koji se ažurira
@@ -1119,8 +1457,8 @@ var RequirementService = class extends BaseService {
       ...requirement,
       updatedAt: /* @__PURE__ */ new Date()
     };
-    const docRef = (0, import_firestore8.doc)(this.requirementsRef, id);
-    await (0, import_firestore8.updateDoc)(docRef, updateData);
+    const docRef = (0, import_firestore9.doc)(this.requirementsRef, id);
+    await (0, import_firestore9.updateDoc)(docRef, updateData);
     return this.getById(id);
   }
   /**
@@ -1136,8 +1474,8 @@ var RequirementService = class extends BaseService {
    * @returns Zahtev ili null ako ne postoji
    */
   async getById(id) {
-    const docRef = (0, import_firestore8.doc)(this.requirementsRef, id);
-    const docSnap = await (0, import_firestore8.getDoc)(docRef);
+    const docRef = (0, import_firestore9.doc)(this.requirementsRef, id);
+    const docSnap = await (0, import_firestore9.getDoc)(docRef);
     if (!docSnap.exists()) return null;
     return {
       id: docSnap.id,
@@ -1147,7 +1485,7 @@ var RequirementService = class extends BaseService {
 };
 
 // src/backoffice/services/subcategory.service.ts
-var import_firestore9 = require("firebase/firestore");
+var import_firestore10 = require("firebase/firestore");
 
 // src/backoffice/types/subcategory.types.ts
 var SUBCATEGORIES_COLLECTION = "subcategories";
@@ -1159,7 +1497,7 @@ var SubcategoryService = class extends BaseService {
    * @param categoryId - ID roditeljske kategorije
    */
   getSubcategoriesRef(categoryId) {
-    return (0, import_firestore9.collection)(
+    return (0, import_firestore10.collection)(
       this.db,
       CATEGORIES_COLLECTION,
       categoryId,
@@ -1181,27 +1519,117 @@ var SubcategoryService = class extends BaseService {
       updatedAt: now,
       isActive: true
     };
-    const docRef = await (0, import_firestore9.addDoc)(
+    const docRef = await (0, import_firestore10.addDoc)(
       this.getSubcategoriesRef(categoryId),
       newSubcategory
     );
     return { id: docRef.id, ...newSubcategory };
   }
   /**
-   * Vraća sve aktivne podkategorije za određenu kategoriju
+   * Returns counts of subcategories for all categories.
+   * @param active - Whether to count active or inactive subcategories.
+   * @returns A record mapping category ID to subcategory count.
+   */
+  async getSubcategoryCounts(active = true) {
+    const categoriesRef = (0, import_firestore10.collection)(this.db, CATEGORIES_COLLECTION);
+    const categoriesSnapshot = await (0, import_firestore10.getDocs)(categoriesRef);
+    const counts = {};
+    for (const categoryDoc of categoriesSnapshot.docs) {
+      const categoryId = categoryDoc.id;
+      const subcategoriesRef = this.getSubcategoriesRef(categoryId);
+      const q = (0, import_firestore10.query)(subcategoriesRef, (0, import_firestore10.where)("isActive", "==", active));
+      const snapshot = await (0, import_firestore10.getCountFromServer)(q);
+      counts[categoryId] = snapshot.data().count;
+    }
+    return counts;
+  }
+  /**
+   * Vraća sve aktivne podkategorije za određenu kategoriju sa paginacijom
    * @param categoryId - ID kategorije čije podkategorije tražimo
-   * @returns Lista aktivnih podkategorija
+   * @param options - Pagination options
+   * @returns Lista aktivnih podkategorija i poslednji vidljiv dokument
+   */
+  async getAllByCategoryId(categoryId, options = {}) {
+    const { active = true, limit: queryLimit = 10, lastVisible } = options;
+    const constraints = [
+      (0, import_firestore10.where)("isActive", "==", active),
+      (0, import_firestore10.orderBy)("name"),
+      queryLimit ? (0, import_firestore10.limit)(queryLimit) : void 0,
+      lastVisible ? (0, import_firestore10.startAfter)(lastVisible) : void 0
+    ].filter((c) => !!c);
+    const q = (0, import_firestore10.query)(this.getSubcategoriesRef(categoryId), ...constraints);
+    const querySnapshot = await (0, import_firestore10.getDocs)(q);
+    const subcategories = querySnapshot.docs.map(
+      (doc11) => ({
+        id: doc11.id,
+        ...doc11.data()
+      })
+    );
+    const newLastVisible = querySnapshot.docs[querySnapshot.docs.length - 1];
+    return { subcategories, lastVisible: newLastVisible };
+  }
+  /**
+   * Vraća sve podkategorije sa paginacijom koristeći collection group query.
+   * NOTE: This query requires a composite index in Firestore on the 'subcategories' collection group.
+   * The index should be on 'isActive' (ascending) and 'name' (ascending).
+   * Firestore will provide a link to create this index in the console error if it's missing.
+   * @param options - Pagination options
+   * @returns Lista podkategorija i poslednji vidljiv dokument
+   */
+  async getAll(options = {}) {
+    const { active = true, limit: queryLimit = 10, lastVisible } = options;
+    const constraints = [
+      (0, import_firestore10.where)("isActive", "==", active),
+      (0, import_firestore10.orderBy)("name"),
+      queryLimit ? (0, import_firestore10.limit)(queryLimit) : void 0,
+      lastVisible ? (0, import_firestore10.startAfter)(lastVisible) : void 0
+    ].filter((c) => !!c);
+    const q = (0, import_firestore10.query)(
+      (0, import_firestore10.collectionGroup)(this.db, SUBCATEGORIES_COLLECTION),
+      ...constraints
+    );
+    const querySnapshot = await (0, import_firestore10.getDocs)(q);
+    const subcategories = querySnapshot.docs.map(
+      (doc11) => ({
+        id: doc11.id,
+        ...doc11.data()
+      })
+    );
+    const newLastVisible = querySnapshot.docs[querySnapshot.docs.length - 1];
+    return { subcategories, lastVisible: newLastVisible };
+  }
+  /**
+   * Vraća sve subkategorije za određenu kategoriju za potrebe filtera (bez paginacije)
+   * @param categoryId - ID kategorije čije subkategorije tražimo
+   * @returns Lista svih aktivnih subkategorija
    */
-  async getAllByCategoryId(categoryId) {
-    const q = (0, import_firestore9.query)(
+  async getAllForFilterByCategoryId(categoryId) {
+    const q = (0, import_firestore10.query)(
       this.getSubcategoriesRef(categoryId),
-      (0, import_firestore9.where)("isActive", "==", true)
+      (0, import_firestore10.where)("isActive", "==", true)
     );
-    const snapshot = await (0, import_firestore9.getDocs)(q);
-    return snapshot.docs.map(
-      (doc10) => ({
-        id: doc10.id,
-        ...doc10.data()
+    const querySnapshot = await (0, import_firestore10.getDocs)(q);
+    return querySnapshot.docs.map(
+      (doc11) => ({
+        id: doc11.id,
+        ...doc11.data()
+      })
+    );
+  }
+  /**
+   * Vraća sve subkategorije za potrebe filtera (bez paginacije)
+   * @returns Lista svih aktivnih subkategorija
+   */
+  async getAllForFilter() {
+    const q = (0, import_firestore10.query)(
+      (0, import_firestore10.collectionGroup)(this.db, SUBCATEGORIES_COLLECTION),
+      (0, import_firestore10.where)("isActive", "==", true)
+    );
+    const querySnapshot = await (0, import_firestore10.getDocs)(q);
+    return querySnapshot.docs.map(
+      (doc11) => ({
+        id: doc11.id,
+        ...doc11.data()
       })
     );
   }
@@ -1213,13 +1641,42 @@ var SubcategoryService = class extends BaseService {
    * @returns Ažurirana podkategorija
    */
   async update(categoryId, subcategoryId, subcategory) {
-    const updateData = {
-      ...subcategory,
-      updatedAt: /* @__PURE__ */ new Date()
-    };
-    const docRef = (0, import_firestore9.doc)(this.getSubcategoriesRef(categoryId), subcategoryId);
-    await (0, import_firestore9.updateDoc)(docRef, updateData);
-    return this.getById(categoryId, subcategoryId);
+    const newCategoryId = subcategory.categoryId;
+    if (newCategoryId && newCategoryId !== categoryId) {
+      const oldDocRef = (0, import_firestore10.doc)(
+        this.getSubcategoriesRef(categoryId),
+        subcategoryId
+      );
+      const docSnap = await (0, import_firestore10.getDoc)(oldDocRef);
+      if (!docSnap.exists()) {
+        throw new Error("Subcategory to update does not exist.");
+      }
+      const existingData = docSnap.data();
+      const newData = {
+        ...existingData,
+        ...subcategory,
+        categoryId: newCategoryId,
+        // Ensure categoryId is updated
+        createdAt: existingData.createdAt,
+        // Preserve original creation date
+        updatedAt: /* @__PURE__ */ new Date()
+      };
+      const newDocRef = (0, import_firestore10.doc)(
+        this.getSubcategoriesRef(newCategoryId),
+        subcategoryId
+      );
+      await (0, import_firestore10.setDoc)(newDocRef, newData);
+      await (0, import_firestore10.deleteDoc)(oldDocRef);
+      return { id: subcategoryId, ...newData };
+    } else {
+      const updateData = {
+        ...subcategory,
+        updatedAt: /* @__PURE__ */ new Date()
+      };
+      const docRef = (0, import_firestore10.doc)(this.getSubcategoriesRef(categoryId), subcategoryId);
+      await (0, import_firestore10.updateDoc)(docRef, updateData);
+      return this.getById(categoryId, subcategoryId);
+    }
   }
   /**
    * Soft delete podkategorije (postavlja isActive na false)
@@ -1229,6 +1686,14 @@ var SubcategoryService = class extends BaseService {
   async delete(categoryId, subcategoryId) {
     await this.update(categoryId, subcategoryId, { isActive: false });
   }
+  /**
+   * Reactivates a subcategory by setting its isActive flag to true.
+   * @param categoryId - The ID of the category to which the subcategory belongs.
+   * @param subcategoryId - The ID of the subcategory to reactivate.
+   */
+  async reactivate(categoryId, subcategoryId) {
+    await this.update(categoryId, subcategoryId, { isActive: true });
+  }
   /**
    * Vraća podkategoriju po ID-u
    * @param categoryId - ID kategorije kojoj pripada podkategorija
@@ -1236,8 +1701,8 @@ var SubcategoryService = class extends BaseService {
    * @returns Podkategorija ili null ako ne postoji
    */
   async getById(categoryId, subcategoryId) {
-    const docRef = (0, import_firestore9.doc)(this.getSubcategoriesRef(categoryId), subcategoryId);
-    const docSnap = await (0, import_firestore9.getDoc)(docRef);
+    const docRef = (0, import_firestore10.doc)(this.getSubcategoriesRef(categoryId), subcategoryId);
+    const docSnap = await (0, import_firestore10.getDoc)(docRef);
     if (!docSnap.exists()) return null;
     return {
       id: docSnap.id,
@@ -1247,7 +1712,7 @@ var SubcategoryService = class extends BaseService {
 };
 
 // src/backoffice/services/technology.service.ts
-var import_firestore10 = require("firebase/firestore");
+var import_firestore11 = require("firebase/firestore");
 
 // src/backoffice/types/static/certification.types.ts
 var CertificationLevel = /* @__PURE__ */ ((CertificationLevel2) => {
@@ -1280,138 +1745,186 @@ var DEFAULT_CERTIFICATION_REQUIREMENT = {
 };
 var TechnologyService = class extends BaseService {
   /**
-   * Vraća referencu na Firestore kolekciju tehnologija
+   * Reference to the Firestore collection of technologies.
    */
-  getTechnologiesRef() {
-    return (0, import_firestore10.collection)(this.db, TECHNOLOGIES_COLLECTION);
+  get technologiesRef() {
+    return (0, import_firestore11.collection)(this.db, TECHNOLOGIES_COLLECTION);
   }
   /**
-   * Kreira novu tehnologiju
-   * @param technology - Podaci za novu tehnologiju
-   * @returns Kreirana tehnologija sa generisanim ID-em
+   * Creates a new technology.
+   * @param technology - Data for the new technology.
+   * @returns The created technology with its generated ID.
    */
   async create(technology) {
     const now = /* @__PURE__ */ new Date();
     const newTechnology = {
-      ...technology,
-      createdAt: now,
-      updatedAt: now,
-      isActive: true,
-      requirements: technology.requirements || {
-        pre: [],
-        post: []
-      },
+      name: technology.name,
+      description: technology.description,
+      family: technology.family,
+      categoryId: technology.categoryId,
+      subcategoryId: technology.subcategoryId,
+      requirements: technology.requirements || { pre: [], post: [] },
       blockingConditions: technology.blockingConditions || [],
       contraindications: technology.contraindications || [],
       benefits: technology.benefits || [],
-      certificationRequirement: technology.certificationRequirement || DEFAULT_CERTIFICATION_REQUIREMENT
+      certificationRequirement: technology.certificationRequirement || DEFAULT_CERTIFICATION_REQUIREMENT,
+      documentationTemplates: technology.documentationTemplates || [],
+      isActive: true,
+      createdAt: now,
+      updatedAt: now
     };
-    const docRef = await (0, import_firestore10.addDoc)(this.getTechnologiesRef(), newTechnology);
+    if (technology.technicalDetails) {
+      newTechnology.technicalDetails = technology.technicalDetails;
+    }
+    const docRef = await (0, import_firestore11.addDoc)(this.technologiesRef, newTechnology);
     return { id: docRef.id, ...newTechnology };
   }
   /**
-   * Vraća sve aktivne tehnologije
-   * @returns Lista aktivnih tehnologija
+   * Returns counts of technologies for each subcategory.
+   * @param active - Whether to count active or inactive technologies.
+   * @returns A record mapping subcategory ID to technology count.
    */
-  async getAll() {
-    const q = (0, import_firestore10.query)(this.getTechnologiesRef(), (0, import_firestore10.where)("isActive", "==", true));
-    const snapshot = await (0, import_firestore10.getDocs)(q);
-    return snapshot.docs.map(
-      (doc10) => ({
-        id: doc10.id,
-        ...doc10.data()
-      })
-    );
+  async getTechnologyCounts(active = true) {
+    const q = (0, import_firestore11.query)(this.technologiesRef, (0, import_firestore11.where)("isActive", "==", active));
+    const snapshot = await (0, import_firestore11.getDocs)(q);
+    const counts = {};
+    snapshot.docs.forEach((doc11) => {
+      const tech = doc11.data();
+      counts[tech.subcategoryId] = (counts[tech.subcategoryId] || 0) + 1;
+    });
+    return counts;
   }
   /**
-   * Vraća sve aktivne tehnologije za određenu familiju
-   * @param family - Familija procedura
-   * @returns Lista aktivnih tehnologija
+   * Returns counts of technologies for each category.
+   * @param active - Whether to count active or inactive technologies.
+   * @returns A record mapping category ID to technology count.
    */
-  async getAllByFamily(family) {
-    const q = (0, import_firestore10.query)(
-      this.getTechnologiesRef(),
-      (0, import_firestore10.where)("isActive", "==", true),
-      (0, import_firestore10.where)("family", "==", family)
-    );
-    const snapshot = await (0, import_firestore10.getDocs)(q);
-    return snapshot.docs.map(
-      (doc10) => ({
-        id: doc10.id,
-        ...doc10.data()
+  async getTechnologyCountsByCategory(active = true) {
+    const q = (0, import_firestore11.query)(this.technologiesRef, (0, import_firestore11.where)("isActive", "==", active));
+    const snapshot = await (0, import_firestore11.getDocs)(q);
+    const counts = {};
+    snapshot.docs.forEach((doc11) => {
+      const tech = doc11.data();
+      counts[tech.categoryId] = (counts[tech.categoryId] || 0) + 1;
+    });
+    return counts;
+  }
+  /**
+   * Returns all technologies with pagination.
+   * @param options - Pagination and filter options.
+   * @returns A list of technologies and the last visible document.
+   */
+  async getAll(options = {}) {
+    const { active = true, limit: queryLimit = 10, lastVisible } = options;
+    const constraints = [
+      (0, import_firestore11.where)("isActive", "==", active),
+      (0, import_firestore11.orderBy)("name"),
+      queryLimit ? (0, import_firestore11.limit)(queryLimit) : void 0,
+      lastVisible ? (0, import_firestore11.startAfter)(lastVisible) : void 0
+    ].filter((c) => !!c);
+    const q = (0, import_firestore11.query)(this.technologiesRef, ...constraints);
+    const snapshot = await (0, import_firestore11.getDocs)(q);
+    const technologies = snapshot.docs.map(
+      (doc11) => ({
+        id: doc11.id,
+        ...doc11.data()
       })
     );
-  }
-  /**
-   * Vraća sve aktivne tehnologije za određenu kategoriju
-   * @param categoryId - ID kategorije
-   * @returns Lista aktivnih tehnologija
-   */
-  async getAllByCategoryId(categoryId) {
-    const q = (0, import_firestore10.query)(
-      this.getTechnologiesRef(),
-      (0, import_firestore10.where)("isActive", "==", true),
-      (0, import_firestore10.where)("categoryId", "==", categoryId)
+    const newLastVisible = snapshot.docs[snapshot.docs.length - 1];
+    return { technologies, lastVisible: newLastVisible };
+  }
+  /**
+   * Returns all technologies for a specific category with pagination.
+   * @param categoryId - The ID of the category.
+   * @param options - Pagination options.
+   * @returns A list of technologies for the specified category.
+   */
+  async getAllByCategoryId(categoryId, options = {}) {
+    const { active = true, limit: queryLimit = 10, lastVisible } = options;
+    const constraints = [
+      (0, import_firestore11.where)("categoryId", "==", categoryId),
+      (0, import_firestore11.where)("isActive", "==", active),
+      (0, import_firestore11.orderBy)("name"),
+      queryLimit ? (0, import_firestore11.limit)(queryLimit) : void 0,
+      lastVisible ? (0, import_firestore11.startAfter)(lastVisible) : void 0
+    ].filter((c) => !!c);
+    const q = (0, import_firestore11.query)(this.technologiesRef, ...constraints);
+    const snapshot = await (0, import_firestore11.getDocs)(q);
+    const technologies = snapshot.docs.map(
+      (doc11) => ({
+        id: doc11.id,
+        ...doc11.data()
+      })
     );
-    const snapshot = await (0, import_firestore10.getDocs)(q);
-    return snapshot.docs.map(
-      (doc10) => ({
-        id: doc10.id,
-        ...doc10.data()
+    const newLastVisible = snapshot.docs[snapshot.docs.length - 1];
+    return { technologies, lastVisible: newLastVisible };
+  }
+  /**
+   * Returns all technologies for a specific subcategory with pagination.
+   * @param subcategoryId - The ID of the subcategory.
+   * @param options - Pagination options.
+   * @returns A list of technologies for the specified subcategory.
+   */
+  async getAllBySubcategoryId(subcategoryId, options = {}) {
+    const { active = true, limit: queryLimit = 10, lastVisible } = options;
+    const constraints = [
+      (0, import_firestore11.where)("subcategoryId", "==", subcategoryId),
+      (0, import_firestore11.where)("isActive", "==", active),
+      (0, import_firestore11.orderBy)("name"),
+      queryLimit ? (0, import_firestore11.limit)(queryLimit) : void 0,
+      lastVisible ? (0, import_firestore11.startAfter)(lastVisible) : void 0
+    ].filter((c) => !!c);
+    const q = (0, import_firestore11.query)(this.technologiesRef, ...constraints);
+    const snapshot = await (0, import_firestore11.getDocs)(q);
+    const technologies = snapshot.docs.map(
+      (doc11) => ({
+        id: doc11.id,
+        ...doc11.data()
       })
     );
+    const newLastVisible = snapshot.docs[snapshot.docs.length - 1];
+    return { technologies, lastVisible: newLastVisible };
   }
   /**
-   * Vraća sve aktivne tehnologije za određenu podkategoriju
-   * @param subcategoryId - ID podkategorije
-   * @returns Lista aktivnih tehnologija
+   * Updates an existing technology.
+   * @param id - The ID of the technology to update.
+   * @param technology - New data for the technology.
+   * @returns The updated technology.
    */
-  async getAllBySubcategoryId(subcategoryId) {
-    const q = (0, import_firestore10.query)(
-      this.getTechnologiesRef(),
-      (0, import_firestore10.where)("isActive", "==", true),
-      (0, import_firestore10.where)("subcategoryId", "==", subcategoryId)
-    );
-    const snapshot = await (0, import_firestore10.getDocs)(q);
-    return snapshot.docs.map(
-      (doc10) => ({
-        id: doc10.id,
-        ...doc10.data()
-      })
-    );
+  async update(id, technology) {
+    const updateData = { ...technology };
+    Object.keys(updateData).forEach((key) => {
+      if (updateData[key] === void 0) {
+        delete updateData[key];
+      }
+    });
+    updateData.updatedAt = /* @__PURE__ */ new Date();
+    const docRef = (0, import_firestore11.doc)(this.technologiesRef, id);
+    await (0, import_firestore11.updateDoc)(docRef, updateData);
+    return this.getById(id);
   }
   /**
-   * Ažurira postojeću tehnologiju
-   * @param technologyId - ID tehnologije
-   * @param technology - Novi podaci za tehnologiju
-   * @returns Ažurirana tehnologija
+   * Soft deletes a technology.
+   * @param id - The ID of the technology to delete.
    */
-  async update(technologyId, technology) {
-    const updateData = {
-      ...technology,
-      updatedAt: /* @__PURE__ */ new Date()
-    };
-    const docRef = (0, import_firestore10.doc)(this.getTechnologiesRef(), technologyId);
-    await (0, import_firestore10.updateDoc)(docRef, updateData);
-    return this.getById(technologyId);
+  async delete(id) {
+    await this.update(id, { isActive: false });
   }
   /**
-   * Soft delete tehnologije (postavlja isActive na false)
-   * @param technologyId - ID tehnologije koja se briše
+   * Reactivates a technology.
+   * @param id - The ID of the technology to reactivate.
    */
-  async delete(technologyId) {
-    await this.update(technologyId, {
-      isActive: false
-    });
+  async reactivate(id) {
+    await this.update(id, { isActive: true });
   }
   /**
-   * Vraća tehnologiju po ID-u
-   * @param technologyId - ID tražene tehnologije
-   * @returns Tehnologija ili null ako ne postoji
+   * Returns a technology by its ID.
+   * @param id - The ID of the requested technology.
+   * @returns The technology or null if it doesn't exist.
    */
-  async getById(technologyId) {
-    const docRef = (0, import_firestore10.doc)(this.getTechnologiesRef(), technologyId);
-    const docSnap = await (0, import_firestore10.getDoc)(docRef);
+  async getById(id) {
+    const docRef = (0, import_firestore11.doc)(this.technologiesRef, id);
+    const docSnap = await (0, import_firestore11.getDoc)(docRef);
     if (!docSnap.exists()) return null;
     return {
       id: docSnap.id,
@@ -1425,10 +1938,10 @@ var TechnologyService = class extends BaseService {
    * @returns Ažurirana tehnologija sa novim zahtevom
    */
   async addRequirement(technologyId, requirement) {
-    const docRef = (0, import_firestore10.doc)(this.getTechnologiesRef(), technologyId);
+    const docRef = (0, import_firestore11.doc)(this.technologiesRef, technologyId);
     const requirementType = requirement.type === "pre" ? "requirements.pre" : "requirements.post";
-    await (0, import_firestore10.updateDoc)(docRef, {
-      [requirementType]: (0, import_firestore10.arrayUnion)(requirement),
+    await (0, import_firestore11.updateDoc)(docRef, {
+      [requirementType]: (0, import_firestore11.arrayUnion)(requirement),
       updatedAt: /* @__PURE__ */ new Date()
     });
     return this.getById(technologyId);
@@ -1440,10 +1953,10 @@ var TechnologyService = class extends BaseService {
    * @returns Ažurirana tehnologija bez uklonjenog zahteva
    */
   async removeRequirement(technologyId, requirement) {
-    const docRef = (0, import_firestore10.doc)(this.getTechnologiesRef(), technologyId);
+    const docRef = (0, import_firestore11.doc)(this.technologiesRef, technologyId);
     const requirementType = requirement.type === "pre" ? "requirements.pre" : "requirements.post";
-    await (0, import_firestore10.updateDoc)(docRef, {
-      [requirementType]: (0, import_firestore10.arrayRemove)(requirement),
+    await (0, import_firestore11.updateDoc)(docRef, {
+      [requirementType]: (0, import_firestore11.arrayRemove)(requirement),
       updatedAt: /* @__PURE__ */ new Date()
     });
     return this.getById(technologyId);
@@ -1480,9 +1993,9 @@ var TechnologyService = class extends BaseService {
    * @returns Ažurirana tehnologija
    */
   async addBlockingCondition(technologyId, condition) {
-    const docRef = (0, import_firestore10.doc)(this.getTechnologiesRef(), technologyId);
-    await (0, import_firestore10.updateDoc)(docRef, {
-      blockingConditions: (0, import_firestore10.arrayUnion)(condition),
+    const docRef = (0, import_firestore11.doc)(this.technologiesRef, technologyId);
+    await (0, import_firestore11.updateDoc)(docRef, {
+      blockingConditions: (0, import_firestore11.arrayUnion)(condition),
       updatedAt: /* @__PURE__ */ new Date()
     });
     return this.getById(technologyId);
@@ -1494,9 +2007,9 @@ var TechnologyService = class extends BaseService {
    * @returns Ažurirana tehnologija
    */
   async removeBlockingCondition(technologyId, condition) {
-    const docRef = (0, import_firestore10.doc)(this.getTechnologiesRef(), technologyId);
-    await (0, import_firestore10.updateDoc)(docRef, {
-      blockingConditions: (0, import_firestore10.arrayRemove)(condition),
+    const docRef = (0, import_firestore11.doc)(this.technologiesRef, technologyId);
+    await (0, import_firestore11.updateDoc)(docRef, {
+      blockingConditions: (0, import_firestore11.arrayRemove)(condition),
       updatedAt: /* @__PURE__ */ new Date()
     });
     return this.getById(technologyId);
@@ -1508,9 +2021,17 @@ var TechnologyService = class extends BaseService {
    * @returns Ažurirana tehnologija
    */
   async addContraindication(technologyId, contraindication) {
-    const docRef = (0, import_firestore10.doc)(this.getTechnologiesRef(), technologyId);
-    await (0, import_firestore10.updateDoc)(docRef, {
-      contraindications: (0, import_firestore10.arrayUnion)(contraindication),
+    const docRef = (0, import_firestore11.doc)(this.technologiesRef, technologyId);
+    const technology = await this.getById(technologyId);
+    if (!technology) {
+      throw new Error(`Technology with id ${technologyId} not found`);
+    }
+    const existingContraindications = technology.contraindications || [];
+    if (existingContraindications.some((c) => c.id === contraindication.id)) {
+      return technology;
+    }
+    await (0, import_firestore11.updateDoc)(docRef, {
+      contraindications: [...existingContraindications, contraindication],
       updatedAt: /* @__PURE__ */ new Date()
     });
     return this.getById(technologyId);
@@ -1522,9 +2043,45 @@ var TechnologyService = class extends BaseService {
    * @returns Ažurirana tehnologija
    */
   async removeContraindication(technologyId, contraindication) {
-    const docRef = (0, import_firestore10.doc)(this.getTechnologiesRef(), technologyId);
-    await (0, import_firestore10.updateDoc)(docRef, {
-      contraindications: (0, import_firestore10.arrayRemove)(contraindication),
+    const docRef = (0, import_firestore11.doc)(this.technologiesRef, technologyId);
+    const technology = await this.getById(technologyId);
+    if (!technology) {
+      throw new Error(`Technology with id ${technologyId} not found`);
+    }
+    const updatedContraindications = (technology.contraindications || []).filter((c) => c.id !== contraindication.id);
+    await (0, import_firestore11.updateDoc)(docRef, {
+      contraindications: updatedContraindications,
+      updatedAt: /* @__PURE__ */ new Date()
+    });
+    return this.getById(technologyId);
+  }
+  /**
+   * Updates an existing contraindication in a technology's list.
+   * If the contraindication does not exist, it will not be added.
+   * @param technologyId - ID of the technology
+   * @param contraindication - The updated contraindication object
+   * @returns The updated technology
+   */
+  async updateContraindication(technologyId, contraindication) {
+    const docRef = (0, import_firestore11.doc)(this.technologiesRef, technologyId);
+    const technology = await this.getById(technologyId);
+    if (!technology) {
+      throw new Error(`Technology with id ${technologyId} not found`);
+    }
+    const contraindications = technology.contraindications || [];
+    const index = contraindications.findIndex(
+      (c) => c.id === contraindication.id
+    );
+    if (index === -1) {
+      console.warn(
+        `Contraindication with id ${contraindication.id} not found for technology ${technologyId}. No update performed.`
+      );
+      return technology;
+    }
+    const updatedContraindications = [...contraindications];
+    updatedContraindications[index] = contraindication;
+    await (0, import_firestore11.updateDoc)(docRef, {
+      contraindications: updatedContraindications,
       updatedAt: /* @__PURE__ */ new Date()
     });
     return this.getById(technologyId);
@@ -1536,9 +2093,17 @@ var TechnologyService = class extends BaseService {
    * @returns Ažurirana tehnologija
    */
   async addBenefit(technologyId, benefit) {
-    const docRef = (0, import_firestore10.doc)(this.getTechnologiesRef(), technologyId);
-    await (0, import_firestore10.updateDoc)(docRef, {
-      benefits: (0, import_firestore10.arrayUnion)(benefit),
+    const docRef = (0, import_firestore11.doc)(this.technologiesRef, technologyId);
+    const technology = await this.getById(technologyId);
+    if (!technology) {
+      throw new Error(`Technology with id ${technologyId} not found`);
+    }
+    const existingBenefits = technology.benefits || [];
+    if (existingBenefits.some((b) => b.id === benefit.id)) {
+      return technology;
+    }
+    await (0, import_firestore11.updateDoc)(docRef, {
+      benefits: [...existingBenefits, benefit],
       updatedAt: /* @__PURE__ */ new Date()
     });
     return this.getById(technologyId);
@@ -1550,9 +2115,45 @@ var TechnologyService = class extends BaseService {
    * @returns Ažurirana tehnologija
    */
   async removeBenefit(technologyId, benefit) {
-    const docRef = (0, import_firestore10.doc)(this.getTechnologiesRef(), technologyId);
-    await (0, import_firestore10.updateDoc)(docRef, {
-      benefits: (0, import_firestore10.arrayRemove)(benefit),
+    const docRef = (0, import_firestore11.doc)(this.technologiesRef, technologyId);
+    const technology = await this.getById(technologyId);
+    if (!technology) {
+      throw new Error(`Technology with id ${technologyId} not found`);
+    }
+    const updatedBenefits = (technology.benefits || []).filter(
+      (b) => b.id !== benefit.id
+    );
+    await (0, import_firestore11.updateDoc)(docRef, {
+      benefits: updatedBenefits,
+      updatedAt: /* @__PURE__ */ new Date()
+    });
+    return this.getById(technologyId);
+  }
+  /**
+   * Updates an existing benefit in a technology's list.
+   * If the benefit does not exist, it will not be added.
+   * @param technologyId - ID of the technology
+   * @param benefit - The updated benefit object
+   * @returns The updated technology
+   */
+  async updateBenefit(technologyId, benefit) {
+    const docRef = (0, import_firestore11.doc)(this.technologiesRef, technologyId);
+    const technology = await this.getById(technologyId);
+    if (!technology) {
+      throw new Error(`Technology with id ${technologyId} not found`);
+    }
+    const benefits = technology.benefits || [];
+    const index = benefits.findIndex((b) => b.id === benefit.id);
+    if (index === -1) {
+      console.warn(
+        `Benefit with id ${benefit.id} not found for technology ${technologyId}. No update performed.`
+      );
+      return technology;
+    }
+    const updatedBenefits = [...benefits];
+    updatedBenefits[index] = benefit;
+    await (0, import_firestore11.updateDoc)(docRef, {
+      benefits: updatedBenefits,
       updatedAt: /* @__PURE__ */ new Date()
     });
     return this.getById(technologyId);
@@ -1591,8 +2192,8 @@ var TechnologyService = class extends BaseService {
    * @returns Ažurirana tehnologija
    */
   async updateCertificationRequirement(technologyId, certificationRequirement) {
-    const docRef = (0, import_firestore10.doc)(this.getTechnologiesRef(), technologyId);
-    await (0, import_firestore10.updateDoc)(docRef, {
+    const docRef = (0, import_firestore11.doc)(this.technologiesRef, technologyId);
+    await (0, import_firestore11.updateDoc)(docRef, {
       certificationRequirement,
       updatedAt: /* @__PURE__ */ new Date()
     });
@@ -1669,7 +2270,7 @@ var TechnologyService = class extends BaseService {
    */
   async getAllowedTechnologies(practitioner) {
     const allTechnologies = await this.getAll();
-    const allowedTechnologies = allTechnologies.filter(
+    const allowedTechnologies = allTechnologies.technologies.filter(
       (technology) => this.validateCertification(
         technology.certificationRequirement,
         practitioner.certification
@@ -1689,6 +2290,276 @@ var TechnologyService = class extends BaseService {
       subcategories
     };
   }
+  /**
+   * Gets all active technologies for a subcategory for filter dropdowns.
+   * @param categoryId - The ID of the parent category.
+   * @param subcategoryId - The ID of the subcategory.
+   */
+  async getAllForFilterBySubcategoryId(categoryId, subcategoryId) {
+    const q = (0, import_firestore11.query)(
+      (0, import_firestore11.collection)(this.db, TECHNOLOGIES_COLLECTION),
+      (0, import_firestore11.where)("isActive", "==", true),
+      (0, import_firestore11.where)("categoryId", "==", categoryId),
+      (0, import_firestore11.where)("subcategoryId", "==", subcategoryId),
+      (0, import_firestore11.orderBy)("name")
+    );
+    const snapshot = await (0, import_firestore11.getDocs)(q);
+    return snapshot.docs.map(
+      (doc11) => ({
+        id: doc11.id,
+        ...doc11.data()
+      })
+    );
+  }
+  /**
+   * Gets all active technologies for filter dropdowns.
+   */
+  async getAllForFilter() {
+    const q = (0, import_firestore11.query)(
+      (0, import_firestore11.collection)(this.db, TECHNOLOGIES_COLLECTION),
+      (0, import_firestore11.where)("isActive", "==", true),
+      (0, import_firestore11.orderBy)("name")
+    );
+    const snapshot = await (0, import_firestore11.getDocs)(q);
+    return snapshot.docs.map(
+      (doc11) => ({
+        id: doc11.id,
+        ...doc11.data()
+      })
+    );
+  }
+};
+
+// src/backoffice/services/constants.service.ts
+var import_firestore12 = require("firebase/firestore");
+var ADMIN_CONSTANTS_COLLECTION = "admin-constants";
+var TREATMENT_BENEFITS_DOC = "treatment-benefits";
+var CONTRAINDICATIONS_DOC = "contraindications";
+var ConstantsService = class extends BaseService {
+  /**
+   * @description Gets the reference to the document holding treatment benefits.
+   * @private
+   * @type {DocumentReference}
+   */
+  get treatmentBenefitsDocRef() {
+    return (0, import_firestore12.doc)(this.db, ADMIN_CONSTANTS_COLLECTION, TREATMENT_BENEFITS_DOC);
+  }
+  /**
+   * @description Gets the reference to the document holding contraindications.
+   * @private
+   * @type {DocumentReference}
+   */
+  get contraindicationsDocRef() {
+    return (0, import_firestore12.doc)(this.db, ADMIN_CONSTANTS_COLLECTION, CONTRAINDICATIONS_DOC);
+  }
+  // =================================================================
+  // Treatment Benefits
+  // =================================================================
+  /**
+   * @description Retrieves all treatment benefits without pagination.
+   * @returns {Promise<TreatmentBenefitDynamic[]>} An array of all treatment benefits.
+   */
+  async getAllBenefitsForFilter() {
+    const docSnap = await (0, import_firestore12.getDoc)(this.treatmentBenefitsDocRef);
+    if (!docSnap.exists()) {
+      return [];
+    }
+    return docSnap.data().benefits;
+  }
+  /**
+   * @description Retrieves a paginated list of treatment benefits.
+   * @param {{ page: number; limit: number }} options - Pagination options.
+   * @returns {Promise<{ benefits: TreatmentBenefitDynamic[]; total: number }>} A paginated list of benefits and the total count.
+   */
+  async getAllBenefits(options) {
+    const allBenefits = await this.getAllBenefitsForFilter();
+    const { page, limit: limit9 } = options;
+    const startIndex = page * limit9;
+    const endIndex = startIndex + limit9;
+    const paginatedBenefits = allBenefits.slice(startIndex, endIndex);
+    return { benefits: paginatedBenefits, total: allBenefits.length };
+  }
+  /**
+   * @description Adds a new treatment benefit.
+   * @param {Omit<TreatmentBenefitDynamic, "id">} benefit - The treatment benefit to add, without an ID.
+   * @returns {Promise<TreatmentBenefitDynamic>} The newly created treatment benefit with its generated ID.
+   */
+  async addTreatmentBenefit(benefit) {
+    const newBenefit = {
+      id: this.generateId(),
+      ...benefit
+    };
+    const docSnap = await (0, import_firestore12.getDoc)(this.treatmentBenefitsDocRef);
+    if (!docSnap.exists()) {
+      await (0, import_firestore12.setDoc)(this.treatmentBenefitsDocRef, { benefits: [newBenefit] });
+    } else {
+      await (0, import_firestore12.updateDoc)(this.treatmentBenefitsDocRef, {
+        benefits: (0, import_firestore12.arrayUnion)(newBenefit)
+      });
+    }
+    return newBenefit;
+  }
+  /**
+   * @description Retrieves a single treatment benefit by its ID.
+   * @param {string} benefitId - The ID of the treatment benefit to retrieve.
+   * @returns {Promise<TreatmentBenefitDynamic | undefined>} The found treatment benefit or undefined.
+   */
+  async getBenefitById(benefitId) {
+    const benefits = await this.getAllBenefitsForFilter();
+    return benefits.find((b) => b.id === benefitId);
+  }
+  /**
+   * @description Searches for treatment benefits by name (case-insensitive).
+   * @param {string} searchTerm - The term to search for in the benefit names.
+   * @returns {Promise<TreatmentBenefitDynamic[]>} An array of matching treatment benefits.
+   */
+  async searchBenefitsByName(searchTerm) {
+    const benefits = await this.getAllBenefitsForFilter();
+    const normalizedSearchTerm = searchTerm.toLowerCase();
+    return benefits.filter(
+      (b) => b.name.toLowerCase().includes(normalizedSearchTerm)
+    );
+  }
+  /**
+   * @description Updates an existing treatment benefit.
+   * @param {TreatmentBenefitDynamic} benefit - The treatment benefit with updated data. Its ID must match an existing benefit.
+   * @returns {Promise<TreatmentBenefitDynamic>} The updated treatment benefit.
+   * @throws {Error} If the treatment benefit is not found.
+   */
+  async updateTreatmentBenefit(benefit) {
+    const benefits = await this.getAllBenefitsForFilter();
+    const benefitIndex = benefits.findIndex((b) => b.id === benefit.id);
+    if (benefitIndex === -1) {
+      throw new Error("Treatment benefit not found.");
+    }
+    benefits[benefitIndex] = benefit;
+    await (0, import_firestore12.updateDoc)(this.treatmentBenefitsDocRef, { benefits });
+    return benefit;
+  }
+  /**
+   * @description Deletes a treatment benefit by its ID.
+   * @param {string} benefitId - The ID of the treatment benefit to delete.
+   * @returns {Promise<void>}
+   */
+  async deleteTreatmentBenefit(benefitId) {
+    const benefits = await this.getAllBenefitsForFilter();
+    const benefitToRemove = benefits.find((b) => b.id === benefitId);
+    if (!benefitToRemove) {
+      return;
+    }
+    await (0, import_firestore12.updateDoc)(this.treatmentBenefitsDocRef, {
+      benefits: (0, import_firestore12.arrayRemove)(benefitToRemove)
+    });
+  }
+  // =================================================================
+  // Contraindications
+  // =================================================================
+  /**
+   * @description Retrieves all contraindications without pagination.
+   * @returns {Promise<ContraindicationDynamic[]>} An array of all contraindications.
+   */
+  async getAllContraindicationsForFilter() {
+    const docSnap = await (0, import_firestore12.getDoc)(this.contraindicationsDocRef);
+    if (!docSnap.exists()) {
+      return [];
+    }
+    return docSnap.data().contraindications;
+  }
+  /**
+   * @description Retrieves a paginated list of contraindications.
+   * @param {{ page: number; limit: number }} options - Pagination options.
+   * @returns {Promise<{ contraindications: ContraindicationDynamic[]; total: number }>} A paginated list and the total count.
+   */
+  async getAllContraindications(options) {
+    const allContraindications = await this.getAllContraindicationsForFilter();
+    const { page, limit: limit9 } = options;
+    const startIndex = page * limit9;
+    const endIndex = startIndex + limit9;
+    const paginatedContraindications = allContraindications.slice(
+      startIndex,
+      endIndex
+    );
+    return {
+      contraindications: paginatedContraindications,
+      total: allContraindications.length
+    };
+  }
+  /**
+   * @description Adds a new contraindication.
+   * @param {Omit<ContraindicationDynamic, "id">} contraindication - The contraindication to add, without an ID.
+   * @returns {Promise<ContraindicationDynamic>} The newly created contraindication with its generated ID.
+   */
+  async addContraindication(contraindication) {
+    const newContraindication = {
+      id: this.generateId(),
+      ...contraindication
+    };
+    const docSnap = await (0, import_firestore12.getDoc)(this.contraindicationsDocRef);
+    if (!docSnap.exists()) {
+      await (0, import_firestore12.setDoc)(this.contraindicationsDocRef, {
+        contraindications: [newContraindication]
+      });
+    } else {
+      await (0, import_firestore12.updateDoc)(this.contraindicationsDocRef, {
+        contraindications: (0, import_firestore12.arrayUnion)(newContraindication)
+      });
+    }
+    return newContraindication;
+  }
+  /**
+   * @description Retrieves a single contraindication by its ID.
+   * @param {string} contraindicationId - The ID of the contraindication to retrieve.
+   * @returns {Promise<ContraindicationDynamic | undefined>} The found contraindication or undefined.
+   */
+  async getContraindicationById(contraindicationId) {
+    const contraindications = await this.getAllContraindicationsForFilter();
+    return contraindications.find((c) => c.id === contraindicationId);
+  }
+  /**
+   * @description Searches for contraindications by name (case-insensitive).
+   * @param {string} searchTerm - The term to search for in the contraindication names.
+   * @returns {Promise<ContraindicationDynamic[]>} An array of matching contraindications.
+   */
+  async searchContraindicationsByName(searchTerm) {
+    const contraindications = await this.getAllContraindicationsForFilter();
+    const normalizedSearchTerm = searchTerm.toLowerCase();
+    return contraindications.filter(
+      (c) => c.name.toLowerCase().includes(normalizedSearchTerm)
+    );
+  }
+  /**
+   * @description Updates an existing contraindication.
+   * @param {ContraindicationDynamic} contraindication - The contraindication with updated data. Its ID must match an existing one.
+   * @returns {Promise<ContraindicationDynamic>} The updated contraindication.
+   * @throws {Error} If the contraindication is not found.
+   */
+  async updateContraindication(contraindication) {
+    const contraindications = await this.getAllContraindicationsForFilter();
+    const index = contraindications.findIndex(
+      (c) => c.id === contraindication.id
+    );
+    if (index === -1) {
+      throw new Error("Contraindication not found.");
+    }
+    contraindications[index] = contraindication;
+    await (0, import_firestore12.updateDoc)(this.contraindicationsDocRef, { contraindications });
+    return contraindication;
+  }
+  /**
+   * @description Deletes a contraindication by its ID.
+   * @param {string} contraindicationId - The ID of the contraindication to delete.
+   * @returns {Promise<void>}
+   */
+  async deleteContraindication(contraindicationId) {
+    const contraindications = await this.getAllContraindicationsForFilter();
+    const toRemove = contraindications.find((c) => c.id === contraindicationId);
+    if (!toRemove) {
+      return;
+    }
+    await (0, import_firestore12.updateDoc)(this.contraindicationsDocRef, {
+      contraindications: (0, import_firestore12.arrayRemove)(toRemove)
+    });
+  }
 };
 
 // src/backoffice/types/static/blocking-condition.types.ts
@@ -1747,13 +2618,6 @@ var Currency = /* @__PURE__ */ ((Currency2) => {
   return Currency2;
 })(Currency || {});
 
-// src/backoffice/types/static/procedure-family.types.ts
-var ProcedureFamily = /* @__PURE__ */ ((ProcedureFamily2) => {
-  ProcedureFamily2["AESTHETICS"] = "aesthetics";
-  ProcedureFamily2["SURGERY"] = "surgery";
-  return ProcedureFamily2;
-})(ProcedureFamily || {});
-
 // src/backoffice/types/static/treatment-benefit.types.ts
 var TreatmentBenefit = /* @__PURE__ */ ((TreatmentBenefit2) => {
   TreatmentBenefit2["WRINKLE_REDUCTION"] = "wrinkle_reduction";
@@ -1776,9 +2640,25 @@ var TreatmentBenefit = /* @__PURE__ */ ((TreatmentBenefit2) => {
 
 // src/backoffice/validations/schemas.ts
 var import_zod2 = require("zod");
+var contraindicationDynamicSchema = import_zod2.z.object({
+  id: import_zod2.z.string().min(1, "Contraindication ID is required").regex(
+    /^[a-z0-9_]+$/,
+    "ID must be in snake_case (lowercase, numbers, and underscores only)"
+  ),
+  name: import_zod2.z.string().min(1, "Contraindication name is required"),
+  description: import_zod2.z.string().optional()
+});
+var treatmentBenefitDynamicSchema = import_zod2.z.object({
+  id: import_zod2.z.string().min(1, "Benefit ID is required").regex(
+    /^[a-z0-9_]+$/,
+    "ID must be in snake_case (lowercase, numbers, and underscores only)"
+  ),
+  name: import_zod2.z.string().min(1, "Benefit name is required"),
+  description: import_zod2.z.string().optional()
+});
 var blockingConditionSchemaBackoffice = import_zod2.z.nativeEnum(BlockingCondition);
-var contraindicationSchemaBackoffice = import_zod2.z.nativeEnum(Contraindication);
-var treatmentBenefitSchemaBackoffice = import_zod2.z.nativeEnum(TreatmentBenefit);
+var contraindicationSchemaBackoffice = contraindicationDynamicSchema;
+var treatmentBenefitSchemaBackoffice = treatmentBenefitDynamicSchema;
 var procedureFamilySchemaBackoffice = import_zod2.z.nativeEnum(ProcedureFamily);
 var timeUnitSchemaBackoffice = import_zod2.z.nativeEnum(TimeUnit);
 var requirementTypeSchema = import_zod2.z.nativeEnum(RequirementType);
@@ -2001,6 +2881,7 @@ var InvalidTreatmentBenefitError = class extends TreatmentBenefitError {
   CertificationLevel,
   CertificationSpecialty,
   CircularReferenceError,
+  ConstantsService,
   Contraindication,
   ContraindicationError,
   Currency,
@@ -2048,6 +2929,7 @@ var InvalidTreatmentBenefitError = class extends TreatmentBenefitError {
   certificationLevelSchema,
   certificationRequirementSchema,
   certificationSpecialtySchema,
+  contraindicationDynamicSchema,
   contraindicationSchemaBackoffice,
   createDocumentTemplateSchema,
   documentElementSchema,
@@ -2064,6 +2946,7 @@ var InvalidTreatmentBenefitError = class extends TreatmentBenefitError {
   technologyUpdateSchema,
   timeUnitSchemaBackoffice,
   timeframeSchema,
+  treatmentBenefitDynamicSchema,
   treatmentBenefitSchemaBackoffice,
   updateDocumentTemplateSchema
 });