@venulog/phasing-engine-schemas 0.7.6-alpha.0 → 0.8.0-alpha.0

package/dist/parkingBooking.js

@@ -3,8 +3,9 @@ import { paginationSchema } from './pagination.js';
 import { BookingStatus } from './enums/bookingStatus.js';
 import { createSuccessResponseSchema, createMessageDataResponseSchema, documentSchema, vehicleTypeSchema } from './common.js';
 import { z } from './zod.js';
-import { parkingAreaScheduleSchema } from './parkingArea.js';
+import { availableTimeSlotV2Schema, getAvailableSlotsBodyV2Schema } from './parkingArea.js';
 import { UnloadingType } from './enums/unloadingType.js';
+import { ParkingAreaScheduleType } from './enums/parkingAreaScheduleType.js';
 // PostGIS geometry schema (GeoJSON-like structure)
 export const geometrySchema = z
     .object({
@@ -84,26 +85,6 @@ export const closeEventBodySchema = z
     })
 })
     .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(),
-    entry_scanned_at: z.string().nullable(),
-    exit_scanned_at: z.string().nullable(),
-    // Include the schedule details
-    parking_area_schedule: parkingAreaScheduleSchema.optional()
-});
 export const companyDetailsSchema = z
     .object({
     hall: z.string().optional().nullable().openapi({
@@ -169,6 +150,27 @@ export const vehicleDetailsSchema = z
     })
 })
     .openapi('VehicleDetails');
+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: companyDetailsSchema,
+    vehicle: vehicleDetailsSchema,
+    entry_scanned_at: z.string().nullable(),
+    exit_scanned_at: z.string().nullable(),
+    parking_spot: z.string(),
+    door: z.string(),
+    parking_schedule_type: z.enum(ParkingAreaScheduleType)
+});
 export const eventBookingsDataSchema = z
     .object({
     event_id: z.number(),
@@ -212,7 +214,11 @@ export const closeEventDataSchema = z
 })
     .openapi('CloseEventData');
 export const closeEventResponseSchema = createMessageDataResponseSchema(closeEventDataSchema, 'CloseEventResponse', 'Event phase closed successfully', 'Details of the closed event phase');
-export const confirmExitBodySchema = z.object({
+export const confirmAccessBodySchema = z.object({
+    event_id: z.number().openapi({
+        description: 'ID of the event',
+        example: 1
+    }),
     plate_number: z
         .object({
         url: z.string().openapi({
@@ -260,170 +266,20 @@ export const confirmAccessResponseSchema = z.object({
 // ------------------------------
 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'
+    ...getAvailableSlotsBodyV2Schema.shape,
+    slot_key: z.string().min(1, 'Slot key is required').openapi({
+        description: 'Unique key identifying the time slot to check',
+        example: 'MainEntrance_2025-12-15_08:00'
     })
 })
     .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');
+export const checkSlotAvailabilityResponseSchema = createSuccessResponseSchema(availableTimeSlotV2Schema, 'CheckSlotAvailabilityResponse', 'Slot availability information with capacity details');
 // ------------------------------
 // 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'
@@ -443,12 +299,17 @@ export const createParkingBookingBodySchema = z
         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'
+    event_id: z.number().positive().openapi({
+        description: 'ID of the event for which the booking is made',
+        example: 1
+    }),
+    slot_key: z.string().min(1, 'Slot key is required').openapi({
+        description: 'Unique key identifying the time slot to book',
+        example: 'MainEntrance_2025-12-25_06:00'
+    }),
+    parking_schedule_type: z.enum(ParkingAreaScheduleType).openapi({
+        description: 'Type of parking area schedule',
+        example: 'assembly'
     })
 })
     .openapi('CreateParkingBookingBody');
@@ -456,7 +317,6 @@ export const createParkingBookingBodySchema = z
 export const createParkingBookingDataSchema = z
     .object({
     id: z.number(),
-    parking_area_schedule_id: z.number(),
     status: z.string(),
     company_role: z.string(),
     company: companyDetailsSchema.openapi({
@@ -468,6 +328,10 @@ export const createParkingBookingDataSchema = z
     booking_date: z.string(),
     start_time: z.string(),
     end_time: z.string(),
+    event_id: z.number(),
+    door: z.string(),
+    parking_spot: z.string(),
+    parking_schedule_type: z.enum(ParkingAreaScheduleType),
     created_at: z.string(),
     created_by: z.string().nullable()
 })
@@ -595,27 +459,25 @@ export const parkingBookingWithRelationsSchema = z
     is_active: z.boolean(),
     created_at: z.string(),
     updated_at: z.string(),
-    parking_area_schedules: z.object({
+    events: z.object({
         id: z.number(),
-        parking_area_schedule_type: z.string(),
-        parking_areas: z.object({
+        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(),
-            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()
-            })
+            name: z.string()
         })
-    })
+            .nullable()
+    }),
+    parking_spot: z.string(),
+    door: z.string(),
+    parking_schedule_type: z.enum(ParkingAreaScheduleType),
+    slot_key: z.string(),
+    entry_scanned_at: z.string().nullable(),
+    exit_scanned_at: z.string().nullable()
 })
     .openapi('ParkingBookingWithRelations');
 // ------------------------------
@@ -696,20 +558,6 @@ export const parkingBookingDetailsDataSchema = z
         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
-    }),
-    parking_area: z.object({
-        id: z.number().openapi({
-            description: 'ID of parking area',
-            example: 30
-        }),
-        name: z.string().openapi({
-            description: 'Name of parking area',
-            example: 'Parking Spot X'
-        })
-    }),
     banner: documentSchema.nullable().openapi({
         description: 'Event banner document',
         example: {
@@ -733,6 +581,22 @@ export const parkingBookingDetailsDataSchema = z
     exit_scanned_at: z.string().nullable().optional().openapi({
         description: 'Timestamp when exit was scanned',
         example: '2025-12-15T08:25:00.000Z'
+    }),
+    slot_key: z.string().openapi({
+        description: 'Unique key identifying the booked time slot',
+        example: 'MainEntrance_2025-12-15_08:00'
+    }),
+    parking_spot: z.string().openapi({
+        description: 'Assigned parking spot for the booking',
+        example: 'A-12'
+    }),
+    door: z.string().openapi({
+        description: 'Assigned door for the booking',
+        example: 'North Gate'
+    }),
+    parking_schedule_type: z.enum(ParkingAreaScheduleType).openapi({
+        description: 'Type of parking area schedule',
+        example: 'assembly'
     })
 })
     .openapi('ParkingBookingDetailsData');
@@ -748,7 +612,6 @@ export const getParkingBookingDetailsByTokenBodySchema = z
     })
 })
     .openapi('GetParkingBookingDetailsByTokenBody');
-export const getParkingBookingDetailsByTokenResponseSchema = createSuccessResponseSchema(bookingDetailsDataSchema, 'GetParkingBookingDetailsByTokenResponse', 'Booking details retrieved by access token');
 // ------------------------------
 // Get booking details by QR schemas
 // ------------------------------
@@ -760,7 +623,6 @@ export const getParkingBookingDetailsByQrBodySchema = z
     })
 })
     .openapi('GetBookingDetailsByQrBody');
-export const getParkingBookingDetailsByQrResponseSchema = createSuccessResponseSchema(bookingDetailsDataSchema, 'GetBookingDetailsByQrResponse', 'Booking details retrieved by QR token');
 // ------------------------------
 // Export All Parking Bookings
 // ------------------------------
@@ -860,9 +722,9 @@ export const updateBookingTimeBodySchema = z
         description: 'New start time (HH:MM)',
         example: '10:00'
     }),
-    parking_area_schedule_id: z.number().int().positive().openapi({
-        description: 'New parking area schedule ID',
-        example: 5
+    slot_key: z.string().min(1, 'Slot key is required').openapi({
+        description: 'Unique key identifying the new time slot',
+        example: 'MainEntrance_2025-12-25_10:00'
     })
 })
     .openapi('UpdateBookingTimeBody');
@@ -872,10 +734,6 @@ export const updateBookingTimeDataSchema = z
         description: 'ID of the updated booking',
         example: 1
     }),
-    parking_area_schedule_id: z.number().openapi({
-        description: 'New parking area schedule ID',
-        example: 5
-    }),
     booking_date: z.string().openapi({
         description: 'New booking date',
         example: '2025-12-25'

package/dist/simulation.d.ts

@@ -0,0 +1,171 @@
+import { z } from './zod.js';
+import { SimulationMode, SimulationStatus } from './enums/simulationMode.js';
+export declare const simulationModeSchema: z.ZodEnum<{
+    entry: SimulationMode.ENTRY;
+    exit: SimulationMode.EXIT;
+    both: SimulationMode.BOTH;
+}>;
+export declare const simulationStatusSchema: z.ZodEnum<{
+    running: SimulationStatus.RUNNING;
+    stopped: SimulationStatus.STOPPED;
+    completed: SimulationStatus.COMPLETED;
+}>;
+export declare const startSimulationBodySchema: z.ZodObject<{
+    event_id: z.ZodNumber;
+    booking_ids: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+    speed_kmh: z.ZodDefault<z.ZodNumber>;
+    update_interval_ms: z.ZodDefault<z.ZodNumber>;
+    mode: z.ZodDefault<z.ZodEnum<{
+        entry: SimulationMode.ENTRY;
+        exit: SimulationMode.EXIT;
+        both: SimulationMode.BOTH;
+    }>>;
+}, z.core.$strip>;
+export type StartSimulationBody = z.infer<typeof startSimulationBodySchema>;
+export declare const startSimulationDataSchema: z.ZodObject<{
+    session_id: z.ZodString;
+    event_id: z.ZodNumber;
+    booking_ids: z.ZodArray<z.ZodNumber>;
+    speed_kmh: z.ZodNumber;
+    update_interval_ms: z.ZodNumber;
+    mode: z.ZodEnum<{
+        entry: SimulationMode.ENTRY;
+        exit: SimulationMode.EXIT;
+        both: SimulationMode.BOTH;
+    }>;
+    started_at: z.ZodString;
+}, z.core.$strip>;
+export type StartSimulationData = z.infer<typeof startSimulationDataSchema>;
+export declare const startSimulationResponseSchema: z.ZodObject<{
+    success: z.ZodBoolean;
+    message: z.ZodString;
+    data: z.ZodObject<{
+        session_id: z.ZodString;
+        event_id: z.ZodNumber;
+        booking_ids: z.ZodArray<z.ZodNumber>;
+        speed_kmh: z.ZodNumber;
+        update_interval_ms: z.ZodNumber;
+        mode: z.ZodEnum<{
+            entry: SimulationMode.ENTRY;
+            exit: SimulationMode.EXIT;
+            both: SimulationMode.BOTH;
+        }>;
+        started_at: z.ZodString;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type StartSimulationResponse = z.infer<typeof startSimulationResponseSchema>;
+export declare const stopSimulationBodySchema: z.ZodObject<{
+    session_id: z.ZodOptional<z.ZodString>;
+    event_id: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export type StopSimulationBody = z.infer<typeof stopSimulationBodySchema>;
+export declare const stopSimulationDataSchema: z.ZodObject<{
+    sessions_stopped: z.ZodNumber;
+    session_ids: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+export type StopSimulationData = z.infer<typeof stopSimulationDataSchema>;
+export declare const stopSimulationResponseSchema: z.ZodObject<{
+    success: z.ZodBoolean;
+    message: z.ZodString;
+    data: z.ZodObject<{
+        sessions_stopped: z.ZodNumber;
+        session_ids: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type StopSimulationResponse = z.infer<typeof stopSimulationResponseSchema>;
+export declare const simulationSessionSchema: z.ZodObject<{
+    id: z.ZodString;
+    event_id: z.ZodNumber;
+    speed_kmh: z.ZodNumber;
+    update_interval_ms: z.ZodNumber;
+    mode: z.ZodEnum<{
+        entry: SimulationMode.ENTRY;
+        exit: SimulationMode.EXIT;
+        both: SimulationMode.BOTH;
+    }>;
+    booking_ids: z.ZodArray<z.ZodNumber>;
+    status: z.ZodEnum<{
+        running: SimulationStatus.RUNNING;
+        stopped: SimulationStatus.STOPPED;
+        completed: SimulationStatus.COMPLETED;
+    }>;
+    started_at: z.ZodString;
+    stopped_at: z.ZodNullable<z.ZodString>;
+    positions_generated: z.ZodNumber;
+}, z.core.$strip>;
+export type SimulationSession = z.infer<typeof simulationSessionSchema>;
+export declare const getSimulationStatusQuerySchema: z.ZodObject<{
+    event_id: z.ZodOptional<z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<number, string>>, z.ZodNumber>>;
+    include_completed: z.ZodPipe<z.ZodDefault<z.ZodOptional<z.ZodString>>, z.ZodTransform<boolean, string>>;
+}, z.core.$strip>;
+export type GetSimulationStatusQuery = z.infer<typeof getSimulationStatusQuerySchema>;
+export declare const simulationStatusDataSchema: z.ZodObject<{
+    active: z.ZodBoolean;
+    sessions: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        event_id: z.ZodNumber;
+        speed_kmh: z.ZodNumber;
+        update_interval_ms: z.ZodNumber;
+        mode: z.ZodEnum<{
+            entry: SimulationMode.ENTRY;
+            exit: SimulationMode.EXIT;
+            both: SimulationMode.BOTH;
+        }>;
+        booking_ids: z.ZodArray<z.ZodNumber>;
+        status: z.ZodEnum<{
+            running: SimulationStatus.RUNNING;
+            stopped: SimulationStatus.STOPPED;
+            completed: SimulationStatus.COMPLETED;
+        }>;
+        started_at: z.ZodString;
+        stopped_at: z.ZodNullable<z.ZodString>;
+        positions_generated: z.ZodNumber;
+    }, z.core.$strip>>;
+    total_active: z.ZodNumber;
+}, z.core.$strip>;
+export type SimulationStatusData = z.infer<typeof simulationStatusDataSchema>;
+export declare const getSimulationStatusResponseSchema: z.ZodObject<{
+    success: z.ZodBoolean;
+    data: z.ZodObject<{
+        active: z.ZodBoolean;
+        sessions: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            event_id: z.ZodNumber;
+            speed_kmh: z.ZodNumber;
+            update_interval_ms: z.ZodNumber;
+            mode: z.ZodEnum<{
+                entry: SimulationMode.ENTRY;
+                exit: SimulationMode.EXIT;
+                both: SimulationMode.BOTH;
+            }>;
+            booking_ids: z.ZodArray<z.ZodNumber>;
+            status: z.ZodEnum<{
+                running: SimulationStatus.RUNNING;
+                stopped: SimulationStatus.STOPPED;
+                completed: SimulationStatus.COMPLETED;
+            }>;
+            started_at: z.ZodString;
+            stopped_at: z.ZodNullable<z.ZodString>;
+            positions_generated: z.ZodNumber;
+        }, z.core.$strip>>;
+        total_active: z.ZodNumber;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type GetSimulationStatusResponse = z.infer<typeof getSimulationStatusResponseSchema>;
+export declare const pathPointSchema: z.ZodObject<{
+    x: z.ZodNumber;
+    y: z.ZodNumber;
+    distance_from_start: z.ZodNumber;
+}, z.core.$strip>;
+export type PathPoint = z.infer<typeof pathPointSchema>;
+export declare const simulatedPathSchema: z.ZodObject<{
+    booking_id: z.ZodNumber;
+    points: z.ZodArray<z.ZodObject<{
+        x: z.ZodNumber;
+        y: z.ZodNumber;
+        distance_from_start: z.ZodNumber;
+    }, z.core.$strip>>;
+    total_distance: z.ZodNumber;
+    estimated_duration: z.ZodNumber;
+}, z.core.$strip>;
+export type SimulatedPath = z.infer<typeof simulatedPathSchema>;