@blackcode_sa/metaestetics-api 1.12.65 → 1.12.67

package/src/backoffice/types/technology.types.ts

@@ -1,163 +1,168 @@
-import { Requirement } from './requirement.types';
-import { BlockingCondition } from './static/blocking-condition.types';
-import { CertificationRequirement } from './static/certification.types';
-import { DocumentTemplate } from '../../types/documentation-templates';
-import { ProcedureFamily } from './static/procedure-family.types';
-import { ContraindicationDynamic } from './admin-constants.types';
-import { TreatmentBenefitDynamic } from './admin-constants.types';
-
-/**
- * Reference to a documentation template with metadata
- * @property templateId - ID of the documentation template
- * @property isUserForm - Whether this template is filled by users
- * @property isRequired - Whether this template is required
- * @property sortingOrder - The display order of this template
- */
-export interface TechnologyDocumentationTemplate {
-  templateId: string;
-  isUserForm: boolean;
-  isRequired: boolean;
-  sortingOrder: number;
-}
-
-/**
- * Zahtevi koji su povezani sa tehnologijom
- * @property pre - Lista zahteva koji se moraju ispuniti pre procedure
- * @property post - Lista zahteva koji se moraju ispuniti posle procedure
- */
-export interface TechnologyRequirements {
-  pre: Requirement[];
-  post: Requirement[];
-}
-
-/**
- * Technology used in medical procedures
- * Technologies are now a top-level collection that reference their full path in the hierarchy
- * through family, category, and subcategory IDs
- *
- * @property id - Unique identifier of the technology
- * @property name - Name of the technology
- * @property description - Detailed description of the technology and its application
- * @property family - The procedure family this technology belongs to (aesthetics/surgery)
- * @property categoryId - ID of the category this technology belongs to
- * @property subcategoryId - ID of the subcategory this technology belongs to
- * @property technicalDetails - Technical specifications and details
- * @property requirements - List of pre and post procedure requirements
- * @property blockingConditions - List of conditions that prevent the procedure
- * @property contraindications - List of conditions requiring special attention
- * @property benefits - List of expected benefits from the procedure
- * @property certificationRequirement - Required certification level and specialties
- * @property documentationTemplates - List of documentation template references
- * @property isActive - Whether the technology is active in the system
- * @property createdAt - Creation date
- * @property updatedAt - Last update date
- */
-export interface Technology {
-  id?: string;
-  name: string;
-  description: string;
-  family: ProcedureFamily;
-  categoryId: string;
-  subcategoryId: string;
-  technicalDetails?: string;
-  requirements: {
-    pre: Requirement[];
-    post: Requirement[];
-  };
-  blockingConditions: BlockingCondition[];
-  contraindications: ContraindicationDynamic[];
-  benefits: TreatmentBenefitDynamic[];
-  certificationRequirement: CertificationRequirement;
-  documentationTemplates?: TechnologyDocumentationTemplate[];
-  /** Media ID of the default photo template image for this technology */
-  photoTemplate?: string;
-  isActive: boolean;
-  createdAt: Date;
-  updatedAt: Date;
-}
-
-/**
- * Collection in Firestore database where technologies are stored
- */
-export const TECHNOLOGIES_COLLECTION = 'technologies';
-
-/**
- * Interface for the TechnologyService class
- */
-export 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[];
-  }>;
-  getAllForFilterBySubcategory(subcategoryId: string): Promise<Technology[]>;
-  getAllForFilterBySubcategoryId(categoryId: string, subcategoryId: string): Promise<Technology[]>;
-  getAllForFilter(): Promise<Technology[]>;
-}
+import { Requirement } from './requirement.types';
+import { BlockingCondition } from './static/blocking-condition.types';
+import { CertificationRequirement } from './static/certification.types';
+import { DocumentTemplate } from '../../types/documentation-templates';
+import { ProcedureFamily } from './static/procedure-family.types';
+import { ContraindicationDynamic } from './admin-constants.types';
+import { TreatmentBenefitDynamic } from './admin-constants.types';
+
+/**
+ * Reference to a documentation template with metadata
+ * @property templateId - ID of the documentation template
+ * @property isUserForm - Whether this template is filled by users
+ * @property isRequired - Whether this template is required
+ * @property sortingOrder - The display order of this template
+ */
+export interface TechnologyDocumentationTemplate {
+  templateId: string;
+  isUserForm: boolean;
+  isRequired: boolean;
+  sortingOrder: number;
+}
+
+/**
+ * Zahtevi koji su povezani sa tehnologijom
+ * @property pre - Lista zahteva koji se moraju ispuniti pre procedure
+ * @property post - Lista zahteva koji se moraju ispuniti posle procedure
+ */
+export interface TechnologyRequirements {
+  pre: Requirement[];
+  post: Requirement[];
+}
+
+/**
+ * Technology used in medical procedures
+ * Technologies are now a top-level collection that reference their full path in the hierarchy
+ * through family, category, and subcategory IDs
+ *
+ * @property id - Unique identifier of the technology
+ * @property name - Name of the technology
+ * @property description - Detailed description of the technology and its application
+ * @property family - The procedure family this technology belongs to (aesthetics/surgery)
+ * @property categoryId - ID of the category this technology belongs to
+ * @property subcategoryId - ID of the subcategory this technology belongs to
+ * @property technicalDetails - Technical specifications and details
+ * @property requirements - List of pre and post procedure requirements
+ * @property blockingConditions - List of conditions that prevent the procedure
+ * @property contraindications - List of conditions requiring special attention
+ * @property benefits - List of expected benefits from the procedure
+ * @property certificationRequirement - Required certification level and specialties
+ * @property documentationTemplates - List of documentation template references
+ * @property isActive - Whether the technology is active in the system
+ * @property createdAt - Creation date
+ * @property updatedAt - Last update date
+ */
+export interface Technology {
+  id?: string;
+  name: string;
+  description: string;
+  family: ProcedureFamily;
+  categoryId: string;
+  subcategoryId: string;
+  technicalDetails?: string;
+  requirements: {
+    pre: Requirement[];
+    post: Requirement[];
+  };
+  blockingConditions: BlockingCondition[];
+  contraindications: ContraindicationDynamic[];
+  benefits: TreatmentBenefitDynamic[];
+  certificationRequirement: CertificationRequirement;
+  documentationTemplates?: TechnologyDocumentationTemplate[];
+  /** Media ID of the default photo template image for this technology */
+  photoTemplate?: string;
+  isActive: boolean;
+  createdAt: Date;
+  updatedAt: Date;
+}
+
+/**
+ * Collection in Firestore database where technologies are stored
+ */
+export const TECHNOLOGIES_COLLECTION = 'technologies';
+
+/**
+ * Interface for the TechnologyService class
+ */
+export 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[];
+  }>;
+  getAllForFilterBySubcategory(subcategoryId: string): Promise<Technology[]>;
+  getAllForFilterBySubcategoryId(categoryId: string, subcategoryId: string): Promise<Technology[]>;
+  getAllForFilter(): Promise<Technology[]>;
+  findByName(name: string): Promise<Technology | null>;
+  exportToCsv(options?: {
+    includeInactive?: boolean;
+    includeBom?: boolean;
+  }): Promise<string>;
+}

package/src/backoffice/validations/index.ts

@@ -1 +1 @@
-export * from "./schemas";
+export * from "./schemas";

package/src/backoffice/validations/schemas.ts

@@ -1,164 +1,164 @@
-import { z } from "zod";
-import { ProcedureFamily } from "../types/static/procedure-family.types";
-import { BlockingCondition } from "../types/static/blocking-condition.types";
-import { TimeUnit, RequirementType } from "../types/requirement.types";
-import {
-  CertificationLevel,
-  CertificationSpecialty,
-} from "../types/static/certification.types";
-
-import { documentTemplateSchema } from "../../validations/documentation-templates.schema";
-
-/**
- * Zod validation schema for a single dynamic contraindication.
- * @see ContraindicationDynamic in admin-constants.types.ts
- */
-export const contraindicationDynamicSchema = z.object({
-  id: z
-    .string()
-    .min(1, "Contraindication ID is required")
-    .regex(
-      /^[a-z0-9_]+$/,
-      "ID must be in snake_case (lowercase, numbers, and underscores only)"
-    ),
-  name: z.string().min(1, "Contraindication name is required"),
-  description: z.string().optional(),
-});
-
-/**
- * Zod validation schema for a single dynamic treatment benefit.
- * @see TreatmentBenefitDynamic in admin-constants.types.ts
- */
-export const treatmentBenefitDynamicSchema = z.object({
-  id: z
-    .string()
-    .min(1, "Benefit ID is required")
-    .regex(
-      /^[a-z0-9_]+$/,
-      "ID must be in snake_case (lowercase, numbers, and underscores only)"
-    ),
-  name: z.string().min(1, "Benefit name is required"),
-  description: z.string().optional(),
-});
-
-/**
- * Base validation schemas for enums
- */
-export const blockingConditionSchemaBackoffice =
-  z.nativeEnum(BlockingCondition);
-export const contraindicationSchemaBackoffice = contraindicationDynamicSchema;
-export const treatmentBenefitSchemaBackoffice = treatmentBenefitDynamicSchema;
-export const procedureFamilySchemaBackoffice = z.nativeEnum(ProcedureFamily);
-export const timeUnitSchemaBackoffice = z.nativeEnum(TimeUnit);
-export const requirementTypeSchema = z.nativeEnum(RequirementType);
-export const certificationLevelSchema = z.nativeEnum(CertificationLevel);
-export const certificationSpecialtySchema = z.nativeEnum(
-  CertificationSpecialty
-);
-
-/**
- * Certification requirement validation schema
- */
-export const certificationRequirementSchema = z.object({
-  minimumLevel: certificationLevelSchema,
-  requiredSpecialties: z
-    .array(certificationSpecialtySchema)
-    .max(5, "Maximum 5 specialties allowed")
-    .optional(),
-});
-
-/**
- * Timeframe validation schema
- */
-export const timeframeSchema = z.object({
-  duration: z.number().min(1, "Duration must be positive"),
-  unit: timeUnitSchemaBackoffice,
-  notifyAt: z
-    .array(z.number())
-    .min(1, "At least one notification point is required"),
-});
-
-/**
- * Requirement validation schema
- */
-export const requirementSchema = z.object({
-  name: z.string().min(1, "Name is required").max(100, "Name is too long"),
-  description: z.string().min(1, "Description is required"),
-  type: requirementTypeSchema,
-  timeframe: timeframeSchema,
-  importance: z.enum(["low", "medium", "high"]),
-  isActive: z.boolean().default(true),
-});
-
-/**
- * Technology requirements validation schema
- */
-export const technologyRequirementsSchema = z.object({
-  pre: z.array(requirementSchema),
-  post: z.array(requirementSchema),
-});
-
-/**
- * Technology validation schema
- */
-export const technologySchema = z.object({
-  name: z.string().min(1, "Name is required").max(100, "Name is too long"),
-  description: z.string().max(1000, "Description is too long").optional(),
-  technicalDetails: z
-    .string()
-    .max(2000, "Technical details are too long")
-    .optional(),
-  family: procedureFamilySchemaBackoffice,
-  categoryId: z.string().min(1, "Category ID is required"),
-  subcategoryId: z.string().min(1, "Subcategory ID is required"),
-  requirements: technologyRequirementsSchema.default({
-    pre: [],
-    post: [],
-  }),
-  blockingConditions: z.array(blockingConditionSchemaBackoffice),
-  contraindications: z.array(contraindicationSchemaBackoffice),
-  documentationTemplates: z.array(documentTemplateSchema),
-  benefits: z.array(treatmentBenefitSchemaBackoffice),
-  certificationRequirement: certificationRequirementSchema,
-  photoTemplate: z.string().url("Photo template must be a valid URL").optional(),
-  isActive: z.boolean().default(true),
-});
-
-/**
- * Category validation schema
- */
-export const categorySchema = z.object({
-  name: z.string().min(1, "Name is required").max(100, "Name is too long"),
-  description: z.string().optional(),
-  family: procedureFamilySchemaBackoffice,
-  isActive: z.boolean().default(true),
-});
-
-/**
- * Subcategory validation schema
- */
-export const subcategorySchema = z.object({
-  name: z.string().min(1, "Name is required").max(100, "Name is too long"),
-  description: z.string().optional(),
-  categoryId: z.string().min(1, "Category ID is required"),
-  isActive: z.boolean().default(true),
-});
-
-/**
- * Partial schemas for updates
- */
-export const categoryUpdateSchema = categorySchema.partial();
-export const subcategoryUpdateSchema = subcategorySchema.partial();
-export const technologyUpdateSchema = technologySchema.partial();
-export const requirementUpdateSchema = requirementSchema.partial();
-
-/**
- * Documentation Templates schemas
- */
-export {
-  createDocumentTemplateSchema,
-  updateDocumentTemplateSchema,
-  documentTemplateSchema,
-  documentElementSchema,
-  documentElementWithoutIdSchema,
-} from "../../validations/documentation-templates.schema";
+import { z } from "zod";
+import { ProcedureFamily } from "../types/static/procedure-family.types";
+import { BlockingCondition } from "../types/static/blocking-condition.types";
+import { TimeUnit, RequirementType } from "../types/requirement.types";
+import {
+  CertificationLevel,
+  CertificationSpecialty,
+} from "../types/static/certification.types";
+
+import { documentTemplateSchema } from "../../validations/documentation-templates.schema";
+
+/**
+ * Zod validation schema for a single dynamic contraindication.
+ * @see ContraindicationDynamic in admin-constants.types.ts
+ */
+export const contraindicationDynamicSchema = z.object({
+  id: z
+    .string()
+    .min(1, "Contraindication ID is required")
+    .regex(
+      /^[a-z0-9_]+$/,
+      "ID must be in snake_case (lowercase, numbers, and underscores only)"
+    ),
+  name: z.string().min(1, "Contraindication name is required"),
+  description: z.string().optional(),
+});
+
+/**
+ * Zod validation schema for a single dynamic treatment benefit.
+ * @see TreatmentBenefitDynamic in admin-constants.types.ts
+ */
+export const treatmentBenefitDynamicSchema = z.object({
+  id: z
+    .string()
+    .min(1, "Benefit ID is required")
+    .regex(
+      /^[a-z0-9_]+$/,
+      "ID must be in snake_case (lowercase, numbers, and underscores only)"
+    ),
+  name: z.string().min(1, "Benefit name is required"),
+  description: z.string().optional(),
+});
+
+/**
+ * Base validation schemas for enums
+ */
+export const blockingConditionSchemaBackoffice =
+  z.nativeEnum(BlockingCondition);
+export const contraindicationSchemaBackoffice = contraindicationDynamicSchema;
+export const treatmentBenefitSchemaBackoffice = treatmentBenefitDynamicSchema;
+export const procedureFamilySchemaBackoffice = z.nativeEnum(ProcedureFamily);
+export const timeUnitSchemaBackoffice = z.nativeEnum(TimeUnit);
+export const requirementTypeSchema = z.nativeEnum(RequirementType);
+export const certificationLevelSchema = z.nativeEnum(CertificationLevel);
+export const certificationSpecialtySchema = z.nativeEnum(
+  CertificationSpecialty
+);
+
+/**
+ * Certification requirement validation schema
+ */
+export const certificationRequirementSchema = z.object({
+  minimumLevel: certificationLevelSchema,
+  requiredSpecialties: z
+    .array(certificationSpecialtySchema)
+    .max(5, "Maximum 5 specialties allowed")
+    .optional(),
+});
+
+/**
+ * Timeframe validation schema
+ */
+export const timeframeSchema = z.object({
+  duration: z.number().min(1, "Duration must be positive"),
+  unit: timeUnitSchemaBackoffice,
+  notifyAt: z
+    .array(z.number())
+    .min(1, "At least one notification point is required"),
+});
+
+/**
+ * Requirement validation schema
+ */
+export const requirementSchema = z.object({
+  name: z.string().min(1, "Name is required").max(100, "Name is too long"),
+  description: z.string().min(1, "Description is required"),
+  type: requirementTypeSchema,
+  timeframe: timeframeSchema,
+  importance: z.enum(["low", "medium", "high"]),
+  isActive: z.boolean().default(true),
+});
+
+/**
+ * Technology requirements validation schema
+ */
+export const technologyRequirementsSchema = z.object({
+  pre: z.array(requirementSchema),
+  post: z.array(requirementSchema),
+});
+
+/**
+ * Technology validation schema
+ */
+export const technologySchema = z.object({
+  name: z.string().min(1, "Name is required").max(100, "Name is too long"),
+  description: z.string().max(1000, "Description is too long").optional(),
+  technicalDetails: z
+    .string()
+    .max(2000, "Technical details are too long")
+    .optional(),
+  family: procedureFamilySchemaBackoffice,
+  categoryId: z.string().min(1, "Category ID is required"),
+  subcategoryId: z.string().min(1, "Subcategory ID is required"),
+  requirements: technologyRequirementsSchema.default({
+    pre: [],
+    post: [],
+  }),
+  blockingConditions: z.array(blockingConditionSchemaBackoffice),
+  contraindications: z.array(contraindicationSchemaBackoffice),
+  documentationTemplates: z.array(documentTemplateSchema),
+  benefits: z.array(treatmentBenefitSchemaBackoffice),
+  certificationRequirement: certificationRequirementSchema,
+  photoTemplate: z.string().url("Photo template must be a valid URL").optional(),
+  isActive: z.boolean().default(true),
+});
+
+/**
+ * Category validation schema
+ */
+export const categorySchema = z.object({
+  name: z.string().min(1, "Name is required").max(100, "Name is too long"),
+  description: z.string().optional(),
+  family: procedureFamilySchemaBackoffice,
+  isActive: z.boolean().default(true),
+});
+
+/**
+ * Subcategory validation schema
+ */
+export const subcategorySchema = z.object({
+  name: z.string().min(1, "Name is required").max(100, "Name is too long"),
+  description: z.string().optional(),
+  categoryId: z.string().min(1, "Category ID is required"),
+  isActive: z.boolean().default(true),
+});
+
+/**
+ * Partial schemas for updates
+ */
+export const categoryUpdateSchema = categorySchema.partial();
+export const subcategoryUpdateSchema = subcategorySchema.partial();
+export const technologyUpdateSchema = technologySchema.partial();
+export const requirementUpdateSchema = requirementSchema.partial();
+
+/**
+ * Documentation Templates schemas
+ */
+export {
+  createDocumentTemplateSchema,
+  updateDocumentTemplateSchema,
+  documentTemplateSchema,
+  documentElementSchema,
+  documentElementWithoutIdSchema,
+} from "../../validations/documentation-templates.schema";