@venulog/phasing-engine-schemas 0.4.3 → 0.5.0-alpha.1

package/dist/phaseBooking.js

@@ -1,1369 +0,0 @@
-// packages/phasing-schemas/src/phaseBooking.ts
-import { paginationSchema } from './pagination.js';
-import { BookingStatus } from './enums/bookingStatus.js';
-import { createSuccessResponseSchema, createMessageDataResponseSchema, documentSchema } from './common.js';
-import { z } from './zod.js';
-import { PhaseSlotScheduleType } from './enums/phaseSlotScheduleType.js';
-import { ParkingAreaScheduleType } from './enums/parkingAreaScheduleType.js';
-// PostGIS geometry schema (GeoJSON-like structure)
-export const geometrySchema = z
-    .object({
-    type: z.enum([
-        'Polygon',
-        'MultiPolygon',
-        'Point',
-        'LineString',
-        'MultiLineString',
-        'MultiPoint'
-    ]),
-    coordinates: z.array(z.unknown()),
-    crs: z
-        .object({
-        type: z.literal('name'),
-        properties: z.object({
-            name: z.string()
-        })
-    })
-        .optional()
-})
-    .nullable()
-    .openapi({
-    description: 'PostGIS geometry object (GeoJSON format)',
-    example: {
-        type: 'Polygon',
-        coordinates: [
-            [
-                [2.3522, 48.8566],
-                [2.3532, 48.8566],
-                [2.3532, 48.8576],
-                [2.3522, 48.8576],
-                [2.3522, 48.8566]
-            ]
-        ]
-    }
-});
-// ------------------------------
-// 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');
-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');
-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()
-});
-// 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 schedule',
-        example: 1
-    }),
-    date: z.string().openapi({
-        description: 'Date of the schedule (YYYY-MM-DD format)',
-        example: '2025-12-15'
-    }),
-    start_time: z.string().openapi({
-        description: 'Start time (HH:MM format)',
-        example: '06:00'
-    }),
-    end_time: z.string().openapi({
-        description: 'End time (HH:MM format)',
-        example: '09:00'
-    }),
-    duration: z.number().openapi({
-        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 schedule was created',
-        example: '2025-12-09T10:00:00.000Z'
-    }),
-    updated_at: z.string().openapi({
-        description: 'Timestamp when schedule was updated',
-        example: '2025-12-09T10:30:00.000Z'
-    }),
-    created_by: z.uuid().nullable().openapi({
-        description: 'UUID of user who created the schedule',
-        example: '550e8400-e29b-41d4-a716-446655440000'
-    }),
-    updated_by: z.uuid().nullable().openapi({
-        description: 'UUID of user who last updated the schedule',
-        example: '550e8400-e29b-41d4-a716-446655440000'
-    })
-})
-    .openapi('PhaseSlotSchedule');
-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(),
-    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(),
-    booking_date: z.string().nullable(),
-    start_time: z.string().nullable(),
-    end_time: z.string().nullable(),
-    company_role: 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({
-    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({
-    // Event & Basic Info
-    event_id: z
-        .number()
-        .int()
-        .positive({
-        message: 'Event ID must be a positive integer'
-    })
-        .openapi({
-        description: 'ID of the event to create the booking for',
-        example: 1
-    }),
-    request_type: z
-        .enum([PhaseSlotScheduleType.ASSEMBLY, PhaseSlotScheduleType.DISMANTLING])
-        .default(PhaseSlotScheduleType.ASSEMBLY)
-        .openapi({
-        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 role for this booking
-    company_role: z.string().min(1, 'Company role is required').openapi({
-        description: 'Company role for this booking',
-        example: 'exhibitor'
-    }),
-    // Company details
-    company: companyDetailsSchema.openapi({
-        description: 'Company details including stand, contact, and driver info'
-    }),
-    // Vehicle details
-    vehicle: vehicleDetailsSchema.openapi({
-        description: 'Vehicle details'
-    })
-})
-    .openapi('CreateBookingBody');
-export const createBookingDataSchema = z
-    .object({
-    booking_id: z.number().openapi({
-        description: 'ID of the created booking',
-        example: 789
-    }),
-    phase_slot_schedule_id: z.number().openapi({
-        description: 'ID of the phase slot schedule',
-        example: 456
-    }),
-    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_role: z.string().nullable().openapi({
-        description: 'Company role for this booking',
-        example: 'exhibitor'
-    }),
-    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'
-    }),
-    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 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'
-    })
-});
-// 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),
-        schedule_id: z.number().openapi({
-            description: 'ID of the phase slot schedule',
-            example: 456
-        }),
-        confirmed_at: z.string(),
-        confirmed_by: z.string().nullable()
-    })
-});
-export const confirmAccessDataSchema = z.object({
-    bookingId: z.coerce.number().int().positive({
-        message: 'Booking ID must be a positive integer'
-    })
-});
-export const confirmAccessResponseSchema = z.object({
-    success: z.boolean(),
-    message: z.string(),
-    data: z.object({
-        booking_id: z.number(),
-        scanned_at: z.string()
-    })
-});
-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');
-// Updated refuse booking response to include schedule_id instead of slot_id
-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
-    }),
-    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',
-        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');
-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({
-        name: z.string().min(1, 'Name is required and cannot be empty').openapi({
-            description: 'Name of the parking area (required)',
-            example: 'Zone A - Loading Dock'
-        }),
-        geometry: geometrySchema.optional().openapi({
-            description: 'PostGIS polygon geometry representing the parking area boundary (optional)',
-            example: {
-                type: 'Polygon',
-                coordinates: [
-                    [
-                        [2.3522, 48.8566],
-                        [2.3532, 48.8566],
-                        [2.3532, 48.8576],
-                        [2.3522, 48.8576],
-                        [2.3522, 48.8566]
-                    ]
-                ]
-            }
-        }),
-        site_plan_image_url: z.url().nullable().optional().openapi({
-            description: 'URL to the site plan image (optional)',
-            example: 'https://storage.example.com/plans/zone-a.jpg'
-        }),
-        surface_area_sqm: z.number().positive().nullable().optional().openapi({
-            description: 'Surface area in square meters (optional, must be positive if provided)',
-            example: 150.5
-        })
-    }))
-        .min(1, 'At least one slot must be provided')
-        .openapi({
-        description: 'Array of slots to create with their properties',
-        example: [
-            {
-                name: 'Zone A - Loading Dock',
-                geometry: null,
-                site_plan_image_url: 'https://storage.example.com/plans/zone-a.jpg',
-                surface_area_sqm: 150.5
-            }
-        ]
-    })
-})
-    .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
-    }),
-    name: z.string().openapi({
-        description: 'Name of the parking area',
-        example: 'Zone A - Loading Dock'
-    }),
-    geometry: geometrySchema.openapi({
-        description: 'PostGIS polygon geometry representing the parking area boundary',
-        example: {
-            type: 'Polygon',
-            coordinates: [
-                [
-                    [2.3522, 48.8566],
-                    [2.3532, 48.8566],
-                    [2.3532, 48.8576],
-                    [2.3522, 48.8576],
-                    [2.3522, 48.8566]
-                ]
-            ]
-        }
-    }),
-    site_plan_image_url: z.string().nullable().openapi({
-        description: 'URL to the site plan image',
-        example: 'https://storage.example.com/plans/zone-a.jpg'
-    }),
-    surface_area_sqm: z.number().nullable().openapi({
-        description: 'Surface area in square meters',
-        example: 150.5
-    }),
-    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({
-        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: 'Failed to create slot'
-        })
-    }))
-        .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({
-    name: z.string().min(1, 'Name cannot be empty').optional().openapi({
-        description: 'New name for the parking area',
-        example: 'Zone B - Assembly Area'
-    }),
-    geometry: geometrySchema.optional().openapi({
-        description: 'New PostGIS polygon geometry',
-        example: {
-            type: 'Polygon',
-            coordinates: [
-                [
-                    [2.3522, 48.8566],
-                    [2.3532, 48.8566],
-                    [2.3532, 48.8576],
-                    [2.3522, 48.8576],
-                    [2.3522, 48.8566]
-                ]
-            ]
-        }
-    }),
-    site_plan_image_url: z.string().url().nullable().optional().openapi({
-        description: 'New site plan image URL',
-        example: 'https://storage.example.com/plans/zone-b.jpg'
-    }),
-    surface_area_sqm: z.number().positive().nullable().optional().openapi({
-        description: 'New surface area in square meters (must be positive if provided)',
-        example: 200.0
-    })
-})
-    .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
-    }),
-    name: z.string().openapi({
-        description: 'Name of the parking area',
-        example: 'Zone B - Assembly Area'
-    }),
-    geometry: geometrySchema.openapi({
-        description: 'PostGIS polygon geometry representing the parking area boundary',
-        example: {
-            type: 'Polygon',
-            coordinates: [
-                [
-                    [2.3522, 48.8566],
-                    [2.3532, 48.8566],
-                    [2.3532, 48.8576],
-                    [2.3522, 48.8576],
-                    [2.3522, 48.8566]
-                ]
-            ]
-        }
-    }),
-    site_plan_image_url: z.string().nullable().openapi({
-        description: 'URL to the site plan image',
-        example: 'https://storage.example.com/plans/zone-b.jpg'
-    }),
-    surface_area_sqm: z.number().nullable().openapi({
-        description: 'Surface area in square meters',
-        example: 200.0
-    }),
-    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 Schedules Schemas
-// ------------------------------
-export const upsertPhaseSlotScheduleItemSchema = z
-    .object({
-    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
-    }),
-    date: z
-        .string()
-        .regex(/^\d{4}-\d{2}-\d{2}$/, 'Date must be in YYYY-MM-DD format')
-        .openapi({
-        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')
-        .default('06:00')
-        .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')
-        .default('09:00')
-        .openapi({
-        description: 'End time (HH:MM format)',
-        example: '09:00'
-    }),
-    duration: z.number().positive().default(60).openapi({
-        description: 'Duration in minutes',
-        example: 180
-    }),
-    phase_slot_schedule_type: z
-        .enum([PhaseSlotScheduleType.ASSEMBLY, PhaseSlotScheduleType.DISMANTLING])
-        .openapi({
-        description: 'Type of schedule',
-        example: PhaseSlotScheduleType.ASSEMBLY
-    }),
-    company_roles: z
-        .array(z.string())
-        .nullable()
-        .optional()
-        .openapi({
-        description: 'Array of company roles allowed for this schedule (moved from phase_slots)',
-        example: ['exhibitor', 'organizer', 'contractor']
-    })
-})
-    .openapi('UpsertPhaseSlotScheduleItem');
-export const deletePhaseSlotScheduleItemSchema = z
-    .object({
-    id: z.number().int().positive().openapi({
-        description: 'ID of the schedule to delete',
-        example: 1
-    })
-})
-    .openapi('DeletePhaseSlotScheduleItem');
-export const upsertPhaseSlotSchedulesBodySchema = z
-    .object({
-    upsert: z
-        .array(upsertPhaseSlotScheduleItemSchema)
-        .optional()
-        .openapi({
-        description: 'Array of schedules to create or update',
-        example: [
-            {
-                phase_slot_id: 101,
-                date: '2025-12-15',
-                start_time: '06:00',
-                end_time: '09:00',
-                duration: 180,
-                phase_slot_schedule_type: 'assembly'
-            },
-            {
-                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_upserted: z.number().int().nonnegative().openapi({
-        description: 'Total number of schedules successfully upserted',
-        example: 3
-    }),
-    total_deleted: z.number().int().nonnegative().openapi({
-        description: 'Total number of schedules successfully deleted',
-        example: 1
-    }),
-    upserted_schedules: z.array(phaseSlotScheduleSchema).openapi({
-        description: 'Array of successfully upserted schedules'
-    }),
-    deleted_schedules: z
-        .array(z.object({
-        id: z.number().int().positive()
-    }))
-        .openapi({
-        description: 'Array of successfully deleted schedule IDs',
-        example: [{ id: 42 }]
-    }),
-    failed_operations: z
-        .array(z.object({
-        operation: z.enum(['upsert', 'delete']),
-        error: z.string(),
-        data: z.union([upsertPhaseSlotScheduleItemSchema, deletePhaseSlotScheduleItemSchema])
-    }))
-        .openapi({
-        description: 'Array of operations that failed to process',
-        example: [
-            {
-                operation: 'upsert',
-                error: 'Phase slot 999 not found or inactive',
-                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', 'Phase slot schedules operation completed', 'Results of the upsert/delete operations');
-// ------------------------------
-// Check Slot Availability schemas
-// ------------------------------
-export const checkSlotAvailabilityBodySchema = z
-    .object({
-    schedule_id: z.number().positive().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'
-    }),
-    company_role: z.string().min(1, 'Company role is required').openapi({
-        description: 'Company role to check availability for',
-        example: 'exhibitor'
-    })
-})
-    .openapi('CheckSlotAvailabilityBody');
-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');
-// ------------------------------
-// QR Code Generation schemas
-// ------------------------------
-export const getBookingDetailsParamsSchema = z
-    .object({
-    bookingId: z.coerce.number().int().positive({
-        message: 'Booking ID must be a positive integer'
-    })
-})
-    .openapi('GetBookingDetailsParams');
-export const bookingDetailsDataSchema = z
-    .object({
-    qr_token: z.string().nullable().openapi({
-        description: 'QR token for verification',
-        example: 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...'
-    }),
-    id: z.number().openapi({
-        description: 'ID of the booking',
-        example: 123
-    }),
-    booking_id: z.number().openapi({
-        description: 'ID of the booking',
-        example: 123
-    }),
-    status: z.string().openapi({
-        description: 'Booking status',
-        example: 'confirmed'
-    }),
-    booking_date: z.string().openapi({
-        description: 'Date of the booking',
-        example: '2025-12-15'
-    }),
-    start_time: z.string().openapi({
-        description: 'Start time of the booking',
-        example: '08:00'
-    }),
-    end_time: z.string().openapi({
-        description: 'End time of the booking',
-        example: '08:30'
-    }),
-    company_role: z.string().nullable().openapi({
-        description: 'Company role for the booking',
-        example: 'exhibitor'
-    }),
-    company: companyDetailsSchema.openapi({
-        description: 'Company details'
-    }),
-    vehicle: vehicleDetailsSchema.openapi({
-        description: 'Vehicle details'
-    }),
-    event_id: z.number().openapi({
-        description: 'ID of the event',
-        example: 1
-    }),
-    event_name: z.string().openapi({
-        description: 'Name of the event',
-        example: 'Paris Fashion Week 2025'
-    }),
-    event_code: z.string().openapi({
-        description: 'Code of the event',
-        example: 'PFW2025'
-    }),
-    venue_id: z.number().nullable().openapi({
-        description: 'ID of the venue',
-        example: 1
-    }),
-    venue_name: z.string().nullable().openapi({
-        description: 'Name of the venue',
-        example: 'Paris Expo Porte de Versailles'
-    }),
-    request_type: z.string().openapi({
-        description: 'Type of phase slot schedule (assembly/dismantling)',
-        example: 'assembly'
-    }),
-    duration: z.number().openapi({
-        description: 'Duration of the booking in minutes',
-        example: 30
-    }),
-    phase_slot_schedule_id: z.number().openapi({
-        description: 'ID of the phase slot schedule',
-        example: 456
-    }),
-    banner: documentSchema.nullable().openapi({
-        description: 'Event banner document',
-        example: {
-            url: 'https://example.com/event-banner.jpg',
-            name: 'event-banner.jpg',
-            type: 'image/jpeg'
-        }
-    }),
-    created_at: z.string().openapi({
-        description: 'Timestamp when booking was created',
-        example: '2025-12-05T10:30:00.000Z'
-    }),
-    updated_at: z.string().openapi({
-        description: 'Timestamp when booking was last updated',
-        example: '2025-12-05T10:30:00.000Z'
-    })
-})
-    .openapi('BookingDetailsData');
-export const getBookingDetailsResponseSchema = createSuccessResponseSchema(bookingDetailsDataSchema, 'GetBookingDetailsResponse', 'Booking details with access pass information');
-// ------------------------------
-// Get booking details by token schemas
-// ------------------------------
-export const getBookingDetailsByTokenBodySchema = z
-    .object({
-    access_token: z.string().min(1, 'Access token is required').openapi({
-        description: 'Access pass token from confirmed booking',
-        example: 'ACCESS_1a2b3c4d5e6f7g8h_eyJib29raW5nSWQiOjEyM30%3D'
-    })
-})
-    .openapi('GetBookingDetailsByTokenBody');
-export const getBookingDetailsByTokenResponseSchema = createSuccessResponseSchema(bookingDetailsDataSchema, 'GetBookingDetailsByTokenResponse', 'Booking details retrieved by access token');
-// ------------------------------
-// Get booking details by QR schemas
-// ------------------------------
-export const getBookingDetailsByQrBodySchema = z
-    .object({
-    qr_token: z.string().min(1, 'QR token is required').openapi({
-        description: 'QR token from confirmed booking',
-        example: 'ACCESS_1a2b3c4d5e6f7g8h_eyJib29raW5nSWQiOjEyM30%3D'
-    })
-})
-    .openapi('GetBookingDetailsByQrBody');
-export const getBookingDetailsByQrResponseSchema = createSuccessResponseSchema(bookingDetailsDataSchema, 'GetBookingDetailsByQrResponse', 'Booking details retrieved by QR token');
-// ------------------------------
-// Update Phase Booking schemas
-// ------------------------------
-export const updatePhaseBookingBodySchema = z
-    .object({
-    company: companyDetailsSchema.optional().openapi({
-        description: 'Updated company details'
-    }),
-    vehicle: vehicleDetailsSchema.optional().openapi({
-        description: 'Updated vehicle details'
-    }),
-    access_token: z.string().min(1, 'Access token is required').openapi({
-        description: 'Access pass token for booking verification',
-        example: 'ACCESS_1a2b3c4d5e6f7g8h_eyJib29raW5nSWQiOjF9'
-    })
-})
-    .refine(data => data.company !== undefined || data.vehicle !== undefined, {
-    message: 'At least one field (company or vehicle) must be provided for update'
-})
-    .openapi('UpdatePhaseBookingBody');
-export const updatePhaseBookingDataSchema = z
-    .object({
-    booking_id: z.number().openapi({
-        description: 'ID of the updated booking',
-        example: 1
-    }),
-    qr_token: z.string().openapi({
-        description: 'New regenerated QR token',
-        example: 'ACCESS_1a2b3c4d5e6f7g8h_eyJib29raW5nSWQiOjF9'
-    }),
-    company: companyDetailsSchema.nullable().openapi({
-        description: 'Updated company details'
-    }),
-    vehicle: vehicleDetailsSchema.nullable().openapi({
-        description: 'Updated vehicle details'
-    }),
-    updated_at: z.string().openapi({
-        description: 'Timestamp when booking was updated',
-        example: '2025-12-23T10:30:00.000Z'
-    }),
-    updated_by: z.string().nullable().openapi({
-        description: 'ID of the user who updated the booking',
-        example: 'user-123'
-    })
-})
-    .openapi('UpdatePhaseBookingData');
-export const updatePhaseBookingResponseSchema = createMessageDataResponseSchema(updatePhaseBookingDataSchema, 'UpdatePhaseBookingResponse', 'Phase booking updated successfully', 'Details of the updated booking');
-// ------------------------------
-// Booking with nested relations schema for QR generation
-// ------------------------------
-export const bookingWithRelationsSchema = z
-    .object({
-    id: z.number(),
-    status: z.string(),
-    qr_token: z.string().nullable(),
-    booking_date: z.string(),
-    start_time: z.string(),
-    end_time: z.string(),
-    company_role: z.string().nullable(),
-    company: z.record(z.string(), z.unknown()).nullable(),
-    vehicle: z.record(z.string(), z.unknown()).nullable(),
-    is_active: z.boolean(),
-    created_at: z.string(),
-    updated_at: z.string(),
-    phase_slot_schedules: z.object({
-        id: z.number(),
-        phase_slot_schedule_type: z.string(),
-        phase_slots: z.object({
-            id: z.number(),
-            events: z.object({
-                id: z.number(),
-                name: z.string(),
-                code: z.string(),
-                venue_id: z.number().nullable(),
-                banner: z.record(z.string(), z.unknown()).nullable(),
-                venues: z
-                    .object({
-                    id: z.number(),
-                    name: z.string()
-                })
-                    .nullable()
-            })
-        })
-    })
-})
-    .openapi('BookingWithRelations');
-// ======================================================================
-// PARKING BOOKING SCHEMAS (New naming convention)
-// These schemas use the new parking_area naming to match the database
-// ======================================================================
-// ------------------------------
-// Parking Booking Schema (matches parking_bookings table)
-// ------------------------------
-/**
- * Parking area schedule schema (from database response)
- * Uses new column names: parking_area_id, parking_area_schedule_type
- */
-export const parkingAreaScheduleSchemaForBooking = z
-    .object({
-    id: z.number().int().positive().openapi({
-        description: 'Unique identifier for the schedule',
-        example: 1
-    }),
-    date: z.string().openapi({
-        description: 'Date of the schedule (YYYY-MM-DD format)',
-        example: '2025-12-15'
-    }),
-    start_time: z.string().openapi({
-        description: 'Start time (HH:MM format)',
-        example: '06:00'
-    }),
-    end_time: z.string().openapi({
-        description: 'End time (HH:MM format)',
-        example: '09:00'
-    }),
-    duration: z.number().openapi({
-        description: 'Duration in minutes',
-        example: 180
-    }),
-    parking_area_id: z.number().int().positive().openapi({
-        description: 'ID of the associated parking area',
-        example: 101
-    }),
-    parking_area_schedule_type: z
-        .enum([ParkingAreaScheduleType.ASSEMBLY, ParkingAreaScheduleType.DISMANTLING])
-        .openapi({
-        description: 'Type of schedule',
-        example: ParkingAreaScheduleType.ASSEMBLY
-    }),
-    company_role: z.string().nullable().openapi({
-        description: 'Company role allowed for this schedule',
-        example: 'exhibitor'
-    }),
-    created_at: z.string().openapi({
-        description: 'Timestamp when schedule was created',
-        example: '2025-12-09T10:00:00.000Z'
-    }),
-    updated_at: z.string().openapi({
-        description: 'Timestamp when schedule was updated',
-        example: '2025-12-09T10:30:00.000Z'
-    }),
-    created_by: z.string().uuid().nullable().openapi({
-        description: 'UUID of user who created the schedule',
-        example: '550e8400-e29b-41d4-a716-446655440000'
-    }),
-    updated_by: z.string().uuid().nullable().openapi({
-        description: 'UUID of user who last updated the schedule',
-        example: '550e8400-e29b-41d4-a716-446655440000'
-    })
-})
-    .openapi('ParkingAreaScheduleForBooking');
-/**
- * Parking booking schema (matches parking_bookings table)
- * Uses new column name: parking_area_schedule_id
- */
-export const parkingBookingSchema = z
-    .object({
-    id: z.number().openapi({
-        description: 'Booking ID',
-        example: 1
-    }),
-    parking_area_schedule_id: z.number().openapi({
-        description: 'ID of the parking area schedule',
-        example: 456
-    }),
-    status: z.enum(BookingStatus).openapi({
-        description: 'Booking status',
-        example: BookingStatus.BOOKED
-    }),
-    is_active: z.boolean().openapi({
-        description: 'Whether the booking is active',
-        example: true
-    }),
-    created_at: z.string().openapi({
-        description: 'Creation timestamp',
-        example: '2025-12-20T10:30:00Z'
-    }),
-    updated_at: z.string().openapi({
-        description: 'Last update timestamp',
-        example: '2025-12-20T10:30:00Z'
-    }),
-    created_by: z.string().nullable().openapi({
-        description: 'User ID who created the booking',
-        example: 'user-uuid-123'
-    }),
-    updated_by: z.string().nullable().openapi({
-        description: 'User ID who last updated the booking',
-        example: 'user-uuid-123'
-    }),
-    booking_date: z.string().nullable().openapi({
-        description: 'Date of the booking',
-        example: '2025-12-15'
-    }),
-    start_time: z.string().nullable().openapi({
-        description: 'Start time of the booking',
-        example: '08:00'
-    }),
-    end_time: z.string().nullable().openapi({
-        description: 'End time of the booking',
-        example: '08:30'
-    }),
-    company: z.record(z.string(), z.unknown()).nullable().optional().openapi({
-        description: 'Company details (JSONB)'
-    }),
-    vehicle: z.record(z.string(), z.unknown()).nullable().optional().openapi({
-        description: 'Vehicle details (JSONB)'
-    }),
-    // Include the schedule details when joined
-    parking_area_schedule: parkingAreaScheduleSchemaForBooking.optional().openapi({
-        description: 'Associated parking area schedule details'
-    })
-})
-    .openapi('ParkingBooking');
-// ------------------------------
-// Create Parking Booking Schemas
-// ------------------------------
-export const createParkingBookingBodySchema = z
-    .object({
-    event_id: z.number().int().positive().openapi({
-        description: 'ID of the event to create the booking for',
-        example: 1
-    }),
-    parking_area_id: z.number().int().positive().openapi({
-        description: 'ID of the parking area',
-        example: 101
-    }),
-    request_type: z
-        .enum([ParkingAreaScheduleType.ASSEMBLY, ParkingAreaScheduleType.DISMANTLING])
-        .default(ParkingAreaScheduleType.ASSEMBLY)
-        .openapi({
-        description: 'Type of request (assembly or dismantling)',
-        example: ParkingAreaScheduleType.ASSEMBLY
-    }),
-    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: companyDetailsSchema.openapi({
-        description: 'Company details including stand, contact, and driver info'
-    }),
-    vehicle: vehicleDetailsSchema.openapi({
-        description: 'Vehicle details'
-    })
-})
-    .openapi('CreateParkingBookingBody');
-export const createParkingBookingDataSchema = z
-    .object({
-    booking_id: z.number().openapi({
-        description: 'ID of the created booking',
-        example: 789
-    }),
-    parking_area_schedule_id: z.number().openapi({
-        description: 'ID of the parking area schedule',
-        example: 456
-    }),
-    parking_area_id: z.number().openapi({
-        description: 'ID of the parking area',
-        example: 101
-    }),
-    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'
-    }),
-    vehicle: vehicleDetailsSchema.openapi({
-        description: 'Vehicle details'
-    }),
-    created_at: z.string().openapi({
-        description: 'Timestamp when booking was created',
-        example: '2025-12-20T10:30:00.000Z'
-    }),
-    created_by: z.string().nullable().openapi({
-        description: 'ID of the user who created the booking',
-        example: 'user-123'
-    })
-})
-    .openapi('CreateParkingBookingData');
-export const createParkingBookingResponseSchema = createMessageDataResponseSchema(createParkingBookingDataSchema, 'CreateParkingBookingResponse', 'Parking booking created successfully', 'Details of the created parking booking');
-// ------------------------------
-// Parking Bookings List Response
-// ------------------------------
-export const parkingBookingsDataSchema = z
-    .object({
-    event_id: z.number().openapi({
-        description: 'Event ID',
-        example: 1
-    }),
-    event_code: z.string().openapi({
-        description: 'Event code',
-        example: 'COEC2025'
-    }),
-    event_name: z.string().openapi({
-        description: 'Event name',
-        example: 'COEC 2025'
-    }),
-    bookings: z.array(parkingBookingSchema).openapi({
-        description: 'List of parking bookings'
-    }),
-    total_count: z.number().openapi({
-        description: 'Total number of bookings',
-        example: 25
-    })
-})
-    .openapi('ParkingBookingsData');
-export const parkingBookingsResponseSchema = createSuccessResponseSchema(parkingBookingsDataSchema, 'ParkingBookingsResponse', 'Parking bookings data with parking area details');