@venulog/phasing-engine-schemas 0.1.0

package/dist/phaseBooking.js

@@ -0,0 +1,890 @@
+// packages/phasing-schemas/src/phaseBooking.ts
+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';
+// ------------------------------
+// Query parameters schema
+// ------------------------------
+export const getEventBookingsQuerySchema = z
+    .object({
+    event_code: z.string().min(1, 'Event code is required').openapi({
+        description: 'Unique code identifying the event',
+        example: 'COEC2025'
+    }),
+    seller_id: z
+        .string()
+        .min(1, 'Seller ID is required')
+        .transform(val => parseInt(val, 10))
+        .refine(val => !isNaN(val) && val > 0, { message: 'Seller ID must be positive' })
+        .openapi({
+        description: 'ID of the seller (must be a positive integer)',
+        example: '1'
+    })
+})
+    .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
+        .string()
+        .min(1, 'Event ID is required')
+        .transform(val => parseInt(val, 10))
+        .refine(val => !isNaN(val) && val > 0, { message: 'Event ID must be positive' })
+        .openapi({
+        description: 'The ID of the event to close',
+        example: '1'
+    })
+})
+    .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({
+        description: 'Optional reason for closing the event phase (for audit purposes)',
+        example: 'Event phase completed - moving to next stage'
+    })
+})
+    .openapi('CloseEventBody');
+// ------------------------------
+// Response schemas
+// ------------------------------
+export const vehicleTypeSchema = z.object({
+    id: z.number(),
+    name: z.string()
+});
+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()
+});
+export const companySchema = z.object({
+    id: z.number(),
+    company_name: z.string(),
+    vat_number: z.string().nullable(),
+    siret_code: z.string().nullable(),
+    tva_intracom: z.string().nullable(),
+    type: z.enum(['E', 'S']),
+    company_role: z.string().nullable(),
+    company_street: z.string().nullable(),
+    company_city: z.string().nullable(),
+    company_postal_code: z.string().nullable(),
+    company_country: z.string().nullable(),
+    company_address: z.string().nullable(),
+    contact_first_name: z.string().nullable(),
+    contact_last_name: z.string().nullable(),
+    contact_email: z.string().nullable(),
+    contact_phone: z.string().nullable(),
+    is_active: z.boolean(),
+    created_at: z.string(),
+    updated_at: z.string(),
+    created_by: z.string().nullable(),
+    updated_by: z.string().nullable()
+});
+export const phaseBookingSchema = z.object({
+    id: z.number(),
+    company_id: z.number(),
+    phase_slot_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
+});
+export const createBookingBodySchema = z
+    .object({
+    company_id: z
+        .number()
+        .int()
+        .positive({
+        message: 'Company ID must be a positive integer'
+    })
+        .openapi({
+        description: 'ID of the company making the booking',
+        example: 123
+    }),
+    phase_slot_id: z
+        .number()
+        .int()
+        .positive({
+        message: 'Phase slot ID must be a positive integer'
+    })
+        .openapi({
+        description: 'ID of the phase slot to book',
+        example: 456
+    })
+})
+    .openapi('CreateBookingBody');
+export const createBookingDataSchema = z
+    .object({
+    booking_id: z.number().openapi({
+        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',
+        example: 456
+    }),
+    slot_number: z.number().openapi({
+        description: 'Slot number',
+        example: 42
+    }),
+    status: z.enum(BookingStatus).openapi({
+        description: 'Booking status',
+        example: BookingStatus.BOOKED
+    }),
+    created_at: z.string().openapi({
+        description: 'Timestamp when booking was created',
+        example: '2025-12-05T10:30:00.000Z'
+    }),
+    created_by: z.string().nullable().openapi({
+        description: 'ID of the user who created the booking',
+        example: 'user-123'
+    })
+})
+    .openapi('CreateBookingData');
+export const createBookingResponseSchema = createMessageDataResponseSchema(createBookingDataSchema, 'CreateBookingResponse', 'Booking created successfully', 'Details of the created booking');
+export const eventBookingsDataSchema = z
+    .object({
+    event_id: z.number(),
+    event_code: z.string(),
+    event_name: z.string(),
+    bookings: z.array(phaseBookingSchema),
+    total_count: z.number()
+})
+    .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({
+        description: 'ID of the close event',
+        example: 1
+    }),
+    event_code: z.string().nullable().openapi({
+        description: 'Code of the close event',
+        example: 'EVENT2025'
+    }),
+    event_name: z.string().openapi({
+        description: 'Name of the close event',
+        example: 'Annual Trade Show 2025'
+    }),
+    is_active: z.boolean().openapi({
+        description: 'Active status of the event',
+        example: false
+    }),
+    close_at: z.string().openapi({
+        description: 'Timestamp when the event was closed',
+        example: '2025-12-04T10:30:00.000Z'
+    }),
+    close_by: z.string().nullable().openapi({
+        description: 'ID of the user who closed the event',
+        example: null
+    }),
+    reason: z.string().nullable().openapi({
+        description: 'Reason for closing the event',
+        example: 'Event cancelled due to logistical issues'
+    })
+})
+    .openapi('CloseEventData');
+export const closeEventResponseSchema = createMessageDataResponseSchema(closeEventDataSchema, 'CloseEventResponse', 'Event phase closed successfully', 'Details of the closed event phase');
+export const confirmBookingParamsSchema = z.object({
+    bookingId: z.coerce.number().int().positive({
+        message: 'Booking ID must be a positive integer'
+    })
+});
+// Response schema
+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),
+        confirmed_at: z.string(),
+        confirmed_by: z.string().nullable()
+    })
+});
+export const refuseBookingParamsSchema = z
+    .object({
+    bookingId: z.coerce
+        .number()
+        .int()
+        .positive({
+        message: 'Booking ID must be a positive integer'
+    })
+        .openapi({
+        description: 'The ID of the booking to refuse',
+        example: 1
+    })
+})
+    .openapi('RefuseBookingParams');
+// Response data schema for refuse endpoint
+export const refuseBookingDataSchema = z
+    .object({
+    booking_id: z.number().openapi({
+        description: 'ID of the refused booking',
+        example: 1
+    }),
+    booking_status: z.enum([BookingStatus.REFUSED]).openapi({
+        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
+    }),
+    refused_at: z.string().openapi({
+        description: 'ISO 8601 timestamp when the booking was refused',
+        example: '2025-12-08T10:30:00.000Z'
+    }),
+    refused_by: z.string().nullable().openapi({
+        description: 'ID of the user who refused the booking',
+        example: 'user-123'
+    })
+})
+    .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
+// ------------------------------
+export const createPhaseSlotsBodySchema = z
+    .object({
+    event_id: z
+        .number()
+        .int()
+        .positive({
+        message: 'Event ID must be a positive integer'
+    })
+        .openapi({
+        description: 'ID of the event to create the slots for',
+        example: 1
+    }),
+    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' }
+        ]
+    })
+})
+    .openapi('CreatePhaseSlotsBody');
+export const createPhaseSlotDataSchema = z
+    .object({
+    slot_id: z.number().openapi({
+        description: 'ID of the created phase slot',
+        example: 123
+    }),
+    event_id: z.number().openapi({
+        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,
+        examples: [true, false]
+    }),
+    created_at: z.string().openapi({
+        description: 'Timestamp when slot was created',
+        example: '2025-12-09T10:30:00.000Z'
+    }),
+    created_by: z.string().nullable().openapi({
+        description: 'ID of the user who created the slot',
+        example: 'user-123'
+    })
+})
+    .openapi('CreatePhaseSlotData');
+export const createPhaseSlotsDataSchema = z
+    .object({
+    event_id: z.number().openapi({
+        description: 'ID of the event',
+        example: 1
+    }),
+    total_created: z.number().openapi({
+        description: 'Total number of slots successfully created',
+        example: 2
+    }),
+    created_slots: z.array(createPhaseSlotDataSchema).openapi({
+        description: 'Array of successfully created slots',
+        example: []
+    }),
+    failed_slots: z
+        .array(z.object({
+        slot_number: z.number().openapi({
+            description: 'Slot number that failed to create',
+            example: 44
+        }),
+        error: z.string().openapi({
+            description: 'Error message explaining why the slot creation failed',
+            example: 'Slot number 44 already exists for event 1'
+        })
+    }))
+        .openapi({
+        description: 'Array of slots that failed to create with error details',
+        example: []
+    })
+})
+    .openapi('CreatePhaseSlotsData');
+export const createPhaseSlotsResponseSchema = createMessageDataResponseSchema(createPhaseSlotsDataSchema, 'CreatePhaseSlotsResponse', 'Bulk phase slots operation completed', 'Details of the bulk creation operation including successes and failures');
+// ------------------------------
+// Update Phase Slot schemas
+// ------------------------------
+export const updatePhaseSlotParamsSchema = 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 update',
+        example: '123'
+    })
+})
+    .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, {
+    message: 'At least one field must be provided for update'
+})
+    .openapi('UpdatePhaseSlotBody');
+export const updatePhaseSlotDataSchema = z
+    .object({
+    slot_id: z.number().openapi({
+        description: 'ID of the updated phase slot',
+        example: 123
+    }),
+    event_id: z.number().openapi({
+        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
+    }),
+    updated_at: z.string().openapi({
+        description: 'Timestamp when slot was updated',
+        example: '2025-12-09T10:35:00.000Z'
+    }),
+    updated_by: z.string().nullable().openapi({
+        description: 'ID of the user who updated the slot',
+        example: 'user-123'
+    })
+})
+    .openapi('UpdatePhaseSlotData');
+export const updatePhaseSlotResponseSchema = createMessageDataResponseSchema(updatePhaseSlotDataSchema, 'UpdatePhaseSlotResponse', 'Phase slot updated successfully', 'Details of the updated phase slot');
+// ------------------------------
+// Phase Slot Assemblies & Dismantlings Schemas
+// ------------------------------
+export const phaseSlotAssemblySchema = z
+    .object({
+    id: z.number().int().positive().openapi({
+        description: 'Unique identifier for the assembly',
+        example: 1
+    }),
+    date: z.string().openapi({
+        description: 'Date of the assembly (YYYY-MM-DD format)',
+        example: '2025-12-15'
+    }),
+    start_time: z.string().openapi({
+        description: 'Start time of the assembly (HH:MM format)',
+        example: '06:00'
+    }),
+    end_time: z.string().openapi({
+        description: 'End time of the assembly (HH:MM format)',
+        example: '09:00'
+    }),
+    duration: z.number().openapi({
+        description: 'Duration of the assembly 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 assembly was created',
+        example: '2025-12-09T10:00:00.000Z'
+    }),
+    updated_at: z.string().openapi({
+        description: 'Timestamp when assembly 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'
+    }),
+    updated_at: z.string().openapi({
+        description: 'Timestamp when dismantling was updated',
+        example: '2025-12-09T10:30:00.000Z'
+    })
+})
+    .openapi('PhaseSlotDismantling');
+export const upsertPhaseSlotAssemblySchema = 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
+    }),
+    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)',
+        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()
+        .openapi({
+        description: 'Start time (HH:MM format)',
+        example: '06:00'
+    }),
+    end_time: z
+        .string()
+        .regex(/^\d{2}:\d{2}$/, 'Time must be in HH:MM format')
+        .optional()
+        .openapi({
+        description: 'End time (HH:MM format)',
+        example: '09:00'
+    }),
+    duration: z.number().positive().optional().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()
+        .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
+    })
+})
+    .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
+    .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'
+    })
+})
+    .openapi('PhaseSlotSchedule');
+export const upsertPhaseSlotSchedulesBodySchema = z
+    .object({
+    schedules: z
+        .array(phaseSlotScheduleSchema)
+        .min(1, 'At least one schedule is required')
+        .openapi({
+        description: 'Array of phase slot schedules to upsert',
+        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
+                }
+            },
+            {
+                phase_slot_id: 102,
+                assembly: {
+                    id: 15,
+                    _delete: true
+                }
+            },
+            {
+                phase_slot_id: 103,
+                dismantling: {
+                    id: 42,
+                    _delete: true
+                }
+            }
+        ]
+    })
+})
+    .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_dismantlings_upserted: z.number().int().nonnegative().openapi({
+        description: 'Total number of dismantlings successfully upserted',
+        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: []
+    }),
+    deleted_dismantlings: z
+        .array(z.object({
+        id: z.number().int().positive(),
+        phase_slot_id: z.number().int().positive()
+    }))
+        .openapi({
+        description: 'Array of successfully deleted dismantlings',
+        example: []
+    }),
+    failed_operations: z
+        .array(z.object({
+        phase_slot_id: z.number().int().positive(),
+        operation: z.enum(['assembly', 'dismantling']),
+        action: 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()
+            })
+        ])
+    }))
+        .openapi({
+        description: 'Array of operations that failed to process',
+        example: [
+            {
+                phase_slot_id: 999,
+                operation: 'assembly',
+                action: 'upsert',
+                error: 'Phase slot 999 not found or inactive',
+                data: { date: '2025-12-15', start_time: '06:00' }
+            }
+        ]
+    })
+})
+    .openapi('UpsertPhaseSlotSchedulesData');
+export const upsertPhaseSlotSchedulesResponseSchema = createMessageDataResponseSchema(upsertPhaseSlotSchedulesDataSchema, 'UpsertPhaseSlotSchedulesResponse', 'Bulk phase slot schedules upsert completed', 'Results of the combined upsert operation');