@blackcode_sa/metaestetics-api 1.11.2 → 1.12.0

package/dist/backoffice/index.d.ts

@@ -1,5 +1,6 @@
+import * as _firebase_firestore from '@firebase/firestore';
+import { Firestore, DocumentData, Timestamp, QueryDocumentSnapshot } from 'firebase/firestore';
 import { Auth } from 'firebase/auth';
-import { Firestore, QueryDocumentSnapshot, Timestamp } from 'firebase/firestore';
 import { FirebaseApp } from 'firebase/app';
 import { FirebaseStorage } from 'firebase/storage';
 import { z } from 'zod';
@@ -20,6 +21,7 @@ import { z } from 'zod';
 interface Brand {
     id?: string;
     name: string;
+    name_lowercase: string;
     manufacturer: string;
     createdAt: Date;
     updatedAt: Date;
@@ -37,7 +39,7 @@ declare class BaseService {
     protected auth: Auth;
     protected app: FirebaseApp;
     protected storage: FirebaseStorage;
-    constructor(db: Firestore, auth: Auth, app: FirebaseApp);
+    constructor(db: Firestore, auth: Auth, app: FirebaseApp, storage?: FirebaseStorage);
     /**
      * Generiše jedinstveni ID za dokumente
      * Format: xxxxxxxxxxxx-timestamp
@@ -54,9 +56,10 @@ declare class BrandService extends BaseService {
     /**
      * Creates a new brand
      */
-    create(brand: Omit<Brand, "id" | "createdAt" | "updatedAt">): Promise<{
+    create(brand: Omit<Brand, "id" | "createdAt" | "updatedAt" | "name_lowercase">): Promise<{
         createdAt: Date;
         updatedAt: Date;
+        name_lowercase: string;
         name: string;
         manufacturer: string;
         isActive: boolean;
@@ -65,13 +68,28 @@ declare class BrandService extends BaseService {
         id: string;
     }>;
     /**
-     * Gets all active brands
+     * Gets a paginated list of active brands, optionally filtered by name.
+     * @param rowsPerPage - The number of brands to fetch.
+     * @param searchTerm - An optional string to filter brand names by (starts-with search).
+     * @param lastVisible - An optional document snapshot to use as a cursor for pagination.
      */
-    getAll(): Promise<Brand[]>;
+    getAll(rowsPerPage: number, searchTerm?: string, lastVisible?: any): Promise<{
+        brands: Brand[];
+        lastVisible: _firebase_firestore.QueryDocumentSnapshot<DocumentData, DocumentData>;
+    }>;
+    /**
+     * Gets the total count of active brands, optionally filtered by name.
+     * @param searchTerm - An optional string to filter brand names by (starts-with search).
+     */
+    getBrandsCount(searchTerm?: string): Promise<number>;
+    /**
+     * Gets all active brands for filter dropdowns (not paginated).
+     */
+    getAllForFilter(): Promise<Brand[]>;
     /**
      * Updates a brand
      */
-    update(brandId: string, brand: Partial<Omit<Brand, "id" | "createdAt">>): Promise<Brand | null>;
+    update(brandId: string, brand: Partial<Omit<Brand, "id" | "createdAt" | "name_lowercase">>): Promise<Brand | null>;
     /**
      * Soft deletes a brand
      */
@@ -164,16 +182,43 @@ declare class CategoryService extends BaseService {
         id: string;
     }>;
     /**
-     * Vraća sve aktivne kategorije
-     * @returns Lista aktivnih kategorija
+     * Returns counts of categories for each family.
+     * @param active - Whether to count active or inactive categories.
+     * @returns A record mapping family to category count.
+     */
+    getCategoryCounts(active?: boolean): Promise<Record<string, number>>;
+    /**
+     * Vraća sve kategorije za potrebe filtera (bez paginacije)
+     * @returns Lista svih aktivnih kategorija
+     */
+    getAllForFilter(): Promise<Category[]>;
+    /**
+     * Vraća sve kategorije sa paginacijom
+     * @param options - Pagination and filter options
+     * @returns Lista kategorija i poslednji vidljiv dokument
      */
-    getAll(): Promise<Category[]>;
+    getAll(options?: {
+        active?: boolean;
+        limit?: number;
+        lastVisible?: DocumentData;
+    }): Promise<{
+        categories: Category[];
+        lastVisible: _firebase_firestore.QueryDocumentSnapshot<DocumentData, DocumentData>;
+    }>;
     /**
-     * Vraća sve aktivne kategorije za određenu familiju procedura
+     * Vraća sve aktivne kategorije za određenu familiju procedura sa paginacijom
      * @param family - Familija procedura (aesthetics/surgery)
+     * @param options - Pagination options
      * @returns Lista kategorija koje pripadaju traženoj familiji
      */
-    getAllByFamily(family: ProcedureFamily): Promise<Category[]>;
+    getAllByFamily(family: ProcedureFamily, options?: {
+        active?: boolean;
+        limit?: number;
+        lastVisible?: DocumentData;
+    }): Promise<{
+        categories: Category[];
+        lastVisible: _firebase_firestore.QueryDocumentSnapshot<DocumentData, DocumentData>;
+    }>;
     /**
      * Ažurira postojeću kategoriju
      * @param id - ID kategorije koja se ažurira
@@ -186,6 +231,11 @@ declare class CategoryService extends BaseService {
      * @param id - ID kategorije koja se briše
      */
     delete(id: string): Promise<void>;
+    /**
+     * Reactivates a category by setting its isActive flag to true.
+     * @param id - The ID of the category to reactivate.
+     */
+    reactivate(id: string): Promise<void>;
     /**
      * Vraća kategoriju po ID-u
      * @param id - ID tražene kategorije
@@ -194,6 +244,83 @@ declare class CategoryService extends BaseService {
     getById(id: string): Promise<Category | null>;
 }
 
+/**
+ * Condensed practitioner review information
+ * @description Used for aggregated data attached to practitioner documents
+ */
+interface PractitionerReviewInfo {
+    totalReviews: number;
+    averageRating: number;
+    knowledgeAndExpertise: number;
+    communicationSkills: number;
+    bedSideManner: number;
+    thoroughness: number;
+    trustworthiness: number;
+    recommendationPercentage: number;
+}
+
+/**
+ * @file Defines types for dynamically managed administrative constants,
+ * such as treatment benefits and contraindications. These are stored in
+ * the 'admin-constants' collection in Firestore.
+ */
+/**
+ * Represents a single dynamic treatment benefit.
+ * These are positive effects or results a patient can expect from a treatment.
+ */
+interface TreatmentBenefitDynamic {
+    /**
+     * A unique identifier for the benefit, typically in snake_case.
+     * @example "wrinkle_reduction"
+     */
+    id: string;
+    /**
+     * A human-readable name for the treatment benefit.
+     * @example "Wrinkle Reduction"
+     */
+    name: string;
+    /**
+     * A detailed description of the benefit.
+     */
+    description?: string;
+}
+/**
+ * Defines the structure of the document storing all treatment benefits
+ * in the 'admin-constants' collection.
+ * The document ID for this type should be 'treatment-benefits'.
+ */
+interface TreatmentBenefitsDocument {
+    benefits: TreatmentBenefitDynamic[];
+}
+/**
+ * Represents a single dynamic contraindication.
+ * These are conditions or factors that can affect a procedure and require special attention.
+ */
+interface ContraindicationDynamic {
+    /**
+     * A unique identifier for the contraindication, typically in snake_case.
+     * @example "sensitive_skin"
+     */
+    id: string;
+    /**
+     * A human-readable name for the contraindication.
+     * @example "Sensitive Skin"
+     */
+    name: string;
+    /**
+     * A detailed description of the contraindication.
+     */
+    description?: string;
+}
+/**
+ * Defines the structure of the document storing all contraindications
+ * in the 'admin-constants' collection.
+ * The document ID for this type should be 'contraindications'.
+ */
+interface ContraindicationsDocument {
+    contraindications: ContraindicationDynamic[];
+}
+
 /**
  * Types for the Medical Documentation Templating System
  */
@@ -413,91 +540,6 @@ interface UpdateDocumentTemplateData {
     sortingOrder?: number;
 }
 
-/**
- * Service for managing documentation templates in the backoffice
- */
-declare class DocumentationTemplateServiceBackoffice {
-    private apiService;
-    /**
-     * Constructor for DocumentationTemplateService
-     * @param db - Firestore instance
-     * @param auth - Firebase Auth instance
-     * @param app - Firebase App instance
-     */
-    constructor(db: Firestore, auth: Auth, app: FirebaseApp);
-    /**
-     * Create a new document template
-     * @param data - Template data
-     * @param userId - ID of the user creating the template
-     * @returns The created template
-     */
-    createTemplate(data: CreateDocumentTemplateData, userId: string): Promise<DocumentTemplate>;
-    /**
-     * 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
-     */
-    getTemplateById(templateId: string, version?: number): Promise<DocumentTemplate | null>;
-    /**
-     * Update an existing document template
-     * @param templateId - ID of the template to update
-     * @param data - Updated template data
-     * @returns The updated template
-     */
-    updateTemplate(templateId: string, data: UpdateDocumentTemplateData): Promise<DocumentTemplate>;
-    /**
-     * Delete a document template
-     * @param templateId - ID of the template to delete
-     */
-    deleteTemplate(templateId: string): Promise<void>;
-    /**
-     * 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
-     */
-    getActiveTemplates(pageSize?: number, lastDoc?: QueryDocumentSnapshot<DocumentTemplate>): Promise<{
-        templates: DocumentTemplate[];
-        lastDoc: QueryDocumentSnapshot<DocumentTemplate> | null;
-    }>;
-    /**
-     * 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
-     */
-    getTemplatesByTags(tags: string[], pageSize?: number, lastDoc?: QueryDocumentSnapshot<DocumentTemplate>): Promise<{
-        templates: DocumentTemplate[];
-        lastDoc: QueryDocumentSnapshot<DocumentTemplate> | null;
-    }>;
-    /**
-     * 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
-     */
-    getTemplatesByCreator(userId: string, pageSize?: number, lastDoc?: QueryDocumentSnapshot<DocumentTemplate>): Promise<{
-        templates: DocumentTemplate[];
-        lastDoc: QueryDocumentSnapshot<DocumentTemplate> | null;
-    }>;
-    /**
-     * 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
-     */
-    getTemplateVersion(templateId: string, versionNumber: number): Promise<DocumentTemplate | null>;
-    /**
-     * Get all versions of a template
-     * @param templateId - ID of the template
-     * @returns Array of template versions
-     */
-    getTemplateVersions(templateId: string): Promise<DocumentTemplate[]>;
-}
-
 /**
  * Product used in procedures
  * Can be consumables, equipment, or any other product needed for performing procedures
@@ -524,6 +566,8 @@ interface Product {
     brandName: string;
     technologyId: string;
     technologyName: string;
+    categoryId: string;
+    subcategoryId: string;
     createdAt: Date;
     updatedAt: Date;
     isActive: boolean;
@@ -533,7 +577,7 @@ interface Product {
     dosage?: string;
     composition?: string;
     indications?: string[];
-    contraindications?: string[];
+    contraindications?: ContraindicationDynamic[];
 }
 /**
  * Collection in Firestore database where products are stored
@@ -551,10 +595,34 @@ interface IProductService {
      */
     create(technologyId: string, brandId: string, product: Omit<Product, "id" | "createdAt" | "updatedAt" | "brandId" | "technologyId">): Promise<Product>;
     /**
-     * Gets all products for a technology
-     * @param technologyId - ID of the technology
+     * Gets a paginated list of all products, with optional filters.
+     */
+    getAll(options: {
+        rowsPerPage: number;
+        lastVisible?: any;
+        categoryId?: string;
+        subcategoryId?: string;
+        technologyId?: string;
+    }): Promise<{
+        products: Product[];
+        lastVisible: any;
+    }>;
+    /**
+     * Gets the total count of active products, with optional filters.
+     */
+    getProductsCount(options: {
+        categoryId?: string;
+        subcategoryId?: string;
+        technologyId?: string;
+    }): Promise<number>;
+    /**
+     * Gets counts of active products grouped by category, subcategory, and technology.
      */
-    getAllByTechnology(technologyId: string): Promise<Product[]>;
+    getProductCounts(): Promise<{
+        byCategory: Record<string, number>;
+        bySubcategory: Record<string, number>;
+        byTechnology: Record<string, number>;
+    }>;
     /**
      * Gets all products for a brand
      * @param brandId - ID of the brand
@@ -581,39 +649,6 @@ interface IProductService {
     getById(technologyId: string, productId: string): Promise<Product | null>;
 }
 
-declare class ProductService extends BaseService implements IProductService {
-    /**
-     * Gets reference to products collection under a technology
-     * @param technologyId - ID of the technology
-     * @returns Firestore collection reference
-     */
-    private getProductsRef;
-    /**
-     * Creates a new product under technology
-     */
-    create(technologyId: string, brandId: string, product: Omit<Product, "id" | "createdAt" | "updatedAt" | "brandId" | "technologyId">): Promise<Product>;
-    /**
-     * Gets all products for a technology
-     */
-    getAllByTechnology(technologyId: string): Promise<Product[]>;
-    /**
-     * Gets all products for a brand by filtering through all technologies
-     */
-    getAllByBrand(brandId: string): Promise<Product[]>;
-    /**
-     * Updates a product
-     */
-    update(technologyId: string, productId: string, product: Partial<Omit<Product, "id" | "createdAt" | "brandId" | "technologyId">>): Promise<Product | null>;
-    /**
-     * Soft deletes a product
-     */
-    delete(technologyId: string, productId: string): Promise<void>;
-    /**
-     * Gets a product by ID
-     */
-    getById(technologyId: string, productId: string): Promise<Product | null>;
-}
-
 /**
  * Jedinica mere za vremenski period
  */
@@ -674,90 +709,17 @@ interface Requirement {
 declare const REQUIREMENTS_COLLECTION = "backoffice_requirements";
 
 /**
- * Servis za upravljanje globalnim zahtevima.
- * Zahtevi se mogu kreirati globalno i zatim povezati sa različitim tehnologijama.
- * Ovo omogućava ponovno korišćenje istih zahteva za različite tehnologije.
- *
- * @example
- * const requirementService = new RequirementService();
+ * Podkategorija procedura
+ * Podkategorije su drugi nivo hijerarhije i pripadaju određenoj kategoriji
+ * One grupišu slične tehnologije u okviru kategorije
  *
- * // Kreiranje globalnog zahteva
- * const requirement = await requirementService.create({
- *   type: "pre",
- *   name: "Stay Hydrated",
- *   description: "Drink plenty of water",
- *   timeframe: {
- *     duration: 2,
- *     unit: "hours",
- *     notifyAt: [2, 1]
- *   },
- *   importance: "high"
- * });
- */
-declare class RequirementService extends BaseService {
-    /**
-     * Referenca na Firestore kolekciju zahteva
-     */
-    private get requirementsRef();
-    /**
-     * Kreira novi globalni zahtev
-     * @param requirement - Podaci za novi zahtev
-     * @returns Kreirani zahtev sa generisanim ID-em
-     */
-    create(requirement: Omit<Requirement, "id" | "createdAt" | "updatedAt">): Promise<{
-        createdAt: Date;
-        updatedAt: Date;
-        name: string;
-        isActive: boolean;
-        description: string;
-        type: RequirementType;
-        timeframe: TimeFrame;
-        importance: RequirementImportance;
-        id: string;
-    }>;
-    /**
-     * Vraća sve aktivne zahteve
-     * @returns Lista aktivnih zahteva
-     */
-    getAll(): Promise<Requirement[]>;
-    /**
-     * Vraća sve aktivne zahteve određenog tipa
-     * @param type - Tip zahteva (pre/post)
-     * @returns Lista zahteva određenog tipa
-     */
-    getAllByType(type: RequirementType): Promise<Requirement[]>;
-    /**
-     * Ažurira postojeći zahtev
-     * @param id - ID zahteva koji se ažurira
-     * @param requirement - Novi podaci za zahtev
-     * @returns Ažurirani zahtev
-     */
-    update(id: string, requirement: Partial<Omit<Requirement, "id" | "createdAt">>): Promise<Requirement | null>;
-    /**
-     * Soft delete zahteva (postavlja isActive na false)
-     * @param id - ID zahteva koji se briše
-     */
-    delete(id: string): Promise<void>;
-    /**
-     * Vraća zahtev po ID-u
-     * @param id - ID traženog zahteva
-     * @returns Zahtev ili null ako ne postoji
-     */
-    getById(id: string): Promise<Requirement | null>;
-}
-
-/**
- * Podkategorija procedura
- * Podkategorije su drugi nivo hijerarhije i pripadaju određenoj kategoriji
- * One grupišu slične tehnologije u okviru kategorije
- *
- * @property id - Jedinstveni identifikator podkategorije
- * @property name - Naziv podkategorije
- * @property description - Detaljan opis podkategorije i njene namene
- * @property categoryId - ID kategorije kojoj podkategorija pripada
- * @property isActive - Da li je podkategorija aktivna u sistemu
- * @property createdAt - Datum kreiranja
- * @property updatedAt - Datum poslednjeg ažuriranja
+ * @property id - Jedinstveni identifikator podkategorije
+ * @property name - Naziv podkategorije
+ * @property description - Detaljan opis podkategorije i njene namene
+ * @property categoryId - ID kategorije kojoj podkategorija pripada
+ * @property isActive - Da li je podkategorija aktivna u sistemu
+ * @property createdAt - Datum kreiranja
+ * @property updatedAt - Datum poslednjeg ažuriranja
  */
 interface Subcategory {
     /** Jedinstveni identifikator podkategorije (automatski generisan od strane Firestore) */
@@ -780,69 +742,6 @@ interface Subcategory {
  */
 declare const SUBCATEGORIES_COLLECTION = "subcategories";
 
-/**
- * Servis za upravljanje podkategorijama procedura.
- * Podkategorije su drugi nivo organizacije i pripadaju određenoj kategoriji.
- *
- * @example
- * const subcategoryService = new SubcategoryService();
- *
- * // Kreiranje nove podkategorije
- * const subcategory = await subcategoryService.create(categoryId, {
- *   name: "Anti-Wrinkle",
- *   description: "Treatments targeting facial wrinkles"
- * });
- */
-declare class SubcategoryService extends BaseService {
-    /**
-     * Vraća referencu na Firestore kolekciju podkategorija za određenu kategoriju
-     * @param categoryId - ID roditeljske kategorije
-     */
-    private getSubcategoriesRef;
-    /**
-     * 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
-     */
-    create(categoryId: string, subcategory: Omit<Subcategory, "id" | "createdAt" | "updatedAt">): Promise<{
-        createdAt: Date;
-        updatedAt: Date;
-        name: string;
-        isActive: boolean;
-        description?: string | undefined;
-        categoryId: string;
-        id: string;
-    }>;
-    /**
-     * Vraća sve aktivne podkategorije za određenu kategoriju
-     * @param categoryId - ID kategorije čije podkategorije tražimo
-     * @returns Lista aktivnih podkategorija
-     */
-    getAllByCategoryId(categoryId: string): Promise<Subcategory[]>;
-    /**
-     * 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
-     */
-    update(categoryId: string, subcategoryId: string, subcategory: Partial<Omit<Subcategory, "id" | "createdAt" | "categoryId">>): Promise<Subcategory | null>;
-    /**
-     * Soft delete podkategorije (postavlja isActive na false)
-     * @param categoryId - ID kategorije kojoj pripada podkategorija
-     * @param subcategoryId - ID podkategorije koja se briše
-     */
-    delete(categoryId: string, subcategoryId: string): Promise<void>;
-    /**
-     * 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
-     */
-    getById(categoryId: string, subcategoryId: string): Promise<Subcategory | null>;
-}
-
 /**
  * Blokirajući uslovi koji mogu sprečiti proceduru
  * Ovi uslovi predstavljaju apsolutne kontraindikacije koje onemogućavaju izvođenje procedure
@@ -865,47 +764,6 @@ declare enum BlockingCondition {
     EPILEPSY = "epilepsy"
 }
 
-/**
- * Kontraindikacije koje mogu uticati na proceduru
- * Ovi uslovi predstavljaju relativne kontraindikacije koje zahtevaju posebnu pažnju
- */
-declare enum Contraindication {
-    SENSITIVE_SKIN = "sensitive_skin",
-    RECENT_TANNING = "recent_tanning",
-    RECENT_BOTOX = "recent_botox",
-    RECENT_FILLERS = "recent_fillers",
-    SKIN_ALLERGIES = "skin_allergies",
-    MEDICATIONS = "medications",
-    RECENT_CHEMICAL_PEEL = "recent_chemical_peel",
-    RECENT_LASER = "recent_laser",
-    SKIN_INFLAMMATION = "skin_inflammation",
-    OPEN_WOUNDS = "open_wounds",
-    HERPES_SIMPLEX = "herpes_simplex",
-    COLD_SORES = "cold_sores"
-}
-
-/**
- * Benefiti koji se mogu očekivati od procedure
- * Lista mogućih pozitivnih efekata i rezultata tretmana
- */
-declare enum TreatmentBenefit {
-    WRINKLE_REDUCTION = "wrinkle_reduction",
-    SKIN_TIGHTENING = "skin_tightening",
-    COLLAGEN_PRODUCTION = "collagen_production",
-    ACNE_REDUCTION = "acne_reduction",
-    SCAR_REDUCTION = "scar_reduction",
-    PIGMENTATION_IMPROVEMENT = "pigmentation_improvement",
-    HAIR_REMOVAL = "hair_removal",
-    MUSCLE_TONING = "muscle_toning",
-    FAT_REDUCTION = "fat_reduction",
-    CELLULITE_REDUCTION = "cellulite_reduction",
-    SKIN_REJUVENATION = "skin_rejuvenation",
-    PORE_REDUCTION = "pore_reduction",
-    TEXTURE_IMPROVEMENT = "texture_improvement",
-    HYDRATION_BOOST = "hydration_boost",
-    CIRCULATION_IMPROVEMENT = "circulation_improvement"
-}
-
 /**
  * Nivoi sertifikacije medicinskog osoblja, poređani od najnižeg do najvišeg
  */
@@ -999,8 +857,8 @@ interface Technology {
         post: Requirement[];
     };
     blockingConditions: BlockingCondition[];
-    contraindications: Contraindication[];
-    benefits: TreatmentBenefit[];
+    contraindications: ContraindicationDynamic[];
+    benefits: TreatmentBenefitDynamic[];
     certificationRequirement: CertificationRequirement;
     documentationTemplates?: TechnologyDocumentationTemplate[];
     isActive: boolean;
@@ -1011,20 +869,87 @@ interface Technology {
  * Collection in Firestore database where technologies are stored
  */
 declare const TECHNOLOGIES_COLLECTION = "technologies";
+/**
+ * Interface for the TechnologyService class
+ */
+interface ITechnologyService {
+    create(technology: Omit<Technology, "id" | "createdAt" | "updatedAt">): Promise<Technology>;
+    getTechnologyCounts(active?: boolean): Promise<Record<string, number>>;
+    getTechnologyCountsByCategory(active?: boolean): Promise<Record<string, number>>;
+    getAll(options?: {
+        active?: boolean;
+        limit?: number;
+        lastVisible?: any;
+    }): Promise<{
+        technologies: Technology[];
+        lastVisible: any;
+    }>;
+    getAllByCategoryId(categoryId: string, options?: {
+        active?: boolean;
+        limit?: number;
+        lastVisible?: any;
+    }): Promise<{
+        technologies: Technology[];
+        lastVisible: any;
+    }>;
+    getAllBySubcategoryId(subcategoryId: string, options?: {
+        active?: boolean;
+        limit?: number;
+        lastVisible?: any;
+    }): Promise<{
+        technologies: Technology[];
+        lastVisible: any;
+    }>;
+    update(id: string, technology: Partial<Omit<Technology, "id" | "createdAt">>): Promise<Technology | null>;
+    delete(id: string): Promise<void>;
+    reactivate(id: string): Promise<void>;
+    getById(id: string): Promise<Technology | null>;
+    addRequirement(technologyId: string, requirement: Requirement): Promise<Technology | null>;
+    removeRequirement(technologyId: string, requirement: Requirement): Promise<Technology | null>;
+    getRequirements(technologyId: string, type?: "pre" | "post"): Promise<Requirement[]>;
+    updateRequirement(technologyId: string, oldRequirement: Requirement, newRequirement: Requirement): Promise<Technology | null>;
+    addBlockingCondition(technologyId: string, condition: BlockingCondition): Promise<Technology | null>;
+    removeBlockingCondition(technologyId: string, condition: BlockingCondition): Promise<Technology | null>;
+    addContraindication(technologyId: string, contraindication: ContraindicationDynamic): Promise<Technology | null>;
+    removeContraindication(technologyId: string, contraindication: ContraindicationDynamic): Promise<Technology | null>;
+    updateContraindication(technologyId: string, contraindication: ContraindicationDynamic): Promise<Technology | null>;
+    addBenefit(technologyId: string, benefit: TreatmentBenefitDynamic): Promise<Technology | null>;
+    removeBenefit(technologyId: string, benefit: TreatmentBenefitDynamic): Promise<Technology | null>;
+    updateBenefit(technologyId: string, benefit: TreatmentBenefitDynamic): Promise<Technology | null>;
+    getBlockingConditions(technologyId: string): Promise<BlockingCondition[]>;
+    getContraindications(technologyId: string): Promise<ContraindicationDynamic[]>;
+    getBenefits(technologyId: string): Promise<TreatmentBenefitDynamic[]>;
+    updateCertificationRequirement(technologyId: string, certificationRequirement: CertificationRequirement): Promise<Technology | null>;
+    getCertificationRequirement(technologyId: string): Promise<CertificationRequirement | null>;
+    validateCertification(requiredCertification: CertificationRequirement, practitionerCertification: any): boolean;
+    getAllowedTechnologies(practitioner: any): Promise<{
+        technologies: Technology[];
+        families: ProcedureFamily[];
+        categories: string[];
+        subcategories: string[];
+    }>;
+    getAllForFilterBySubcategoryId(categoryId: string, subcategoryId: string): Promise<Technology[]>;
+    getAllForFilter(): Promise<Technology[]>;
+}
 
 /**
- * Condensed practitioner review information
- * @description Used for aggregated data attached to practitioner documents
+ * @deprecated
+ * Kontraindikacije koje mogu uticati na proceduru
+ * Ovi uslovi predstavljaju relativne kontraindikacije koje zahtevaju posebnu pažnju
  */
-interface PractitionerReviewInfo {
-    totalReviews: number;
-    averageRating: number;
-    knowledgeAndExpertise: number;
-    communicationSkills: number;
-    bedSideManner: number;
-    thoroughness: number;
-    trustworthiness: number;
-    recommendationPercentage: number;
+declare enum Contraindication {
+    SENSITIVE_SKIN = "sensitive_skin",
+    RECENT_TANNING = "recent_tanning",
+    RECENT_BOTOX = "recent_botox",
+    RECENT_FILLERS = "recent_fillers",
+    SKIN_ALLERGIES = "skin_allergies",
+    MEDICATIONS = "medications",
+    RECENT_CHEMICAL_PEEL = "recent_chemical_peel",
+    RECENT_LASER = "recent_laser",
+    SKIN_INFLAMMATION = "skin_inflammation",
+    OPEN_WOUNDS = "open_wounds",
+    HERPES_SIMPLEX = "herpes_simplex",
+    COLD_SORES = "cold_sores"
 }
 
 declare enum PricingMeasure {
@@ -1043,6 +968,29 @@ declare enum Currency {
     AUD = "AUD"
 }
 
+/**
+ * @deprecated
+ * Benefiti koji se mogu očekivati od procedure
+ * Lista mogućih pozitivnih efekata i rezultata tretmana
+ */
+declare enum TreatmentBenefit {
+    WRINKLE_REDUCTION = "wrinkle_reduction",
+    SKIN_TIGHTENING = "skin_tightening",
+    COLLAGEN_PRODUCTION = "collagen_production",
+    ACNE_REDUCTION = "acne_reduction",
+    SCAR_REDUCTION = "scar_reduction",
+    PIGMENTATION_IMPROVEMENT = "pigmentation_improvement",
+    HAIR_REMOVAL = "hair_removal",
+    MUSCLE_TONING = "muscle_toning",
+    FAT_REDUCTION = "fat_reduction",
+    CELLULITE_REDUCTION = "cellulite_reduction",
+    SKIN_REJUVENATION = "skin_rejuvenation",
+    PORE_REDUCTION = "pore_reduction",
+    TEXTURE_IMPROVEMENT = "texture_improvement",
+    HYDRATION_BOOST = "hydration_boost",
+    CIRCULATION_IMPROVEMENT = "circulation_improvement"
+}
+
 /**
  * Type that allows a field to be either a URL string or a File object
  */
@@ -1096,18 +1044,6 @@ interface ClinicLocation {
     tz?: string | null;
 }
 
-/**
- * Interface for clinic profile information
- */
-interface ClinicInfo {
-    id: string;
-    featuredPhoto: string;
-    name: string;
-    description?: string | null;
-    location: ClinicLocation;
-    contactInfo: ClinicContactInfo;
-}
-
 /**
  * Osnovne informacije o zdravstvenom radniku
  */
@@ -1205,38 +1141,520 @@ interface Practitioner {
 }
 
 /**
- * Servis za upravljanje tehnologijama i njihovim zahtevima.
- * Tehnologije su sada top-level kolekcija koja referencira svoju putanju u hijerarhiji
- * kroz family, categoryId i subcategoryId.
- *
- * @example
- * const technologyService = new TechnologyService();
- *
- * // Kreiranje nove tehnologije
- * const technology = await technologyService.create({
- *   name: "Botulinum Toxin",
- *   description: "Neurotoxin injections for wrinkle reduction",
- *   family: ProcedureFamily.AESTHETICS,
- *   categoryId: "category123",
- *   subcategoryId: "subcategory456"
- * });
- *
- * // Dodavanje zahteva
- * await technologyService.addRequirement(technology.id, {
- *   type: "pre",
- *   name: "Stay Hydrated",
- *   description: "Drink plenty of water"
- * });
+ * Interface for clinic profile information
+ */
+interface ClinicInfo {
+    id: string;
+    featuredPhoto: string;
+    name: string;
+    description?: string | null;
+    location: ClinicLocation;
+    contactInfo: ClinicContactInfo;
+}
+
+/**
+ * Service for managing documentation templates
+ */
+declare class DocumentationTemplateService extends BaseService {
+    private readonly collectionRef;
+    constructor(...args: ConstructorParameters<typeof BaseService>);
+    /**
+     * Create a new document template
+     * @param data - Template data
+     * @param userId - ID of the user creating the template
+     * @returns The created template
+     */
+    createTemplate(data: CreateDocumentTemplateData, userId: string): Promise<DocumentTemplate>;
+    /**
+     * 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
+     */
+    getTemplateById(templateId: string, version?: number): Promise<DocumentTemplate | null>;
+    /**
+     * Update an existing document template
+     * @param templateId - ID of the template to update
+     * @param data - Updated template data
+     * @returns The updated template
+     */
+    updateTemplate(templateId: string, data: UpdateDocumentTemplateData): Promise<DocumentTemplate>;
+    /**
+     * 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
+     */
+    getTemplateVersion(templateId: string, versionNumber: number): Promise<DocumentTemplate | null>;
+    /**
+     * Get all versions of a template
+     * @param templateId - ID of the template
+     * @returns Array of template versions
+     */
+    getTemplateOldVersions(templateId: string): Promise<DocumentTemplate[]>;
+    /**
+     * Delete a document template
+     * @param templateId - ID of the template to delete
+     */
+    deleteTemplate(templateId: string): Promise<void>;
+    /**
+     * 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
+     */
+    getActiveTemplates(pageSize?: number, lastDoc?: QueryDocumentSnapshot<DocumentTemplate>): Promise<{
+        templates: DocumentTemplate[];
+        lastDoc: QueryDocumentSnapshot<DocumentTemplate> | null;
+    }>;
+    /**
+     * Get all active templates with optional filters and pagination.
+     * @param options - Options for filtering and pagination.
+     * @returns A promise that resolves to the templates and the last visible document.
+     */
+    getTemplates(options: {
+        pageSize?: number;
+        lastDoc?: QueryDocumentSnapshot<DocumentTemplate>;
+        isUserForm?: boolean;
+        isRequired?: boolean;
+        sortingOrder?: number;
+    }): Promise<{
+        templates: DocumentTemplate[];
+        lastDoc: QueryDocumentSnapshot<DocumentTemplate> | null;
+    }>;
+    /**
+     * Get the total count of active templates with optional filters.
+     * @param options - Options for filtering.
+     * @returns A promise that resolves to the total count of templates.
+     */
+    getTemplatesCount(options: {
+        isUserForm?: boolean;
+        isRequired?: boolean;
+        sortingOrder?: number;
+        search?: string;
+    }): Promise<number>;
+    /**
+     * Get all active templates without pagination for filtering purposes.
+     * @returns A promise that resolves to an array of all active templates.
+     */
+    getAllActiveTemplates(): Promise<DocumentTemplate[]>;
+    /**
+     * 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
+     */
+    getTemplatesByTags(tags: string[], pageSize?: number, lastDoc?: QueryDocumentSnapshot<DocumentTemplate>): Promise<{
+        templates: DocumentTemplate[];
+        lastDoc: QueryDocumentSnapshot<DocumentTemplate> | null;
+    }>;
+    /**
+     * 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
+     */
+    getTemplatesByCreator(userId: string, pageSize?: number, lastDoc?: QueryDocumentSnapshot<DocumentTemplate>): Promise<{
+        templates: DocumentTemplate[];
+        lastDoc: QueryDocumentSnapshot<DocumentTemplate> | null;
+    }>;
+    /**
+     * Get all templates for selection with optional filtering
+     * @param options - Filtering options
+     * @returns Array of templates
+     */
+    getAllTemplatesForSelection(options?: {
+        isUserForm?: boolean;
+        isRequired?: boolean;
+    }): Promise<DocumentTemplate[]>;
+}
+
+/**
+ * Service for managing documentation templates in the backoffice
+ */
+declare class DocumentationTemplateServiceBackoffice {
+    private apiService;
+    /**
+     * Constructor for DocumentationTemplateService
+     * @param db - Firestore instance
+     * @param auth - Firebase Auth instance
+     * @param app - Firebase App instance
+     */
+    constructor(...args: ConstructorParameters<typeof DocumentationTemplateService>);
+    /**
+     * Create a new document template
+     * @param data - Template data
+     * @param userId - ID of the user creating the template
+     * @returns The created template
+     */
+    createTemplate(data: CreateDocumentTemplateData, userId: string): Promise<DocumentTemplate>;
+    /**
+     * 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
+     */
+    getTemplateById(templateId: string, version?: number): Promise<DocumentTemplate | null>;
+    /**
+     * Update an existing document template
+     * @param templateId - ID of the template to update
+     * @param data - Updated template data
+     * @returns The updated template
+     */
+    updateTemplate(templateId: string, data: UpdateDocumentTemplateData): Promise<DocumentTemplate>;
+    /**
+     * Delete a document template
+     * @param templateId - ID of the template to delete
+     */
+    deleteTemplate(templateId: string): Promise<void>;
+    /**
+     * 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
+     */
+    getActiveTemplates(pageSize?: number, lastDoc?: QueryDocumentSnapshot<DocumentTemplate>): Promise<{
+        templates: DocumentTemplate[];
+        lastDoc: QueryDocumentSnapshot<DocumentTemplate> | null;
+    }>;
+    /**
+     * Get all active templates with optional filters and pagination.
+     * @param options - Options for filtering and pagination.
+     * @returns A promise that resolves to the templates and the last visible document.
+     */
+    getTemplates(options: {
+        pageSize?: number;
+        lastDoc?: QueryDocumentSnapshot<DocumentTemplate>;
+        isUserForm?: boolean;
+        isRequired?: boolean;
+        sortingOrder?: number;
+    }): Promise<{
+        templates: DocumentTemplate[];
+        lastDoc: QueryDocumentSnapshot<DocumentTemplate> | null;
+    }>;
+    /**
+     * Get the total count of active templates with optional filters.
+     * @param options - Options for filtering.
+     * @returns A promise that resolves to the total count of templates.
+     */
+    getTemplatesCount(options: {
+        isUserForm?: boolean;
+        isRequired?: boolean;
+        sortingOrder?: number;
+        search?: string;
+    }): Promise<number>;
+    /**
+     * Get all active templates without pagination for filtering purposes.
+     * @returns A promise that resolves to an array of all active templates.
+     */
+    getAllActiveTemplates(): Promise<DocumentTemplate[]>;
+    /**
+     * Searches for active templates by title.
+     * @param title - The title to search for.
+     * @returns A list of templates that match the search criteria.
+     */
+    search(title: string): Promise<DocumentTemplate[]>;
+    /**
+     * 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
+     */
+    getTemplatesByTags(tags: string[], pageSize?: number, lastDoc?: QueryDocumentSnapshot<DocumentTemplate>): Promise<{
+        templates: DocumentTemplate[];
+        lastDoc: QueryDocumentSnapshot<DocumentTemplate> | null;
+    }>;
+    /**
+     * 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
+     */
+    getTemplatesByCreator(userId: string, pageSize?: number, lastDoc?: QueryDocumentSnapshot<DocumentTemplate>): Promise<{
+        templates: DocumentTemplate[];
+        lastDoc: QueryDocumentSnapshot<DocumentTemplate> | null;
+    }>;
+    /**
+     * 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
+     */
+    getTemplateVersion(templateId: string, versionNumber: number): Promise<DocumentTemplate | null>;
+    /**
+     * Get all versions of a template
+     * @param templateId - ID of the template
+     * @returns Array of template versions
+     */
+    getTemplateVersions(templateId: string): Promise<DocumentTemplate[]>;
+}
+
+declare class ProductService extends BaseService implements IProductService {
+    /**
+     * Gets reference to products collection under a technology
+     * @param technologyId - ID of the technology
+     * @returns Firestore collection reference
+     */
+    private getProductsRef;
+    /**
+     * Creates a new product under technology
+     */
+    create(technologyId: string, brandId: string, product: Omit<Product, "id" | "createdAt" | "updatedAt" | "brandId" | "technologyId">): Promise<Product>;
+    /**
+     * Gets a paginated list of all products, with optional filters.
+     * This uses a collectionGroup query to search across all technologies.
+     */
+    getAll(options: {
+        rowsPerPage: number;
+        lastVisible?: any;
+        categoryId?: string;
+        subcategoryId?: string;
+        technologyId?: string;
+    }): Promise<{
+        products: Product[];
+        lastVisible: any;
+    }>;
+    /**
+     * Gets the total count of active products, with optional filters.
+     */
+    getProductsCount(options: {
+        categoryId?: string;
+        subcategoryId?: string;
+        technologyId?: string;
+    }): Promise<number>;
+    /**
+     * Gets counts of active products grouped by category, subcategory, and technology.
+     * This uses a single collectionGroup query for efficiency.
+     */
+    getProductCounts(): Promise<{
+        byCategory: Record<string, number>;
+        bySubcategory: Record<string, number>;
+        byTechnology: Record<string, number>;
+    }>;
+    /**
+     * Gets all products for a brand by filtering through all technologies
+     */
+    getAllByBrand(brandId: string): Promise<Product[]>;
+    /**
+     * Updates a product
+     */
+    update(technologyId: string, productId: string, product: Partial<Omit<Product, "id" | "createdAt" | "brandId" | "technologyId">>): Promise<Product | null>;
+    /**
+     * Soft deletes a product
+     */
+    delete(technologyId: string, productId: string): Promise<void>;
+    /**
+     * Gets a product by ID
+     */
+    getById(technologyId: string, productId: string): Promise<Product | null>;
+}
+
+/**
+ * Servis za upravljanje globalnim zahtevima.
+ * Zahtevi se mogu kreirati globalno i zatim povezati sa različitim tehnologijama.
+ * Ovo omogućava ponovno korišćenje istih zahteva za različite tehnologije.
+ *
+ * @example
+ * const requirementService = new RequirementService();
+ *
+ * // Kreiranje globalnog zahteva
+ * const requirement = await requirementService.create({
+ *   type: "pre",
+ *   name: "Stay Hydrated",
+ *   description: "Drink plenty of water",
+ *   timeframe: {
+ *     duration: 2,
+ *     unit: "hours",
+ *     notifyAt: [2, 1]
+ *   },
+ *   importance: "high"
+ * });
+ */
+declare class RequirementService extends BaseService {
+    /**
+     * Referenca na Firestore kolekciju zahteva
+     */
+    private get requirementsRef();
+    /**
+     * Kreira novi globalni zahtev
+     * @param requirement - Podaci za novi zahtev
+     * @returns Kreirani zahtev sa generisanim ID-em
+     */
+    create(requirement: Omit<Requirement, "id" | "createdAt" | "updatedAt">): Promise<{
+        createdAt: Date;
+        updatedAt: Date;
+        name: string;
+        isActive: boolean;
+        description: string;
+        type: RequirementType;
+        timeframe: TimeFrame;
+        importance: RequirementImportance;
+        id: string;
+    }>;
+    /**
+     * Vraća sve aktivne zahteve
+     * @returns Lista aktivnih zahteva
+     */
+    getAll(): Promise<Requirement[]>;
+    /**
+     * Vraća sve aktivne zahteve određenog tipa
+     * @param type - Tip zahteva (pre/post)
+     * @returns Lista zahteva određenog tipa
+     */
+    getAllByType(type: RequirementType): Promise<Requirement[]>;
+    /**
+     * Searches for requirements by name.
+     * @param name - The name to search for.
+     * @param type - The type of requirement (pre/post).
+     * @returns A list of requirements that match the search criteria.
+     */
+    search(name: string, type: RequirementType): Promise<Requirement[]>;
+    /**
+     * Ažurira postojeći zahtev
+     * @param id - ID zahteva koji se ažurira
+     * @param requirement - Novi podaci za zahtev
+     * @returns Ažurirani zahtev
+     */
+    update(id: string, requirement: Partial<Omit<Requirement, "id" | "createdAt">>): Promise<Requirement | null>;
+    /**
+     * Soft delete zahteva (postavlja isActive na false)
+     * @param id - ID zahteva koji se briše
+     */
+    delete(id: string): Promise<void>;
+    /**
+     * Vraća zahtev po ID-u
+     * @param id - ID traženog zahteva
+     * @returns Zahtev ili null ako ne postoji
+     */
+    getById(id: string): Promise<Requirement | null>;
+}
+
+/**
+ * Servis za upravljanje podkategorijama procedura.
+ * Podkategorije su drugi nivo organizacije i pripadaju određenoj kategoriji.
+ *
+ * @example
+ * const subcategoryService = new SubcategoryService();
+ *
+ * // Kreiranje nove podkategorije
+ * const subcategory = await subcategoryService.create(categoryId, {
+ *   name: "Anti-Wrinkle",
+ *   description: "Treatments targeting facial wrinkles"
+ * });
+ */
+declare class SubcategoryService extends BaseService {
+    /**
+     * Vraća referencu na Firestore kolekciju podkategorija za određenu kategoriju
+     * @param categoryId - ID roditeljske kategorije
+     */
+    private getSubcategoriesRef;
+    /**
+     * 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
+     */
+    create(categoryId: string, subcategory: Omit<Subcategory, "id" | "createdAt" | "updatedAt">): Promise<{
+        createdAt: Date;
+        updatedAt: Date;
+        name: string;
+        isActive: boolean;
+        description?: string | undefined;
+        categoryId: string;
+        id: string;
+    }>;
+    /**
+     * Returns counts of subcategories for all categories.
+     * @param active - Whether to count active or inactive subcategories.
+     * @returns A record mapping category ID to subcategory count.
+     */
+    getSubcategoryCounts(active?: boolean): Promise<Record<string, number>>;
+    /**
+     * Vraća sve aktivne podkategorije za određenu kategoriju sa paginacijom
+     * @param categoryId - ID kategorije čije podkategorije tražimo
+     * @param options - Pagination options
+     * @returns Lista aktivnih podkategorija i poslednji vidljiv dokument
+     */
+    getAllByCategoryId(categoryId: string, options?: {
+        active?: boolean;
+        limit?: number;
+        lastVisible?: DocumentData;
+    }): Promise<{
+        subcategories: Subcategory[];
+        lastVisible: _firebase_firestore.QueryDocumentSnapshot<DocumentData, DocumentData>;
+    }>;
+    /**
+     * Vraća sve podkategorije sa paginacijom koristeći collection group query.
+     * NOTE: This query requires a composite index in Firestore on the 'subcategories' collection group.
+     * The index should be on 'isActive' (ascending) and 'name' (ascending).
+     * Firestore will provide a link to create this index in the console error if it's missing.
+     * @param options - Pagination options
+     * @returns Lista podkategorija i poslednji vidljiv dokument
+     */
+    getAll(options?: {
+        active?: boolean;
+        limit?: number;
+        lastVisible?: DocumentData;
+    }): Promise<{
+        subcategories: Subcategory[];
+        lastVisible: _firebase_firestore.QueryDocumentSnapshot<DocumentData, DocumentData>;
+    }>;
+    /**
+     * Vraća sve subkategorije za određenu kategoriju za potrebe filtera (bez paginacije)
+     * @param categoryId - ID kategorije čije subkategorije tražimo
+     * @returns Lista svih aktivnih subkategorija
+     */
+    getAllForFilterByCategoryId(categoryId: string): Promise<Subcategory[]>;
+    /**
+     * Vraća sve subkategorije za potrebe filtera (bez paginacije)
+     * @returns Lista svih aktivnih subkategorija
+     */
+    getAllForFilter(): Promise<Subcategory[]>;
+    /**
+     * 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
+     */
+    update(categoryId: string, subcategoryId: string, subcategory: Partial<Omit<Subcategory, "id" | "createdAt">>): Promise<Subcategory | null>;
+    /**
+     * Soft delete podkategorije (postavlja isActive na false)
+     * @param categoryId - ID kategorije kojoj pripada podkategorija
+     * @param subcategoryId - ID podkategorije koja se briše
+     */
+    delete(categoryId: string, subcategoryId: string): Promise<void>;
+    /**
+     * Reactivates a subcategory by setting its isActive flag to true.
+     * @param categoryId - The ID of the category to which the subcategory belongs.
+     * @param subcategoryId - The ID of the subcategory to reactivate.
+     */
+    reactivate(categoryId: string, subcategoryId: string): Promise<void>;
+    /**
+     * 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
+     */
+    getById(categoryId: string, subcategoryId: string): Promise<Subcategory | null>;
+}
+
+/**
+ * Service for managing technologies.
  */
 declare class TechnologyService extends BaseService {
     /**
-     * Vraća referencu na Firestore kolekciju tehnologija
+     * Reference to the Firestore collection of technologies.
      */
-    private getTechnologiesRef;
+    private get technologiesRef();
     /**
-     * Kreira novu tehnologiju
-     * @param technology - Podaci za novu tehnologiju
-     * @returns Kreirana tehnologija sa generisanim ID-em
+     * Creates a new technology.
+     * @param technology - Data for the new technology.
+     * @returns The created technology with its generated ID.
      */
     create(technology: Omit<Technology, "id" | "createdAt" | "updatedAt">): Promise<{
         createdAt: Date;
@@ -1245,61 +1663,96 @@ declare class TechnologyService extends BaseService {
         isActive: boolean;
         description: string;
         family: ProcedureFamily;
-        technicalDetails?: string | undefined;
-        contraindications: Contraindication[];
-        blockingConditions: BlockingCondition[];
         categoryId: string;
         subcategoryId: string;
+        technicalDetails?: string | undefined;
+        contraindications: ContraindicationDynamic[];
         requirements: {
             pre: Requirement[];
             post: Requirement[];
         };
-        benefits: TreatmentBenefit[];
+        blockingConditions: BlockingCondition[];
+        benefits: TreatmentBenefitDynamic[];
         certificationRequirement: CertificationRequirement;
         documentationTemplates?: TechnologyDocumentationTemplate[] | undefined;
         id: string;
     }>;
     /**
-     * Vraća sve aktivne tehnologije
-     * @returns Lista aktivnih tehnologija
+     * Returns counts of technologies for each subcategory.
+     * @param active - Whether to count active or inactive technologies.
+     * @returns A record mapping subcategory ID to technology count.
      */
-    getAll(): Promise<Technology[]>;
+    getTechnologyCounts(active?: boolean): Promise<Record<string, number>>;
     /**
-     * Vraća sve aktivne tehnologije za određenu familiju
-     * @param family - Familija procedura
-     * @returns Lista aktivnih tehnologija
+     * Returns counts of technologies for each category.
+     * @param active - Whether to count active or inactive technologies.
+     * @returns A record mapping category ID to technology count.
      */
-    getAllByFamily(family: ProcedureFamily): Promise<Technology[]>;
+    getTechnologyCountsByCategory(active?: boolean): Promise<Record<string, number>>;
     /**
-     * Vraća sve aktivne tehnologije za određenu kategoriju
-     * @param categoryId - ID kategorije
-     * @returns Lista aktivnih tehnologija
+     * Returns all technologies with pagination.
+     * @param options - Pagination and filter options.
+     * @returns A list of technologies and the last visible document.
      */
-    getAllByCategoryId(categoryId: string): Promise<Technology[]>;
+    getAll(options?: {
+        active?: boolean;
+        limit?: number;
+        lastVisible?: DocumentData;
+    }): Promise<{
+        technologies: Technology[];
+        lastVisible: _firebase_firestore.QueryDocumentSnapshot<DocumentData, DocumentData>;
+    }>;
     /**
-     * Vraća sve aktivne tehnologije za određenu podkategoriju
-     * @param subcategoryId - ID podkategorije
-     * @returns Lista aktivnih tehnologija
+     * Returns all technologies for a specific category with pagination.
+     * @param categoryId - The ID of the category.
+     * @param options - Pagination options.
+     * @returns A list of technologies for the specified category.
      */
-    getAllBySubcategoryId(subcategoryId: string): Promise<Technology[]>;
+    getAllByCategoryId(categoryId: string, options?: {
+        active?: boolean;
+        limit?: number;
+        lastVisible?: DocumentData;
+    }): Promise<{
+        technologies: Technology[];
+        lastVisible: _firebase_firestore.QueryDocumentSnapshot<DocumentData, DocumentData>;
+    }>;
     /**
-     * Ažurira postojeću tehnologiju
-     * @param technologyId - ID tehnologije
-     * @param technology - Novi podaci za tehnologiju
-     * @returns Ažurirana tehnologija
+     * Returns all technologies for a specific subcategory with pagination.
+     * @param subcategoryId - The ID of the subcategory.
+     * @param options - Pagination options.
+     * @returns A list of technologies for the specified subcategory.
+     */
+    getAllBySubcategoryId(subcategoryId: string, options?: {
+        active?: boolean;
+        limit?: number;
+        lastVisible?: DocumentData;
+    }): Promise<{
+        technologies: Technology[];
+        lastVisible: _firebase_firestore.QueryDocumentSnapshot<DocumentData, DocumentData>;
+    }>;
+    /**
+     * Updates an existing technology.
+     * @param id - The ID of the technology to update.
+     * @param technology - New data for the technology.
+     * @returns The updated technology.
+     */
+    update(id: string, technology: Partial<Omit<Technology, "id" | "createdAt">>): Promise<Technology | null>;
+    /**
+     * Soft deletes a technology.
+     * @param id - The ID of the technology to delete.
      */
-    update(technologyId: string, technology: Partial<Omit<Technology, "id" | "createdAt" | "family" | "categoryId" | "subcategoryId">>): Promise<Technology | null>;
+    delete(id: string): Promise<void>;
     /**
-     * Soft delete tehnologije (postavlja isActive na false)
-     * @param technologyId - ID tehnologije koja se briše
+     * Reactivates a technology.
+     * @param id - The ID of the technology to reactivate.
      */
-    delete(technologyId: string): Promise<void>;
+    reactivate(id: string): Promise<void>;
     /**
-     * Vraća tehnologiju po ID-u
-     * @param technologyId - ID tražene tehnologije
-     * @returns Tehnologija ili null ako ne postoji
+     * Returns a technology by its ID.
+     * @param id - The ID of the requested technology.
+     * @returns The technology or null if it doesn't exist.
      */
-    getById(technologyId: string): Promise<Technology | null>;
+    getById(id: string): Promise<Technology | null>;
     /**
      * Dodaje novi zahtev tehnologiji
      * @param technologyId - ID tehnologije
@@ -1349,28 +1802,44 @@ declare class TechnologyService extends BaseService {
      * @param contraindication - Kontraindikacija koja se dodaje
      * @returns Ažurirana tehnologija
      */
-    addContraindication(technologyId: string, contraindication: Contraindication): Promise<Technology | null>;
+    addContraindication(technologyId: string, contraindication: ContraindicationDynamic): Promise<Technology | null>;
     /**
      * Uklanja kontraindikaciju iz tehnologije
      * @param technologyId - ID tehnologije
      * @param contraindication - Kontraindikacija koja se uklanja
      * @returns Ažurirana tehnologija
      */
-    removeContraindication(technologyId: string, contraindication: Contraindication): Promise<Technology | null>;
+    removeContraindication(technologyId: string, contraindication: ContraindicationDynamic): Promise<Technology | null>;
+    /**
+     * Updates an existing contraindication in a technology's list.
+     * If the contraindication does not exist, it will not be added.
+     * @param technologyId - ID of the technology
+     * @param contraindication - The updated contraindication object
+     * @returns The updated technology
+     */
+    updateContraindication(technologyId: string, contraindication: ContraindicationDynamic): Promise<Technology | null>;
     /**
      * Dodaje benefit tehnologiji
      * @param technologyId - ID tehnologije
      * @param benefit - Benefit koji se dodaje
      * @returns Ažurirana tehnologija
      */
-    addBenefit(technologyId: string, benefit: TreatmentBenefit): Promise<Technology | null>;
+    addBenefit(technologyId: string, benefit: TreatmentBenefitDynamic): Promise<Technology | null>;
     /**
      * Uklanja benefit iz tehnologije
      * @param technologyId - ID tehnologije
      * @param benefit - Benefit koji se uklanja
      * @returns Ažurirana tehnologija
      */
-    removeBenefit(technologyId: string, benefit: TreatmentBenefit): Promise<Technology | null>;
+    removeBenefit(technologyId: string, benefit: TreatmentBenefitDynamic): Promise<Technology | null>;
+    /**
+     * Updates an existing benefit in a technology's list.
+     * If the benefit does not exist, it will not be added.
+     * @param technologyId - ID of the technology
+     * @param benefit - The updated benefit object
+     * @returns The updated technology
+     */
+    updateBenefit(technologyId: string, benefit: TreatmentBenefitDynamic): Promise<Technology | null>;
     /**
      * Vraća sve blokirajuće uslove za tehnologiju
      * @param technologyId - ID tehnologije
@@ -1382,13 +1851,13 @@ declare class TechnologyService extends BaseService {
      * @param technologyId - ID tehnologije
      * @returns Lista kontraindikacija
      */
-    getContraindications(technologyId: string): Promise<Contraindication[]>;
+    getContraindications(technologyId: string): Promise<ContraindicationDynamic[]>;
     /**
      * Vraća sve benefite za tehnologiju
      * @param technologyId - ID tehnologije
      * @returns Lista benefita
      */
-    getBenefits(technologyId: string): Promise<TreatmentBenefit[]>;
+    getBenefits(technologyId: string): Promise<TreatmentBenefitDynamic[]>;
     /**
      * Ažurira zahteve sertifikacije za tehnologiju
      * @param technologyId - ID tehnologije
@@ -1451,6 +1920,135 @@ declare class TechnologyService extends BaseService {
         categories: string[];
         subcategories: string[];
     }>;
+    /**
+     * Gets all active technologies for a subcategory for filter dropdowns.
+     * @param categoryId - The ID of the parent category.
+     * @param subcategoryId - The ID of the subcategory.
+     */
+    getAllForFilterBySubcategoryId(categoryId: string, subcategoryId: string): Promise<Technology[]>;
+    /**
+     * Gets all active technologies for filter dropdowns.
+     */
+    getAllForFilter(): Promise<Technology[]>;
+}
+
+/**
+ * @class ConstantsService
+ * @description Service for managing administrative constants, such as treatment benefits and contraindications.
+ * These constants are stored in a single Firestore collection 'admin-constants',
+ * with each type of constant in its own document ('treatment-benefits', 'contraindications').
+ * The constants themselves are stored in an array within these documents.
+ * @extends {BaseService}
+ */
+declare class ConstantsService extends BaseService {
+    /**
+     * @description Gets the reference to the document holding treatment benefits.
+     * @private
+     * @type {DocumentReference}
+     */
+    private get treatmentBenefitsDocRef();
+    /**
+     * @description Gets the reference to the document holding contraindications.
+     * @private
+     * @type {DocumentReference}
+     */
+    private get contraindicationsDocRef();
+    /**
+     * @description Retrieves all treatment benefits without pagination.
+     * @returns {Promise<TreatmentBenefitDynamic[]>} An array of all treatment benefits.
+     */
+    getAllBenefitsForFilter(): Promise<TreatmentBenefitDynamic[]>;
+    /**
+     * @description Retrieves a paginated list of treatment benefits.
+     * @param {{ page: number; limit: number }} options - Pagination options.
+     * @returns {Promise<{ benefits: TreatmentBenefitDynamic[]; total: number }>} A paginated list of benefits and the total count.
+     */
+    getAllBenefits(options: {
+        page: number;
+        limit: number;
+    }): Promise<{
+        benefits: TreatmentBenefitDynamic[];
+        total: number;
+    }>;
+    /**
+     * @description Adds a new treatment benefit.
+     * @param {Omit<TreatmentBenefitDynamic, "id">} benefit - The treatment benefit to add, without an ID.
+     * @returns {Promise<TreatmentBenefitDynamic>} The newly created treatment benefit with its generated ID.
+     */
+    addTreatmentBenefit(benefit: Omit<TreatmentBenefitDynamic, "id">): Promise<TreatmentBenefitDynamic>;
+    /**
+     * @description Retrieves a single treatment benefit by its ID.
+     * @param {string} benefitId - The ID of the treatment benefit to retrieve.
+     * @returns {Promise<TreatmentBenefitDynamic | undefined>} The found treatment benefit or undefined.
+     */
+    getBenefitById(benefitId: string): Promise<TreatmentBenefitDynamic | undefined>;
+    /**
+     * @description Searches for treatment benefits by name (case-insensitive).
+     * @param {string} searchTerm - The term to search for in the benefit names.
+     * @returns {Promise<TreatmentBenefitDynamic[]>} An array of matching treatment benefits.
+     */
+    searchBenefitsByName(searchTerm: string): Promise<TreatmentBenefitDynamic[]>;
+    /**
+     * @description Updates an existing treatment benefit.
+     * @param {TreatmentBenefitDynamic} benefit - The treatment benefit with updated data. Its ID must match an existing benefit.
+     * @returns {Promise<TreatmentBenefitDynamic>} The updated treatment benefit.
+     * @throws {Error} If the treatment benefit is not found.
+     */
+    updateTreatmentBenefit(benefit: TreatmentBenefitDynamic): Promise<TreatmentBenefitDynamic>;
+    /**
+     * @description Deletes a treatment benefit by its ID.
+     * @param {string} benefitId - The ID of the treatment benefit to delete.
+     * @returns {Promise<void>}
+     */
+    deleteTreatmentBenefit(benefitId: string): Promise<void>;
+    /**
+     * @description Retrieves all contraindications without pagination.
+     * @returns {Promise<ContraindicationDynamic[]>} An array of all contraindications.
+     */
+    getAllContraindicationsForFilter(): Promise<ContraindicationDynamic[]>;
+    /**
+     * @description Retrieves a paginated list of contraindications.
+     * @param {{ page: number; limit: number }} options - Pagination options.
+     * @returns {Promise<{ contraindications: ContraindicationDynamic[]; total: number }>} A paginated list and the total count.
+     */
+    getAllContraindications(options: {
+        page: number;
+        limit: number;
+    }): Promise<{
+        contraindications: ContraindicationDynamic[];
+        total: number;
+    }>;
+    /**
+     * @description Adds a new contraindication.
+     * @param {Omit<ContraindicationDynamic, "id">} contraindication - The contraindication to add, without an ID.
+     * @returns {Promise<ContraindicationDynamic>} The newly created contraindication with its generated ID.
+     */
+    addContraindication(contraindication: Omit<ContraindicationDynamic, "id">): Promise<ContraindicationDynamic>;
+    /**
+     * @description Retrieves a single contraindication by its ID.
+     * @param {string} contraindicationId - The ID of the contraindication to retrieve.
+     * @returns {Promise<ContraindicationDynamic | undefined>} The found contraindication or undefined.
+     */
+    getContraindicationById(contraindicationId: string): Promise<ContraindicationDynamic | undefined>;
+    /**
+     * @description Searches for contraindications by name (case-insensitive).
+     * @param {string} searchTerm - The term to search for in the contraindication names.
+     * @returns {Promise<ContraindicationDynamic[]>} An array of matching contraindications.
+     */
+    searchContraindicationsByName(searchTerm: string): Promise<ContraindicationDynamic[]>;
+    /**
+     * @description Updates an existing contraindication.
+     * @param {ContraindicationDynamic} contraindication - The contraindication with updated data. Its ID must match an existing one.
+     * @returns {Promise<ContraindicationDynamic>} The updated contraindication.
+     * @throws {Error} If the contraindication is not found.
+     */
+    updateContraindication(contraindication: ContraindicationDynamic): Promise<ContraindicationDynamic>;
+    /**
+     * @description Deletes a contraindication by its ID.
+     * @param {string} contraindicationId - The ID of the contraindication to delete.
+     * @returns {Promise<void>}
+     */
+    deleteContraindication(contraindicationId: string): Promise<void>;
 }
 
 declare const documentElementSchema: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
@@ -3209,12 +3807,70 @@ declare const documentTemplateSchema: z.ZodObject<{
     sortingOrder?: number | undefined;
 }>;
 
+/**
+ * Zod validation schema for a single dynamic contraindication.
+ * @see ContraindicationDynamic in admin-constants.types.ts
+ */
+declare const contraindicationDynamicSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    name: string;
+    description?: string | undefined;
+}, {
+    id: string;
+    name: string;
+    description?: string | undefined;
+}>;
+/**
+ * Zod validation schema for a single dynamic treatment benefit.
+ * @see TreatmentBenefitDynamic in admin-constants.types.ts
+ */
+declare const treatmentBenefitDynamicSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    name: string;
+    description?: string | undefined;
+}, {
+    id: string;
+    name: string;
+    description?: string | undefined;
+}>;
 /**
  * Base validation schemas for enums
  */
 declare const blockingConditionSchemaBackoffice: z.ZodNativeEnum<typeof BlockingCondition>;
-declare const contraindicationSchemaBackoffice: z.ZodNativeEnum<typeof Contraindication>;
-declare const treatmentBenefitSchemaBackoffice: z.ZodNativeEnum<typeof TreatmentBenefit>;
+declare const contraindicationSchemaBackoffice: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    name: string;
+    description?: string | undefined;
+}, {
+    id: string;
+    name: string;
+    description?: string | undefined;
+}>;
+declare const treatmentBenefitSchemaBackoffice: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    name: string;
+    description?: string | undefined;
+}, {
+    id: string;
+    name: string;
+    description?: string | undefined;
+}>;
 declare const procedureFamilySchemaBackoffice: z.ZodNativeEnum<typeof ProcedureFamily>;
 declare const timeUnitSchemaBackoffice: z.ZodNativeEnum<typeof TimeUnit>;
 declare const requirementTypeSchema: z.ZodNativeEnum<typeof RequirementType>;
@@ -3580,7 +4236,19 @@ declare const technologySchema: z.ZodObject<{
         }[];
     }>>;
     blockingConditions: z.ZodArray<z.ZodNativeEnum<typeof BlockingCondition>, "many">;
-    contraindications: z.ZodArray<z.ZodNativeEnum<typeof Contraindication>, "many">;
+    contraindications: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        name: string;
+        description?: string | undefined;
+    }, {
+        id: string;
+        name: string;
+        description?: string | undefined;
+    }>, "many">;
     documentationTemplates: z.ZodArray<z.ZodObject<{
         id: z.ZodString;
         title: z.ZodString;
@@ -4047,7 +4715,19 @@ declare const technologySchema: z.ZodObject<{
         isRequired?: boolean | undefined;
         sortingOrder?: number | undefined;
     }>, "many">;
-    benefits: z.ZodArray<z.ZodNativeEnum<typeof TreatmentBenefit>, "many">;
+    benefits: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        name: string;
+        description?: string | undefined;
+    }, {
+        id: string;
+        name: string;
+        description?: string | undefined;
+    }>, "many">;
     certificationRequirement: z.ZodObject<{
         minimumLevel: z.ZodNativeEnum<typeof CertificationLevel>;
         requiredSpecialties: z.ZodOptional<z.ZodArray<z.ZodNativeEnum<typeof CertificationSpecialty>, "many">>;
@@ -4063,10 +4743,13 @@ declare const technologySchema: z.ZodObject<{
     name: string;
     isActive: boolean;
     family: ProcedureFamily;
-    contraindications: Contraindication[];
-    blockingConditions: BlockingCondition[];
     categoryId: string;
     subcategoryId: string;
+    contraindications: {
+        id: string;
+        name: string;
+        description?: string | undefined;
+    }[];
     requirements: {
         pre: {
             name: string;
@@ -4093,7 +4776,12 @@ declare const technologySchema: z.ZodObject<{
             importance: "low" | "medium" | "high";
         }[];
     };
-    benefits: TreatmentBenefit[];
+    blockingConditions: BlockingCondition[];
+    benefits: {
+        id: string;
+        name: string;
+        description?: string | undefined;
+    }[];
     certificationRequirement: {
         minimumLevel: CertificationLevel;
         requiredSpecialties?: CertificationSpecialty[] | undefined;
@@ -4200,11 +4888,19 @@ declare const technologySchema: z.ZodObject<{
 }, {
     name: string;
     family: ProcedureFamily;
-    contraindications: Contraindication[];
-    blockingConditions: BlockingCondition[];
     categoryId: string;
     subcategoryId: string;
-    benefits: TreatmentBenefit[];
+    contraindications: {
+        id: string;
+        name: string;
+        description?: string | undefined;
+    }[];
+    blockingConditions: BlockingCondition[];
+    benefits: {
+        id: string;
+        name: string;
+        description?: string | undefined;
+    }[];
     certificationRequirement: {
         minimumLevel: CertificationLevel;
         requiredSpecialties?: CertificationSpecialty[] | undefined;
@@ -4553,7 +5249,19 @@ declare const technologyUpdateSchema: z.ZodObject<{
         }[];
     }>>>;
     blockingConditions: z.ZodOptional<z.ZodArray<z.ZodNativeEnum<typeof BlockingCondition>, "many">>;
-    contraindications: z.ZodOptional<z.ZodArray<z.ZodNativeEnum<typeof Contraindication>, "many">>;
+    contraindications: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        name: string;
+        description?: string | undefined;
+    }, {
+        id: string;
+        name: string;
+        description?: string | undefined;
+    }>, "many">>;
     documentationTemplates: z.ZodOptional<z.ZodArray<z.ZodObject<{
         id: z.ZodString;
         title: z.ZodString;
@@ -5020,7 +5728,19 @@ declare const technologyUpdateSchema: z.ZodObject<{
         isRequired?: boolean | undefined;
         sortingOrder?: number | undefined;
     }>, "many">>;
-    benefits: z.ZodOptional<z.ZodArray<z.ZodNativeEnum<typeof TreatmentBenefit>, "many">>;
+    benefits: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        name: string;
+        description?: string | undefined;
+    }, {
+        id: string;
+        name: string;
+        description?: string | undefined;
+    }>, "many">>;
     certificationRequirement: z.ZodOptional<z.ZodObject<{
         minimumLevel: z.ZodNativeEnum<typeof CertificationLevel>;
         requiredSpecialties: z.ZodOptional<z.ZodArray<z.ZodNativeEnum<typeof CertificationSpecialty>, "many">>;
@@ -5037,11 +5757,14 @@ declare const technologyUpdateSchema: z.ZodObject<{
     isActive?: boolean | undefined;
     description?: string | undefined;
     family?: ProcedureFamily | undefined;
-    technicalDetails?: string | undefined;
-    contraindications?: Contraindication[] | undefined;
-    blockingConditions?: BlockingCondition[] | undefined;
     categoryId?: string | undefined;
     subcategoryId?: string | undefined;
+    technicalDetails?: string | undefined;
+    contraindications?: {
+        id: string;
+        name: string;
+        description?: string | undefined;
+    }[] | undefined;
     requirements?: {
         pre: {
             name: string;
@@ -5068,7 +5791,12 @@ declare const technologyUpdateSchema: z.ZodObject<{
             importance: "low" | "medium" | "high";
         }[];
     } | undefined;
-    benefits?: TreatmentBenefit[] | undefined;
+    blockingConditions?: BlockingCondition[] | undefined;
+    benefits?: {
+        id: string;
+        name: string;
+        description?: string | undefined;
+    }[] | undefined;
     certificationRequirement?: {
         minimumLevel: CertificationLevel;
         requiredSpecialties?: CertificationSpecialty[] | undefined;
@@ -5175,11 +5903,14 @@ declare const technologyUpdateSchema: z.ZodObject<{
     isActive?: boolean | undefined;
     description?: string | undefined;
     family?: ProcedureFamily | undefined;
-    technicalDetails?: string | undefined;
-    contraindications?: Contraindication[] | undefined;
-    blockingConditions?: BlockingCondition[] | undefined;
     categoryId?: string | undefined;
     subcategoryId?: string | undefined;
+    technicalDetails?: string | undefined;
+    contraindications?: {
+        id: string;
+        name: string;
+        description?: string | undefined;
+    }[] | undefined;
     requirements?: {
         pre: {
             name: string;
@@ -5206,7 +5937,12 @@ declare const technologyUpdateSchema: z.ZodObject<{
             isActive?: boolean | undefined;
         }[];
     } | undefined;
-    benefits?: TreatmentBenefit[] | undefined;
+    blockingConditions?: BlockingCondition[] | undefined;
+    benefits?: {
+        id: string;
+        name: string;
+        description?: string | undefined;
+    }[] | undefined;
     certificationRequirement?: {
         minimumLevel: CertificationLevel;
         requiredSpecialties?: CertificationSpecialty[] | undefined;
@@ -5446,4 +6182,4 @@ declare class InvalidTreatmentBenefitError extends TreatmentBenefitError {
     constructor(benefit: string);
 }
 
-export { BRANDS_COLLECTION, BackofficeError, BlockingCondition, BlockingConditionError, type Brand, BrandService, CATEGORIES_COLLECTION, type Category, CategoryError, CategoryNotFoundError, CategoryService, CertificationLevel, type CertificationRequirement, CertificationSpecialty, CircularReferenceError, Contraindication, ContraindicationError, type CreateDocumentTemplateData, Currency, DEFAULT_CERTIFICATION_REQUIREMENT, DOCUMENTATION_TEMPLATES_COLLECTION, type DocumentElement, DocumentElementType, type DocumentTemplate, DocumentationTemplateServiceBackoffice, DynamicVariable, FILLED_DOCUMENTS_COLLECTION, HeadingLevel, type IProductService, InvalidBlockingConditionError, InvalidCategoryDataError, InvalidContraindicationError, InvalidHierarchyError, InvalidRequirementDataError, InvalidSubcategoryDataError, InvalidTechnologyDataError, InvalidTimeframeError, InvalidTreatmentBenefitError, ListType, PRODUCTS_COLLECTION, PricingMeasure, ProcedureFamily, type Product, ProductService, REQUIREMENTS_COLLECTION, RelationshipError, type Requirement, RequirementError, type RequirementImportance, RequirementNotFoundError, RequirementService, RequirementType, SUBCATEGORIES_COLLECTION, type Subcategory, SubcategoryError, SubcategoryNotFoundError, SubcategoryService, TECHNOLOGIES_COLLECTION, type Technology, type TechnologyDocumentationTemplate, TechnologyError, TechnologyNotFoundError, type TechnologyRequirements, TechnologyService, type TimeFrame, TimeUnit, TreatmentBenefit, TreatmentBenefitError, type UpdateDocumentTemplateData, blockingConditionSchemaBackoffice, categorySchema, categoryUpdateSchema, certificationLevelSchema, certificationRequirementSchema, certificationSpecialtySchema, contraindicationSchemaBackoffice, createDocumentTemplateSchema, documentElementSchema, documentElementWithoutIdSchema, documentTemplateSchema, procedureFamilySchemaBackoffice, requirementSchema, requirementTypeSchema, requirementUpdateSchema, subcategorySchema, subcategoryUpdateSchema, technologyRequirementsSchema, technologySchema, technologyUpdateSchema, timeUnitSchemaBackoffice, timeframeSchema, treatmentBenefitSchemaBackoffice, updateDocumentTemplateSchema };
+export { BRANDS_COLLECTION, BackofficeError, BlockingCondition, BlockingConditionError, type Brand, BrandService, CATEGORIES_COLLECTION, type Category, CategoryError, CategoryNotFoundError, CategoryService, CertificationLevel, type CertificationRequirement, CertificationSpecialty, CircularReferenceError, ConstantsService, Contraindication, type ContraindicationDynamic, ContraindicationError, type ContraindicationsDocument, type CreateDocumentTemplateData, Currency, DEFAULT_CERTIFICATION_REQUIREMENT, DOCUMENTATION_TEMPLATES_COLLECTION, type DocumentElement, DocumentElementType, type DocumentTemplate, DocumentationTemplateServiceBackoffice, DynamicVariable, FILLED_DOCUMENTS_COLLECTION, HeadingLevel, type IProductService, type ITechnologyService, InvalidBlockingConditionError, InvalidCategoryDataError, InvalidContraindicationError, InvalidHierarchyError, InvalidRequirementDataError, InvalidSubcategoryDataError, InvalidTechnologyDataError, InvalidTimeframeError, InvalidTreatmentBenefitError, ListType, PRODUCTS_COLLECTION, PricingMeasure, ProcedureFamily, type Product, ProductService, REQUIREMENTS_COLLECTION, RelationshipError, type Requirement, RequirementError, type RequirementImportance, RequirementNotFoundError, RequirementService, RequirementType, SUBCATEGORIES_COLLECTION, type Subcategory, SubcategoryError, SubcategoryNotFoundError, SubcategoryService, TECHNOLOGIES_COLLECTION, type Technology, type TechnologyDocumentationTemplate, TechnologyError, TechnologyNotFoundError, type TechnologyRequirements, TechnologyService, type TimeFrame, TimeUnit, TreatmentBenefit, type TreatmentBenefitDynamic, TreatmentBenefitError, type TreatmentBenefitsDocument, type UpdateDocumentTemplateData, blockingConditionSchemaBackoffice, categorySchema, categoryUpdateSchema, certificationLevelSchema, certificationRequirementSchema, certificationSpecialtySchema, contraindicationDynamicSchema, contraindicationSchemaBackoffice, createDocumentTemplateSchema, documentElementSchema, documentElementWithoutIdSchema, documentTemplateSchema, procedureFamilySchemaBackoffice, requirementSchema, requirementTypeSchema, requirementUpdateSchema, subcategorySchema, subcategoryUpdateSchema, technologyRequirementsSchema, technologySchema, technologyUpdateSchema, timeUnitSchemaBackoffice, timeframeSchema, treatmentBenefitDynamicSchema, treatmentBenefitSchemaBackoffice, updateDocumentTemplateSchema };