@venulog/phasing-engine-schemas 0.7.5 → 0.7.6

package/dist/parkingAreaLayer.js

@@ -0,0 +1,385 @@
+// packages/phasing-schemas/src/parkingAreaLayer.ts
+import { z } from './zod.js';
+import { createSuccessResponseSchema, createMessageDataResponseSchema } from './common.js';
+// ------------------------------
+// Layer Transform Schema
+// ------------------------------
+/**
+ * Transform data for layer positioning and rotation
+ */
+export const layerTransformSchema = z
+    .object({
+    left: z.number().openapi({
+        description: 'Horizontal position offset in pixels',
+        example: 100
+    }),
+    top: z.number().openapi({
+        description: 'Vertical position offset in pixels',
+        example: 50
+    }),
+    scaleX: z.number().positive().openapi({
+        description: 'Horizontal scale factor',
+        example: 1.2
+    }),
+    scaleY: z.number().positive().openapi({
+        description: 'Vertical scale factor',
+        example: 1.2
+    }),
+    angle: z.number().min(-180).max(180).openapi({
+        description: 'Rotation angle in degrees',
+        example: 15
+    })
+})
+    .openapi('LayerTransform');
+// ------------------------------
+// Parking Area Layer Schemas
+// ------------------------------
+/**
+ * Core parking area layer item schema matching database structure
+ */
+export const parkingAreaLayerItemSchema = z
+    .object({
+    id: z.number().int().positive().openapi({
+        description: 'Layer ID',
+        example: 1
+    }),
+    event_id: z.number().int().positive().openapi({
+        description: 'Event ID this layer belongs to',
+        example: 1
+    }),
+    name: z.string().openapi({
+        description: 'Name of the layer',
+        example: 'Ground Floor Plan'
+    }),
+    layer_order: z.number().int().nonnegative().openapi({
+        description: 'Display order (lower numbers appear first)',
+        example: 0
+    }),
+    image_url: z.string().url().openapi({
+        description: 'URL to the layer image',
+        example: 'https://storage.example.com/layers/floor-1.png'
+    }),
+    visible: z.boolean().openapi({
+        description: 'Whether the layer is visible',
+        example: true
+    }),
+    opacity: z.number().min(0).max(1).openapi({
+        description: 'Layer opacity (0.0 to 1.0)',
+        example: 0.8
+    }),
+    altitude_meters: z.number().min(-100).max(100).openapi({
+        description: 'Altitude in meters for 3D rendering (-100 to +100)',
+        example: 0
+    }),
+    transform: layerTransformSchema.openapi({
+        description: 'Transform data for layer positioning and rotation'
+    }),
+    is_active: z.boolean().openapi({
+        description: 'Whether the layer is active',
+        example: true
+    }),
+    created_at: z.string().openapi({
+        description: 'Creation timestamp (ISO 8601)',
+        example: '2026-01-06T10:30:00Z'
+    }),
+    updated_at: z.string().openapi({
+        description: 'Last update timestamp (ISO 8601)',
+        example: '2026-01-06T10:30:00Z'
+    }),
+    created_by: z.string().uuid().nullable().openapi({
+        description: 'UUID of user who created this layer',
+        example: '550e8400-e29b-41d4-a716-446655440000'
+    }),
+    updated_by: z.string().uuid().nullable().openapi({
+        description: 'UUID of user who last updated this layer',
+        example: '550e8400-e29b-41d4-a716-446655440000'
+    })
+})
+    .openapi('ParkingAreaLayerItem');
+// ------------------------------
+// Query Schemas
+// ------------------------------
+export const getLayersByEventIdParamsSchema = z
+    .object({
+    eventId: z
+        .string()
+        .min(1)
+        .transform(val => parseInt(val, 10))
+        .refine(val => !isNaN(val) && val > 0, {
+        message: 'Event ID must be a positive number'
+    })
+        .openapi({
+        description: 'The ID of the event',
+        example: '1'
+    })
+})
+    .openapi('GetLayersByEventIdParams');
+export const getLayerByIdParamsSchema = z
+    .object({
+    layerId: z
+        .string()
+        .min(1)
+        .transform(val => parseInt(val, 10))
+        .refine(val => !isNaN(val) && val > 0, {
+        message: 'Layer ID must be a positive number'
+    })
+        .openapi({
+        description: 'The ID of the layer',
+        example: '1'
+    })
+})
+    .openapi('GetLayerByIdParams');
+// ------------------------------
+// Create Layer Schemas
+// ------------------------------
+export const createLayerBodySchema = z
+    .object({
+    event_id: z.number().int().positive().openapi({
+        description: 'ID of the event',
+        example: 1
+    }),
+    name: z.string().min(1).max(255).openapi({
+        description: 'Name of the layer',
+        example: 'Ground Floor Plan'
+    }),
+    layer_order: z.number().int().nonnegative().optional().openapi({
+        description: 'Display order (auto-assigned if not provided)',
+        example: 0
+    }),
+    image_url: z.string().url().openapi({
+        description: 'URL to the layer image',
+        example: 'https://storage.example.com/layers/floor-1.png'
+    }),
+    visible: z.boolean().default(true).openapi({
+        description: 'Whether the layer is visible',
+        example: true
+    }),
+    opacity: z.number().min(0).max(1).default(1).openapi({
+        description: 'Layer opacity (0.0 to 1.0)',
+        example: 1
+    }),
+    altitude_meters: z.number().min(-100).max(100).default(0).openapi({
+        description: 'Altitude in meters for 3D rendering',
+        example: 0
+    }),
+    transform: layerTransformSchema
+        .default({ left: 0, top: 0, scaleX: 1, scaleY: 1, angle: 0 })
+        .openapi({
+        description: 'Transform data for layer positioning'
+    })
+})
+    .openapi('CreateLayerBody');
+export const createLayerDataSchema = z
+    .object({
+    layer_id: z.number().openapi({
+        description: 'ID of the created layer',
+        example: 1
+    }),
+    event_id: z.number().openapi({
+        description: 'ID of the event',
+        example: 1
+    }),
+    name: z.string().openapi({
+        description: 'Name of the layer',
+        example: 'Ground Floor Plan'
+    }),
+    layer_order: z.number().openapi({
+        description: 'Display order',
+        example: 0
+    }),
+    image_url: z.string().openapi({
+        description: 'URL to the layer image'
+    }),
+    visible: z.boolean().openapi({
+        description: 'Whether the layer is visible',
+        example: true
+    }),
+    opacity: z.number().openapi({
+        description: 'Layer opacity',
+        example: 1
+    }),
+    altitude_meters: z.number().openapi({
+        description: 'Altitude in meters',
+        example: 0
+    }),
+    transform: layerTransformSchema.openapi({
+        description: 'Transform data'
+    }),
+    created_at: z.string().openapi({
+        description: 'Timestamp when layer was created'
+    }),
+    created_by: z.string().nullable().openapi({
+        description: 'ID of the user who created the layer'
+    })
+})
+    .openapi('CreateLayerData');
+export const createLayerResponseSchema = createMessageDataResponseSchema(createLayerDataSchema, 'CreateLayerResponse', 'Layer created successfully', 'Details of the created layer');
+// ------------------------------
+// Update Layer Schemas
+// ------------------------------
+export const updateLayerParamsSchema = z
+    .object({
+    layerId: z
+        .string()
+        .min(1)
+        .transform(val => parseInt(val, 10))
+        .refine(val => !isNaN(val) && val > 0, {
+        message: 'Layer ID must be a positive number'
+    })
+        .openapi({
+        description: 'The ID of the layer to update',
+        example: '1'
+    })
+})
+    .openapi('UpdateLayerParams');
+export const updateLayerBodySchema = z
+    .object({
+    name: z.string().min(1).max(255).optional().openapi({
+        description: 'New name for the layer'
+    }),
+    layer_order: z.number().int().nonnegative().optional().openapi({
+        description: 'New display order'
+    }),
+    visible: z.boolean().optional().openapi({
+        description: 'Whether the layer is visible'
+    }),
+    opacity: z.number().min(0).max(1).optional().openapi({
+        description: 'New opacity value'
+    }),
+    altitude_meters: z.number().min(-100).max(100).optional().openapi({
+        description: 'New altitude in meters'
+    }),
+    transform: layerTransformSchema.optional().openapi({
+        description: 'New transform data'
+    }),
+    is_active: z.boolean().optional().openapi({
+        description: 'Whether the layer is active'
+    })
+})
+    .refine(data => Object.keys(data).length > 0, {
+    message: 'At least one field must be provided for update'
+})
+    .openapi('UpdateLayerBody');
+export const updateLayerDataSchema = createLayerDataSchema
+    .extend({
+    updated_at: z.string().openapi({
+        description: 'Timestamp when layer was updated'
+    }),
+    updated_by: z.string().nullable().openapi({
+        description: 'ID of the user who updated the layer'
+    })
+})
+    .omit({ layer_id: true })
+    .extend({
+    layer_id: z.number().openapi({
+        description: 'ID of the updated layer'
+    })
+})
+    .openapi('UpdateLayerData');
+export const updateLayerResponseSchema = createMessageDataResponseSchema(updateLayerDataSchema, 'UpdateLayerResponse', 'Layer updated successfully', 'Details of the updated layer');
+// ------------------------------
+// Delete Layer Schemas
+// ------------------------------
+export const deleteLayerParamsSchema = z
+    .object({
+    layerId: z
+        .string()
+        .min(1)
+        .transform(val => parseInt(val, 10))
+        .refine(val => !isNaN(val) && val > 0, {
+        message: 'Layer ID must be a positive number'
+    })
+        .openapi({
+        description: 'The ID of the layer to delete',
+        example: '1'
+    })
+})
+    .openapi('DeleteLayerParams');
+export const deleteLayerDataSchema = z
+    .object({
+    layer_id: z.number().openapi({
+        description: 'ID of the deleted layer',
+        example: 1
+    }),
+    deleted_at: z.string().openapi({
+        description: 'Timestamp when layer was deleted'
+    })
+})
+    .openapi('DeleteLayerData');
+export const deleteLayerResponseSchema = createMessageDataResponseSchema(deleteLayerDataSchema, 'DeleteLayerResponse', 'Layer deleted successfully', 'Details of the deleted layer');
+// ------------------------------
+// Get Layers Response Schemas
+// ------------------------------
+export const getLayersDataSchema = z
+    .object({
+    event_id: z.number().openapi({
+        description: 'ID of the event',
+        example: 1
+    }),
+    layers: z.array(parkingAreaLayerItemSchema).openapi({
+        description: 'List of layers for the event, ordered by layer_order'
+    }),
+    total_count: z.number().openapi({
+        description: 'Total number of layers',
+        example: 3
+    })
+})
+    .openapi('GetLayersData');
+export const getLayersResponseSchema = createSuccessResponseSchema(getLayersDataSchema, 'GetLayersResponse', 'Layers for the event');
+export const getLayerDetailResponseSchema = createSuccessResponseSchema(parkingAreaLayerItemSchema, 'GetLayerDetailResponse', 'Layer details');
+// ------------------------------
+// Bulk Upsert Layers Schemas
+// ------------------------------
+export const bulkUpsertLayersBodySchema = z
+    .object({
+    event_id: z.number().int().positive().openapi({
+        description: 'ID of the event',
+        example: 1
+    }),
+    layers: z
+        .array(z.object({
+        id: z.number().int().positive().optional().openapi({
+            description: 'Layer ID (for updates). Omit for new layers.'
+        }),
+        name: z.string().min(1).max(255).openapi({
+            description: 'Name of the layer'
+        }),
+        layer_order: z.number().int().nonnegative().openapi({
+            description: 'Display order'
+        }),
+        image_url: z.string().url().openapi({
+            description: 'URL to the layer image'
+        }),
+        visible: z.boolean().default(true),
+        opacity: z.number().min(0).max(1).default(1),
+        altitude_meters: z.number().min(-100).max(100).default(0),
+        transform: layerTransformSchema.default({
+            left: 0,
+            top: 0,
+            scaleX: 1,
+            scaleY: 1,
+            angle: 0
+        })
+    }))
+        .min(1, 'At least one layer must be provided')
+        .openapi({
+        description: 'Array of layers to create or update'
+    })
+})
+    .openapi('BulkUpsertLayersBody');
+export const bulkUpsertLayersDataSchema = z
+    .object({
+    event_id: z.number().openapi({
+        description: 'ID of the event',
+        example: 1
+    }),
+    total_upserted: z.number().openapi({
+        description: 'Total number of layers successfully upserted',
+        example: 3
+    }),
+    upserted_layers: z.array(parkingAreaLayerItemSchema).openapi({
+        description: 'Array of successfully upserted layers'
+    })
+})
+    .openapi('BulkUpsertLayersData');
+export const bulkUpsertLayersResponseSchema = createMessageDataResponseSchema(bulkUpsertLayersDataSchema, 'BulkUpsertLayersResponse', 'Layers upserted successfully', 'Details of the upserted layers');

package/dist/parkingBooking.d.ts

@@ -67,9 +67,9 @@ export declare const parkingBookingSchema: z.ZodObject<{
         }>;
         company_roles: z.ZodNullable<z.ZodArray<z.ZodString>>;
         vehicle_types: z.ZodNullable<z.ZodArray<z.ZodEnum<{
-            PL: import("./enums/vehicleType.js").VehicleType.PL;
-            VUL: import("./enums/vehicleType.js").VehicleType.VUL;
-            VL: import("./enums/vehicleType.js").VehicleType.VL;
+            PL: import("./index.js").VehicleType.PL;
+            VUL: import("./index.js").VehicleType.VUL;
+            VL: import("./index.js").VehicleType.VL;
         }>>>;
         created_at: z.ZodString;
         updated_at: z.ZodString;
@@ -91,7 +91,7 @@ export declare const companyDetailsSchema: z.ZodObject<{
     transport_company: z.ZodString;
 }, z.core.$strip>;
 export declare const vehicleDetailsSchema: z.ZodObject<{
-    vehicle_type: z.ZodEnum<typeof import("./enums/vehicleType.js").VehicleType>;
+    vehicle_type: z.ZodEnum<typeof import("./index.js").VehicleType>;
     unloading_method: z.ZodEnum<typeof UnloadingType>;
     license_plate: z.ZodString;
     trailer_registration: z.ZodOptional<z.ZodString>;
@@ -130,9 +130,9 @@ export declare const eventBookingsDataSchema: z.ZodObject<{
             }>;
             company_roles: z.ZodNullable<z.ZodArray<z.ZodString>>;
             vehicle_types: z.ZodNullable<z.ZodArray<z.ZodEnum<{
-                PL: import("./enums/vehicleType.js").VehicleType.PL;
-                VUL: import("./enums/vehicleType.js").VehicleType.VUL;
-                VL: import("./enums/vehicleType.js").VehicleType.VL;
+                PL: import("./index.js").VehicleType.PL;
+                VUL: import("./index.js").VehicleType.VUL;
+                VL: import("./index.js").VehicleType.VL;
             }>>>;
             created_at: z.ZodString;
             updated_at: z.ZodString;
@@ -178,9 +178,9 @@ export declare const eventBookingsResponseSchema: z.ZodObject<{
                 }>;
                 company_roles: z.ZodNullable<z.ZodArray<z.ZodString>>;
                 vehicle_types: z.ZodNullable<z.ZodArray<z.ZodEnum<{
-                    PL: import("./enums/vehicleType.js").VehicleType.PL;
-                    VUL: import("./enums/vehicleType.js").VehicleType.VUL;
-                    VL: import("./enums/vehicleType.js").VehicleType.VL;
+                    PL: import("./index.js").VehicleType.PL;
+                    VUL: import("./index.js").VehicleType.VUL;
+                    VL: import("./index.js").VehicleType.VL;
                 }>>>;
                 created_at: z.ZodString;
                 updated_at: z.ZodString;
@@ -213,7 +213,8 @@ export declare const closeEventResponseSchema: z.ZodObject<{
         reason: z.ZodNullable<z.ZodString>;
     }, z.core.$strip>;
 }, z.core.$strip>;
-export declare const confirmExitBodySchema: z.ZodObject<{
+export declare const confirmAccessBodySchema: z.ZodObject<{
+    event_id: z.ZodNumber;
     plate_number: z.ZodOptional<z.ZodObject<{
         url: z.ZodString;
         name: z.ZodString;
@@ -286,7 +287,7 @@ export declare const bookingDetailsDataSchema: z.ZodObject<{
         transport_company: z.ZodString;
     }, z.core.$strip>;
     vehicle: z.ZodObject<{
-        vehicle_type: z.ZodEnum<typeof import("./enums/vehicleType.js").VehicleType>;
+        vehicle_type: z.ZodEnum<typeof import("./index.js").VehicleType>;
         unloading_method: z.ZodEnum<typeof UnloadingType>;
         license_plate: z.ZodString;
         trailer_registration: z.ZodOptional<z.ZodString>;
@@ -327,7 +328,7 @@ export declare const createParkingBookingBodySchema: z.ZodObject<{
     }, z.core.$strip>;
     company_role: z.ZodString;
     vehicle: z.ZodObject<{
-        vehicle_type: z.ZodEnum<typeof import("./enums/vehicleType.js").VehicleType>;
+        vehicle_type: z.ZodEnum<typeof import("./index.js").VehicleType>;
         unloading_method: z.ZodEnum<typeof UnloadingType>;
         license_plate: z.ZodString;
         trailer_registration: z.ZodOptional<z.ZodString>;
@@ -354,7 +355,7 @@ export declare const createParkingBookingDataSchema: z.ZodObject<{
         transport_company: z.ZodString;
     }, z.core.$strip>;
     vehicle: z.ZodObject<{
-        vehicle_type: z.ZodEnum<typeof import("./enums/vehicleType.js").VehicleType>;
+        vehicle_type: z.ZodEnum<typeof import("./index.js").VehicleType>;
         unloading_method: z.ZodEnum<typeof UnloadingType>;
         license_plate: z.ZodString;
         trailer_registration: z.ZodOptional<z.ZodString>;
@@ -387,7 +388,7 @@ export declare const createParkingBookingResponseSchema: z.ZodObject<{
             transport_company: z.ZodString;
         }, z.core.$strip>;
         vehicle: z.ZodObject<{
-            vehicle_type: z.ZodEnum<typeof import("./enums/vehicleType.js").VehicleType>;
+            vehicle_type: z.ZodEnum<typeof import("./index.js").VehicleType>;
             unloading_method: z.ZodEnum<typeof UnloadingType>;
             license_plate: z.ZodString;
             trailer_registration: z.ZodOptional<z.ZodString>;
@@ -414,7 +415,7 @@ export declare const updateParkingBookingBodySchema: z.ZodObject<{
         transport_company: z.ZodString;
     }, z.core.$strip>>;
     vehicle: z.ZodOptional<z.ZodObject<{
-        vehicle_type: z.ZodEnum<typeof import("./enums/vehicleType.js").VehicleType>;
+        vehicle_type: z.ZodEnum<typeof import("./index.js").VehicleType>;
         unloading_method: z.ZodEnum<typeof UnloadingType>;
         license_plate: z.ZodString;
         trailer_registration: z.ZodOptional<z.ZodString>;
@@ -438,7 +439,7 @@ export declare const updateParkingBookingDataSchema: z.ZodObject<{
         transport_company: z.ZodString;
     }, z.core.$strip>>;
     vehicle: z.ZodNullable<z.ZodObject<{
-        vehicle_type: z.ZodEnum<typeof import("./enums/vehicleType.js").VehicleType>;
+        vehicle_type: z.ZodEnum<typeof import("./index.js").VehicleType>;
         unloading_method: z.ZodEnum<typeof UnloadingType>;
         license_plate: z.ZodString;
         trailer_registration: z.ZodOptional<z.ZodString>;
@@ -466,7 +467,7 @@ export declare const updateParkingBookingResponseSchema: z.ZodObject<{
             transport_company: z.ZodString;
         }, z.core.$strip>>;
         vehicle: z.ZodNullable<z.ZodObject<{
-            vehicle_type: z.ZodEnum<typeof import("./enums/vehicleType.js").VehicleType>;
+            vehicle_type: z.ZodEnum<typeof import("./index.js").VehicleType>;
             unloading_method: z.ZodEnum<typeof UnloadingType>;
             license_plate: z.ZodString;
             trailer_registration: z.ZodOptional<z.ZodString>;
@@ -576,7 +577,7 @@ export declare const parkingBookingDetailsDataSchema: z.ZodObject<{
         transport_company: z.ZodString;
     }, z.core.$strip>;
     vehicle: z.ZodObject<{
-        vehicle_type: z.ZodEnum<typeof import("./enums/vehicleType.js").VehicleType>;
+        vehicle_type: z.ZodEnum<typeof import("./index.js").VehicleType>;
         unloading_method: z.ZodEnum<typeof UnloadingType>;
         license_plate: z.ZodString;
         trailer_registration: z.ZodOptional<z.ZodString>;
@@ -631,7 +632,7 @@ export declare const getParkingBookingDetailsResponseSchema: z.ZodObject<{
             transport_company: z.ZodString;
         }, z.core.$strip>;
         vehicle: z.ZodObject<{
-            vehicle_type: z.ZodEnum<typeof import("./enums/vehicleType.js").VehicleType>;
+            vehicle_type: z.ZodEnum<typeof import("./index.js").VehicleType>;
             unloading_method: z.ZodEnum<typeof UnloadingType>;
             license_plate: z.ZodString;
             trailer_registration: z.ZodOptional<z.ZodString>;
@@ -690,7 +691,7 @@ export declare const getParkingBookingDetailsByTokenResponseSchema: z.ZodObject<
             transport_company: z.ZodString;
         }, z.core.$strip>;
         vehicle: z.ZodObject<{
-            vehicle_type: z.ZodEnum<typeof import("./enums/vehicleType.js").VehicleType>;
+            vehicle_type: z.ZodEnum<typeof import("./index.js").VehicleType>;
             unloading_method: z.ZodEnum<typeof UnloadingType>;
             license_plate: z.ZodString;
             trailer_registration: z.ZodOptional<z.ZodString>;
@@ -743,7 +744,7 @@ export declare const getParkingBookingDetailsByQrResponseSchema: z.ZodObject<{
             transport_company: z.ZodString;
         }, z.core.$strip>;
         vehicle: z.ZodObject<{
-            vehicle_type: z.ZodEnum<typeof import("./enums/vehicleType.js").VehicleType>;
+            vehicle_type: z.ZodEnum<typeof import("./index.js").VehicleType>;
             unloading_method: z.ZodEnum<typeof UnloadingType>;
             license_plate: z.ZodString;
             trailer_registration: z.ZodOptional<z.ZodString>;
@@ -816,6 +817,36 @@ export declare const exportBookingsResponseSchema: z.ZodObject<{
         filters_applied: z.ZodRecord<z.ZodString, z.ZodUnknown>;
     }, z.core.$strip>;
 }, z.core.$strip>;
+export declare const updateBookingTimeParamsSchema: z.ZodObject<{
+    bookingId: z.ZodPipe<z.ZodString, z.ZodTransform<number, string>>;
+}, z.core.$strip>;
+export declare const updateBookingTimeBodySchema: z.ZodObject<{
+    booking_date: z.ZodString;
+    start_time: z.ZodString;
+    parking_area_schedule_id: z.ZodNumber;
+}, z.core.$strip>;
+export declare const updateBookingTimeDataSchema: z.ZodObject<{
+    booking_id: z.ZodNumber;
+    parking_area_schedule_id: z.ZodNumber;
+    booking_date: z.ZodString;
+    start_time: z.ZodString;
+    end_time: z.ZodString;
+    updated_at: z.ZodString;
+    updated_by: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+export declare const updateBookingTimeResponseSchema: z.ZodObject<{
+    success: z.ZodBoolean;
+    message: z.ZodString;
+    data: z.ZodObject<{
+        booking_id: z.ZodNumber;
+        parking_area_schedule_id: z.ZodNumber;
+        booking_date: z.ZodString;
+        start_time: z.ZodString;
+        end_time: z.ZodString;
+        updated_at: z.ZodString;
+        updated_by: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
 export type Geometry = z.infer<typeof geometrySchema>;
 export type ParkingBooking = z.infer<typeof parkingBookingSchema>;
 export type CompanyDetails = z.infer<typeof companyDetailsSchema>;
@@ -833,7 +864,7 @@ export type CloseEventBody = z.infer<typeof closeEventBodySchema>;
 export type CloseEventData = z.infer<typeof closeEventDataSchema>;
 export type CloseEventResponse = z.infer<typeof closeEventResponseSchema>;
 export type EventBookingsResponse = z.infer<typeof eventBookingsResponseSchema>;
-export type ConfirmExitData = z.infer<typeof confirmExitBodySchema>;
+export type ConfirmVehicleAccessData = z.infer<typeof confirmAccessBodySchema>;
 export type ConfirmBookingParams = z.infer<typeof confirmBookingParamsSchema>;
 export type ConfirmBookingResponse = z.infer<typeof confirmBookingResponseSchema>;
 export type CreateBookingBody = z.infer<typeof createParkingBookingBodySchema>;
@@ -857,3 +888,7 @@ export type ExportBookingData = z.infer<typeof exportBookingDataSchema>;
 export type ExportBookingsQuery = z.infer<typeof exportBookingsQuerySchema>;
 export type ExportBookingsData = z.infer<typeof exportBookingsDataSchema>;
 export type ExportBookingsResponse = z.infer<typeof exportBookingsResponseSchema>;
+export type UpdateBookingTimeParams = z.infer<typeof updateBookingTimeParamsSchema>;
+export type UpdateBookingTimeBody = z.infer<typeof updateBookingTimeBodySchema>;
+export type UpdateBookingTimeData = z.infer<typeof updateBookingTimeDataSchema>;
+export type UpdateBookingTimeResponse = z.infer<typeof updateBookingTimeResponseSchema>;

package/dist/parkingBooking.js

@@ -212,7 +212,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({
@@ -830,3 +834,72 @@ export const exportBookingsDataSchema = z
 })
     .openapi('ExportBookingsData');
 export const exportBookingsResponseSchema = createSuccessResponseSchema(exportBookingsDataSchema, 'ExportBookingsResponse', 'Exported parking bookings data');
+export const updateBookingTimeParamsSchema = 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('UpdateBookingTimeParams');
+export const updateBookingTimeBodySchema = z
+    .object({
+    booking_date: z
+        .string()
+        .regex(/^\d{4}-\d{2}-\d{2}$/, 'Date must be in YYYY-MM-DD format')
+        .openapi({
+        description: 'New booking date (YYYY-MM-DD)',
+        example: '2025-12-25'
+    }),
+    start_time: z
+        .string()
+        .regex(/^\d{2}:\d{2}$/, 'Time must be in HH:MM format')
+        .openapi({
+        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
+    })
+})
+    .openapi('UpdateBookingTimeBody');
+export const updateBookingTimeDataSchema = z
+    .object({
+    booking_id: z.number().openapi({
+        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'
+    }),
+    start_time: z.string().openapi({
+        description: 'New start time',
+        example: '10:00'
+    }),
+    end_time: z.string().openapi({
+        description: 'Calculated end time based on schedule duration',
+        example: '13:00'
+    }),
+    updated_at: z.string().openapi({
+        description: 'Timestamp when booking was updated',
+        example: '2025-12-24T10:30:00Z'
+    }),
+    updated_by: z.string().nullable().openapi({
+        description: 'ID of the user who updated the booking',
+        example: 'user-123'
+    })
+})
+    .openapi('UpdateBookingTimeData');
+export const updateBookingTimeResponseSchema = createMessageDataResponseSchema(updateBookingTimeDataSchema, 'UpdateBookingTimeResponse', 'Booking time updated successfully', 'Details of the updated booking time');