@blackcode_sa/metaestetics-api 1.8.0 → 1.8.1

package/dist/backoffice/index.mjs

@@ -1,323 +1,293 @@
+// src/backoffice/services/brand.service.ts
+import {
+  addDoc,
+  collection,
+  doc,
+  getDoc,
+  getDocs,
+  query,
+  updateDoc,
+  where
+} from "firebase/firestore";
+
 // src/backoffice/types/brand.types.ts
 var BRANDS_COLLECTION = "brands";
 
-// src/backoffice/types/category.types.ts
-var CATEGORIES_COLLECTION = "backoffice_categories";
-
-// src/backoffice/types/product.types.ts
-var PRODUCTS_COLLECTION = "products";
-
-// src/backoffice/types/requirement.types.ts
-var TimeUnit = /* @__PURE__ */ ((TimeUnit2) => {
-  TimeUnit2["HOURS"] = "hours";
-  TimeUnit2["DAYS"] = "days";
-  return TimeUnit2;
-})(TimeUnit || {});
-var RequirementType = /* @__PURE__ */ ((RequirementType3) => {
-  RequirementType3["PRE"] = "pre";
-  RequirementType3["POST"] = "post";
-  return RequirementType3;
-})(RequirementType || {});
-var REQUIREMENTS_COLLECTION = "backoffice_requirements";
-
-// src/backoffice/types/subcategory.types.ts
-var SUBCATEGORIES_COLLECTION = "subcategories";
-
-// src/backoffice/types/technology.types.ts
-var TECHNOLOGIES_COLLECTION = "technologies";
-
-// src/backoffice/types/static/blocking-condition.types.ts
-var BlockingCondition = /* @__PURE__ */ ((BlockingCondition2) => {
-  BlockingCondition2["PREGNANCY"] = "pregnancy";
-  BlockingCondition2["BREASTFEEDING"] = "breastfeeding";
-  BlockingCondition2["ACTIVE_INFECTION"] = "active_infection";
-  BlockingCondition2["SKIN_CONDITION"] = "skin_condition";
-  BlockingCondition2["AUTOIMMUNE_DISEASE"] = "autoimmune_disease";
-  BlockingCondition2["BLOOD_THINNERS"] = "blood_thinners";
-  BlockingCondition2["RECENT_SURGERY"] = "recent_surgery";
-  BlockingCondition2["DIABETES"] = "diabetes";
-  BlockingCondition2["HEART_CONDITION"] = "heart_condition";
-  BlockingCondition2["HIGH_BLOOD_PRESSURE"] = "high_blood_pressure";
-  BlockingCondition2["KELOID_SCARRING"] = "keloid_scarring";
-  BlockingCondition2["METAL_IMPLANTS"] = "metal_implants";
-  BlockingCondition2["PACEMAKER"] = "pacemaker";
-  BlockingCondition2["CANCER"] = "cancer";
-  BlockingCondition2["EPILEPSY"] = "epilepsy";
-  return BlockingCondition2;
-})(BlockingCondition || {});
-
-// 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/backoffice/types/static/contraindication.types.ts
-var Contraindication = /* @__PURE__ */ ((Contraindication2) => {
-  Contraindication2["SENSITIVE_SKIN"] = "sensitive_skin";
-  Contraindication2["RECENT_TANNING"] = "recent_tanning";
-  Contraindication2["RECENT_BOTOX"] = "recent_botox";
-  Contraindication2["RECENT_FILLERS"] = "recent_fillers";
-  Contraindication2["SKIN_ALLERGIES"] = "skin_allergies";
-  Contraindication2["MEDICATIONS"] = "medications";
-  Contraindication2["RECENT_CHEMICAL_PEEL"] = "recent_chemical_peel";
-  Contraindication2["RECENT_LASER"] = "recent_laser";
-  Contraindication2["SKIN_INFLAMMATION"] = "skin_inflammation";
-  Contraindication2["OPEN_WOUNDS"] = "open_wounds";
-  Contraindication2["HERPES_SIMPLEX"] = "herpes_simplex";
-  Contraindication2["COLD_SORES"] = "cold_sores";
-  return Contraindication2;
-})(Contraindication || {});
-
-// 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";
-  TreatmentBenefit2["SKIN_TIGHTENING"] = "skin_tightening";
-  TreatmentBenefit2["COLLAGEN_PRODUCTION"] = "collagen_production";
-  TreatmentBenefit2["ACNE_REDUCTION"] = "acne_reduction";
-  TreatmentBenefit2["SCAR_REDUCTION"] = "scar_reduction";
-  TreatmentBenefit2["PIGMENTATION_IMPROVEMENT"] = "pigmentation_improvement";
-  TreatmentBenefit2["HAIR_REMOVAL"] = "hair_removal";
-  TreatmentBenefit2["MUSCLE_TONING"] = "muscle_toning";
-  TreatmentBenefit2["FAT_REDUCTION"] = "fat_reduction";
-  TreatmentBenefit2["CELLULITE_REDUCTION"] = "cellulite_reduction";
-  TreatmentBenefit2["SKIN_REJUVENATION"] = "skin_rejuvenation";
-  TreatmentBenefit2["PORE_REDUCTION"] = "pore_reduction";
-  TreatmentBenefit2["TEXTURE_IMPROVEMENT"] = "texture_improvement";
-  TreatmentBenefit2["HYDRATION_BOOST"] = "hydration_boost";
-  TreatmentBenefit2["CIRCULATION_IMPROVEMENT"] = "circulation_improvement";
-  return TreatmentBenefit2;
-})(TreatmentBenefit || {});
-
-// src/types/documentation-templates/index.ts
-var DOCUMENTATION_TEMPLATES_COLLECTION = "documentation-templates";
-var DocumentElementType = /* @__PURE__ */ ((DocumentElementType2) => {
-  DocumentElementType2["HEADING"] = "heading";
-  DocumentElementType2["PARAGRAPH"] = "paragraph";
-  DocumentElementType2["LIST"] = "list";
-  DocumentElementType2["DYNAMIC_TEXT"] = "dynamic_text";
-  DocumentElementType2["BINARY_CHOICE"] = "binary_choice";
-  DocumentElementType2["MULTIPLE_CHOICE"] = "multiple_choice";
-  DocumentElementType2["SINGLE_CHOICE"] = "single_choice";
-  DocumentElementType2["RATING_SCALE"] = "rating_scale";
-  DocumentElementType2["TEXT_INPUT"] = "text_input";
-  DocumentElementType2["DATE_PICKER"] = "date_picker";
-  DocumentElementType2["SIGNATURE"] = "signature";
-  DocumentElementType2["DITIGAL_SIGNATURE"] = "digital_signature";
-  DocumentElementType2["FILE_UPLOAD"] = "file_upload";
-  return DocumentElementType2;
-})(DocumentElementType || {});
-var ListType = /* @__PURE__ */ ((ListType2) => {
-  ListType2["ORDERED"] = "ordered";
-  ListType2["UNORDERED"] = "unordered";
-  return ListType2;
-})(ListType || {});
-var HeadingLevel = /* @__PURE__ */ ((HeadingLevel2) => {
-  HeadingLevel2["H1"] = "h1";
-  HeadingLevel2["H2"] = "h2";
-  HeadingLevel2["H3"] = "h3";
-  HeadingLevel2["H4"] = "h4";
-  HeadingLevel2["H5"] = "h5";
-  HeadingLevel2["H6"] = "h6";
-  return HeadingLevel2;
-})(HeadingLevel || {});
-var DynamicVariable = /* @__PURE__ */ ((DynamicVariable2) => {
-  DynamicVariable2["PATIENT_NAME"] = "$[PATIENT_NAME]";
-  DynamicVariable2["DOCTOR_NAME"] = "$[DOCTOR_NAME]";
-  DynamicVariable2["CLINIC_NAME"] = "$[CLINIC_NAME]";
-  DynamicVariable2["PATIENT_BIRTHDAY"] = "$[PATIENT_BIRTHDAY]";
-  DynamicVariable2["APPOINTMENT_DATE"] = "$[APPOINTMENT_DATE]";
-  DynamicVariable2["CURRENT_DATE"] = "$[CURRENT_DATE]";
-  DynamicVariable2["PROCEDURE_NAME"] = "$[PROCEDURE_NAME]";
-  DynamicVariable2["PROCEDURE_DESCRIPTION"] = "$[PROCEDURE_DESCRIPTION]";
-  DynamicVariable2["PROCEDURE_COST"] = "$[PROCEDURE_COST]";
-  DynamicVariable2["PROCEDURE_DURATION"] = "$[PROCEDURE_DURATION]";
-  DynamicVariable2["PROCEDURE_RISK"] = "$[PROCEDURE_RISK]";
-  return DynamicVariable2;
-})(DynamicVariable || {});
-var FilledDocumentStatus = /* @__PURE__ */ ((FilledDocumentStatus2) => {
-  FilledDocumentStatus2["DRAFT"] = "draft";
-  FilledDocumentStatus2["SKIPPED"] = "skipped";
-  FilledDocumentStatus2["PENDING"] = "pending";
-  FilledDocumentStatus2["COMPLETED"] = "completed";
-  FilledDocumentStatus2["SIGNED"] = "signed";
-  FilledDocumentStatus2["REJECTED"] = "rejected";
-  return FilledDocumentStatus2;
-})(FilledDocumentStatus || {});
-
-// src/backoffice/constants/certification.constants.ts
-var DEFAULT_CERTIFICATION_REQUIREMENT = {
-  minimumLevel: "aesthetician" /* AESTHETICIAN */,
-  requiredSpecialties: []
-};
-
-// src/backoffice/errors/backoffice.errors.ts
-var BackofficeError = class extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "BackofficeError";
-  }
-};
-var CategoryError = class extends BackofficeError {
-  constructor(message) {
-    super(message);
-    this.name = "CategoryError";
-  }
-};
-var CategoryNotFoundError = class extends CategoryError {
-  constructor(id) {
-    super(`Kategorija sa ID-em ${id} nije prona\u0111ena`);
-    this.name = "CategoryNotFoundError";
-  }
-};
-var InvalidCategoryDataError = class extends CategoryError {
-  constructor(message) {
-    super(`Neva\u017Ee\u0107i podaci za kategoriju: ${message}`);
-    this.name = "InvalidCategoryDataError";
-  }
-};
-var SubcategoryError = class extends BackofficeError {
-  constructor(message) {
-    super(message);
-    this.name = "SubcategoryError";
-  }
-};
-var SubcategoryNotFoundError = class extends SubcategoryError {
-  constructor(id) {
-    super(`Podkategorija sa ID-em ${id} nije prona\u0111ena`);
-    this.name = "SubcategoryNotFoundError";
-  }
-};
-var InvalidSubcategoryDataError = class extends SubcategoryError {
-  constructor(message) {
-    super(`Neva\u017Ee\u0107i podaci za podkategoriju: ${message}`);
-    this.name = "InvalidSubcategoryDataError";
-  }
-};
-var TechnologyError = class extends BackofficeError {
-  constructor(message) {
-    super(message);
-    this.name = "TechnologyError";
-  }
-};
-var TechnologyNotFoundError = class extends TechnologyError {
-  constructor(id) {
-    super(`Tehnologija sa ID-em ${id} nije prona\u0111ena`);
-    this.name = "TechnologyNotFoundError";
+// src/services/base.service.ts
+import { getStorage } from "firebase/storage";
+var BaseService = class {
+  constructor(db, auth, app) {
+    this.db = db;
+    this.auth = auth;
+    this.app = app;
+    this.storage = getStorage(app);
   }
-};
-var InvalidTechnologyDataError = class extends TechnologyError {
-  constructor(message) {
-    super(`Neva\u017Ee\u0107i podaci za tehnologiju: ${message}`);
-    this.name = "InvalidTechnologyDataError";
+  /**
+   * Generiše jedinstveni ID za dokumente
+   * Format: xxxxxxxxxxxx-timestamp
+   * Gde je x random karakter (broj ili slovo)
+   */
+  generateId() {
+    const chars = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
+    const timestamp = Date.now().toString(36);
+    const randomPart = Array.from(
+      { length: 12 },
+      () => chars.charAt(Math.floor(Math.random() * chars.length))
+    ).join("");
+    return `${randomPart}-${timestamp}`;
   }
 };
-var RequirementError = class extends BackofficeError {
-  constructor(message) {
-    super(message);
-    this.name = "RequirementError";
+
+// src/backoffice/services/brand.service.ts
+var BrandService = class extends BaseService {
+  /**
+   * Gets reference to brands collection
+   */
+  getBrandsRef() {
+    return collection(this.db, BRANDS_COLLECTION);
   }
-};
-var RequirementNotFoundError = class extends RequirementError {
-  constructor(id) {
-    super(`Zahtev sa ID-em ${id} nije prona\u0111en`);
-    this.name = "RequirementNotFoundError";
+  /**
+   * Creates a new brand
+   */
+  async create(brand) {
+    const now = /* @__PURE__ */ new Date();
+    const newBrand = {
+      ...brand,
+      createdAt: now,
+      updatedAt: now,
+      isActive: true
+    };
+    const docRef = await addDoc(this.getBrandsRef(), newBrand);
+    return { id: docRef.id, ...newBrand };
   }
-};
-var InvalidRequirementDataError = class extends RequirementError {
-  constructor(message) {
-    super(`Neva\u017Ee\u0107i podaci za zahtev: ${message}`);
-    this.name = "InvalidRequirementDataError";
+  /**
+   * Gets all active brands
+   */
+  async getAll() {
+    const q = query(this.getBrandsRef(), where("isActive", "==", true));
+    const snapshot = await getDocs(q);
+    return snapshot.docs.map(
+      (doc10) => ({
+        id: doc10.id,
+        ...doc10.data()
+      })
+    );
   }
-};
-var InvalidTimeframeError = class extends RequirementError {
-  constructor(message) {
-    super(`Invalid timeframe: ${message}`);
-    this.name = "InvalidTimeframeError";
+  /**
+   * Updates a brand
+   */
+  async update(brandId, brand) {
+    const updateData = {
+      ...brand,
+      updatedAt: /* @__PURE__ */ new Date()
+    };
+    const docRef = doc(this.getBrandsRef(), brandId);
+    await updateDoc(docRef, updateData);
+    return this.getById(brandId);
   }
-};
-var RelationshipError = class extends BackofficeError {
-  constructor(message) {
-    super(message);
-    this.name = "RelationshipError";
+  /**
+   * Soft deletes a brand
+   */
+  async delete(brandId) {
+    await this.update(brandId, {
+      isActive: false
+    });
   }
-};
-var InvalidHierarchyError = class extends RelationshipError {
-  constructor(message) {
-    super(`Invalid hierarchy: ${message}`);
-    this.name = "InvalidHierarchyError";
+  /**
+   * Gets a brand by ID
+   */
+  async getById(brandId) {
+    const docRef = doc(this.getBrandsRef(), brandId);
+    const docSnap = await getDoc(docRef);
+    if (!docSnap.exists()) return null;
+    return {
+      id: docSnap.id,
+      ...docSnap.data()
+    };
   }
 };
-var CircularReferenceError = class extends RelationshipError {
-  constructor(message) {
-    super(`Circular reference detected: ${message}`);
-    this.name = "CircularReferenceError";
+
+// src/backoffice/services/category.service.ts
+import {
+  addDoc as addDoc2,
+  collection as collection2,
+  doc as doc2,
+  getDoc as getDoc2,
+  getDocs as getDocs2,
+  query as query2,
+  updateDoc as updateDoc2,
+  where as where2
+} from "firebase/firestore";
+
+// src/backoffice/types/category.types.ts
+var CATEGORIES_COLLECTION = "backoffice_categories";
+
+// src/backoffice/services/category.service.ts
+var CategoryService = class extends BaseService {
+  /**
+   * Referenca na Firestore kolekciju kategorija
+   */
+  get categoriesRef() {
+    return collection2(this.db, CATEGORIES_COLLECTION);
   }
-};
-var BlockingConditionError = class extends BackofficeError {
-  constructor(message) {
-    super(message);
-    this.name = "BlockingConditionError";
+  /**
+   * Kreira novu kategoriju u sistemu
+   * @param category - Podaci za novu kategoriju
+   * @returns Kreirana kategorija sa generisanim ID-em
+   */
+  async create(category) {
+    const now = /* @__PURE__ */ new Date();
+    const newCategory = {
+      ...category,
+      createdAt: now,
+      updatedAt: now,
+      isActive: true
+    };
+    const docRef = await addDoc2(this.categoriesRef, newCategory);
+    return { id: docRef.id, ...newCategory };
   }
-};
-var InvalidBlockingConditionError = class extends BlockingConditionError {
-  constructor(condition) {
-    super(`Neva\u017Ee\u0107i blokiraju\u0107i uslov: ${condition}`);
-    this.name = "InvalidBlockingConditionError";
+  /**
+   * Vraća sve aktivne kategorije
+   * @returns Lista aktivnih kategorija
+   */
+  async getAll() {
+    const q = query2(this.categoriesRef, where2("isActive", "==", true));
+    const snapshot = await getDocs2(q);
+    return snapshot.docs.map(
+      (doc10) => ({
+        id: doc10.id,
+        ...doc10.data()
+      })
+    );
   }
-};
-var ContraindicationError = class extends BackofficeError {
-  constructor(message) {
-    super(message);
-    this.name = "ContraindicationError";
+  /**
+   * Vraća sve aktivne kategorije za određenu familiju procedura
+   * @param family - Familija procedura (aesthetics/surgery)
+   * @returns Lista kategorija koje pripadaju traženoj familiji
+   */
+  async getAllByFamily(family) {
+    const q = query2(
+      this.categoriesRef,
+      where2("family", "==", family),
+      where2("isActive", "==", true)
+    );
+    const snapshot = await getDocs2(q);
+    return snapshot.docs.map(
+      (doc10) => ({
+        id: doc10.id,
+        ...doc10.data()
+      })
+    );
   }
-};
-var InvalidContraindicationError = class extends ContraindicationError {
-  constructor(contraindication) {
-    super(`Neva\u017Ee\u0107a kontraindikacija: ${contraindication}`);
-    this.name = "InvalidContraindicationError";
+  /**
+   * Ažurira postojeću kategoriju
+   * @param id - ID kategorije koja se ažurira
+   * @param category - Novi podaci za kategoriju
+   * @returns Ažurirana kategorija
+   */
+  async update(id, category) {
+    const updateData = {
+      ...category,
+      updatedAt: /* @__PURE__ */ new Date()
+    };
+    const docRef = doc2(this.categoriesRef, id);
+    await updateDoc2(docRef, updateData);
+    return this.getById(id);
   }
-};
-var TreatmentBenefitError = class extends BackofficeError {
-  constructor(message) {
-    super(message);
-    this.name = "TreatmentBenefitError";
+  /**
+   * Soft delete kategorije (postavlja isActive na false)
+   * @param id - ID kategorije koja se briše
+   */
+  async delete(id) {
+    await this.update(id, { isActive: false });
   }
-};
-var InvalidTreatmentBenefitError = class extends TreatmentBenefitError {
-  constructor(benefit) {
-    super(`Neva\u017Ee\u0107i benefit tretmana: ${benefit}`);
-    this.name = "InvalidTreatmentBenefitError";
+  /**
+   * Vraća kategoriju po ID-u
+   * @param id - ID tražene kategorije
+   * @returns Kategorija ili null ako ne postoji
+   */
+  async getById(id) {
+    const docRef = doc2(this.categoriesRef, id);
+    const docSnap = await getDoc2(docRef);
+    if (!docSnap.exists()) return null;
+    return {
+      id: docSnap.id,
+      ...docSnap.data()
+    };
   }
 };
 
-// src/backoffice/validations/schemas.ts
-import { z as z2 } from "zod";
+// src/services/documentation-templates/documentation-template.service.ts
+import {
+  collection as collection3,
+  doc as doc3,
+  getDoc as getDoc3,
+  getDocs as getDocs3,
+  setDoc,
+  updateDoc as updateDoc3,
+  deleteDoc,
+  query as query3,
+  where as where3,
+  orderBy,
+  limit,
+  startAfter
+} from "firebase/firestore";
+
+// src/types/documentation-templates/index.ts
+var DOCUMENTATION_TEMPLATES_COLLECTION = "documentation-templates";
+var DocumentElementType = /* @__PURE__ */ ((DocumentElementType2) => {
+  DocumentElementType2["HEADING"] = "heading";
+  DocumentElementType2["PARAGRAPH"] = "paragraph";
+  DocumentElementType2["LIST"] = "list";
+  DocumentElementType2["DYNAMIC_TEXT"] = "dynamic_text";
+  DocumentElementType2["BINARY_CHOICE"] = "binary_choice";
+  DocumentElementType2["MULTIPLE_CHOICE"] = "multiple_choice";
+  DocumentElementType2["SINGLE_CHOICE"] = "single_choice";
+  DocumentElementType2["RATING_SCALE"] = "rating_scale";
+  DocumentElementType2["TEXT_INPUT"] = "text_input";
+  DocumentElementType2["DATE_PICKER"] = "date_picker";
+  DocumentElementType2["SIGNATURE"] = "signature";
+  DocumentElementType2["DITIGAL_SIGNATURE"] = "digital_signature";
+  DocumentElementType2["FILE_UPLOAD"] = "file_upload";
+  return DocumentElementType2;
+})(DocumentElementType || {});
+var ListType = /* @__PURE__ */ ((ListType2) => {
+  ListType2["ORDERED"] = "ordered";
+  ListType2["UNORDERED"] = "unordered";
+  return ListType2;
+})(ListType || {});
+var HeadingLevel = /* @__PURE__ */ ((HeadingLevel2) => {
+  HeadingLevel2["H1"] = "h1";
+  HeadingLevel2["H2"] = "h2";
+  HeadingLevel2["H3"] = "h3";
+  HeadingLevel2["H4"] = "h4";
+  HeadingLevel2["H5"] = "h5";
+  HeadingLevel2["H6"] = "h6";
+  return HeadingLevel2;
+})(HeadingLevel || {});
+var DynamicVariable = /* @__PURE__ */ ((DynamicVariable2) => {
+  DynamicVariable2["PATIENT_NAME"] = "$[PATIENT_NAME]";
+  DynamicVariable2["DOCTOR_NAME"] = "$[DOCTOR_NAME]";
+  DynamicVariable2["CLINIC_NAME"] = "$[CLINIC_NAME]";
+  DynamicVariable2["PATIENT_BIRTHDAY"] = "$[PATIENT_BIRTHDAY]";
+  DynamicVariable2["APPOINTMENT_DATE"] = "$[APPOINTMENT_DATE]";
+  DynamicVariable2["CURRENT_DATE"] = "$[CURRENT_DATE]";
+  DynamicVariable2["PROCEDURE_NAME"] = "$[PROCEDURE_NAME]";
+  DynamicVariable2["PROCEDURE_DESCRIPTION"] = "$[PROCEDURE_DESCRIPTION]";
+  DynamicVariable2["PROCEDURE_COST"] = "$[PROCEDURE_COST]";
+  DynamicVariable2["PROCEDURE_DURATION"] = "$[PROCEDURE_DURATION]";
+  DynamicVariable2["PROCEDURE_RISK"] = "$[PROCEDURE_RISK]";
+  return DynamicVariable2;
+})(DynamicVariable || {});
+var FilledDocumentStatus = /* @__PURE__ */ ((FilledDocumentStatus2) => {
+  FilledDocumentStatus2["DRAFT"] = "draft";
+  FilledDocumentStatus2["SKIPPED"] = "skipped";
+  FilledDocumentStatus2["PENDING"] = "pending";
+  FilledDocumentStatus2["COMPLETED"] = "completed";
+  FilledDocumentStatus2["SIGNED"] = "signed";
+  FilledDocumentStatus2["REJECTED"] = "rejected";
+  return FilledDocumentStatus2;
+})(FilledDocumentStatus || {});
 
 // src/validations/documentation-templates/template.schema.ts
 import { z } from "zod";
@@ -493,261 +463,478 @@ var updateFilledDocumentDataSchema = z.object({
   status: filledDocumentStatusSchema.optional()
 });
 
-// src/backoffice/validations/schemas.ts
-var blockingConditionSchema = z2.nativeEnum(BlockingCondition);
-var contraindicationSchema = z2.nativeEnum(Contraindication);
-var treatmentBenefitSchema = z2.nativeEnum(TreatmentBenefit);
-var procedureFamilySchema = z2.nativeEnum(ProcedureFamily);
-var timeUnitSchema = z2.nativeEnum(TimeUnit);
-var requirementTypeSchema = z2.nativeEnum(RequirementType);
-var certificationLevelSchema = z2.nativeEnum(CertificationLevel);
-var certificationSpecialtySchema = z2.nativeEnum(
-  CertificationSpecialty
-);
-var certificationRequirementSchema = z2.object({
-  minimumLevel: certificationLevelSchema,
-  requiredSpecialties: z2.array(certificationSpecialtySchema).max(5, "Maximum 5 specialties allowed").optional()
-});
-var timeframeSchema = z2.object({
-  duration: z2.number().min(1, "Duration must be positive"),
-  unit: timeUnitSchema,
-  notifyAt: z2.array(z2.number()).min(1, "At least one notification point is required")
-});
-var requirementSchema = z2.object({
-  name: z2.string().min(1, "Name is required").max(100, "Name is too long"),
-  description: z2.string().min(1, "Description is required"),
-  type: requirementTypeSchema,
-  timeframe: timeframeSchema,
-  importance: z2.enum(["low", "medium", "high"]),
-  isActive: z2.boolean().default(true)
-});
-var technologyRequirementsSchema = z2.object({
-  pre: z2.array(requirementSchema),
-  post: z2.array(requirementSchema)
-});
-var technologySchema = z2.object({
-  name: z2.string().min(1, "Name is required").max(100, "Name is too long"),
-  description: z2.string().max(1e3, "Description is too long").optional(),
-  technicalDetails: z2.string().max(2e3, "Technical details are too long").optional(),
-  family: procedureFamilySchema,
-  categoryId: z2.string().min(1, "Category ID is required"),
-  subcategoryId: z2.string().min(1, "Subcategory ID is required"),
-  requirements: technologyRequirementsSchema.default({
-    pre: [],
-    post: []
-  }),
-  blockingConditions: z2.array(blockingConditionSchema),
-  contraindications: z2.array(contraindicationSchema),
-  documentationTemplates: z2.array(documentTemplateSchema),
-  benefits: z2.array(treatmentBenefitSchema),
-  certificationRequirement: certificationRequirementSchema,
-  isActive: z2.boolean().default(true)
-});
-var categorySchema = z2.object({
-  name: z2.string().min(1, "Name is required").max(100, "Name is too long"),
-  description: z2.string().optional(),
-  family: procedureFamilySchema,
-  isActive: z2.boolean().default(true)
-});
-var subcategorySchema = z2.object({
-  name: z2.string().min(1, "Name is required").max(100, "Name is too long"),
-  description: z2.string().optional(),
-  categoryId: z2.string().min(1, "Category ID is required"),
-  isActive: z2.boolean().default(true)
-});
-var categoryUpdateSchema = categorySchema.partial();
-var subcategoryUpdateSchema = subcategorySchema.partial();
-var technologyUpdateSchema = technologySchema.partial();
-var requirementUpdateSchema = requirementSchema.partial();
+// src/services/documentation-templates/documentation-template.service.ts
+var DocumentationTemplateService = class extends BaseService {
+  constructor() {
+    super(...arguments);
+    this.collectionRef = collection3(
+      this.db,
+      DOCUMENTATION_TEMPLATES_COLLECTION
+    );
+  }
+  /**
+   * Create a new document template
+   * @param data - Template data
+   * @param userId - ID of the user creating the template
+   * @returns The created template
+   */
+  async createTemplate(data, userId) {
+    const validatedData = createDocumentTemplateSchema.parse(data);
+    const templateId = this.generateId();
+    const elementsWithIds = validatedData.elements.map((element) => ({
+      ...element,
+      id: this.generateId()
+    }));
+    const now = Date.now();
+    const template = {
+      id: templateId,
+      title: validatedData.title,
+      description: validatedData.description,
+      elements: elementsWithIds,
+      createdAt: now,
+      updatedAt: now,
+      createdBy: userId,
+      version: 1,
+      isActive: true,
+      tags: validatedData.tags || [],
+      isUserForm: validatedData.isUserForm || false,
+      isRequired: validatedData.isRequired || false,
+      sortingOrder: validatedData.sortingOrder || 0
+    };
+    const docRef = doc3(this.collectionRef, templateId);
+    await setDoc(docRef, template);
+    return template;
+  }
+  /**
+   * Get a document template by ID
+   * @param templateId - ID of the template to retrieve
+   * @param version - Optional version number to retrieve (defaults to latest version)
+   * @returns The template or null if not found
+   */
+  async getTemplateById(templateId, version) {
+    const docRef = doc3(this.collectionRef, templateId);
+    const docSnap = await getDoc3(docRef);
+    if (!docSnap.exists()) {
+      return null;
+    }
+    const currentTemplate = docSnap.data();
+    if (version === void 0) {
+      return currentTemplate;
+    }
+    if (currentTemplate.version === version) {
+      return currentTemplate;
+    }
+    try {
+      const versionTemplate = await this.getTemplateVersion(
+        templateId,
+        version
+      );
+      if (versionTemplate) {
+        return versionTemplate;
+      }
+    } catch (error) {
+      console.error(`Error getting template version ${version}:`, error);
+    }
+    return null;
+  }
+  /**
+   * Update an existing document template
+   * @param templateId - ID of the template to update
+   * @param data - Updated template data
+   * @returns The updated template
+   */
+  async updateTemplate(templateId, data) {
+    var _a, _b, _c;
+    const validatedData = updateDocumentTemplateSchema.parse(data);
+    console.log("Validated data", validatedData);
+    const template = await this.getTemplateById(templateId);
+    if (!template) {
+      throw new Error(`Template with ID ${templateId} not found`);
+    }
+    const versionsCollectionRef = collection3(
+      this.db,
+      `${DOCUMENTATION_TEMPLATES_COLLECTION}/${templateId}/versions`
+    );
+    const versionDocRef = doc3(
+      versionsCollectionRef,
+      template.version.toString()
+    );
+    await setDoc(versionDocRef, template);
+    let updatedElements = template.elements;
+    if (validatedData.elements) {
+      updatedElements = validatedData.elements.map((element) => ({
+        ...element,
+        id: element.id || this.generateId()
+      }));
+    }
+    const updatePayload = {
+      elements: updatedElements,
+      updatedAt: Date.now(),
+      version: template.version + 1
+    };
+    if (validatedData.title !== void 0)
+      updatePayload.title = validatedData.title;
+    if (validatedData.description !== void 0)
+      updatePayload.description = validatedData.description;
+    if (validatedData.isActive !== void 0)
+      updatePayload.isActive = validatedData.isActive;
+    if (validatedData.tags !== void 0)
+      updatePayload.tags = validatedData.tags;
+    updatePayload.isUserForm = (_a = validatedData.isUserForm) != null ? _a : false;
+    updatePayload.isRequired = (_b = validatedData.isRequired) != null ? _b : false;
+    updatePayload.sortingOrder = (_c = validatedData.sortingOrder) != null ? _c : 0;
+    const docRef = doc3(this.collectionRef, templateId);
+    console.log("Update payload", updatePayload);
+    await updateDoc3(docRef, updatePayload);
+    return { ...template, ...updatePayload };
+  }
+  /**
+   * Get a specific version of a template
+   * @param templateId - ID of the template
+   * @param versionNumber - Version number to retrieve
+   * @returns The template version or null if not found
+   */
+  async getTemplateVersion(templateId, versionNumber) {
+    const versionDocRef = doc3(
+      this.db,
+      `${DOCUMENTATION_TEMPLATES_COLLECTION}/${templateId}/versions/${versionNumber}`
+    );
+    const versionDocSnap = await getDoc3(versionDocRef);
+    if (!versionDocSnap.exists()) {
+      return null;
+    }
+    return versionDocSnap.data();
+  }
+  /**
+   * Get all versions of a template
+   * @param templateId - ID of the template
+   * @returns Array of template versions
+   */
+  async getTemplateOldVersions(templateId) {
+    const versionsCollectionRef = collection3(
+      this.db,
+      `${DOCUMENTATION_TEMPLATES_COLLECTION}/${templateId}/versions`
+    );
+    const q = query3(versionsCollectionRef, orderBy("version", "desc"));
+    const querySnapshot = await getDocs3(q);
+    const versions = [];
+    querySnapshot.forEach((doc10) => {
+      versions.push(doc10.data());
+    });
+    return versions;
+  }
+  /**
+   * Delete a document template
+   * @param templateId - ID of the template to delete
+   */
+  async deleteTemplate(templateId) {
+    const docRef = doc3(this.collectionRef, templateId);
+    await deleteDoc(docRef);
+  }
+  /**
+   * Get all active templates
+   * @param pageSize - Number of templates to retrieve
+   * @param lastDoc - Last document from previous page for pagination
+   * @returns Array of templates and the last document for pagination
+   */
+  async getActiveTemplates(pageSize = 20, lastDoc) {
+    let q = query3(
+      this.collectionRef,
+      where3("isActive", "==", true),
+      orderBy("updatedAt", "desc"),
+      limit(pageSize)
+    );
+    if (lastDoc) {
+      q = query3(q, startAfter(lastDoc));
+    }
+    const querySnapshot = await getDocs3(q);
+    const templates = [];
+    let lastVisible = null;
+    querySnapshot.forEach((doc10) => {
+      templates.push(doc10.data());
+      lastVisible = doc10;
+    });
+    return {
+      templates,
+      lastDoc: lastVisible
+    };
+  }
+  /**
+   * Get templates by tags
+   * @param tags - Tags to filter by
+   * @param pageSize - Number of templates to retrieve
+   * @param lastDoc - Last document from previous page for pagination
+   * @returns Array of templates and the last document for pagination
+   */
+  async getTemplatesByTags(tags, pageSize = 20, lastDoc) {
+    let q = query3(
+      this.collectionRef,
+      where3("isActive", "==", true),
+      where3("tags", "array-contains-any", tags),
+      orderBy("updatedAt", "desc"),
+      limit(pageSize)
+    );
+    if (lastDoc) {
+      q = query3(q, startAfter(lastDoc));
+    }
+    const querySnapshot = await getDocs3(q);
+    const templates = [];
+    let lastVisible = null;
+    querySnapshot.forEach((doc10) => {
+      templates.push(doc10.data());
+      lastVisible = doc10;
+    });
+    return {
+      templates,
+      lastDoc: lastVisible
+    };
+  }
+  /**
+   * Get templates created by a specific user
+   * @param userId - ID of the user who created the templates
+   * @param pageSize - Number of templates to retrieve
+   * @param lastDoc - Last document from previous page for pagination
+   * @returns Array of templates and the last document for pagination
+   */
+  async getTemplatesByCreator(userId, pageSize = 20, lastDoc) {
+    let q = query3(
+      this.collectionRef,
+      where3("createdBy", "==", userId),
+      orderBy("updatedAt", "desc"),
+      limit(pageSize)
+    );
+    if (lastDoc) {
+      q = query3(q, startAfter(lastDoc));
+    }
+    const querySnapshot = await getDocs3(q);
+    const templates = [];
+    let lastVisible = null;
+    querySnapshot.forEach((doc10) => {
+      templates.push(doc10.data());
+      lastVisible = doc10;
+    });
+    return {
+      templates,
+      lastDoc: lastVisible
+    };
+  }
+  /**
+   * Get all templates for selection with optional filtering
+   * @param options - Filtering options
+   * @returns Array of templates
+   */
+  async getAllTemplatesForSelection(options) {
+    let q = query3(
+      this.collectionRef,
+      where3("isActive", "==", true),
+      orderBy("updatedAt", "desc")
+    );
+    if ((options == null ? void 0 : options.isUserForm) !== void 0) {
+      q = query3(q, where3("isUserForm", "==", options.isUserForm));
+    }
+    if ((options == null ? void 0 : options.isRequired) !== void 0) {
+      q = query3(q, where3("isRequired", "==", options.isRequired));
+    }
+    const querySnapshot = await getDocs3(q);
+    const templates = [];
+    querySnapshot.forEach((doc10) => {
+      templates.push(doc10.data());
+    });
+    return templates;
+  }
+};
+
+// src/services/documentation-templates/filled-document.service.ts
+import {
+  collection as collection5,
+  doc as doc5,
+  getDoc as getDoc5,
+  getDocs as getDocs5,
+  setDoc as setDoc3,
+  updateDoc as updateDoc5,
+  query as query5,
+  orderBy as orderBy3,
+  limit as limit3,
+  startAfter as startAfter2
+} from "firebase/firestore";
 
-// src/backoffice/services/category.service.ts
+// src/services/media/media.service.ts
+import { Timestamp as Timestamp2 } from "firebase/firestore";
 import {
-  addDoc,
-  collection,
-  doc,
-  getDoc,
-  getDocs,
-  query,
-  updateDoc,
-  where
+  ref,
+  uploadBytes,
+  getDownloadURL,
+  deleteObject,
+  getBytes
+} from "firebase/storage";
+import {
+  doc as doc4,
+  getDoc as getDoc4,
+  setDoc as setDoc2,
+  updateDoc as updateDoc4,
+  collection as collection4,
+  query as query4,
+  where as where4,
+  limit as limit2,
+  getDocs as getDocs4,
+  deleteDoc as deleteDoc2,
+  orderBy as orderBy2
 } from "firebase/firestore";
 
-// src/services/base.service.ts
-import { getStorage } from "firebase/storage";
-var BaseService = class {
+// src/backoffice/services/documentation-template.service.ts
+var DocumentationTemplateService2 = class {
+  /**
+   * Constructor for DocumentationTemplateService
+   * @param db - Firestore instance
+   * @param auth - Firebase Auth instance
+   * @param app - Firebase App instance
+   */
   constructor(db, auth, app) {
-    this.db = db;
-    this.auth = auth;
-    this.app = app;
-    this.storage = getStorage(app);
+    this.apiService = new DocumentationTemplateService(db, auth, app);
   }
   /**
-   * Generiše jedinstveni ID za dokumente
-   * Format: xxxxxxxxxxxx-timestamp
-   * Gde je x random karakter (broj ili slovo)
+   * Create a new document template
+   * @param data - Template data
+   * @param userId - ID of the user creating the template
+   * @returns The created template
    */
-  generateId() {
-    const chars = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
-    const timestamp = Date.now().toString(36);
-    const randomPart = Array.from(
-      { length: 12 },
-      () => chars.charAt(Math.floor(Math.random() * chars.length))
-    ).join("");
-    return `${randomPart}-${timestamp}`;
+  async createTemplate(data, userId) {
+    return this.apiService.createTemplate(data, userId);
   }
-};
-
-// src/backoffice/services/category.service.ts
-var CategoryService = class extends BaseService {
   /**
-   * Referenca na Firestore kolekciju kategorija
+   * Get a document template by ID
+   * @param templateId - ID of the template to retrieve
+   * @param version - Optional version number to retrieve (defaults to latest version)
+   * @returns The template or null if not found
    */
-  get categoriesRef() {
-    return collection(this.db, CATEGORIES_COLLECTION);
+  async getTemplateById(templateId, version) {
+    return this.apiService.getTemplateById(templateId, version);
   }
   /**
-   * Kreira novu kategoriju u sistemu
-   * @param category - Podaci za novu kategoriju
-   * @returns Kreirana kategorija sa generisanim ID-em
+   * Update an existing document template
+   * @param templateId - ID of the template to update
+   * @param data - Updated template data
+   * @returns The updated template
    */
-  async create(category) {
-    const now = /* @__PURE__ */ new Date();
-    const newCategory = {
-      ...category,
-      createdAt: now,
-      updatedAt: now,
-      isActive: true
-    };
-    const docRef = await addDoc(this.categoriesRef, newCategory);
-    return { id: docRef.id, ...newCategory };
+  async updateTemplate(templateId, data) {
+    return this.apiService.updateTemplate(templateId, data);
   }
   /**
-   * Vraća sve aktivne kategorije
-   * @returns Lista aktivnih kategorija
+   * Delete a document template
+   * @param templateId - ID of the template to delete
    */
-  async getAll() {
-    const q = query(this.categoriesRef, where("isActive", "==", true));
-    const snapshot = await getDocs(q);
-    return snapshot.docs.map(
-      (doc10) => ({
-        id: doc10.id,
-        ...doc10.data()
-      })
-    );
+  async deleteTemplate(templateId) {
+    return this.apiService.deleteTemplate(templateId);
   }
   /**
-   * Vraća sve aktivne kategorije za određenu familiju procedura
-   * @param family - Familija procedura (aesthetics/surgery)
-   * @returns Lista kategorija koje pripadaju traženoj familiji
+   * Get all active templates
+   * @param pageSize - Number of templates to retrieve
+   * @param lastDoc - Last document from previous page for pagination
+   * @returns Array of templates and the last document for pagination
    */
-  async getAllByFamily(family) {
-    const q = query(
-      this.categoriesRef,
-      where("family", "==", family),
-      where("isActive", "==", true)
-    );
-    const snapshot = await getDocs(q);
-    return snapshot.docs.map(
-      (doc10) => ({
-        id: doc10.id,
-        ...doc10.data()
-      })
-    );
+  async getActiveTemplates(pageSize = 20, lastDoc) {
+    return this.apiService.getActiveTemplates(pageSize, lastDoc);
   }
   /**
-   * Ažurira postojeću kategoriju
-   * @param id - ID kategorije koja se ažurira
-   * @param category - Novi podaci za kategoriju
-   * @returns Ažurirana kategorija
+   * Get templates by tags
+   * @param tags - Tags to filter by
+   * @param pageSize - Number of templates to retrieve
+   * @param lastDoc - Last document from previous page for pagination
+   * @returns Array of templates and the last document for pagination
    */
-  async update(id, category) {
-    const updateData = {
-      ...category,
-      updatedAt: /* @__PURE__ */ new Date()
-    };
-    const docRef = doc(this.categoriesRef, id);
-    await updateDoc(docRef, updateData);
-    return this.getById(id);
+  async getTemplatesByTags(tags, pageSize = 20, lastDoc) {
+    return this.apiService.getTemplatesByTags(tags, pageSize, lastDoc);
   }
   /**
-   * Soft delete kategorije (postavlja isActive na false)
-   * @param id - ID kategorije koja se briše
+   * Get templates created by a specific user
+   * @param userId - ID of the user who created the templates
+   * @param pageSize - Number of templates to retrieve
+   * @param lastDoc - Last document from previous page for pagination
+   * @returns Array of templates and the last document for pagination
    */
-  async delete(id) {
-    await this.update(id, { isActive: false });
+  async getTemplatesByCreator(userId, pageSize = 20, lastDoc) {
+    return this.apiService.getTemplatesByCreator(userId, pageSize, lastDoc);
   }
   /**
-   * Vraća kategoriju po ID-u
-   * @param id - ID tražene kategorije
-   * @returns Kategorija ili null ako ne postoji
+   * Get a specific version of a template
+   * @param templateId - ID of the template
+   * @param versionNumber - Version number to retrieve
+   * @returns The template version or null if not found
    */
-  async getById(id) {
-    const docRef = doc(this.categoriesRef, id);
-    const docSnap = await getDoc(docRef);
-    if (!docSnap.exists()) return null;
-    return {
-      id: docSnap.id,
-      ...docSnap.data()
-    };
+  async getTemplateVersion(templateId, versionNumber) {
+    return this.apiService.getTemplateVersion(templateId, versionNumber);
+  }
+  /**
+   * Get all versions of a template
+   * @param templateId - ID of the template
+   * @returns Array of template versions
+   */
+  async getTemplateVersions(templateId) {
+    return this.apiService.getTemplateOldVersions(templateId);
   }
 };
 
-// src/backoffice/services/subcategory.service.ts
+// src/backoffice/services/product.service.ts
 import {
-  addDoc as addDoc2,
-  collection as collection2,
-  doc as doc2,
-  getDoc as getDoc2,
-  getDocs as getDocs2,
-  query as query2,
-  updateDoc as updateDoc2,
-  where as where2
+  addDoc as addDoc3,
+  collection as collection6,
+  doc as doc6,
+  getDoc as getDoc6,
+  getDocs as getDocs6,
+  query as query6,
+  updateDoc as updateDoc6,
+  where as where6
 } from "firebase/firestore";
-var SubcategoryService = class extends BaseService {
+
+// src/backoffice/types/product.types.ts
+var PRODUCTS_COLLECTION = "products";
+
+// src/backoffice/types/technology.types.ts
+var TECHNOLOGIES_COLLECTION = "technologies";
+
+// src/backoffice/services/product.service.ts
+var ProductService = class extends BaseService {
   /**
-   * Vraća referencu na Firestore kolekciju podkategorija za određenu kategoriju
-   * @param categoryId - ID roditeljske kategorije
+   * Gets reference to products collection under a technology
+   * @param technologyId - ID of the technology
+   * @returns Firestore collection reference
    */
-  getSubcategoriesRef(categoryId) {
-    return collection2(
+  getProductsRef(technologyId) {
+    return collection6(
       this.db,
-      CATEGORIES_COLLECTION,
-      categoryId,
-      SUBCATEGORIES_COLLECTION
+      TECHNOLOGIES_COLLECTION,
+      technologyId,
+      PRODUCTS_COLLECTION
     );
   }
   /**
-   * Kreira novu podkategoriju u okviru kategorije
-   * @param categoryId - ID kategorije kojoj će pripadati nova podkategorija
-   * @param subcategory - Podaci za novu podkategoriju
-   * @returns Kreirana podkategorija sa generisanim ID-em
+   * Creates a new product under technology
    */
-  async create(categoryId, subcategory) {
+  async create(technologyId, brandId, product) {
     const now = /* @__PURE__ */ new Date();
-    const newSubcategory = {
-      ...subcategory,
-      categoryId,
+    const newProduct = {
+      ...product,
+      brandId,
+      technologyId,
       createdAt: now,
       updatedAt: now,
       isActive: true
     };
-    const docRef = await addDoc2(
-      this.getSubcategoriesRef(categoryId),
-      newSubcategory
+    const productRef = await addDoc3(
+      this.getProductsRef(technologyId),
+      newProduct
     );
-    return { id: docRef.id, ...newSubcategory };
+    return { id: productRef.id, ...newProduct };
   }
   /**
-   * Vraća sve aktivne podkategorije za određenu kategoriju
-   * @param categoryId - ID kategorije čije podkategorije tražimo
-   * @returns Lista aktivnih podkategorija
+   * Gets all products for a technology
    */
-  async getAllByCategoryId(categoryId) {
-    const q = query2(
-      this.getSubcategoriesRef(categoryId),
-      where2("isActive", "==", true)
+  async getAllByTechnology(technologyId) {
+    const q = query6(
+      this.getProductsRef(technologyId),
+      where6("isActive", "==", true)
     );
-    const snapshot = await getDocs2(q);
+    const snapshot = await getDocs6(q);
     return snapshot.docs.map(
       (doc10) => ({
         id: doc10.id,
@@ -756,38 +943,56 @@ var SubcategoryService = class extends BaseService {
     );
   }
   /**
-   * Ažurira postojeću podkategoriju
-   * @param categoryId - ID kategorije kojoj pripada podkategorija
-   * @param subcategoryId - ID podkategorije koja se ažurira
-   * @param subcategory - Novi podaci za podkategoriju
-   * @returns Ažurirana podkategorija
+   * Gets all products for a brand by filtering through all technologies
    */
-  async update(categoryId, subcategoryId, subcategory) {
+  async getAllByBrand(brandId) {
+    const allTechnologiesRef = collection6(this.db, TECHNOLOGIES_COLLECTION);
+    const technologiesSnapshot = await getDocs6(allTechnologiesRef);
+    const products = [];
+    for (const techDoc of technologiesSnapshot.docs) {
+      const q = query6(
+        this.getProductsRef(techDoc.id),
+        where6("brandId", "==", brandId),
+        where6("isActive", "==", true)
+      );
+      const snapshot = await getDocs6(q);
+      products.push(
+        ...snapshot.docs.map(
+          (doc10) => ({
+            id: doc10.id,
+            ...doc10.data()
+          })
+        )
+      );
+    }
+    return products;
+  }
+  /**
+   * Updates a product
+   */
+  async update(technologyId, productId, product) {
     const updateData = {
-      ...subcategory,
+      ...product,
       updatedAt: /* @__PURE__ */ new Date()
     };
-    const docRef = doc2(this.getSubcategoriesRef(categoryId), subcategoryId);
-    await updateDoc2(docRef, updateData);
-    return this.getById(categoryId, subcategoryId);
+    const docRef = doc6(this.getProductsRef(technologyId), productId);
+    await updateDoc6(docRef, updateData);
+    return this.getById(technologyId, productId);
   }
   /**
-   * Soft delete podkategorije (postavlja isActive na false)
-   * @param categoryId - ID kategorije kojoj pripada podkategorija
-   * @param subcategoryId - ID podkategorije koja se briše
+   * Soft deletes a product
    */
-  async delete(categoryId, subcategoryId) {
-    await this.update(categoryId, subcategoryId, { isActive: false });
+  async delete(technologyId, productId) {
+    await this.update(technologyId, productId, {
+      isActive: false
+    });
   }
   /**
-   * Vraća podkategoriju po ID-u
-   * @param categoryId - ID kategorije kojoj pripada podkategorija
-   * @param subcategoryId - ID tražene podkategorije
-   * @returns Podkategorija ili null ako ne postoji
+   * Gets a product by ID
    */
-  async getById(categoryId, subcategoryId) {
-    const docRef = doc2(this.getSubcategoriesRef(categoryId), subcategoryId);
-    const docSnap = await getDoc2(docRef);
+  async getById(technologyId, productId) {
+    const docRef = doc6(this.getProductsRef(technologyId), productId);
+    const docSnap = await getDoc6(docRef);
     if (!docSnap.exists()) return null;
     return {
       id: docSnap.id,
@@ -796,99 +1001,62 @@ var SubcategoryService = class extends BaseService {
   }
 };
 
-// src/backoffice/services/technology.service.ts
+// src/backoffice/services/requirement.service.ts
 import {
-  addDoc as addDoc3,
-  collection as collection3,
-  doc as doc3,
-  getDoc as getDoc3,
-  getDocs as getDocs3,
-  query as query3,
-  updateDoc as updateDoc3,
-  where as where3,
-  arrayUnion,
-  arrayRemove
+  addDoc as addDoc4,
+  collection as collection7,
+  doc as doc7,
+  getDoc as getDoc7,
+  getDocs as getDocs7,
+  query as query7,
+  updateDoc as updateDoc7,
+  where as where7
 } from "firebase/firestore";
-var DEFAULT_CERTIFICATION_REQUIREMENT2 = {
-  minimumLevel: "aesthetician" /* AESTHETICIAN */,
-  requiredSpecialties: []
-};
-var TechnologyService = class extends BaseService {
-  /**
-   * Vraća referencu na Firestore kolekciju tehnologija
-   */
-  getTechnologiesRef() {
-    return collection3(this.db, TECHNOLOGIES_COLLECTION);
-  }
-  /**
-   * Kreira novu tehnologiju
-   * @param technology - Podaci za novu tehnologiju
-   * @returns Kreirana tehnologija sa generisanim ID-em
-   */
-  async create(technology) {
-    const now = /* @__PURE__ */ new Date();
-    const newTechnology = {
-      ...technology,
-      createdAt: now,
-      updatedAt: now,
-      isActive: true,
-      requirements: technology.requirements || {
-        pre: [],
-        post: []
-      },
-      blockingConditions: technology.blockingConditions || [],
-      contraindications: technology.contraindications || [],
-      benefits: technology.benefits || [],
-      certificationRequirement: technology.certificationRequirement || DEFAULT_CERTIFICATION_REQUIREMENT2
-    };
-    const docRef = await addDoc3(this.getTechnologiesRef(), newTechnology);
-    return { id: docRef.id, ...newTechnology };
-  }
+
+// src/backoffice/types/requirement.types.ts
+var TimeUnit = /* @__PURE__ */ ((TimeUnit2) => {
+  TimeUnit2["HOURS"] = "hours";
+  TimeUnit2["DAYS"] = "days";
+  return TimeUnit2;
+})(TimeUnit || {});
+var RequirementType = /* @__PURE__ */ ((RequirementType3) => {
+  RequirementType3["PRE"] = "pre";
+  RequirementType3["POST"] = "post";
+  return RequirementType3;
+})(RequirementType || {});
+var REQUIREMENTS_COLLECTION = "backoffice_requirements";
+
+// src/backoffice/services/requirement.service.ts
+var RequirementService = class extends BaseService {
   /**
-   * Vraća sve aktivne tehnologije
-   * @returns Lista aktivnih tehnologija
+   * Referenca na Firestore kolekciju zahteva
    */
-  async getAll() {
-    const q = query3(this.getTechnologiesRef(), where3("isActive", "==", true));
-    const snapshot = await getDocs3(q);
-    return snapshot.docs.map(
-      (doc10) => ({
-        id: doc10.id,
-        ...doc10.data()
-      })
-    );
+  get requirementsRef() {
+    return collection7(this.db, REQUIREMENTS_COLLECTION);
   }
   /**
-   * Vraća sve aktivne tehnologije za određenu familiju
-   * @param family - Familija procedura
-   * @returns Lista aktivnih tehnologija
+   * Kreira novi globalni zahtev
+   * @param requirement - Podaci za novi zahtev
+   * @returns Kreirani zahtev sa generisanim ID-em
    */
-  async getAllByFamily(family) {
-    const q = query3(
-      this.getTechnologiesRef(),
-      where3("isActive", "==", true),
-      where3("family", "==", family)
-    );
-    const snapshot = await getDocs3(q);
-    return snapshot.docs.map(
-      (doc10) => ({
-        id: doc10.id,
-        ...doc10.data()
-      })
-    );
+  async create(requirement) {
+    const now = /* @__PURE__ */ new Date();
+    const newRequirement = {
+      ...requirement,
+      createdAt: now,
+      updatedAt: now,
+      isActive: true
+    };
+    const docRef = await addDoc4(this.requirementsRef, newRequirement);
+    return { id: docRef.id, ...newRequirement };
   }
   /**
-   * Vraća sve aktivne tehnologije za određenu kategoriju
-   * @param categoryId - ID kategorije
-   * @returns Lista aktivnih tehnologija
+   * Vraća sve aktivne zahteve
+   * @returns Lista aktivnih zahteva
    */
-  async getAllByCategoryId(categoryId) {
-    const q = query3(
-      this.getTechnologiesRef(),
-      where3("isActive", "==", true),
-      where3("categoryId", "==", categoryId)
-    );
-    const snapshot = await getDocs3(q);
+  async getAll() {
+    const q = query7(this.requirementsRef, where7("isActive", "==", true));
+    const snapshot = await getDocs7(q);
     return snapshot.docs.map(
       (doc10) => ({
         id: doc10.id,
@@ -897,17 +1065,17 @@ var TechnologyService = class extends BaseService {
     );
   }
   /**
-   * Vraća sve aktivne tehnologije za određenu podkategoriju
-   * @param subcategoryId - ID podkategorije
-   * @returns Lista aktivnih tehnologija
+   * Vraća sve aktivne zahteve određenog tipa
+   * @param type - Tip zahteva (pre/post)
+   * @returns Lista zahteva određenog tipa
    */
-  async getAllBySubcategoryId(subcategoryId) {
-    const q = query3(
-      this.getTechnologiesRef(),
-      where3("isActive", "==", true),
-      where3("subcategoryId", "==", subcategoryId)
+  async getAllByType(type) {
+    const q = query7(
+      this.requirementsRef,
+      where7("type", "==", type),
+      where7("isActive", "==", true)
     );
-    const snapshot = await getDocs3(q);
+    const snapshot = await getDocs7(q);
     return snapshot.docs.map(
       (doc10) => ({
         id: doc10.id,
@@ -916,357 +1084,271 @@ var TechnologyService = class extends BaseService {
     );
   }
   /**
-   * Ažurira postojeću tehnologiju
-   * @param technologyId - ID tehnologije
-   * @param technology - Novi podaci za tehnologiju
-   * @returns Ažurirana tehnologija
+   * Ažurira postojeći zahtev
+   * @param id - ID zahteva koji se ažurira
+   * @param requirement - Novi podaci za zahtev
+   * @returns Ažurirani zahtev
    */
-  async update(technologyId, technology) {
+  async update(id, requirement) {
     const updateData = {
-      ...technology,
+      ...requirement,
       updatedAt: /* @__PURE__ */ new Date()
     };
-    const docRef = doc3(this.getTechnologiesRef(), technologyId);
-    await updateDoc3(docRef, updateData);
-    return this.getById(technologyId);
+    const docRef = doc7(this.requirementsRef, id);
+    await updateDoc7(docRef, updateData);
+    return this.getById(id);
   }
   /**
-   * Soft delete tehnologije (postavlja isActive na false)
-   * @param technologyId - ID tehnologije koja se briše
+   * Soft delete zahteva (postavlja isActive na false)
+   * @param id - ID zahteva koji se briše
    */
-  async delete(technologyId) {
-    await this.update(technologyId, {
-      isActive: false
-    });
+  async delete(id) {
+    await this.update(id, { isActive: false });
   }
   /**
-   * Vraća tehnologiju po ID-u
-   * @param technologyId - ID tražene tehnologije
-   * @returns Tehnologija ili null ako ne postoji
+   * Vraća zahtev po ID-u
+   * @param id - ID traženog zahteva
+   * @returns Zahtev ili null ako ne postoji
    */
-  async getById(technologyId) {
-    const docRef = doc3(this.getTechnologiesRef(), technologyId);
-    const docSnap = await getDoc3(docRef);
+  async getById(id) {
+    const docRef = doc7(this.requirementsRef, id);
+    const docSnap = await getDoc7(docRef);
     if (!docSnap.exists()) return null;
     return {
       id: docSnap.id,
       ...docSnap.data()
     };
   }
+};
+
+// src/backoffice/services/subcategory.service.ts
+import {
+  addDoc as addDoc5,
+  collection as collection8,
+  doc as doc8,
+  getDoc as getDoc8,
+  getDocs as getDocs8,
+  query as query8,
+  updateDoc as updateDoc8,
+  where as where8
+} from "firebase/firestore";
+
+// src/backoffice/types/subcategory.types.ts
+var SUBCATEGORIES_COLLECTION = "subcategories";
+
+// src/backoffice/services/subcategory.service.ts
+var SubcategoryService = class extends BaseService {
   /**
-   * Dodaje novi zahtev tehnologiji
-   * @param technologyId - ID tehnologije
-   * @param requirement - Zahtev koji se dodaje
-   * @returns Ažurirana tehnologija sa novim zahtevom
-   */
-  async addRequirement(technologyId, requirement) {
-    const docRef = doc3(this.getTechnologiesRef(), technologyId);
-    const requirementType = requirement.type === "pre" ? "requirements.pre" : "requirements.post";
-    await updateDoc3(docRef, {
-      [requirementType]: arrayUnion(requirement),
-      updatedAt: /* @__PURE__ */ new Date()
-    });
-    return this.getById(technologyId);
-  }
-  /**
-   * Uklanja zahtev iz tehnologije
-   * @param technologyId - ID tehnologije
-   * @param requirement - Zahtev koji se uklanja
-   * @returns Ažurirana tehnologija bez uklonjenog zahteva
-   */
-  async removeRequirement(technologyId, requirement) {
-    const docRef = doc3(this.getTechnologiesRef(), technologyId);
-    const requirementType = requirement.type === "pre" ? "requirements.pre" : "requirements.post";
-    await updateDoc3(docRef, {
-      [requirementType]: arrayRemove(requirement),
-      updatedAt: /* @__PURE__ */ new Date()
-    });
-    return this.getById(technologyId);
-  }
-  /**
-   * Vraća sve zahteve za tehnologiju
-   * @param technologyId - ID tehnologije
-   * @param type - Opcioni filter za tip zahteva (pre/post)
-   * @returns Lista zahteva
-   */
-  async getRequirements(technologyId, type) {
-    const technology = await this.getById(technologyId);
-    if (!technology || !technology.requirements) return [];
-    if (type) {
-      return technology.requirements[type];
-    }
-    return [...technology.requirements.pre, ...technology.requirements.post];
-  }
-  /**
-   * Ažurira postojeći zahtev
-   * @param technologyId - ID tehnologije
-   * @param oldRequirement - Stari zahtev koji se menja
-   * @param newRequirement - Novi zahtev koji zamenjuje stari
-   * @returns Ažurirana tehnologija
-   */
-  async updateRequirement(technologyId, oldRequirement, newRequirement) {
-    await this.removeRequirement(technologyId, oldRequirement);
-    return this.addRequirement(technologyId, newRequirement);
-  }
-  /**
-   * Dodaje blokirajući uslov tehnologiji
-   * @param technologyId - ID tehnologije
-   * @param condition - Blokirajući uslov koji se dodaje
-   * @returns Ažurirana tehnologija
-   */
-  async addBlockingCondition(technologyId, condition) {
-    const docRef = doc3(this.getTechnologiesRef(), technologyId);
-    await updateDoc3(docRef, {
-      blockingConditions: arrayUnion(condition),
-      updatedAt: /* @__PURE__ */ new Date()
-    });
-    return this.getById(technologyId);
-  }
-  /**
-   * Uklanja blokirajući uslov iz tehnologije
-   * @param technologyId - ID tehnologije
-   * @param condition - Blokirajući uslov koji se uklanja
-   * @returns Ažurirana tehnologija
-   */
-  async removeBlockingCondition(technologyId, condition) {
-    const docRef = doc3(this.getTechnologiesRef(), technologyId);
-    await updateDoc3(docRef, {
-      blockingConditions: arrayRemove(condition),
-      updatedAt: /* @__PURE__ */ new Date()
-    });
-    return this.getById(technologyId);
-  }
-  /**
-   * Dodaje kontraindikaciju tehnologiji
-   * @param technologyId - ID tehnologije
-   * @param contraindication - Kontraindikacija koja se dodaje
-   * @returns Ažurirana tehnologija
-   */
-  async addContraindication(technologyId, contraindication) {
-    const docRef = doc3(this.getTechnologiesRef(), technologyId);
-    await updateDoc3(docRef, {
-      contraindications: arrayUnion(contraindication),
-      updatedAt: /* @__PURE__ */ new Date()
-    });
-    return this.getById(technologyId);
-  }
-  /**
-   * Uklanja kontraindikaciju iz tehnologije
-   * @param technologyId - ID tehnologije
-   * @param contraindication - Kontraindikacija koja se uklanja
-   * @returns Ažurirana tehnologija
-   */
-  async removeContraindication(technologyId, contraindication) {
-    const docRef = doc3(this.getTechnologiesRef(), technologyId);
-    await updateDoc3(docRef, {
-      contraindications: arrayRemove(contraindication),
-      updatedAt: /* @__PURE__ */ new Date()
-    });
-    return this.getById(technologyId);
-  }
-  /**
-   * Dodaje benefit tehnologiji
-   * @param technologyId - ID tehnologije
-   * @param benefit - Benefit koji se dodaje
-   * @returns Ažurirana tehnologija
-   */
-  async addBenefit(technologyId, benefit) {
-    const docRef = doc3(this.getTechnologiesRef(), technologyId);
-    await updateDoc3(docRef, {
-      benefits: arrayUnion(benefit),
-      updatedAt: /* @__PURE__ */ new Date()
-    });
-    return this.getById(technologyId);
-  }
-  /**
-   * Uklanja benefit iz tehnologije
-   * @param technologyId - ID tehnologije
-   * @param benefit - Benefit koji se uklanja
-   * @returns Ažurirana tehnologija
-   */
-  async removeBenefit(technologyId, benefit) {
-    const docRef = doc3(this.getTechnologiesRef(), technologyId);
-    await updateDoc3(docRef, {
-      benefits: arrayRemove(benefit),
-      updatedAt: /* @__PURE__ */ new Date()
-    });
-    return this.getById(technologyId);
-  }
-  /**
-   * Vraća sve blokirajuće uslove za tehnologiju
-   * @param technologyId - ID tehnologije
-   * @returns Lista blokirajućih uslova
-   */
-  async getBlockingConditions(technologyId) {
-    const technology = await this.getById(technologyId);
-    return (technology == null ? void 0 : technology.blockingConditions) || [];
-  }
-  /**
-   * Vraća sve kontraindikacije za tehnologiju
-   * @param technologyId - ID tehnologije
-   * @returns Lista kontraindikacija
+   * Vraća referencu na Firestore kolekciju podkategorija za određenu kategoriju
+   * @param categoryId - ID roditeljske kategorije
    */
-  async getContraindications(technologyId) {
-    const technology = await this.getById(technologyId);
-    return (technology == null ? void 0 : technology.contraindications) || [];
+  getSubcategoriesRef(categoryId) {
+    return collection8(
+      this.db,
+      CATEGORIES_COLLECTION,
+      categoryId,
+      SUBCATEGORIES_COLLECTION
+    );
   }
   /**
-   * Vraća sve benefite za tehnologiju
-   * @param technologyId - ID tehnologije
-   * @returns Lista benefita
+   * Kreira novu podkategoriju u okviru kategorije
+   * @param categoryId - ID kategorije kojoj će pripadati nova podkategorija
+   * @param subcategory - Podaci za novu podkategoriju
+   * @returns Kreirana podkategorija sa generisanim ID-em
    */
-  async getBenefits(technologyId) {
-    const technology = await this.getById(technologyId);
-    return (technology == null ? void 0 : technology.benefits) || [];
+  async create(categoryId, subcategory) {
+    const now = /* @__PURE__ */ new Date();
+    const newSubcategory = {
+      ...subcategory,
+      categoryId,
+      createdAt: now,
+      updatedAt: now,
+      isActive: true
+    };
+    const docRef = await addDoc5(
+      this.getSubcategoriesRef(categoryId),
+      newSubcategory
+    );
+    return { id: docRef.id, ...newSubcategory };
   }
   /**
-   * Ažurira zahteve sertifikacije za tehnologiju
-   * @param technologyId - ID tehnologije
-   * @param certificationRequirement - Novi zahtevi sertifikacije
-   * @returns Ažurirana tehnologija
+   * Vraća sve aktivne podkategorije za određenu kategoriju
+   * @param categoryId - ID kategorije čije podkategorije tražimo
+   * @returns Lista aktivnih podkategorija
    */
-  async updateCertificationRequirement(technologyId, certificationRequirement) {
-    const docRef = doc3(this.getTechnologiesRef(), technologyId);
-    await updateDoc3(docRef, {
-      certificationRequirement,
-      updatedAt: /* @__PURE__ */ new Date()
-    });
-    return this.getById(technologyId);
+  async getAllByCategoryId(categoryId) {
+    const q = query8(
+      this.getSubcategoriesRef(categoryId),
+      where8("isActive", "==", true)
+    );
+    const snapshot = await getDocs8(q);
+    return snapshot.docs.map(
+      (doc10) => ({
+        id: doc10.id,
+        ...doc10.data()
+      })
+    );
   }
   /**
-   * Vraća zahteve sertifikacije za tehnologiju
-   * @param technologyId - ID tehnologije
-   * @returns Zahtevi sertifikacije ili null ako tehnologija ne postoji
+   * Ažurira postojeću podkategoriju
+   * @param categoryId - ID kategorije kojoj pripada podkategorija
+   * @param subcategoryId - ID podkategorije koja se ažurira
+   * @param subcategory - Novi podaci za podkategoriju
+   * @returns Ažurirana podkategorija
    */
-  async getCertificationRequirement(technologyId) {
-    const technology = await this.getById(technologyId);
-    return (technology == null ? void 0 : technology.certificationRequirement) || null;
+  async update(categoryId, subcategoryId, subcategory) {
+    const updateData = {
+      ...subcategory,
+      updatedAt: /* @__PURE__ */ new Date()
+    };
+    const docRef = doc8(this.getSubcategoriesRef(categoryId), subcategoryId);
+    await updateDoc8(docRef, updateData);
+    return this.getById(categoryId, subcategoryId);
   }
   /**
-   * Proverava da li doktor ima odgovarajuću sertifikaciju za izvođenje tehnologije
-   *
-   * @param requiredCertification - Zahtevana sertifikacija za tehnologiju
-   * @param practitionerCertification - Sertifikacija zdravstvenog radnika
-   * @returns true ako zdravstveni radnik ima odgovarajuću sertifikaciju, false ako nema
-   *
-   * @example
-   * const isValid = technologyService.validateCertification(
-   *   {
-   *     minimumLevel: CertificationLevel.DOCTOR,
-   *     requiredSpecialties: [CertificationSpecialty.INJECTABLES]
-   *   },
-   *   {
-   *     level: CertificationLevel.SPECIALIST,
-   *     specialties: [CertificationSpecialty.INJECTABLES, CertificationSpecialty.LASER]
-   *   }
-   * );
+   * Soft delete podkategorije (postavlja isActive na false)
+   * @param categoryId - ID kategorije kojoj pripada podkategorija
+   * @param subcategoryId - ID podkategorije koja se briše
    */
-  validateCertification(requiredCertification, practitionerCertification) {
-    const doctorLevel = Object.values(CertificationLevel).indexOf(
-      practitionerCertification.level
-    );
-    const requiredLevel = Object.values(CertificationLevel).indexOf(
-      requiredCertification.minimumLevel
-    );
-    if (doctorLevel < requiredLevel) return false;
-    const requiredSpecialties = requiredCertification.requiredSpecialties || [];
-    if (requiredSpecialties.length > 0) {
-      const doctorSpecialties = practitionerCertification.specialties;
-      const hasAllRequiredSpecialties = requiredSpecialties.every(
-        (requiredSpecialty) => doctorSpecialties.includes(requiredSpecialty)
-      );
-      if (!hasAllRequiredSpecialties) return false;
-    }
-    return true;
+  async delete(categoryId, subcategoryId) {
+    await this.update(categoryId, subcategoryId, { isActive: false });
   }
   /**
-   * Vraća sve tehnologije koje je zdravstveni radnik sertifikovan da izvodi
-   * zajedno sa listama dozvoljenih familija, kategorija i podkategorija
-   *
-   * @param practitioner - Profil zdravstvenog radnika
-   * @returns Objekat koji sadrži:
-   * - technologies: Lista tehnologija koje zdravstveni radnik može da izvodi
-   * - families: Lista familija procedura koje zdravstveni radnik može da izvodi
-   * - categories: Lista ID-eva kategorija koje zdravstveni radnik može da izvodi
-   * - subcategories: Lista ID-eva podkategorija koje zdravstveni radnik može da izvodi
-   *
-   * @example
-   * const practitioner = {
-   *   certification: {
-   *     level: CertificationLevel.DOCTOR,
-   *     specialties: [CertificationSpecialty.INJECTABLES]
-   *   }
-   * };
-   * const allowedTechnologies = await technologyService.getAllowedTechnologies(practitioner);
-   * console.log(allowedTechnologies.families); // [ProcedureFamily.AESTHETICS]
-   * console.log(allowedTechnologies.categories); // ["category1", "category2"]
-   * console.log(allowedTechnologies.subcategories); // ["subcategory1", "subcategory2"]
+   * Vraća podkategoriju po ID-u
+   * @param categoryId - ID kategorije kojoj pripada podkategorija
+   * @param subcategoryId - ID tražene podkategorije
+   * @returns Podkategorija ili null ako ne postoji
    */
-  async getAllowedTechnologies(practitioner) {
-    const allTechnologies = await this.getAll();
-    const allowedTechnologies = allTechnologies.filter(
-      (technology) => this.validateCertification(
-        technology.certificationRequirement,
-        practitioner.certification
-      )
-    );
-    const families = [...new Set(allowedTechnologies.map((t) => t.family))];
-    const categories = [
-      ...new Set(allowedTechnologies.map((t) => t.categoryId))
-    ];
-    const subcategories = [
-      ...new Set(allowedTechnologies.map((t) => t.subcategoryId))
-    ];
+  async getById(categoryId, subcategoryId) {
+    const docRef = doc8(this.getSubcategoriesRef(categoryId), subcategoryId);
+    const docSnap = await getDoc8(docRef);
+    if (!docSnap.exists()) return null;
     return {
-      technologies: allowedTechnologies,
-      families,
-      categories,
-      subcategories
+      id: docSnap.id,
+      ...docSnap.data()
     };
   }
 };
 
-// src/backoffice/services/requirement.service.ts
+// src/backoffice/services/technology.service.ts
 import {
-  addDoc as addDoc4,
-  collection as collection4,
-  doc as doc4,
-  getDoc as getDoc4,
-  getDocs as getDocs4,
-  query as query4,
-  updateDoc as updateDoc4,
-  where as where4
+  addDoc as addDoc6,
+  collection as collection9,
+  doc as doc9,
+  getDoc as getDoc9,
+  getDocs as getDocs9,
+  query as query9,
+  updateDoc as updateDoc9,
+  where as where9,
+  arrayUnion,
+  arrayRemove
 } from "firebase/firestore";
-var RequirementService = class extends BaseService {
+
+// 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/backoffice/services/technology.service.ts
+var DEFAULT_CERTIFICATION_REQUIREMENT = {
+  minimumLevel: "aesthetician" /* AESTHETICIAN */,
+  requiredSpecialties: []
+};
+var TechnologyService = class extends BaseService {
   /**
-   * Referenca na Firestore kolekciju zahteva
+   * Vraća referencu na Firestore kolekciju tehnologija
    */
-  get requirementsRef() {
-    return collection4(this.db, REQUIREMENTS_COLLECTION);
+  getTechnologiesRef() {
+    return collection9(this.db, TECHNOLOGIES_COLLECTION);
   }
   /**
-   * Kreira novi globalni zahtev
-   * @param requirement - Podaci za novi zahtev
-   * @returns Kreirani zahtev sa generisanim ID-em
+   * Kreira novu tehnologiju
+   * @param technology - Podaci za novu tehnologiju
+   * @returns Kreirana tehnologija sa generisanim ID-em
    */
-  async create(requirement) {
+  async create(technology) {
     const now = /* @__PURE__ */ new Date();
-    const newRequirement = {
-      ...requirement,
+    const newTechnology = {
+      ...technology,
       createdAt: now,
       updatedAt: now,
-      isActive: true
+      isActive: true,
+      requirements: technology.requirements || {
+        pre: [],
+        post: []
+      },
+      blockingConditions: technology.blockingConditions || [],
+      contraindications: technology.contraindications || [],
+      benefits: technology.benefits || [],
+      certificationRequirement: technology.certificationRequirement || DEFAULT_CERTIFICATION_REQUIREMENT
     };
-    const docRef = await addDoc4(this.requirementsRef, newRequirement);
-    return { id: docRef.id, ...newRequirement };
+    const docRef = await addDoc6(this.getTechnologiesRef(), newTechnology);
+    return { id: docRef.id, ...newTechnology };
   }
   /**
-   * Vraća sve aktivne zahteve
-   * @returns Lista aktivnih zahteva
+   * Vraća sve aktivne tehnologije
+   * @returns Lista aktivnih tehnologija
+   */
+  async getAll() {
+    const q = query9(this.getTechnologiesRef(), where9("isActive", "==", true));
+    const snapshot = await getDocs9(q);
+    return snapshot.docs.map(
+      (doc10) => ({
+        id: doc10.id,
+        ...doc10.data()
+      })
+    );
+  }
+  /**
+   * Vraća sve aktivne tehnologije za određenu familiju
+   * @param family - Familija procedura
+   * @returns Lista aktivnih tehnologija
+   */
+  async getAllByFamily(family) {
+    const q = query9(
+      this.getTechnologiesRef(),
+      where9("isActive", "==", true),
+      where9("family", "==", family)
+    );
+    const snapshot = await getDocs9(q);
+    return snapshot.docs.map(
+      (doc10) => ({
+        id: doc10.id,
+        ...doc10.data()
+      })
+    );
+  }
+  /**
+   * Vraća sve aktivne tehnologije za određenu kategoriju
+   * @param categoryId - ID kategorije
+   * @returns Lista aktivnih tehnologija
    */
-  async getAll() {
-    const q = query4(this.requirementsRef, where4("isActive", "==", true));
-    const snapshot = await getDocs4(q);
+  async getAllByCategoryId(categoryId) {
+    const q = query9(
+      this.getTechnologiesRef(),
+      where9("isActive", "==", true),
+      where9("categoryId", "==", categoryId)
+    );
+    const snapshot = await getDocs9(q);
     return snapshot.docs.map(
       (doc10) => ({
         id: doc10.id,
@@ -1275,17 +1357,17 @@ var RequirementService = class extends BaseService {
     );
   }
   /**
-   * Vraća sve aktivne zahteve određenog tipa
-   * @param type - Tip zahteva (pre/post)
-   * @returns Lista zahteva određenog tipa
+   * Vraća sve aktivne tehnologije za određenu podkategoriju
+   * @param subcategoryId - ID podkategorije
+   * @returns Lista aktivnih tehnologija
    */
-  async getAllByType(type) {
-    const q = query4(
-      this.requirementsRef,
-      where4("type", "==", type),
-      where4("isActive", "==", true)
+  async getAllBySubcategoryId(subcategoryId) {
+    const q = query9(
+      this.getTechnologiesRef(),
+      where9("isActive", "==", true),
+      where9("subcategoryId", "==", subcategoryId)
     );
-    const snapshot = await getDocs4(q);
+    const snapshot = await getDocs9(q);
     return snapshot.docs.map(
       (doc10) => ({
         id: doc10.id,
@@ -1294,663 +1376,591 @@ var RequirementService = class extends BaseService {
     );
   }
   /**
-   * Ažurira postojeći zahtev
-   * @param id - ID zahteva koji se ažurira
-   * @param requirement - Novi podaci za zahtev
-   * @returns Ažurirani zahtev
+   * Ažurira postojeću tehnologiju
+   * @param technologyId - ID tehnologije
+   * @param technology - Novi podaci za tehnologiju
+   * @returns Ažurirana tehnologija
    */
-  async update(id, requirement) {
+  async update(technologyId, technology) {
     const updateData = {
-      ...requirement,
+      ...technology,
       updatedAt: /* @__PURE__ */ new Date()
     };
-    const docRef = doc4(this.requirementsRef, id);
-    await updateDoc4(docRef, updateData);
-    return this.getById(id);
+    const docRef = doc9(this.getTechnologiesRef(), technologyId);
+    await updateDoc9(docRef, updateData);
+    return this.getById(technologyId);
   }
   /**
-   * Soft delete zahteva (postavlja isActive na false)
-   * @param id - ID zahteva koji se briše
+   * Soft delete tehnologije (postavlja isActive na false)
+   * @param technologyId - ID tehnologije koja se briše
    */
-  async delete(id) {
-    await this.update(id, { isActive: false });
+  async delete(technologyId) {
+    await this.update(technologyId, {
+      isActive: false
+    });
   }
   /**
-   * Vraća zahtev po ID-u
-   * @param id - ID traženog zahteva
-   * @returns Zahtev ili null ako ne postoji
+   * Vraća tehnologiju po ID-u
+   * @param technologyId - ID tražene tehnologije
+   * @returns Tehnologija ili null ako ne postoji
    */
-  async getById(id) {
-    const docRef = doc4(this.requirementsRef, id);
-    const docSnap = await getDoc4(docRef);
+  async getById(technologyId) {
+    const docRef = doc9(this.getTechnologiesRef(), technologyId);
+    const docSnap = await getDoc9(docRef);
     if (!docSnap.exists()) return null;
     return {
       id: docSnap.id,
       ...docSnap.data()
     };
   }
-};
-
-// src/backoffice/services/brand.service.ts
-import {
-  addDoc as addDoc5,
-  collection as collection5,
-  doc as doc5,
-  getDoc as getDoc5,
-  getDocs as getDocs5,
-  query as query5,
-  updateDoc as updateDoc5,
-  where as where5
-} from "firebase/firestore";
-var BrandService = class extends BaseService {
   /**
-   * Gets reference to brands collection
+   * Dodaje novi zahtev tehnologiji
+   * @param technologyId - ID tehnologije
+   * @param requirement - Zahtev koji se dodaje
+   * @returns Ažurirana tehnologija sa novim zahtevom
    */
-  getBrandsRef() {
-    return collection5(this.db, BRANDS_COLLECTION);
+  async addRequirement(technologyId, requirement) {
+    const docRef = doc9(this.getTechnologiesRef(), technologyId);
+    const requirementType = requirement.type === "pre" ? "requirements.pre" : "requirements.post";
+    await updateDoc9(docRef, {
+      [requirementType]: arrayUnion(requirement),
+      updatedAt: /* @__PURE__ */ new Date()
+    });
+    return this.getById(technologyId);
   }
   /**
-   * Creates a new brand
+   * Uklanja zahtev iz tehnologije
+   * @param technologyId - ID tehnologije
+   * @param requirement - Zahtev koji se uklanja
+   * @returns Ažurirana tehnologija bez uklonjenog zahteva
    */
-  async create(brand) {
-    const now = /* @__PURE__ */ new Date();
-    const newBrand = {
-      ...brand,
-      createdAt: now,
-      updatedAt: now,
-      isActive: true
-    };
-    const docRef = await addDoc5(this.getBrandsRef(), newBrand);
-    return { id: docRef.id, ...newBrand };
+  async removeRequirement(technologyId, requirement) {
+    const docRef = doc9(this.getTechnologiesRef(), technologyId);
+    const requirementType = requirement.type === "pre" ? "requirements.pre" : "requirements.post";
+    await updateDoc9(docRef, {
+      [requirementType]: arrayRemove(requirement),
+      updatedAt: /* @__PURE__ */ new Date()
+    });
+    return this.getById(technologyId);
   }
   /**
-   * Gets all active brands
+   * Vraća sve zahteve za tehnologiju
+   * @param technologyId - ID tehnologije
+   * @param type - Opcioni filter za tip zahteva (pre/post)
+   * @returns Lista zahteva
    */
-  async getAll() {
-    const q = query5(this.getBrandsRef(), where5("isActive", "==", true));
-    const snapshot = await getDocs5(q);
-    return snapshot.docs.map(
-      (doc10) => ({
-        id: doc10.id,
-        ...doc10.data()
-      })
-    );
+  async getRequirements(technologyId, type) {
+    const technology = await this.getById(technologyId);
+    if (!technology || !technology.requirements) return [];
+    if (type) {
+      return technology.requirements[type];
+    }
+    return [...technology.requirements.pre, ...technology.requirements.post];
   }
   /**
-   * Updates a brand
+   * Ažurira postojeći zahtev
+   * @param technologyId - ID tehnologije
+   * @param oldRequirement - Stari zahtev koji se menja
+   * @param newRequirement - Novi zahtev koji zamenjuje stari
+   * @returns Ažurirana tehnologija
    */
-  async update(brandId, brand) {
-    const updateData = {
-      ...brand,
+  async updateRequirement(technologyId, oldRequirement, newRequirement) {
+    await this.removeRequirement(technologyId, oldRequirement);
+    return this.addRequirement(technologyId, newRequirement);
+  }
+  /**
+   * Dodaje blokirajući uslov tehnologiji
+   * @param technologyId - ID tehnologije
+   * @param condition - Blokirajući uslov koji se dodaje
+   * @returns Ažurirana tehnologija
+   */
+  async addBlockingCondition(technologyId, condition) {
+    const docRef = doc9(this.getTechnologiesRef(), technologyId);
+    await updateDoc9(docRef, {
+      blockingConditions: arrayUnion(condition),
       updatedAt: /* @__PURE__ */ new Date()
-    };
-    const docRef = doc5(this.getBrandsRef(), brandId);
-    await updateDoc5(docRef, updateData);
-    return this.getById(brandId);
+    });
+    return this.getById(technologyId);
   }
   /**
-   * Soft deletes a brand
+   * Uklanja blokirajući uslov iz tehnologije
+   * @param technologyId - ID tehnologije
+   * @param condition - Blokirajući uslov koji se uklanja
+   * @returns Ažurirana tehnologija
    */
-  async delete(brandId) {
-    await this.update(brandId, {
-      isActive: false
+  async removeBlockingCondition(technologyId, condition) {
+    const docRef = doc9(this.getTechnologiesRef(), technologyId);
+    await updateDoc9(docRef, {
+      blockingConditions: arrayRemove(condition),
+      updatedAt: /* @__PURE__ */ new Date()
     });
+    return this.getById(technologyId);
   }
   /**
-   * Gets a brand by ID
+   * Dodaje kontraindikaciju tehnologiji
+   * @param technologyId - ID tehnologije
+   * @param contraindication - Kontraindikacija koja se dodaje
+   * @returns Ažurirana tehnologija
    */
-  async getById(brandId) {
-    const docRef = doc5(this.getBrandsRef(), brandId);
-    const docSnap = await getDoc5(docRef);
-    if (!docSnap.exists()) return null;
-    return {
-      id: docSnap.id,
-      ...docSnap.data()
-    };
+  async addContraindication(technologyId, contraindication) {
+    const docRef = doc9(this.getTechnologiesRef(), technologyId);
+    await updateDoc9(docRef, {
+      contraindications: arrayUnion(contraindication),
+      updatedAt: /* @__PURE__ */ new Date()
+    });
+    return this.getById(technologyId);
   }
-};
-
-// src/backoffice/services/product.service.ts
-import {
-  addDoc as addDoc6,
-  collection as collection6,
-  doc as doc6,
-  getDoc as getDoc6,
-  getDocs as getDocs6,
-  query as query6,
-  updateDoc as updateDoc6,
-  where as where6
-} from "firebase/firestore";
-var ProductService = class extends BaseService {
   /**
-   * Gets reference to products collection under a technology
-   * @param technologyId - ID of the technology
-   * @returns Firestore collection reference
+   * Uklanja kontraindikaciju iz tehnologije
+   * @param technologyId - ID tehnologije
+   * @param contraindication - Kontraindikacija koja se uklanja
+   * @returns Ažurirana tehnologija
    */
-  getProductsRef(technologyId) {
-    return collection6(
-      this.db,
-      TECHNOLOGIES_COLLECTION,
-      technologyId,
-      PRODUCTS_COLLECTION
-    );
+  async removeContraindication(technologyId, contraindication) {
+    const docRef = doc9(this.getTechnologiesRef(), technologyId);
+    await updateDoc9(docRef, {
+      contraindications: arrayRemove(contraindication),
+      updatedAt: /* @__PURE__ */ new Date()
+    });
+    return this.getById(technologyId);
   }
   /**
-   * Creates a new product under technology
+   * Dodaje benefit tehnologiji
+   * @param technologyId - ID tehnologije
+   * @param benefit - Benefit koji se dodaje
+   * @returns Ažurirana tehnologija
    */
-  async create(technologyId, brandId, product) {
-    const now = /* @__PURE__ */ new Date();
-    const newProduct = {
-      ...product,
-      brandId,
-      technologyId,
-      createdAt: now,
-      updatedAt: now,
-      isActive: true
-    };
-    const productRef = await addDoc6(
-      this.getProductsRef(technologyId),
-      newProduct
-    );
-    return { id: productRef.id, ...newProduct };
+  async addBenefit(technologyId, benefit) {
+    const docRef = doc9(this.getTechnologiesRef(), technologyId);
+    await updateDoc9(docRef, {
+      benefits: arrayUnion(benefit),
+      updatedAt: /* @__PURE__ */ new Date()
+    });
+    return this.getById(technologyId);
   }
   /**
-   * Gets all products for a technology
+   * Uklanja benefit iz tehnologije
+   * @param technologyId - ID tehnologije
+   * @param benefit - Benefit koji se uklanja
+   * @returns Ažurirana tehnologija
    */
-  async getAllByTechnology(technologyId) {
-    const q = query6(
-      this.getProductsRef(technologyId),
-      where6("isActive", "==", true)
-    );
-    const snapshot = await getDocs6(q);
-    return snapshot.docs.map(
-      (doc10) => ({
-        id: doc10.id,
-        ...doc10.data()
-      })
-    );
+  async removeBenefit(technologyId, benefit) {
+    const docRef = doc9(this.getTechnologiesRef(), technologyId);
+    await updateDoc9(docRef, {
+      benefits: arrayRemove(benefit),
+      updatedAt: /* @__PURE__ */ new Date()
+    });
+    return this.getById(technologyId);
+  }
+  /**
+   * Vraća sve blokirajuće uslove za tehnologiju
+   * @param technologyId - ID tehnologije
+   * @returns Lista blokirajućih uslova
+   */
+  async getBlockingConditions(technologyId) {
+    const technology = await this.getById(technologyId);
+    return (technology == null ? void 0 : technology.blockingConditions) || [];
+  }
+  /**
+   * Vraća sve kontraindikacije za tehnologiju
+   * @param technologyId - ID tehnologije
+   * @returns Lista kontraindikacija
+   */
+  async getContraindications(technologyId) {
+    const technology = await this.getById(technologyId);
+    return (technology == null ? void 0 : technology.contraindications) || [];
   }
   /**
-   * Gets all products for a brand by filtering through all technologies
+   * Vraća sve benefite za tehnologiju
+   * @param technologyId - ID tehnologije
+   * @returns Lista benefita
    */
-  async getAllByBrand(brandId) {
-    const allTechnologiesRef = collection6(this.db, TECHNOLOGIES_COLLECTION);
-    const technologiesSnapshot = await getDocs6(allTechnologiesRef);
-    const products = [];
-    for (const techDoc of technologiesSnapshot.docs) {
-      const q = query6(
-        this.getProductsRef(techDoc.id),
-        where6("brandId", "==", brandId),
-        where6("isActive", "==", true)
-      );
-      const snapshot = await getDocs6(q);
-      products.push(
-        ...snapshot.docs.map(
-          (doc10) => ({
-            id: doc10.id,
-            ...doc10.data()
-          })
-        )
-      );
-    }
-    return products;
+  async getBenefits(technologyId) {
+    const technology = await this.getById(technologyId);
+    return (technology == null ? void 0 : technology.benefits) || [];
   }
   /**
-   * Updates a product
+   * Ažurira zahteve sertifikacije za tehnologiju
+   * @param technologyId - ID tehnologije
+   * @param certificationRequirement - Novi zahtevi sertifikacije
+   * @returns Ažurirana tehnologija
    */
-  async update(technologyId, productId, product) {
-    const updateData = {
-      ...product,
+  async updateCertificationRequirement(technologyId, certificationRequirement) {
+    const docRef = doc9(this.getTechnologiesRef(), technologyId);
+    await updateDoc9(docRef, {
+      certificationRequirement,
       updatedAt: /* @__PURE__ */ new Date()
-    };
-    const docRef = doc6(this.getProductsRef(technologyId), productId);
-    await updateDoc6(docRef, updateData);
-    return this.getById(technologyId, productId);
+    });
+    return this.getById(technologyId);
   }
   /**
-   * Soft deletes a product
+   * Vraća zahteve sertifikacije za tehnologiju
+   * @param technologyId - ID tehnologije
+   * @returns Zahtevi sertifikacije ili null ako tehnologija ne postoji
    */
-  async delete(technologyId, productId) {
-    await this.update(technologyId, productId, {
-      isActive: false
-    });
+  async getCertificationRequirement(technologyId) {
+    const technology = await this.getById(technologyId);
+    return (technology == null ? void 0 : technology.certificationRequirement) || null;
   }
   /**
-   * Gets a product by ID
+   * Proverava da li doktor ima odgovarajuću sertifikaciju za izvođenje tehnologije
+   *
+   * @param requiredCertification - Zahtevana sertifikacija za tehnologiju
+   * @param practitionerCertification - Sertifikacija zdravstvenog radnika
+   * @returns true ako zdravstveni radnik ima odgovarajuću sertifikaciju, false ako nema
+   *
+   * @example
+   * const isValid = technologyService.validateCertification(
+   *   {
+   *     minimumLevel: CertificationLevel.DOCTOR,
+   *     requiredSpecialties: [CertificationSpecialty.INJECTABLES]
+   *   },
+   *   {
+   *     level: CertificationLevel.SPECIALIST,
+   *     specialties: [CertificationSpecialty.INJECTABLES, CertificationSpecialty.LASER]
+   *   }
+   * );
    */
-  async getById(technologyId, productId) {
-    const docRef = doc6(this.getProductsRef(technologyId), productId);
-    const docSnap = await getDoc6(docRef);
-    if (!docSnap.exists()) return null;
+  validateCertification(requiredCertification, practitionerCertification) {
+    const doctorLevel = Object.values(CertificationLevel).indexOf(
+      practitionerCertification.level
+    );
+    const requiredLevel = Object.values(CertificationLevel).indexOf(
+      requiredCertification.minimumLevel
+    );
+    if (doctorLevel < requiredLevel) return false;
+    const requiredSpecialties = requiredCertification.requiredSpecialties || [];
+    if (requiredSpecialties.length > 0) {
+      const doctorSpecialties = practitionerCertification.specialties;
+      const hasAllRequiredSpecialties = requiredSpecialties.every(
+        (requiredSpecialty) => doctorSpecialties.includes(requiredSpecialty)
+      );
+      if (!hasAllRequiredSpecialties) return false;
+    }
+    return true;
+  }
+  /**
+   * Vraća sve tehnologije koje je zdravstveni radnik sertifikovan da izvodi
+   * zajedno sa listama dozvoljenih familija, kategorija i podkategorija
+   *
+   * @param practitioner - Profil zdravstvenog radnika
+   * @returns Objekat koji sadrži:
+   * - technologies: Lista tehnologija koje zdravstveni radnik može da izvodi
+   * - families: Lista familija procedura koje zdravstveni radnik može da izvodi
+   * - categories: Lista ID-eva kategorija koje zdravstveni radnik može da izvodi
+   * - subcategories: Lista ID-eva podkategorija koje zdravstveni radnik može da izvodi
+   *
+   * @example
+   * const practitioner = {
+   *   certification: {
+   *     level: CertificationLevel.DOCTOR,
+   *     specialties: [CertificationSpecialty.INJECTABLES]
+   *   }
+   * };
+   * const allowedTechnologies = await technologyService.getAllowedTechnologies(practitioner);
+   * console.log(allowedTechnologies.families); // [ProcedureFamily.AESTHETICS]
+   * console.log(allowedTechnologies.categories); // ["category1", "category2"]
+   * console.log(allowedTechnologies.subcategories); // ["subcategory1", "subcategory2"]
+   */
+  async getAllowedTechnologies(practitioner) {
+    const allTechnologies = await this.getAll();
+    const allowedTechnologies = allTechnologies.filter(
+      (technology) => this.validateCertification(
+        technology.certificationRequirement,
+        practitioner.certification
+      )
+    );
+    const families = [...new Set(allowedTechnologies.map((t) => t.family))];
+    const categories = [
+      ...new Set(allowedTechnologies.map((t) => t.categoryId))
+    ];
+    const subcategories = [
+      ...new Set(allowedTechnologies.map((t) => t.subcategoryId))
+    ];
     return {
-      id: docSnap.id,
-      ...docSnap.data()
+      technologies: allowedTechnologies,
+      families,
+      categories,
+      subcategories
     };
   }
 };
 
-// src/services/documentation-templates/documentation-template.service.ts
-import {
-  collection as collection7,
-  doc as doc7,
-  getDoc as getDoc7,
-  getDocs as getDocs7,
-  setDoc,
-  updateDoc as updateDoc7,
-  deleteDoc,
-  query as query7,
-  where as where7,
-  orderBy,
-  limit,
-  startAfter
-} from "firebase/firestore";
-var DocumentationTemplateService = class extends BaseService {
-  constructor() {
-    super(...arguments);
-    this.collectionRef = collection7(
-      this.db,
-      DOCUMENTATION_TEMPLATES_COLLECTION
-    );
+// src/backoffice/types/static/blocking-condition.types.ts
+var BlockingCondition = /* @__PURE__ */ ((BlockingCondition2) => {
+  BlockingCondition2["PREGNANCY"] = "pregnancy";
+  BlockingCondition2["BREASTFEEDING"] = "breastfeeding";
+  BlockingCondition2["ACTIVE_INFECTION"] = "active_infection";
+  BlockingCondition2["SKIN_CONDITION"] = "skin_condition";
+  BlockingCondition2["AUTOIMMUNE_DISEASE"] = "autoimmune_disease";
+  BlockingCondition2["BLOOD_THINNERS"] = "blood_thinners";
+  BlockingCondition2["RECENT_SURGERY"] = "recent_surgery";
+  BlockingCondition2["DIABETES"] = "diabetes";
+  BlockingCondition2["HEART_CONDITION"] = "heart_condition";
+  BlockingCondition2["HIGH_BLOOD_PRESSURE"] = "high_blood_pressure";
+  BlockingCondition2["KELOID_SCARRING"] = "keloid_scarring";
+  BlockingCondition2["METAL_IMPLANTS"] = "metal_implants";
+  BlockingCondition2["PACEMAKER"] = "pacemaker";
+  BlockingCondition2["CANCER"] = "cancer";
+  BlockingCondition2["EPILEPSY"] = "epilepsy";
+  return BlockingCondition2;
+})(BlockingCondition || {});
+
+// src/backoffice/types/static/contraindication.types.ts
+var Contraindication = /* @__PURE__ */ ((Contraindication2) => {
+  Contraindication2["SENSITIVE_SKIN"] = "sensitive_skin";
+  Contraindication2["RECENT_TANNING"] = "recent_tanning";
+  Contraindication2["RECENT_BOTOX"] = "recent_botox";
+  Contraindication2["RECENT_FILLERS"] = "recent_fillers";
+  Contraindication2["SKIN_ALLERGIES"] = "skin_allergies";
+  Contraindication2["MEDICATIONS"] = "medications";
+  Contraindication2["RECENT_CHEMICAL_PEEL"] = "recent_chemical_peel";
+  Contraindication2["RECENT_LASER"] = "recent_laser";
+  Contraindication2["SKIN_INFLAMMATION"] = "skin_inflammation";
+  Contraindication2["OPEN_WOUNDS"] = "open_wounds";
+  Contraindication2["HERPES_SIMPLEX"] = "herpes_simplex";
+  Contraindication2["COLD_SORES"] = "cold_sores";
+  return Contraindication2;
+})(Contraindication || {});
+
+// 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";
+  TreatmentBenefit2["SKIN_TIGHTENING"] = "skin_tightening";
+  TreatmentBenefit2["COLLAGEN_PRODUCTION"] = "collagen_production";
+  TreatmentBenefit2["ACNE_REDUCTION"] = "acne_reduction";
+  TreatmentBenefit2["SCAR_REDUCTION"] = "scar_reduction";
+  TreatmentBenefit2["PIGMENTATION_IMPROVEMENT"] = "pigmentation_improvement";
+  TreatmentBenefit2["HAIR_REMOVAL"] = "hair_removal";
+  TreatmentBenefit2["MUSCLE_TONING"] = "muscle_toning";
+  TreatmentBenefit2["FAT_REDUCTION"] = "fat_reduction";
+  TreatmentBenefit2["CELLULITE_REDUCTION"] = "cellulite_reduction";
+  TreatmentBenefit2["SKIN_REJUVENATION"] = "skin_rejuvenation";
+  TreatmentBenefit2["PORE_REDUCTION"] = "pore_reduction";
+  TreatmentBenefit2["TEXTURE_IMPROVEMENT"] = "texture_improvement";
+  TreatmentBenefit2["HYDRATION_BOOST"] = "hydration_boost";
+  TreatmentBenefit2["CIRCULATION_IMPROVEMENT"] = "circulation_improvement";
+  return TreatmentBenefit2;
+})(TreatmentBenefit || {});
+
+// src/backoffice/validations/schemas.ts
+import { z as z2 } from "zod";
+var blockingConditionSchema = z2.nativeEnum(BlockingCondition);
+var contraindicationSchema = z2.nativeEnum(Contraindication);
+var treatmentBenefitSchema = z2.nativeEnum(TreatmentBenefit);
+var procedureFamilySchema = z2.nativeEnum(ProcedureFamily);
+var timeUnitSchema = z2.nativeEnum(TimeUnit);
+var requirementTypeSchema = z2.nativeEnum(RequirementType);
+var certificationLevelSchema = z2.nativeEnum(CertificationLevel);
+var certificationSpecialtySchema = z2.nativeEnum(
+  CertificationSpecialty
+);
+var certificationRequirementSchema = z2.object({
+  minimumLevel: certificationLevelSchema,
+  requiredSpecialties: z2.array(certificationSpecialtySchema).max(5, "Maximum 5 specialties allowed").optional()
+});
+var timeframeSchema = z2.object({
+  duration: z2.number().min(1, "Duration must be positive"),
+  unit: timeUnitSchema,
+  notifyAt: z2.array(z2.number()).min(1, "At least one notification point is required")
+});
+var requirementSchema = z2.object({
+  name: z2.string().min(1, "Name is required").max(100, "Name is too long"),
+  description: z2.string().min(1, "Description is required"),
+  type: requirementTypeSchema,
+  timeframe: timeframeSchema,
+  importance: z2.enum(["low", "medium", "high"]),
+  isActive: z2.boolean().default(true)
+});
+var technologyRequirementsSchema = z2.object({
+  pre: z2.array(requirementSchema),
+  post: z2.array(requirementSchema)
+});
+var technologySchema = z2.object({
+  name: z2.string().min(1, "Name is required").max(100, "Name is too long"),
+  description: z2.string().max(1e3, "Description is too long").optional(),
+  technicalDetails: z2.string().max(2e3, "Technical details are too long").optional(),
+  family: procedureFamilySchema,
+  categoryId: z2.string().min(1, "Category ID is required"),
+  subcategoryId: z2.string().min(1, "Subcategory ID is required"),
+  requirements: technologyRequirementsSchema.default({
+    pre: [],
+    post: []
+  }),
+  blockingConditions: z2.array(blockingConditionSchema),
+  contraindications: z2.array(contraindicationSchema),
+  documentationTemplates: z2.array(documentTemplateSchema),
+  benefits: z2.array(treatmentBenefitSchema),
+  certificationRequirement: certificationRequirementSchema,
+  isActive: z2.boolean().default(true)
+});
+var categorySchema = z2.object({
+  name: z2.string().min(1, "Name is required").max(100, "Name is too long"),
+  description: z2.string().optional(),
+  family: procedureFamilySchema,
+  isActive: z2.boolean().default(true)
+});
+var subcategorySchema = z2.object({
+  name: z2.string().min(1, "Name is required").max(100, "Name is too long"),
+  description: z2.string().optional(),
+  categoryId: z2.string().min(1, "Category ID is required"),
+  isActive: z2.boolean().default(true)
+});
+var categoryUpdateSchema = categorySchema.partial();
+var subcategoryUpdateSchema = subcategorySchema.partial();
+var technologyUpdateSchema = technologySchema.partial();
+var requirementUpdateSchema = requirementSchema.partial();
+
+// src/backoffice/constants/certification.constants.ts
+var DEFAULT_CERTIFICATION_REQUIREMENT2 = {
+  minimumLevel: "aesthetician" /* AESTHETICIAN */,
+  requiredSpecialties: []
+};
+
+// src/backoffice/errors/backoffice.errors.ts
+var BackofficeError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "BackofficeError";
   }
-  /**
-   * Create a new document template
-   * @param data - Template data
-   * @param userId - ID of the user creating the template
-   * @returns The created template
-   */
-  async createTemplate(data, userId) {
-    const validatedData = createDocumentTemplateSchema.parse(data);
-    const templateId = this.generateId();
-    const elementsWithIds = validatedData.elements.map((element) => ({
-      ...element,
-      id: this.generateId()
-    }));
-    const now = Date.now();
-    const template = {
-      id: templateId,
-      title: validatedData.title,
-      description: validatedData.description,
-      elements: elementsWithIds,
-      createdAt: now,
-      updatedAt: now,
-      createdBy: userId,
-      version: 1,
-      isActive: true,
-      tags: validatedData.tags || [],
-      isUserForm: validatedData.isUserForm || false,
-      isRequired: validatedData.isRequired || false,
-      sortingOrder: validatedData.sortingOrder || 0
-    };
-    const docRef = doc7(this.collectionRef, templateId);
-    await setDoc(docRef, template);
-    return template;
+};
+var CategoryError = class extends BackofficeError {
+  constructor(message) {
+    super(message);
+    this.name = "CategoryError";
   }
-  /**
-   * Get a document template by ID
-   * @param templateId - ID of the template to retrieve
-   * @param version - Optional version number to retrieve (defaults to latest version)
-   * @returns The template or null if not found
-   */
-  async getTemplateById(templateId, version) {
-    const docRef = doc7(this.collectionRef, templateId);
-    const docSnap = await getDoc7(docRef);
-    if (!docSnap.exists()) {
-      return null;
-    }
-    const currentTemplate = docSnap.data();
-    if (version === void 0) {
-      return currentTemplate;
-    }
-    if (currentTemplate.version === version) {
-      return currentTemplate;
-    }
-    try {
-      const versionTemplate = await this.getTemplateVersion(
-        templateId,
-        version
-      );
-      if (versionTemplate) {
-        return versionTemplate;
-      }
-    } catch (error) {
-      console.error(`Error getting template version ${version}:`, error);
-    }
-    return null;
+};
+var CategoryNotFoundError = class extends CategoryError {
+  constructor(id) {
+    super(`Kategorija sa ID-em ${id} nije prona\u0111ena`);
+    this.name = "CategoryNotFoundError";
   }
-  /**
-   * Update an existing document template
-   * @param templateId - ID of the template to update
-   * @param data - Updated template data
-   * @returns The updated template
-   */
-  async updateTemplate(templateId, data) {
-    var _a, _b, _c;
-    const validatedData = updateDocumentTemplateSchema.parse(data);
-    console.log("Validated data", validatedData);
-    const template = await this.getTemplateById(templateId);
-    if (!template) {
-      throw new Error(`Template with ID ${templateId} not found`);
-    }
-    const versionsCollectionRef = collection7(
-      this.db,
-      `${DOCUMENTATION_TEMPLATES_COLLECTION}/${templateId}/versions`
-    );
-    const versionDocRef = doc7(
-      versionsCollectionRef,
-      template.version.toString()
-    );
-    await setDoc(versionDocRef, template);
-    let updatedElements = template.elements;
-    if (validatedData.elements) {
-      updatedElements = validatedData.elements.map((element) => ({
-        ...element,
-        id: element.id || this.generateId()
-      }));
-    }
-    const updatePayload = {
-      elements: updatedElements,
-      updatedAt: Date.now(),
-      version: template.version + 1
-    };
-    if (validatedData.title !== void 0)
-      updatePayload.title = validatedData.title;
-    if (validatedData.description !== void 0)
-      updatePayload.description = validatedData.description;
-    if (validatedData.isActive !== void 0)
-      updatePayload.isActive = validatedData.isActive;
-    if (validatedData.tags !== void 0)
-      updatePayload.tags = validatedData.tags;
-    updatePayload.isUserForm = (_a = validatedData.isUserForm) != null ? _a : false;
-    updatePayload.isRequired = (_b = validatedData.isRequired) != null ? _b : false;
-    updatePayload.sortingOrder = (_c = validatedData.sortingOrder) != null ? _c : 0;
-    const docRef = doc7(this.collectionRef, templateId);
-    console.log("Update payload", updatePayload);
-    await updateDoc7(docRef, updatePayload);
-    return { ...template, ...updatePayload };
+};
+var InvalidCategoryDataError = class extends CategoryError {
+  constructor(message) {
+    super(`Neva\u017Ee\u0107i podaci za kategoriju: ${message}`);
+    this.name = "InvalidCategoryDataError";
   }
-  /**
-   * Get a specific version of a template
-   * @param templateId - ID of the template
-   * @param versionNumber - Version number to retrieve
-   * @returns The template version or null if not found
-   */
-  async getTemplateVersion(templateId, versionNumber) {
-    const versionDocRef = doc7(
-      this.db,
-      `${DOCUMENTATION_TEMPLATES_COLLECTION}/${templateId}/versions/${versionNumber}`
-    );
-    const versionDocSnap = await getDoc7(versionDocRef);
-    if (!versionDocSnap.exists()) {
-      return null;
-    }
-    return versionDocSnap.data();
+};
+var SubcategoryError = class extends BackofficeError {
+  constructor(message) {
+    super(message);
+    this.name = "SubcategoryError";
   }
-  /**
-   * Get all versions of a template
-   * @param templateId - ID of the template
-   * @returns Array of template versions
-   */
-  async getTemplateOldVersions(templateId) {
-    const versionsCollectionRef = collection7(
-      this.db,
-      `${DOCUMENTATION_TEMPLATES_COLLECTION}/${templateId}/versions`
-    );
-    const q = query7(versionsCollectionRef, orderBy("version", "desc"));
-    const querySnapshot = await getDocs7(q);
-    const versions = [];
-    querySnapshot.forEach((doc10) => {
-      versions.push(doc10.data());
-    });
-    return versions;
+};
+var SubcategoryNotFoundError = class extends SubcategoryError {
+  constructor(id) {
+    super(`Podkategorija sa ID-em ${id} nije prona\u0111ena`);
+    this.name = "SubcategoryNotFoundError";
   }
-  /**
-   * Delete a document template
-   * @param templateId - ID of the template to delete
-   */
-  async deleteTemplate(templateId) {
-    const docRef = doc7(this.collectionRef, templateId);
-    await deleteDoc(docRef);
+};
+var InvalidSubcategoryDataError = class extends SubcategoryError {
+  constructor(message) {
+    super(`Neva\u017Ee\u0107i podaci za podkategoriju: ${message}`);
+    this.name = "InvalidSubcategoryDataError";
   }
-  /**
-   * Get all active templates
-   * @param pageSize - Number of templates to retrieve
-   * @param lastDoc - Last document from previous page for pagination
-   * @returns Array of templates and the last document for pagination
-   */
-  async getActiveTemplates(pageSize = 20, lastDoc) {
-    let q = query7(
-      this.collectionRef,
-      where7("isActive", "==", true),
-      orderBy("updatedAt", "desc"),
-      limit(pageSize)
-    );
-    if (lastDoc) {
-      q = query7(q, startAfter(lastDoc));
-    }
-    const querySnapshot = await getDocs7(q);
-    const templates = [];
-    let lastVisible = null;
-    querySnapshot.forEach((doc10) => {
-      templates.push(doc10.data());
-      lastVisible = doc10;
-    });
-    return {
-      templates,
-      lastDoc: lastVisible
-    };
+};
+var TechnologyError = class extends BackofficeError {
+  constructor(message) {
+    super(message);
+    this.name = "TechnologyError";
+  }
+};
+var TechnologyNotFoundError = class extends TechnologyError {
+  constructor(id) {
+    super(`Tehnologija sa ID-em ${id} nije prona\u0111ena`);
+    this.name = "TechnologyNotFoundError";
   }
-  /**
-   * Get templates by tags
-   * @param tags - Tags to filter by
-   * @param pageSize - Number of templates to retrieve
-   * @param lastDoc - Last document from previous page for pagination
-   * @returns Array of templates and the last document for pagination
-   */
-  async getTemplatesByTags(tags, pageSize = 20, lastDoc) {
-    let q = query7(
-      this.collectionRef,
-      where7("isActive", "==", true),
-      where7("tags", "array-contains-any", tags),
-      orderBy("updatedAt", "desc"),
-      limit(pageSize)
-    );
-    if (lastDoc) {
-      q = query7(q, startAfter(lastDoc));
-    }
-    const querySnapshot = await getDocs7(q);
-    const templates = [];
-    let lastVisible = null;
-    querySnapshot.forEach((doc10) => {
-      templates.push(doc10.data());
-      lastVisible = doc10;
-    });
-    return {
-      templates,
-      lastDoc: lastVisible
-    };
+};
+var InvalidTechnologyDataError = class extends TechnologyError {
+  constructor(message) {
+    super(`Neva\u017Ee\u0107i podaci za tehnologiju: ${message}`);
+    this.name = "InvalidTechnologyDataError";
   }
-  /**
-   * Get templates created by a specific user
-   * @param userId - ID of the user who created the templates
-   * @param pageSize - Number of templates to retrieve
-   * @param lastDoc - Last document from previous page for pagination
-   * @returns Array of templates and the last document for pagination
-   */
-  async getTemplatesByCreator(userId, pageSize = 20, lastDoc) {
-    let q = query7(
-      this.collectionRef,
-      where7("createdBy", "==", userId),
-      orderBy("updatedAt", "desc"),
-      limit(pageSize)
-    );
-    if (lastDoc) {
-      q = query7(q, startAfter(lastDoc));
-    }
-    const querySnapshot = await getDocs7(q);
-    const templates = [];
-    let lastVisible = null;
-    querySnapshot.forEach((doc10) => {
-      templates.push(doc10.data());
-      lastVisible = doc10;
-    });
-    return {
-      templates,
-      lastDoc: lastVisible
-    };
+};
+var RequirementError = class extends BackofficeError {
+  constructor(message) {
+    super(message);
+    this.name = "RequirementError";
   }
-  /**
-   * Get all templates for selection with optional filtering
-   * @param options - Filtering options
-   * @returns Array of templates
-   */
-  async getAllTemplatesForSelection(options) {
-    let q = query7(
-      this.collectionRef,
-      where7("isActive", "==", true),
-      orderBy("updatedAt", "desc")
-    );
-    if ((options == null ? void 0 : options.isUserForm) !== void 0) {
-      q = query7(q, where7("isUserForm", "==", options.isUserForm));
-    }
-    if ((options == null ? void 0 : options.isRequired) !== void 0) {
-      q = query7(q, where7("isRequired", "==", options.isRequired));
-    }
-    const querySnapshot = await getDocs7(q);
-    const templates = [];
-    querySnapshot.forEach((doc10) => {
-      templates.push(doc10.data());
-    });
-    return templates;
+};
+var RequirementNotFoundError = class extends RequirementError {
+  constructor(id) {
+    super(`Zahtev sa ID-em ${id} nije prona\u0111en`);
+    this.name = "RequirementNotFoundError";
   }
 };
-
-// src/services/documentation-templates/filled-document.service.ts
-import {
-  collection as collection9,
-  doc as doc9,
-  getDoc as getDoc9,
-  getDocs as getDocs9,
-  setDoc as setDoc3,
-  updateDoc as updateDoc9,
-  query as query9,
-  orderBy as orderBy3,
-  limit as limit3,
-  startAfter as startAfter2
-} from "firebase/firestore";
-
-// src/services/media/media.service.ts
-import { Timestamp as Timestamp2 } from "firebase/firestore";
-import {
-  ref,
-  uploadBytes,
-  getDownloadURL,
-  deleteObject,
-  getBytes
-} from "firebase/storage";
-import {
-  doc as doc8,
-  getDoc as getDoc8,
-  setDoc as setDoc2,
-  updateDoc as updateDoc8,
-  collection as collection8,
-  query as query8,
-  where as where8,
-  limit as limit2,
-  getDocs as getDocs8,
-  deleteDoc as deleteDoc2,
-  orderBy as orderBy2
-} from "firebase/firestore";
-
-// src/backoffice/services/documentation-template.service.ts
-var DocumentationTemplateService2 = class {
-  /**
-   * Constructor for DocumentationTemplateService
-   * @param db - Firestore instance
-   * @param auth - Firebase Auth instance
-   * @param app - Firebase App instance
-   */
-  constructor(db, auth, app) {
-    this.apiService = new DocumentationTemplateService(db, auth, app);
+var InvalidRequirementDataError = class extends RequirementError {
+  constructor(message) {
+    super(`Neva\u017Ee\u0107i podaci za zahtev: ${message}`);
+    this.name = "InvalidRequirementDataError";
   }
-  /**
-   * Create a new document template
-   * @param data - Template data
-   * @param userId - ID of the user creating the template
-   * @returns The created template
-   */
-  async createTemplate(data, userId) {
-    return this.apiService.createTemplate(data, userId);
+};
+var InvalidTimeframeError = class extends RequirementError {
+  constructor(message) {
+    super(`Invalid timeframe: ${message}`);
+    this.name = "InvalidTimeframeError";
   }
-  /**
-   * Get a document template by ID
-   * @param templateId - ID of the template to retrieve
-   * @param version - Optional version number to retrieve (defaults to latest version)
-   * @returns The template or null if not found
-   */
-  async getTemplateById(templateId, version) {
-    return this.apiService.getTemplateById(templateId, version);
+};
+var RelationshipError = class extends BackofficeError {
+  constructor(message) {
+    super(message);
+    this.name = "RelationshipError";
   }
-  /**
-   * Update an existing document template
-   * @param templateId - ID of the template to update
-   * @param data - Updated template data
-   * @returns The updated template
-   */
-  async updateTemplate(templateId, data) {
-    return this.apiService.updateTemplate(templateId, data);
+};
+var InvalidHierarchyError = class extends RelationshipError {
+  constructor(message) {
+    super(`Invalid hierarchy: ${message}`);
+    this.name = "InvalidHierarchyError";
   }
-  /**
-   * Delete a document template
-   * @param templateId - ID of the template to delete
-   */
-  async deleteTemplate(templateId) {
-    return this.apiService.deleteTemplate(templateId);
+};
+var CircularReferenceError = class extends RelationshipError {
+  constructor(message) {
+    super(`Circular reference detected: ${message}`);
+    this.name = "CircularReferenceError";
   }
-  /**
-   * Get all active templates
-   * @param pageSize - Number of templates to retrieve
-   * @param lastDoc - Last document from previous page for pagination
-   * @returns Array of templates and the last document for pagination
-   */
-  async getActiveTemplates(pageSize = 20, lastDoc) {
-    return this.apiService.getActiveTemplates(pageSize, lastDoc);
+};
+var BlockingConditionError = class extends BackofficeError {
+  constructor(message) {
+    super(message);
+    this.name = "BlockingConditionError";
   }
-  /**
-   * Get templates by tags
-   * @param tags - Tags to filter by
-   * @param pageSize - Number of templates to retrieve
-   * @param lastDoc - Last document from previous page for pagination
-   * @returns Array of templates and the last document for pagination
-   */
-  async getTemplatesByTags(tags, pageSize = 20, lastDoc) {
-    return this.apiService.getTemplatesByTags(tags, pageSize, lastDoc);
+};
+var InvalidBlockingConditionError = class extends BlockingConditionError {
+  constructor(condition) {
+    super(`Neva\u017Ee\u0107i blokiraju\u0107i uslov: ${condition}`);
+    this.name = "InvalidBlockingConditionError";
   }
-  /**
-   * Get templates created by a specific user
-   * @param userId - ID of the user who created the templates
-   * @param pageSize - Number of templates to retrieve
-   * @param lastDoc - Last document from previous page for pagination
-   * @returns Array of templates and the last document for pagination
-   */
-  async getTemplatesByCreator(userId, pageSize = 20, lastDoc) {
-    return this.apiService.getTemplatesByCreator(userId, pageSize, lastDoc);
+};
+var ContraindicationError = class extends BackofficeError {
+  constructor(message) {
+    super(message);
+    this.name = "ContraindicationError";
   }
-  /**
-   * Get a specific version of a template
-   * @param templateId - ID of the template
-   * @param versionNumber - Version number to retrieve
-   * @returns The template version or null if not found
-   */
-  async getTemplateVersion(templateId, versionNumber) {
-    return this.apiService.getTemplateVersion(templateId, versionNumber);
+};
+var InvalidContraindicationError = class extends ContraindicationError {
+  constructor(contraindication) {
+    super(`Neva\u017Ee\u0107a kontraindikacija: ${contraindication}`);
+    this.name = "InvalidContraindicationError";
   }
-  /**
-   * Get all versions of a template
-   * @param templateId - ID of the template
-   * @returns Array of template versions
-   */
-  async getTemplateVersions(templateId) {
-    return this.apiService.getTemplateOldVersions(templateId);
+};
+var TreatmentBenefitError = class extends BackofficeError {
+  constructor(message) {
+    super(message);
+    this.name = "TreatmentBenefitError";
+  }
+};
+var InvalidTreatmentBenefitError = class extends TreatmentBenefitError {
+  constructor(benefit) {
+    super(`Neva\u017Ee\u0107i benefit tretmana: ${benefit}`);
+    this.name = "InvalidTreatmentBenefitError";
   }
 };
 export {
@@ -1966,7 +1976,7 @@ export {
   CircularReferenceError,
   Contraindication,
   ContraindicationError,
-  DEFAULT_CERTIFICATION_REQUIREMENT,
+  DEFAULT_CERTIFICATION_REQUIREMENT2 as DEFAULT_CERTIFICATION_REQUIREMENT,
   DocumentElementType,
   DocumentationTemplateService2 as DocumentationTemplateService,
   DynamicVariable,