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

package/dist/parkingBooking.js

@@ -0,0 +1,734 @@
+// packages/phasing-schemas/src/parkingBooking.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 { parkingAreaScheduleSchema } from './parkingArea.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');
+export const parkingBookingSchema = z.object({
+    id: z.number(),
+    parking_area_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
+    parking_area_schedule: parkingAreaScheduleSchema.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 eventBookingsDataSchema = z
+    .object({
+    event_id: z.number(),
+    event_code: z.string(),
+    event_name: z.string(),
+    bookings: z.array(parkingBookingSchema),
+    total_count: z.number()
+})
+    .openapi('EventBookingsData');
+export const eventBookingsResponseSchema = createSuccessResponseSchema(eventBookingsDataSchema, 'EventBookingsResponse', 'Event bookings data with parking area 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 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()
+    })
+});
+// ------------------------------
+// Check Slot Availability schemas
+// ------------------------------
+export const checkSlotAvailabilityBodySchema = z
+    .object({
+    schedule_id: z.number().positive().openapi({
+        description: 'The ID of the parking area 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 parking area 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 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 parking area schedule (assembly/dismantling)',
+        example: 'assembly'
+    }),
+    duration: z.number().openapi({
+        description: 'Duration of the booking in minutes',
+        example: 30
+    }),
+    parking_area_schedule_id: z.number().openapi({
+        description: 'ID of the parking area 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');
+// ------------------------------
+// Create Parking Booking schemas
+// ------------------------------
+// Request schema
+export const createParkingBookingBodySchema = z
+    .object({
+    parking_area_schedule_id: z.number().int().positive().openapi({
+        description: 'ID of the parking area schedule to book',
+        example: 1
+    }),
+    // Company details
+    company: companyDetailsSchema.openapi({
+        description: 'Company details including stand, contact, and driver info'
+    }),
+    company_role: z.string().min(1).openapi({
+        description: 'Company role (e.g., exhibitor, contractor, organizer)',
+        example: 'exhibitor'
+    }),
+    // Vehicle details
+    vehicle: vehicleDetailsSchema.openapi({
+        description: 'Vehicle details'
+    }),
+    vehicle_type: z.enum(['PL', 'VUL', 'VL']).openapi({
+        description: 'Vehicle type: PL (poids lourd), VUL (véhicule utilitaire léger), VL (véhicule léger)',
+        example: 'PL'
+    }),
+    booking_date: z
+        .string()
+        .regex(/^\d{4}-\d{2}-\d{2}$/)
+        .openapi({
+        description: 'Booking date (YYYY-MM-DD)',
+        example: '2025-12-25'
+    }),
+    start_time: z
+        .string()
+        .regex(/^\d{2}:\d{2}$/)
+        .openapi({
+        description: 'Start time (HH:MM)',
+        example: '06:00'
+    }),
+    end_time: z
+        .string()
+        .regex(/^\d{2}:\d{2}$/)
+        .openapi({
+        description: 'End time (HH:MM)',
+        example: '09:00'
+    })
+})
+    .openapi('CreateParkingBookingBody');
+// Response schema
+export const createParkingBookingDataSchema = z
+    .object({
+    id: z.number(),
+    parking_area_schedule_id: z.number(),
+    status: z.string(),
+    company_role: z.string(),
+    company: companyDetailsSchema.openapi({
+        description: 'Company details including stand, contact, and driver info'
+    }),
+    vehicle: vehicleDetailsSchema.openapi({
+        description: 'Vehicle details'
+    }),
+    vehicle_type: z.string(),
+    booking_date: z.string(),
+    start_time: z.string(),
+    end_time: z.string(),
+    created_at: z.string(),
+    created_by: z.string().nullable()
+})
+    .openapi('CreateParkingBookingData');
+export const createParkingBookingResponseSchema = createMessageDataResponseSchema(createParkingBookingDataSchema, 'CreateParkingBookingResponse', 'Parking booking created successfully', 'Details of the created booking');
+// ------------------------------
+// Update Parking Booking schemas
+// ------------------------------
+export const updateParkingBookingBodySchema = 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('UpdateParkingBookingBody');
+export const updateParkingBookingDataSchema = 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('UpdateParkingBookingData');
+export const updateParkingBookingResponseSchema = createMessageDataResponseSchema(updateParkingBookingDataSchema, 'UpdateParkingBookingResponse', 'Parking booking updated successfully', 'Details of the updated booking');
+// ------------------------------
+// Confirm Booking Schemas
+// ------------------------------
+// Path params schema
+export const confirmBookingParamsSchema = z
+    .object({
+    bookingId: z
+        .string()
+        .transform(val => parseInt(val, 10))
+        .refine(val => !isNaN(val) && val > 0, {
+        message: 'Booking ID must be a positive number'
+    })
+        .openapi({
+        description: 'Parking booking ID',
+        example: '1'
+    })
+})
+    .openapi('ConfirmBookingParams');
+// Response schema
+export const confirmBookingDataSchema = z
+    .object({
+    success: z.boolean(),
+    message: z.string(),
+    data: z.object({
+        id: z.number(),
+        status: z.string(),
+        parking_area_schedule_id: z.number(),
+        updated_at: z.string(),
+        updated_by: z.string()
+    })
+})
+    .openapi('ConfirmBookingData');
+export const confirmBookingResponseSchema = createMessageDataResponseSchema(confirmBookingDataSchema, 'ConfirmBookingResponse', 'Parking booking confirmed successfully', 'Details of the confirmed booking');
+// ------------------------------
+// Refuse Booking Schemas
+// ------------------------------
+// Path params schema
+export const refuseBookingParamsSchema = z
+    .object({
+    bookingId: z
+        .string()
+        .transform(val => parseInt(val, 10))
+        .refine(val => !isNaN(val) && val > 0, {
+        message: 'Booking ID must be a positive number'
+    })
+        .openapi({
+        description: 'Parking booking ID',
+        example: '1'
+    })
+})
+    .openapi('RefuseBookingParams');
+// Response schema
+export const refuseBookingDataSchema = z
+    .object({
+    success: z.boolean(),
+    message: z.string(),
+    data: z.object({
+        id: z.number(),
+        status: z.string(),
+        parking_area_schedule_id: z.number(),
+        updated_at: z.string(),
+        updated_by: z.string()
+    })
+})
+    .openapi('RefuseBookingData');
+export const refuseBookingResponseSchema = createMessageDataResponseSchema(refuseBookingDataSchema, 'RefuseBookingResponse', 'Parking booking refused successfully', 'Details of the refused booking');
+// ------------------------------
+// Booking with nested relations schema for QR generation
+// ------------------------------
+export const parkingBookingWithRelationsSchema = 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(),
+    parking_area_schedules: z.object({
+        id: z.number(),
+        parking_area_schedule_type: z.string(),
+        parking_areas: 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('ParkingBookingWithRelations');
+// ------------------------------
+// QR Code Generation schemas
+// ------------------------------
+export const getParkingBookingDetailsParamsSchema = z
+    .object({
+    bookingId: z.coerce.number().int().positive({
+        message: 'Booking ID must be a positive integer'
+    })
+})
+    .openapi('GetParkingBookingDetailsParams');
+export const parkingBookingDetailsDataSchema = 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 parking area schedule (assembly/dismantling)',
+        example: 'assembly'
+    }),
+    duration: z.number().openapi({
+        description: 'Duration of the booking in minutes',
+        example: 30
+    }),
+    parking_area_schedule_id: z.number().openapi({
+        description: 'ID of the parking area 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('ParkingBookingDetailsData');
+export const getParkingBookingDetailsResponseSchema = createSuccessResponseSchema(parkingBookingDetailsDataSchema, 'GetParkingBookingDetailsResponse', 'Booking details with access pass information');
+// ------------------------------
+// Get booking details by token schemas
+// ------------------------------
+export const getParkingBookingDetailsByTokenBodySchema = 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('GetParkingBookingDetailsByTokenBody');
+export const getParkingBookingDetailsByTokenResponseSchema = createSuccessResponseSchema(bookingDetailsDataSchema, 'GetParkingBookingDetailsByTokenResponse', 'Booking details retrieved by access token');
+// ------------------------------
+// Get booking details by QR schemas
+// ------------------------------
+export const getParkingBookingDetailsByQrBodySchema = 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 getParkingBookingDetailsByQrResponseSchema = createSuccessResponseSchema(bookingDetailsDataSchema, 'GetBookingDetailsByQrResponse', 'Booking details retrieved by QR token');