@blackcode_sa/metaestetics-api 1.6.3 → 1.6.5

package/src/validations/appointment.schema.ts

@@ -1,86 +1,275 @@
 import { z } from "zod";
-import { AppointmentStatus, PaymentStatus } from "../types/appointment";
+import {
+  AppointmentStatus,
+  PaymentStatus,
+  MediaType,
+} from "../types/appointment";
+import { filledDocumentStatusSchema } from "./documentation-templates.schema";
 
-/**
- * Schema for validating appointment creation data
- */
-export const createAppointmentSchema = z.object({
-  calendarEventId: z.string().min(1, "Calendar event ID is required"),
-  clinicBranchId: z.string().min(1, "Clinic branch ID is required"),
-  practitionerId: z.string().min(1, "Practitioner ID is required"),
-  patientId: z.string().min(1, "Patient ID is required"),
-  procedureId: z.string().min(1, "Procedure ID is required"),
-  appointmentStartTime: z
+// Define common constants locally if not available from common.schema.ts
+const MIN_STRING_LENGTH = 1;
+const MAX_STRING_LENGTH = 1024; // Example value
+const MAX_STRING_LENGTH_LONG = 4096; // Example value for longer notes/comments
+const MAX_ARRAY_LENGTH = 100; // Example value
+
+// --- Enum Schemas ---
+export const appointmentStatusSchema = z.nativeEnum(AppointmentStatus);
+export const paymentStatusSchema = z.nativeEnum(PaymentStatus);
+export const mediaTypeSchema = z.nativeEnum(MediaType);
+
+// --- Schemas for Nested Objects from types/appointment/index.ts ---
+
+export const appointmentMediaItemSchema = z.object({
+  id: z.string().min(MIN_STRING_LENGTH, "Media item ID is required"),
+  type: mediaTypeSchema,
+  url: z.string().url("Media URL must be a valid URL"),
+  fileName: z.string().optional(),
+  uploadedAt: z
     .any()
     .refine(
-      (val) => val instanceof Date || val?._seconds !== undefined,
-      "Appointment start time must be a valid timestamp"
+      (val) =>
+        val instanceof Date ||
+        val?._seconds !== undefined ||
+        typeof val === "number",
+      "uploadedAt must be a valid timestamp or Date object"
     ),
-  appointmentEndTime: z
+  uploadedBy: z
+    .string()
+    .min(MIN_STRING_LENGTH, "Uploaded by user ID is required"),
+  description: z
+    .string()
+    .max(MAX_STRING_LENGTH, "Description too long")
+    .optional(),
+});
+
+export const procedureExtendedInfoSchema = z.object({
+  id: z.string().min(MIN_STRING_LENGTH),
+  name: z.string().min(MIN_STRING_LENGTH),
+  description: z.string(),
+  cost: z.number().min(0),
+  duration: z.number().min(0),
+  procedureFamily: z.any(),
+  procedureCategoryId: z.string(),
+  procedureCategoryName: z.string(),
+  procedureSubCategoryId: z.string(),
+  procedureSubCategoryName: z.string(),
+  procedureTechnologyId: z.string(),
+  procedureTechnologyName: z.string(),
+  procedureProductBrandId: z.string(),
+  procedureProductBrandName: z.string(),
+  procedureProductId: z.string(),
+  procedureProductName: z.string(),
+});
+
+export const linkedFormInfoSchema = z.object({
+  formId: z.string().min(MIN_STRING_LENGTH, "Form ID is required"),
+  templateId: z.string().min(MIN_STRING_LENGTH, "Template ID is required"),
+  templateVersion: z
+    .number()
+    .int()
+    .positive("Template version must be a positive integer"),
+  title: z.string().min(MIN_STRING_LENGTH, "Form title is required"),
+  isUserForm: z.boolean(),
+  status: filledDocumentStatusSchema,
+  path: z.string().min(MIN_STRING_LENGTH, "Form path is required"),
+  submittedAt: z
+    .any()
+    .refine(
+      (val) =>
+        val === undefined ||
+        val instanceof Date ||
+        val?._seconds !== undefined ||
+        typeof val === "number",
+      "submittedAt must be a valid timestamp or Date object"
+    )
+    .optional(),
+  completedAt: z
     .any()
     .refine(
-      (val) => val instanceof Date || val?._seconds !== undefined,
-      "Appointment end time must be a valid timestamp"
+      (val) =>
+        val === undefined ||
+        val instanceof Date ||
+        val?._seconds !== undefined ||
+        typeof val === "number",
+      "completedAt must be a valid timestamp or Date object"
+    )
+    .optional(),
+});
+
+export const patientReviewInfoSchema = z.object({
+  reviewId: z.string().min(MIN_STRING_LENGTH, "Review ID is required"),
+  rating: z.number().min(1).max(5, "Rating must be between 1 and 5"),
+  comment: z
+    .string()
+    .max(MAX_STRING_LENGTH_LONG, "Comment too long")
+    .optional(),
+  reviewedAt: z
+    .any()
+    .refine(
+      (val) =>
+        val instanceof Date ||
+        val?._seconds !== undefined ||
+        typeof val === "number",
+      "reviewedAt must be a valid timestamp or Date object"
     ),
-  cost: z.number().min(0, "Cost must be a non-negative number"),
-  currency: z.string().min(1, "Currency is required"),
-  patientNotes: z.string().nullable().optional(),
-  initialStatus: z.nativeEnum(AppointmentStatus, {
-    errorMap: () => ({ message: "Invalid appointment status" }),
-  }),
-  initialPaymentStatus: z
-    .nativeEnum(PaymentStatus, {
-      errorMap: () => ({ message: "Invalid payment status" }),
-    })
-    .optional()
-    .default(PaymentStatus.UNPAID),
 });
 
+export const finalizedDetailsSchema = z.object({
+  by: z.string().min(MIN_STRING_LENGTH, "Finalized by user ID is required"),
+  at: z
+    .any()
+    .refine(
+      (val) =>
+        val instanceof Date ||
+        val?._seconds !== undefined ||
+        typeof val === "number",
+      "Finalized at must be a valid timestamp or Date object"
+    ),
+  notes: z
+    .string()
+    .max(MAX_STRING_LENGTH_LONG, "Finalization notes too long")
+    .optional(),
+});
+
+// --- Main Appointment Schemas ---
+
+/**
+ * Schema for validating appointment creation data
+ */
+export const createAppointmentSchema = z
+  .object({
+    clinicBranchId: z
+      .string()
+      .min(MIN_STRING_LENGTH, "Clinic branch ID is required"),
+    practitionerId: z
+      .string()
+      .min(MIN_STRING_LENGTH, "Practitioner ID is required"),
+    patientId: z.string().min(MIN_STRING_LENGTH, "Patient ID is required"),
+    procedureId: z.string().min(MIN_STRING_LENGTH, "Procedure ID is required"),
+    appointmentStartTime: z
+      .any()
+      .refine(
+        (val) =>
+          val instanceof Date ||
+          val?._seconds !== undefined ||
+          typeof val === "number",
+        "Appointment start time must be a valid timestamp or Date object"
+      ),
+    appointmentEndTime: z
+      .any()
+      .refine(
+        (val) =>
+          val instanceof Date ||
+          val?._seconds !== undefined ||
+          typeof val === "number",
+        "Appointment end time must be a valid timestamp or Date object"
+      ),
+    cost: z.number().min(0, "Cost must be a non-negative number"),
+    currency: z.string().min(1, "Currency is required"),
+    patientNotes: z
+      .string()
+      .max(MAX_STRING_LENGTH, "Patient notes too long")
+      .nullable()
+      .optional(),
+    initialStatus: appointmentStatusSchema,
+    initialPaymentStatus: paymentStatusSchema
+      .optional()
+      .default(PaymentStatus.UNPAID),
+  })
+  .refine((data) => data.appointmentEndTime > data.appointmentStartTime, {
+    message: "Appointment end time must be after start time",
+    path: ["appointmentEndTime"],
+  });
+
 /**
  * Schema for validating appointment update data
  */
 export const updateAppointmentSchema = z
   .object({
-    status: z
-      .nativeEnum(AppointmentStatus, {
-        errorMap: () => ({ message: "Invalid appointment status" }),
-      })
+    status: appointmentStatusSchema.optional(),
+    confirmationTime: z.any().optional().nullable(),
+    cancellationTime: z.any().optional().nullable(),
+    rescheduleTime: z.any().optional().nullable(),
+    procedureActualStartTime: z.any().optional().nullable(),
+    actualDurationMinutes: z
+      .number()
+      .int()
+      .positive("Duration must be a positive integer")
+      .optional(),
+    cancellationReason: z
+      .string()
+      .max(MAX_STRING_LENGTH, "Cancellation reason too long")
+      .nullable()
+      .optional(),
+    canceledBy: z
+      .enum(["patient", "clinic", "practitioner", "system"])
+      .optional(),
+    internalNotes: z
+      .string()
+      .max(MAX_STRING_LENGTH_LONG, "Internal notes too long")
+      .nullable()
+      .optional(),
+    patientNotes: z.any().optional().nullable(),
+    paymentStatus: paymentStatusSchema.optional(),
+    paymentTransactionId: z.any().optional().nullable(),
+    completedPreRequirements: z
+      .union([z.array(z.string()), z.any()])
       .optional(),
-    confirmationTime: z
+    completedPostRequirements: z
+      .union([z.array(z.string()), z.any()])
+      .optional(),
+    linkedFormIds: z.union([z.array(z.string()), z.any()]).optional(),
+    pendingUserFormsIds: z.union([z.array(z.string()), z.any()]).optional(),
+    appointmentStartTime: z
       .any()
       .refine(
         (val) =>
-          val === null ||
           val === undefined ||
           val instanceof Date ||
-          val?._seconds !== undefined,
-        "Confirmation time must be a valid timestamp or null"
+          val?._seconds !== undefined ||
+          typeof val === "number",
+        "Appointment start time must be a valid timestamp or Date object"
       )
       .optional(),
-    actualDurationMinutes: z
-      .number()
-      .positive("Duration must be positive")
+    appointmentEndTime: z
+      .any()
+      .refine(
+        (val) =>
+          val === undefined ||
+          val instanceof Date ||
+          val?._seconds !== undefined ||
+          typeof val === "number",
+        "Appointment end time must be a valid timestamp or Date object"
+      )
       .optional(),
-    cancellationReason: z.string().nullable().optional(),
-    canceledBy: z
-      .enum(["patient", "clinic", "practitioner", "system"])
+    calendarEventId: z.string().min(MIN_STRING_LENGTH).optional(),
+    cost: z.number().min(0).optional(),
+    clinicBranchId: z.string().min(MIN_STRING_LENGTH).optional(),
+    practitionerId: z.string().min(MIN_STRING_LENGTH).optional(),
+    linkedForms: z
+      .union([z.array(linkedFormInfoSchema).max(MAX_ARRAY_LENGTH), z.any()])
       .optional(),
-    internalNotes: z.string().nullable().optional(),
-    paymentStatus: z
-      .nativeEnum(PaymentStatus, {
-        errorMap: () => ({ message: "Invalid payment status" }),
-      })
+    media: z
+      .union([
+        z.array(appointmentMediaItemSchema).max(MAX_ARRAY_LENGTH),
+        z.any(),
+      ])
+      .optional(),
+    reviewInfo: z
+      .union([patientReviewInfoSchema.nullable(), z.any()])
+      .optional(),
+    finalizedDetails: z
+      .union([finalizedDetailsSchema.nullable(), z.any()])
       .optional(),
-    paymentTransactionId: z.string().nullable().optional(),
-    completedPreRequirements: z.array(z.string()).optional(),
-    completedPostRequirements: z.array(z.string()).optional(),
+    isArchived: z.boolean().optional(),
+    updatedAt: z.any().optional(),
   })
   .refine(
     (data) => {
-      // If status is being set to canceled, make sure reason and canceledBy are provided
       if (
         data.status === AppointmentStatus.CANCELED_CLINIC ||
-        data.status === AppointmentStatus.CANCELED_PATIENT
+        data.status === AppointmentStatus.CANCELED_PATIENT ||
+        data.status === AppointmentStatus.CANCELED_PATIENT_RESCHEDULED
       ) {
         return !!data.cancellationReason && !!data.canceledBy;
       }
@@ -88,9 +277,22 @@ export const updateAppointmentSchema = z
     },
     {
       message:
-        "Cancellation reason and canceled by must be provided when canceling an appointment",
+        "Cancellation reason and canceled by must be provided when canceling an appointment with patient or clinic origin.",
       path: ["status"],
     }
+  )
+  .refine(
+    (data) => {
+      if (data.appointmentStartTime && data.appointmentEndTime) {
+        return data.appointmentEndTime > data.appointmentStartTime;
+      }
+      return true;
+    },
+    {
+      message:
+        "Appointment end time must be after start time if both are provided",
+      path: ["appointmentEndTime"],
+    }
   );
 
 /**
@@ -101,25 +303,59 @@ export const searchAppointmentsSchema = z
     patientId: z.string().optional(),
     practitionerId: z.string().optional(),
     clinicBranchId: z.string().optional(),
-    startDate: z.date().optional(),
-    endDate: z.date().optional(),
+    startDate: z
+      .any()
+      .refine(
+        (val) =>
+          val === undefined ||
+          val instanceof Date ||
+          val?._seconds !== undefined ||
+          typeof val === "number",
+        "Start date must be a valid timestamp or Date object"
+      )
+      .optional(),
+    endDate: z
+      .any()
+      .refine(
+        (val) =>
+          val === undefined ||
+          val instanceof Date ||
+          val?._seconds !== undefined ||
+          typeof val === "number",
+        "End date must be a valid timestamp or Date object"
+      )
+      .optional(),
     status: z
       .union([
-        z.nativeEnum(AppointmentStatus),
-        z.array(z.nativeEnum(AppointmentStatus)),
+        appointmentStatusSchema,
+        z.array(appointmentStatusSchema).nonempty(),
       ])
       .optional(),
-    limit: z.number().positive().optional(),
+    limit: z.number().positive().int().optional().default(20),
     startAfter: z.any().optional(),
   })
   .refine(
     (data) => {
-      // Ensure at least one search parameter is provided
-      return !!(data.patientId || data.practitionerId || data.clinicBranchId);
+      if (!data.startDate && !data.endDate && !data.status) {
+        return !!(data.patientId || data.practitionerId || data.clinicBranchId);
+      }
+      return true;
     },
     {
       message:
-        "At least one of patientId, practitionerId, or clinicBranchId must be provided",
-      path: ["searchCriteria"],
+        "At least one of patientId, practitionerId, or clinicBranchId must be provided if no date or status filters are set.",
+      path: ["patientId"],
+    }
+  )
+  .refine(
+    (data) => {
+      if (data.startDate && data.endDate) {
+        return data.endDate >= data.startDate;
+      }
+      return true;
+    },
+    {
+      message: "End date must be after or the same as start date",
+      path: ["endDate"],
     }
   );

package/src/validations/documentation-templates/template.schema.ts

@@ -3,6 +3,7 @@ import {
   DocumentElementType,
   HeadingLevel,
   ListType,
+  FilledDocumentStatus,
 } from "../../types/documentation-templates";
 
 // Base element schema
@@ -93,6 +94,12 @@ const signatureElementSchema = baseElementSchema.extend({
   label: z.string().min(1).max(200),
 });
 
+// NEW: Digital signature element schema
+const digitalSignatureElementSchema = baseElementSchema.extend({
+  type: z.literal(DocumentElementType.DITIGAL_SIGNATURE), // Matching your type enum
+  label: z.string().min(1).max(200),
+});
+
 // File upload element schema
 const fileUploadElementSchema = baseElementSchema.extend({
   type: z.literal(DocumentElementType.FILE_UPLOAD),
@@ -114,6 +121,7 @@ export const documentElementSchema = z.discriminatedUnion("type", [
   textInputElementSchema,
   datePickerElementSchema,
   signatureElementSchema,
+  digitalSignatureElementSchema,
   fileUploadElementSchema,
 ]);
 
@@ -130,6 +138,7 @@ export const documentElementWithoutIdSchema = z.discriminatedUnion("type", [
   textInputElementSchema.omit({ id: true }),
   datePickerElementSchema.omit({ id: true }),
   signatureElementSchema.omit({ id: true }),
+  digitalSignatureElementSchema.omit({ id: true }),
   fileUploadElementSchema.omit({ id: true }),
 ]);
 
@@ -139,6 +148,9 @@ export const createDocumentTemplateSchema = z.object({
   description: z.string().max(1000).optional(),
   elements: z.array(documentElementWithoutIdSchema).min(1).max(100),
   tags: z.array(z.string().min(1).max(50)).max(20).optional(),
+  isUserForm: z.boolean().optional().default(false),
+  isRequired: z.boolean().optional().default(false),
+  sortingOrder: z.number().int().optional().default(0),
 });
 
 // Schema for updating a document template
@@ -148,6 +160,9 @@ export const updateDocumentTemplateSchema = z.object({
   elements: z.array(documentElementWithoutIdSchema).min(1).max(100).optional(),
   tags: z.array(z.string().min(1).max(50)).max(20).optional(),
   isActive: z.boolean().optional(),
+  isUserForm: z.boolean().optional(),
+  isRequired: z.boolean().optional(),
+  sortingOrder: z.number().int().optional(),
 });
 
 // Schema for a document template
@@ -162,4 +177,44 @@ export const documentTemplateSchema = z.object({
   tags: z.array(z.string().min(1).max(50)).max(20).optional(),
   version: z.number().int().positive(),
   isActive: z.boolean(),
+  isUserForm: z.boolean().optional().default(false),
+  isRequired: z.boolean().optional().default(false),
+  sortingOrder: z.number().int().optional().default(0),
+});
+
+// Filled Document Schemas
+export const filledDocumentStatusSchema = z.nativeEnum(FilledDocumentStatus);
+
+export const filledDocumentSchema = z.object({
+  id: z.string(),
+  templateId: z.string(),
+  templateVersion: z.number(),
+  isUserForm: z.boolean(),
+  procedureId: z.string(),
+  appointmentId: z.string(),
+  patientId: z.string(),
+  practitionerId: z.string(),
+  clinicId: z.string(),
+  createdAt: z.number(),
+  updatedAt: z.number(),
+  values: z.record(z.string(), z.any()),
+  status: filledDocumentStatusSchema,
+});
+
+export const createFilledDocumentDataSchema = z.object({
+  templateId: z.string(),
+  procedureId: z.string(),
+  appointmentId: z.string(),
+  patientId: z.string(),
+  practitionerId: z.string(),
+  clinicId: z.string(),
+  values: z.record(z.string(), z.any()).optional().default({}),
+  status: filledDocumentStatusSchema
+    .optional()
+    .default(FilledDocumentStatus.DRAFT),
+});
+
+export const updateFilledDocumentDataSchema = z.object({
+  values: z.record(z.string(), z.any()).optional(),
+  status: filledDocumentStatusSchema.optional(),
 });

package/src/validations/documentation-templates.schema.ts

@@ -1,15 +1,10 @@
-import {
-  createDocumentTemplateSchema,
-  updateDocumentTemplateSchema,
-  documentTemplateSchema,
-  documentElementSchema,
-  documentElementWithoutIdSchema,
-} from "./documentation-templates/template.schema";
+/**
+ * This file re-exports all schemas related to documentation templates and filled documents
+ * from their specific definition files.
+ */
 
-export {
-  createDocumentTemplateSchema,
-  updateDocumentTemplateSchema,
-  documentTemplateSchema,
-  documentElementSchema,
-  documentElementWithoutIdSchema,
-};
+// Assuming all relevant schemas, including filledDocumentStatusSchema,
+// documentTemplateSchema, createDocumentTemplateSchema, updateDocumentTemplateSchema,
+// filledDocumentSchema, createFilledDocumentDataSchema, updateFilledDocumentDataSchema etc.,
+// are defined and exported from './documentation-templates/template.schema.ts'
+export * from "./documentation-templates/template.schema";

package/src/validations/notification.schema.ts

@@ -24,7 +24,7 @@ export const baseNotificationSchema = z.object({
  * Validaciona šema za pre-requirement notifikaciju
  */
 export const preRequirementNotificationSchema = baseNotificationSchema.extend({
-  notificationType: z.literal(NotificationType.PRE_REQUIREMENT),
+  notificationType: z.literal(NotificationType.REQUIREMENT_INSTRUCTION_DUE),
   treatmentId: z.string(),
   requirements: z.array(z.string()),
   deadline: z.any(), // Timestamp
@@ -34,7 +34,7 @@ export const preRequirementNotificationSchema = baseNotificationSchema.extend({
  * Validaciona šema za post-requirement notifikaciju
  */
 export const postRequirementNotificationSchema = baseNotificationSchema.extend({
-  notificationType: z.literal(NotificationType.POST_REQUIREMENT),
+  notificationType: z.literal(NotificationType.REQUIREMENT_INSTRUCTION_DUE),
   treatmentId: z.string(),
   requirements: z.array(z.string()),
   deadline: z.any(), // Timestamp
@@ -56,7 +56,7 @@ export const appointmentReminderNotificationSchema =
  * Validaciona šema za appointment notifikaciju
  */
 export const appointmentNotificationSchema = baseNotificationSchema.extend({
-  notificationType: z.literal(NotificationType.APPOINTMENT_NOTIFICATION),
+  notificationType: z.literal(NotificationType.APPOINTMENT_STATUS_CHANGE),
   appointmentId: z.string(),
   appointmentStatus: z.string(),
   previousStatus: z.string(),

package/src/validations/patient/patient-requirements.schema.ts

@@ -0,0 +1,75 @@
+import { z } from "zod";
+import {
+  PatientInstructionStatus,
+  PatientRequirementOverallStatus,
+} from "../../types/patient/patient-requirements";
+import {
+  requirementTypeSchema,
+  timeUnitSchema, // Corrected import name to lowercase 'u'
+} from "../../backoffice/validations/schemas";
+
+/**
+ * Zod schema for `PatientInstructionStatus` enum.
+ */
+export const patientInstructionStatusSchema = z.nativeEnum(
+  PatientInstructionStatus
+);
+
+/**
+ * Zod schema for `PatientRequirementInstruction` interface.
+ */
+export const patientRequirementInstructionSchema = z.object({
+  instructionId: z.string().min(1, "Instruction ID is required."),
+  instructionText: z.string().min(1, "Instruction text is required."),
+  dueTime: z.any(), // Firestore Timestamp
+  actionableWindow: z.number().default(1),
+  status: patientInstructionStatusSchema,
+  originalNotifyAtValue: z.number(),
+  originalTimeframeUnit: timeUnitSchema, // Use the correctly imported timeUnitSchema
+  notificationId: z.string().optional(),
+  actionTakenAt: z.any().optional().nullable(), // Firestore Timestamp or null
+  updatedAt: z.any(), // Firestore Timestamp
+});
+
+/**
+ * Zod schema for `PatientRequirementOverallStatus` enum.
+ */
+export const patientRequirementOverallStatusSchema = z.nativeEnum(
+  PatientRequirementOverallStatus
+);
+
+/**
+ * Define requirementImportanceSchema locally as it's not exported directly from backoffice.
+ */
+export const requirementImportanceSchema = z.enum(["low", "medium", "high"]);
+
+/**
+ * Zod schema for `PatientRequirementInstance` interface.
+ */
+export const patientRequirementInstanceSchema = z.object({
+  id: z.string().min(1, "Instance ID is required."),
+  patientId: z.string().min(1, "Patient ID is required."),
+  appointmentId: z.string().min(1, "Appointment ID is required."),
+  originalRequirementId: z
+    .string()
+    .min(1, "Original Requirement ID is required."),
+  requirementType: requirementTypeSchema,
+  requirementName: z.string().min(1, "Requirement name is required."),
+  requirementDescription: z.string(),
+  requirementImportance: requirementImportanceSchema, // Use the locally defined schema
+  overallStatus: patientRequirementOverallStatusSchema,
+  instructions: z
+    .array(patientRequirementInstructionSchema)
+    .min(1, "At least one instruction is required."),
+  createdAt: z.any(), // Firestore Timestamp
+  updatedAt: z.any(), // Firestore Timestamp
+});
+
+/**
+ * Schema for updating a `PatientRequirementInstruction` status (subset of fields).
+ * Useful for when a patient marks an instruction as actioned.
+ */
+export const updatePatientInstructionStatusSchema = z.object({
+  status: z.literal(PatientInstructionStatus.ACTION_TAKEN),
+  actionTakenAt: z.any(), // Should be a Timestamp from the server
+});

package/src/validations/procedure.schema.ts

@@ -24,6 +24,7 @@ export const createProcedureSchema = z.object({
   duration: z.number().min(1).max(480), // Max 8 hours
   practitionerId: z.string().min(1),
   clinicBranchId: z.string().min(1),
+  photos: z.array(z.string()).optional(),
 });
 
 /**
@@ -43,6 +44,7 @@ export const updateProcedureSchema = z.object({
   technologyId: z.string().optional(),
   productId: z.string().optional(),
   clinicBranchId: z.string().optional(),
+  photos: z.array(z.string()).optional(),
 });
 
 /**
@@ -55,6 +57,7 @@ export const procedureSchema = createProcedureSchema.extend({
   technology: z.any(), // We'll validate the full technology object separately
   product: z.any(), // We'll validate the full product object separately
   blockingConditions: z.array(z.any()), // We'll validate blocking conditions separately
+  contraindications: z.array(z.any()), // We'll validate contraindications separately
   treatmentBenefits: z.array(z.any()), // We'll validate treatment benefits separately
   preRequirements: z.array(z.any()), // We'll validate requirements separately
   postRequirements: z.array(z.any()), // We'll validate requirements separately