@venulog/phasing-engine-schemas 0.2.0-alpha.1 → 0.2.1

package/dist/phaseBooking.js

@@ -3,7 +3,7 @@ import { paginationSchema } from './pagination.js';
 import { BookingStatus } from './enums/bookingStatus.js';
 import { createSuccessResponseSchema, createMessageDataResponseSchema } from './common.js';
 import { z } from './zod.js';
-import { SlotStatus } from './enums/slotStatus.js';
+import { PhaseSlotScheduleType } from './enums/phaseSlotScheduleType.js';
 // ------------------------------
 // Query parameters schema
 // ------------------------------
@@ -25,22 +25,6 @@ export const getEventBookingsQuerySchema = z
 })
     .extend(paginationSchema.shape)
     .openapi('GetEventBookingsQuery');
-// ------------------------------
-// Path parameters schema
-// ------------------------------
-export const cancelPhaseSlotParamsSchema = z
-    .object({
-    slotId: z
-        .string()
-        .min(1, 'Slot ID is required')
-        .transform(val => parseInt(val, 10))
-        .refine(val => !isNaN(val) && val > 0, { message: 'Slot ID must be positive' })
-        .openapi({
-        description: 'The ID of the phase slot to cancel',
-        example: '1'
-    })
-})
-    .openapi('CancelPhaseSlotParams');
 export const closeEventParamsSchema = z
     .object({
     eventId: z
@@ -54,17 +38,6 @@ export const closeEventParamsSchema = z
     })
 })
     .openapi('CloseEventParams');
-// ------------------------------
-// Request body schemas
-// ------------------------------
-export const cancelPhaseSlotBodySchema = z
-    .object({
-    reason: z.string().optional().openapi({
-        description: 'Optional reason for cancellation (for audit purposes)',
-        example: 'Event postponed'
-    })
-})
-    .openapi('CancelPhaseSlotBody');
 export const closeEventBodySchema = z
     .object({
     reason: z.string().optional().openapi({
@@ -80,94 +53,57 @@ export const vehicleTypeSchema = z.object({
     id: z.number(),
     name: z.string()
 });
-export const phaseSlotAssemblySchema = z
+// New unified phase slot schedule schema (from database response)
+export const phaseSlotScheduleSchema = z
     .object({
     id: z.number().int().positive().openapi({
-        description: 'Unique identifier for the assembly',
+        description: 'Unique identifier for the schedule',
         example: 1
     }),
     date: z.string().openapi({
-        description: 'Date of the assembly (YYYY-MM-DD format)',
+        description: 'Date of the schedule (YYYY-MM-DD format)',
         example: '2025-12-15'
     }),
     start_time: z.string().openapi({
-        description: 'Start time of the assembly (HH:MM format)',
+        description: 'Start time (HH:MM format)',
         example: '06:00'
     }),
     end_time: z.string().openapi({
-        description: 'End time of the assembly (HH:MM format)',
+        description: 'End time (HH:MM format)',
         example: '09:00'
     }),
     duration: z.number().openapi({
-        description: 'Duration of the assembly in minutes',
+        description: 'Duration in minutes',
         example: 180
     }),
     phase_slot_id: z.number().int().positive().openapi({
         description: 'ID of the associated phase slot',
         example: 101
     }),
+    phase_slot_schedule_type: z
+        .enum([PhaseSlotScheduleType.ASSEMBLY, PhaseSlotScheduleType.DISMANTLING])
+        .openapi({
+        description: 'Type of schedule',
+        example: PhaseSlotScheduleType.ASSEMBLY
+    }),
     created_at: z.string().openapi({
-        description: 'Timestamp when assembly was created',
+        description: 'Timestamp when schedule was created',
         example: '2025-12-09T10:00:00.000Z'
     }),
     updated_at: z.string().openapi({
-        description: 'Timestamp when assembly was updated',
+        description: 'Timestamp when schedule was updated',
         example: '2025-12-09T10:30:00.000Z'
-    })
-})
-    .openapi('PhaseSlotAssembly');
-export const phaseSlotDismantlingSchema = z
-    .object({
-    id: z.number().int().positive().openapi({
-        description: 'Unique identifier for the dismantling',
-        example: 1
-    }),
-    date: z.string().openapi({
-        description: 'Date of the dismantling (YYYY-MM-DD format)',
-        example: '2025-12-15'
-    }),
-    start_time: z.string().openapi({
-        description: 'Start time of the dismantling (HH:MM format)',
-        example: '06:00'
-    }),
-    end_time: z.string().openapi({
-        description: 'End time of the dismantling (HH:MM format)',
-        example: '09:00'
-    }),
-    duration: z.number().openapi({
-        description: 'Duration of the dismantling in minutes',
-        example: 180
-    }),
-    phase_slot_id: z.number().int().positive().openapi({
-        description: 'ID of the associated phase slot',
-        example: 101
     }),
-    created_at: z.string().openapi({
-        description: 'Timestamp when dismantling was created',
-        example: '2025-12-09T10:00:00.000Z'
+    created_by: z.uuid().nullable().openapi({
+        description: 'UUID of user who created the schedule',
+        example: '550e8400-e29b-41d4-a716-446655440000'
     }),
-    updated_at: z.string().openapi({
-        description: 'Timestamp when dismantling was updated',
-        example: '2025-12-09T10:30:00.000Z'
+    updated_by: z.uuid().nullable().openapi({
+        description: 'UUID of user who last updated the schedule',
+        example: '550e8400-e29b-41d4-a716-446655440000'
     })
 })
-    .openapi('PhaseSlotDismantling');
-export const phaseSlotSchema = z.object({
-    id: z.number(),
-    event_id: z.number(),
-    slot_number: z.number(),
-    vehicle_type_id: z.number().nullable(),
-    company_role: z.string().nullable(),
-    status: z.enum(BookingStatus),
-    is_active: z.boolean(),
-    created_at: z.string(),
-    updated_at: z.string(),
-    created_by: z.string().nullable(),
-    updated_by: z.string().nullable(),
-    vehicle_type: vehicleTypeSchema.nullable().optional(),
-    assembly: phaseSlotAssemblySchema.nullable().optional(),
-    dismantling: phaseSlotDismantlingSchema.nullable().optional()
-});
+    .openapi('PhaseSlotSchedule');
 export const companySchema = z.object({
     id: z.number(),
     company_name: z.string(),
@@ -193,38 +129,129 @@ export const companySchema = z.object({
 });
 export const phaseBookingSchema = z.object({
     id: z.number(),
-    company_id: z.number(),
-    phase_slot_id: z.number(),
+    phase_slot_schedule_id: z.number(),
     status: z.enum(BookingStatus),
     is_active: z.boolean(),
     created_at: z.string(),
     updated_at: z.string(),
     created_by: z.string().nullable(),
     updated_by: z.string().nullable(),
-    company: companySchema,
-    phase_slot: phaseSlotSchema
+    booking_date: z.string().nullable(),
+    start_time: z.string().nullable(),
+    end_time: z.string().nullable(),
+    company: z.record(z.string(), z.unknown()).nullable().optional(),
+    vehicle: z.record(z.string(), z.unknown()).nullable().optional(),
+    // Include the schedule details
+    phase_slot_schedule: phaseSlotScheduleSchema.optional()
 });
+export const companyDetailsSchema = z
+    .object({
+    company_role: z.string().min(1, 'Company role is required').openapi({
+        description: 'Company role',
+        example: 'exhibitor'
+    }),
+    hall: z.string().min(1, 'Hall is required').openapi({
+        description: 'Hall location',
+        example: 'Hall 1'
+    }),
+    stand_number: z.string().min(1, 'Stand number is required').openapi({
+        description: 'Stand number',
+        example: 'A-123'
+    }),
+    company_name: z.string().min(1, 'Company name is required').openapi({
+        description: 'Company name',
+        example: 'Acme Corp'
+    }),
+    business: z.string().min(1, 'Business is required').openapi({
+        description: 'Type of business',
+        example: 'Technology'
+    }),
+    departure_city: z.string().min(1, 'Departure city is required').openapi({
+        description: 'City of departure',
+        example: 'Paris'
+    }),
+    contact_name: z.string().min(1, 'Contact name is required').openapi({
+        description: 'Contact person name',
+        example: 'John Doe'
+    }),
+    email: z.email('Valid email is required').openapi({
+        description: 'Contact email',
+        example: 'john.doe@acme.com'
+    }),
+    phone: z.string().min(1, 'Phone is required').openapi({
+        description: 'Contact phone number',
+        example: '+33 1 23 45 67 89'
+    }),
+    driver_name: z.string().min(1, 'Driver name is required').openapi({
+        description: 'Driver name',
+        example: 'Jean Martin'
+    }),
+    driver_phone: z.string().min(1, 'Driver phone is required').openapi({
+        description: 'Driver phone number',
+        example: '+33 6 12 34 56 78'
+    }),
+    transport_company: z.string().min(1, 'Transport company is required').openapi({
+        description: 'Transport company name',
+        example: 'Fast Transport Ltd'
+    })
+})
+    .openapi('CompanyDetails');
+export const vehicleDetailsSchema = z
+    .object({
+    vehicle_type: z.string().min(1, 'Vehicle type is required').openapi({
+        description: 'Type of vehicle',
+        example: 'Truck'
+    }),
+    unloading_method: z.string().min(1, 'Unloading method is required').openapi({
+        description: 'Method of unloading',
+        example: 'Manual'
+    }),
+    license_plate: z.string().min(1, 'License plate is required').openapi({
+        description: 'Vehicle license plate',
+        example: 'AB-123-CD'
+    }),
+    trailer_registration: z.string().optional().openapi({
+        description: 'Trailer registration number',
+        example: 'TR-456-EF'
+    })
+})
+    .openapi('VehicleDetails');
 export const createBookingBodySchema = z
     .object({
-    company_id: z
+    // Event & Basic Info
+    event_id: z
         .number()
         .int()
         .positive({
-        message: 'Company ID must be a positive integer'
+        message: 'Event ID must be a positive integer'
     })
         .openapi({
-        description: 'ID of the company making the booking',
-        example: 123
+        description: 'ID of the event to create the booking for',
+        example: 1
     }),
-    phase_slot_id: z
-        .number()
-        .int()
-        .positive({
-        message: 'Phase slot ID must be a positive integer'
-    })
+    request_type: z
+        .enum([PhaseSlotScheduleType.ASSEMBLY, PhaseSlotScheduleType.DISMANTLING])
+        .default(PhaseSlotScheduleType.ASSEMBLY)
         .openapi({
-        description: 'ID of the phase slot to book',
-        example: 456
+        description: 'Type of request (assembly or dismantling)',
+        example: PhaseSlotScheduleType.ASSEMBLY
+    }),
+    // Time slot selection
+    selected_date: z.string().min(1, 'Date is required').openapi({
+        description: 'Selected date (YYYY-MM-DD)',
+        example: '2025-12-15'
+    }),
+    selected_time: z.string().min(1, 'Time is required').openapi({
+        description: 'Selected time slot (HH:MM)',
+        example: '08:00'
+    }),
+    // Company details
+    company: companyDetailsSchema.openapi({
+        description: 'Company details including stand, contact, and driver info'
+    }),
+    // Vehicle details
+    vehicle: vehicleDetailsSchema.openapi({
+        description: 'Vehicle details'
     })
 })
     .openapi('CreateBookingBody');
@@ -234,22 +261,32 @@ export const createBookingDataSchema = z
         description: 'ID of the created booking',
         example: 789
     }),
-    company_id: z.number().openapi({
-        description: 'ID of the company',
-        example: 123
-    }),
-    phase_slot_id: z.number().openapi({
-        description: 'ID of the booked phase slot',
+    phase_slot_schedule_id: z.number().openapi({
+        description: 'ID of the phase slot schedule',
         example: 456
     }),
-    slot_number: z.number().openapi({
-        description: 'Slot number',
-        example: 42
-    }),
     status: z.enum(BookingStatus).openapi({
         description: 'Booking status',
         example: BookingStatus.BOOKED
     }),
+    booking_date: z.string().openapi({
+        description: 'Booking date',
+        example: '2025-12-15'
+    }),
+    start_time: z.string().openapi({
+        description: 'Start time',
+        example: '08:00'
+    }),
+    end_time: z.string().openapi({
+        description: 'End time',
+        example: '08:30'
+    }),
+    company: companyDetailsSchema.openapi({
+        description: 'Company details including stand, contact, and driver info'
+    }),
+    vehicle: vehicleDetailsSchema.openapi({
+        description: 'Vehicle details'
+    }),
     created_at: z.string().openapi({
         description: 'Timestamp when booking was created',
         example: '2025-12-05T10:30:00.000Z'
@@ -271,31 +308,6 @@ export const eventBookingsDataSchema = z
 })
     .openapi('EventBookingsData');
 export const eventBookingsResponseSchema = createSuccessResponseSchema(eventBookingsDataSchema, 'EventBookingsResponse', 'Event bookings data with phase slot details');
-export const cancelPhaseSlotDataSchema = z
-    .object({
-    slot_id: z.number().openapi({
-        description: 'ID of the cancelled slot',
-        example: 1
-    }),
-    status: z.enum(SlotStatus).openapi({
-        description: 'New status of the slot',
-        example: SlotStatus.AVAILABLE
-    }),
-    cancelled_at: z.string().openapi({
-        description: 'Timestamp when the slot was cancelled',
-        example: '2025-12-03T20:47:00.000Z'
-    }),
-    cancelled_by: z.string().nullable().openapi({
-        description: 'ID of the user who cancelled the slot',
-        example: null
-    }),
-    reason: z.string().nullable().openapi({
-        description: 'Reason for cancellation',
-        example: 'Event postponed'
-    })
-})
-    .openapi('CancelPhaseSlotData');
-export const cancelPhaseSlotResponseSchema = createMessageDataResponseSchema(cancelPhaseSlotDataSchema, 'CancelPhaseSlotResponse', 'Phase slot cancelled successfully', 'Details of the cancelled phase slot');
 export const closeEventDataSchema = z
     .object({
     event_id: z.number().openapi({
@@ -334,15 +346,17 @@ export const confirmBookingParamsSchema = z.object({
         message: 'Booking ID must be a positive integer'
     })
 });
-// Response schema
+// Updated confirm booking response to include schedule_id instead of slot_id
 export const confirmBookingResponseSchema = z.object({
     success: z.boolean(),
     message: z.string(),
     data: z.object({
         booking_id: z.number(),
         booking_status: z.enum(BookingStatus),
-        slot_id: z.number(),
-        slot_status: z.enum(SlotStatus),
+        schedule_id: z.number().openapi({
+            description: 'ID of the phase slot schedule',
+            example: 456
+        }),
         confirmed_at: z.string(),
         confirmed_by: z.string().nullable()
     })
@@ -361,7 +375,7 @@ export const refuseBookingParamsSchema = z
     })
 })
     .openapi('RefuseBookingParams');
-// Response data schema for refuse endpoint
+// Updated refuse booking response to include schedule_id instead of slot_id
 export const refuseBookingDataSchema = z
     .object({
     booking_id: z.number().openapi({
@@ -372,13 +386,9 @@ export const refuseBookingDataSchema = z
         description: 'New status of the booking',
         example: BookingStatus.REFUSED
     }),
-    slot_id: z.number().openapi({
-        description: 'ID of the associated phase slot',
-        example: 10
-    }),
-    slot_status: z.enum([SlotStatus.AVAILABLE]).openapi({
-        description: 'New status of the phase slot',
-        example: SlotStatus.AVAILABLE
+    schedule_id: z.number().openapi({
+        description: 'ID of the associated phase slot schedule',
+        example: 456
     }),
     refused_at: z.string().openapi({
         description: 'ISO 8601 timestamp when the booking was refused',
@@ -390,7 +400,6 @@ export const refuseBookingDataSchema = z
     })
 })
     .openapi('RefuseBookingData');
-// Response schema for refuse endpoint
 export const refuseBookingResponseSchema = createMessageDataResponseSchema(refuseBookingDataSchema, 'RefuseBookingResponse', 'Phase booking refused successfully', 'Details of the refused booking');
 // ------------------------------
 // Create Phase Slots schemas
@@ -409,44 +418,15 @@ export const createPhaseSlotsBodySchema = z
     }),
     slots: z
         .array(z.object({
-        slot_number: z
-            .number()
-            .int()
-            .positive({
-            message: 'Slot number must be a positive integer'
-        })
-            .openapi({
-            description: 'Unique slot number within the event',
-            example: 42
-        }),
-        vehicle_type_id: z
-            .number()
-            .int()
-            .positive({
-            message: 'Vehicle type ID must be a positive integer'
-        })
-            .nullable()
-            .optional()
-            .openapi({
-            description: 'Optional vehicle type ID for the slot',
-            example: 1
-        }),
         company_role: z.string().min(1).nullable().optional().openapi({
             description: 'Optional company role for the slot',
             example: 'buyer'
-        }),
-        status: z.enum(SlotStatus).optional().openapi({
-            description: 'Initial status of the slot (defaults to available)',
-            example: SlotStatus.AVAILABLE
         })
     }))
         .min(1, 'At least one slot must be provided')
         .openapi({
         description: 'Array of slots to create',
-        example: [
-            { slot_number: 42, vehicle_type_id: 1, company_role: 'buyer' },
-            { slot_number: 43, vehicle_type_id: 2, company_role: 'seller' }
-        ]
+        example: [{ company_role: 'buyer' }, { company_role: 'seller' }]
     })
 })
     .openapi('CreatePhaseSlotsBody');
@@ -460,22 +440,10 @@ export const createPhaseSlotDataSchema = z
         description: 'ID of the event',
         example: 1
     }),
-    slot_number: z.number().openapi({
-        description: 'Slot number',
-        example: 42
-    }),
-    vehicle_type_id: z.number().nullable().openapi({
-        description: 'Vehicle type ID',
-        example: 1
-    }),
     company_role: z.string().nullable().openapi({
         description: 'Company role',
         example: 'buyer'
     }),
-    status: z.enum(SlotStatus).openapi({
-        description: 'Slot status',
-        example: SlotStatus.AVAILABLE
-    }),
     is_active: z.boolean().openapi({
         description: 'Whether the slot is active',
         example: true,
@@ -507,13 +475,13 @@ export const createPhaseSlotsDataSchema = z
     }),
     failed_slots: z
         .array(z.object({
-        slot_number: z.number().openapi({
-            description: 'Slot number that failed to create',
-            example: 44
+        index: z.number().openapi({
+            description: 'Index of the slot in the request that failed to create',
+            example: 0
         }),
         error: z.string().openapi({
             description: 'Error message explaining why the slot creation failed',
-            example: 'Slot number 44 already exists for event 1'
+            example: 'Failed to create slot'
         })
     }))
         .openapi({
@@ -541,36 +509,9 @@ export const updatePhaseSlotParamsSchema = z
     .openapi('UpdatePhaseSlotParams');
 export const updatePhaseSlotBodySchema = z
     .object({
-    slot_number: z
-        .number()
-        .int()
-        .positive({
-        message: 'Slot number must be a positive integer'
-    })
-        .optional()
-        .openapi({
-        description: 'New slot number (must be unique within the event)',
-        example: 43
-    }),
-    vehicle_type_id: z
-        .number()
-        .int()
-        .positive({
-        message: 'Vehicle type ID must be a positive integer'
-    })
-        .nullable()
-        .optional()
-        .openapi({
-        description: 'New vehicle type ID for the slot',
-        example: 2
-    }),
     company_role: z.string().min(1).nullable().optional().openapi({
         description: 'New company role for the slot',
         example: 'seller'
-    }),
-    status: z.enum(SlotStatus).optional().openapi({
-        description: 'New status for the slot',
-        example: SlotStatus.RESERVED
     })
 })
     .refine(data => Object.keys(data).length > 0, {
@@ -587,22 +528,10 @@ export const updatePhaseSlotDataSchema = z
         description: 'ID of the event',
         example: 1
     }),
-    slot_number: z.number().openapi({
-        description: 'Updated slot number',
-        example: 43
-    }),
-    vehicle_type_id: z.number().nullable().openapi({
-        description: 'Updated vehicle type ID',
-        example: 2
-    }),
     company_role: z.string().nullable().openapi({
         description: 'Updated company role',
         example: 'seller'
     }),
-    status: z.enum(SlotStatus).openapi({
-        description: 'Updated slot status',
-        example: SlotStatus.RESERVED
-    }),
     is_active: z.boolean().openapi({
         description: 'Whether the slot is active',
         example: true
@@ -619,91 +548,29 @@ export const updatePhaseSlotDataSchema = z
     .openapi('UpdatePhaseSlotData');
 export const updatePhaseSlotResponseSchema = createMessageDataResponseSchema(updatePhaseSlotDataSchema, 'UpdatePhaseSlotResponse', 'Phase slot updated successfully', 'Details of the updated phase slot');
 // ------------------------------
-// Phase Slot Assemblies & Dismantlings Schemas
+// Phase Slot Schedules Schemas
 // ------------------------------
-export const upsertPhaseSlotAssemblySchema = z
+export const upsertPhaseSlotScheduleItemSchema = z
     .object({
-    date: z
-        .string()
-        .regex(/^\d{4}-\d{2}-\d{2}$/, 'Date must be in YYYY-MM-DD format')
-        .openapi({
-        description: 'Date of the assembly (YYYY-MM-DD format)',
-        example: '2025-12-15'
-    }),
-    start_time: z
-        .string()
-        .regex(/^\d{2}:\d{2}$/, 'Time must be in HH:MM format')
-        .optional()
-        .openapi({
-        description: 'Start time of the assembly (HH:MM format). Defaults to 06:00',
-        example: '06:00'
-    }),
-    end_time: z
-        .string()
-        .regex(/^\d{2}:\d{2}$/, 'Time must be in HH:MM format')
-        .optional()
-        .openapi({
-        description: 'End time of the assembly (HH:MM format). Defaults to 09:00',
-        example: '09:00'
-    }),
-    duration: z.number().positive().optional().openapi({
-        description: 'Duration of the assembly in minutes. Defaults to 60',
-        example: 180
+    id: z.number().int().positive().optional().openapi({
+        description: 'Unique identifier for existing schedule (required for updates)',
+        example: 1
     }),
     phase_slot_id: z.number().int().positive().openapi({
         description: 'ID of the associated phase slot',
         example: 101
-    })
-})
-    .openapi('UpsertPhaseSlotAssembly');
-export const upsertPhaseSlotDismantlingSchema = z
-    .object({
+    }),
     date: z
         .string()
         .regex(/^\d{4}-\d{2}-\d{2}$/, 'Date must be in YYYY-MM-DD format')
         .openapi({
-        description: 'Date of the dismantling (YYYY-MM-DD format)',
+        description: 'Date of the schedule (YYYY-MM-DD format)',
         example: '2025-12-15'
     }),
     start_time: z
         .string()
         .regex(/^\d{2}:\d{2}$/, 'Time must be in HH:MM format')
-        .optional()
-        .openapi({
-        description: 'Start time of the dismantling (HH:MM format). Defaults to 06:00',
-        example: '06:00'
-    }),
-    end_time: z
-        .string()
-        .regex(/^\d{2}:\d{2}$/, 'Time must be in HH:MM format')
-        .optional()
-        .openapi({
-        description: 'End time of the dismantling (HH:MM format). Defaults to 09:00',
-        example: '09:00'
-    }),
-    duration: z.number().positive().optional().openapi({
-        description: 'Duration of the dismantling in minutes. Defaults to 60',
-        example: 180
-    }),
-    phase_slot_id: z.number().int().positive().openapi({
-        description: 'ID of the associated phase slot',
-        example: 101
-    })
-})
-    .openapi('UpsertPhaseSlotDismantling');
-// ------------------------------
-// Combined Phase Slot Schedules Schemas (Assembly + Dismantling)
-// ------------------------------
-export const phaseSlotScheduleOperationSchema = z
-    .object({
-    id: z.number().int().positive().optional().openapi({
-        description: 'Unique identifier for existing records (required for updates and deletes)',
-        example: 1
-    }),
-    start_time: z
-        .string()
-        .regex(/^\d{2}:\d{2}$/, 'Time must be in HH:MM format')
-        .optional()
+        .default('06:00')
         .openapi({
         description: 'Start time (HH:MM format)',
         example: '06:00'
@@ -711,182 +578,183 @@ export const phaseSlotScheduleOperationSchema = z
     end_time: z
         .string()
         .regex(/^\d{2}:\d{2}$/, 'Time must be in HH:MM format')
-        .optional()
+        .default('09:00')
         .openapi({
         description: 'End time (HH:MM format)',
         example: '09:00'
     }),
-    duration: z.number().positive().optional().openapi({
+    duration: z.number().positive().default(60).openapi({
         description: 'Duration in minutes',
         example: 180
     }),
-    date: z
-        .string()
-        .regex(/^\d{4}-\d{2}-\d{2}$/, 'Date must be in YYYY-MM-DD format')
-        .optional()
+    phase_slot_schedule_type: z
+        .enum([PhaseSlotScheduleType.ASSEMBLY, PhaseSlotScheduleType.DISMANTLING])
         .openapi({
-        description: 'Date for assembly (YYYY-MM-DD format)',
-        example: '2025-12-15'
-    }),
-    _delete: z.boolean().optional().openapi({
-        description: 'Flag to mark this record for deletion. Requires existing id.',
-        example: false
+        description: 'Type of schedule',
+        example: PhaseSlotScheduleType.ASSEMBLY
     })
 })
-    .check(data => {
-    // If delete is true, id is required
-    if (data.value._delete === true && !data.value.id) {
-        data.issues.push({
-            code: 'custom',
-            message: 'ID is required when delete is true',
-            path: ['id'],
-            input: data.value
-        });
-    }
-    // If delete is false or undefined, date is required
-    if ((data.value._delete === false || data.value._delete === undefined) && !data.value.date) {
-        data.issues.push({
-            code: 'custom',
-            message: 'Date is required when delete is false or undefined',
-            path: ['date'],
-            input: data.value
-        });
-    }
-})
-    .openapi('PhaseSlotScheduleOperation');
-export const phaseSlotScheduleSchema = z
+    .openapi('UpsertPhaseSlotScheduleItem');
+export const deletePhaseSlotScheduleItemSchema = z
     .object({
-    phase_slot_id: z.number().int().positive().openapi({
-        description: 'ID of the associated phase slot',
-        example: 101
-    }),
-    assembly: phaseSlotScheduleOperationSchema.openapi({
-        description: 'Assembly operation details with date'
-    }),
-    dismantling: phaseSlotScheduleOperationSchema.openapi({
-        description: 'Dismantling operation details with date'
+    id: z.number().int().positive().openapi({
+        description: 'ID of the schedule to delete',
+        example: 1
     })
 })
-    .openapi('PhaseSlotSchedule');
+    .openapi('DeletePhaseSlotScheduleItem');
 export const upsertPhaseSlotSchedulesBodySchema = z
     .object({
-    schedules: z
-        .array(phaseSlotScheduleSchema)
-        .min(1, 'At least one schedule is required')
+    upsert: z
+        .array(upsertPhaseSlotScheduleItemSchema)
+        .optional()
         .openapi({
-        description: 'Array of phase slot schedules to upsert',
+        description: 'Array of schedules to create or update',
         example: [
             {
                 phase_slot_id: 101,
-                assembly: {
-                    date: '2025-12-15',
-                    start_time: '06:00',
-                    end_time: '09:00',
-                    duration: 180
-                },
-                dismantling: {
-                    date: '2025-12-16',
-                    start_time: '15:00',
-                    end_time: '18:00',
-                    duration: 180
-                }
+                date: '2025-12-15',
+                start_time: '06:00',
+                end_time: '09:00',
+                duration: 180,
+                phase_slot_schedule_type: 'assembly'
             },
             {
-                phase_slot_id: 102,
-                assembly: {
-                    id: 15,
-                    _delete: true
-                }
-            },
-            {
-                phase_slot_id: 103,
-                dismantling: {
-                    id: 42,
-                    _delete: true
-                }
+                id: 5,
+                phase_slot_id: 101,
+                date: '2025-12-16',
+                start_time: '15:00',
+                end_time: '18:00',
+                duration: 180,
+                phase_slot_schedule_type: 'dismantling'
             }
         ]
+    }),
+    delete: z
+        .array(deletePhaseSlotScheduleItemSchema)
+        .optional()
+        .openapi({
+        description: 'Array of schedule IDs to delete',
+        example: [{ id: 42 }]
     })
+})
+    .refine(data => (data.upsert && data.upsert.length > 0) || (data.delete && data.delete.length > 0), {
+    message: 'At least one upsert or delete operation is required'
 })
     .openapi('UpsertPhaseSlotSchedulesBody');
 export const upsertPhaseSlotSchedulesDataSchema = z
     .object({
-    total_processed: z.number().int().nonnegative().openapi({
-        description: 'Total number of schedules processed',
-        example: 2
-    }),
-    total_assemblies_upserted: z.number().int().nonnegative().openapi({
-        description: 'Total number of assemblies successfully upserted',
-        example: 2
+    total_upserted: z.number().int().nonnegative().openapi({
+        description: 'Total number of schedules successfully upserted',
+        example: 3
     }),
-    total_dismantlings_upserted: z.number().int().nonnegative().openapi({
-        description: 'Total number of dismantlings successfully upserted',
+    total_deleted: z.number().int().nonnegative().openapi({
+        description: 'Total number of schedules successfully deleted',
         example: 1
     }),
-    total_assemblies_deleted: z.number().int().nonnegative().openapi({
-        description: 'Total number of assemblies successfully deleted',
-        example: 0
-    }),
-    total_dismantlings_deleted: z.number().int().nonnegative().openapi({
-        description: 'Total number of dismantlings successfully deleted',
-        example: 0
-    }),
-    upserted_assemblies: z.array(phaseSlotAssemblySchema).openapi({
-        description: 'Array of successfully upserted assemblies'
-    }),
-    upserted_dismantlings: z.array(phaseSlotDismantlingSchema).openapi({
-        description: 'Array of successfully upserted dismantlings'
-    }),
-    deleted_assemblies: z
-        .array(z.object({
-        id: z.number().int().positive(),
-        phase_slot_id: z.number().int().positive()
-    }))
-        .openapi({
-        description: 'Array of successfully deleted assemblies',
-        example: []
+    upserted_schedules: z.array(phaseSlotScheduleSchema).openapi({
+        description: 'Array of successfully upserted schedules'
     }),
-    deleted_dismantlings: z
+    deleted_schedules: z
         .array(z.object({
-        id: z.number().int().positive(),
-        phase_slot_id: z.number().int().positive()
+        id: z.number().int().positive()
     }))
         .openapi({
-        description: 'Array of successfully deleted dismantlings',
-        example: []
+        description: 'Array of successfully deleted schedule IDs',
+        example: [{ id: 42 }]
     }),
     failed_operations: z
         .array(z.object({
-        phase_slot_id: z.number().int().positive(),
-        operation: z.enum(['assembly', 'dismantling']),
-        action: z.enum(['upsert', 'delete']),
+        operation: z.enum(['upsert', 'delete']),
         error: z.string(),
-        data: z.union([
-            z.object({
-                id: z.number().int().positive().optional(),
-                date: z.string().optional(),
-                start_time: z.string().optional(),
-                end_time: z.string().optional(),
-                duration: z.number().positive().optional(),
-                _delete: z.boolean().optional()
-            }),
-            z.object({
-                id: z.number().int().positive()
-            })
-        ])
+        data: z.union([upsertPhaseSlotScheduleItemSchema, deletePhaseSlotScheduleItemSchema])
     }))
         .openapi({
         description: 'Array of operations that failed to process',
         example: [
             {
-                phase_slot_id: 999,
-                operation: 'assembly',
-                action: 'upsert',
+                operation: 'upsert',
                 error: 'Phase slot 999 not found or inactive',
-                data: { date: '2025-12-15', start_time: '06:00' }
+                data: {
+                    phase_slot_id: 999,
+                    date: '2025-12-15',
+                    start_time: '06:00',
+                    end_time: '09:00',
+                    duration: 180,
+                    phase_slot_schedule_type: 'assembly'
+                }
             }
         ]
     })
 })
     .openapi('UpsertPhaseSlotSchedulesData');
-export const upsertPhaseSlotSchedulesResponseSchema = createMessageDataResponseSchema(upsertPhaseSlotSchedulesDataSchema, 'UpsertPhaseSlotSchedulesResponse', 'Bulk phase slot schedules upsert completed', 'Results of the combined upsert operation');
+export const upsertPhaseSlotSchedulesResponseSchema = createMessageDataResponseSchema(upsertPhaseSlotSchedulesDataSchema, 'UpsertPhaseSlotSchedulesResponse', 'Phase slot schedules operation completed', 'Results of the upsert/delete operations');
+// ------------------------------
+// Check Slot Availability schemas
+// ------------------------------
+export const checkSlotAvailabilityQuerySchema = z
+    .object({
+    schedule_id: z
+        .string()
+        .min(1)
+        .transform(val => parseInt(val, 10))
+        .refine(val => !isNaN(val) && val > 0, {
+        message: 'Schedule ID must be a positive number'
+    })
+        .openapi({
+        description: 'The ID of the phase slot schedule',
+        example: '1'
+    }),
+    date: z
+        .string()
+        .regex(/^\d{4}-\d{2}-\d{2}$/, 'Date must be in YYYY-MM-DD format')
+        .openapi({
+        description: 'The date to check availability (YYYY-MM-DD)',
+        example: '2025-12-15'
+    }),
+    start_time: z
+        .string()
+        .regex(/^\d{2}:\d{2}$/, 'Time must be in HH:MM format')
+        .openapi({
+        description: 'The start time to check availability (HH:MM)',
+        example: '08:00'
+    })
+})
+    .openapi('CheckSlotAvailabilityQuery');
+export const checkSlotAvailabilityDataSchema = z
+    .object({
+    schedule_id: z.number().openapi({
+        description: 'ID of the phase slot schedule',
+        example: 1
+    }),
+    date: z.string().openapi({
+        description: 'Date checked',
+        example: '2025-12-15'
+    }),
+    start_time: z.string().openapi({
+        description: 'Time slot checked',
+        example: '08:00'
+    }),
+    is_available: z.boolean().openapi({
+        description: 'Whether the slot is available for booking',
+        example: true
+    }),
+    max_capacity: z.number().openapi({
+        description: 'Maximum booking capacity',
+        example: 5
+    }),
+    current_bookings: z.number().openapi({
+        description: 'Current number of total bookings',
+        example: 3
+    }),
+    confirmed_bookings: z.number().openapi({
+        description: 'Current number of confirmed bookings',
+        example: 1
+    }),
+    available_capacity: z.number().openapi({
+        description: 'Remaining available capacity',
+        example: 2
+    })
+})
+    .openapi('CheckSlotAvailabilityData');
+export const checkSlotAvailabilityResponseSchema = createSuccessResponseSchema(checkSlotAvailabilityDataSchema, 'CheckSlotAvailabilityResponse', 'Slot availability information with capacity details');