@venulog/phasing-engine-schemas 0.3.0 → 0.3.1

package/dist/phaseBooking.js

@@ -1,9 +1,10 @@
 // packages/phasing-schemas/src/phaseBooking.ts
 import { paginationSchema } from './pagination.js';
 import { BookingStatus } from './enums/bookingStatus.js';
-import { createSuccessResponseSchema, createMessageDataResponseSchema } from './common.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({
@@ -444,6 +445,50 @@ export const refuseBookingDataSchema = z
 })
     .openapi('RefuseBookingData');
 export const refuseBookingResponseSchema = createMessageDataResponseSchema(refuseBookingDataSchema, 'RefuseBookingResponse', 'Phase booking refused successfully', 'Details of the refused booking');
+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');
 // ------------------------------
 // Create Phase Slots schemas
 // ------------------------------
@@ -905,3 +950,400 @@ export const checkSlotAvailabilityDataSchema = z
 })
     .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...'
+    }),
+    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');
+// ------------------------------
+// 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');

package/dist/phaseSlot.d.ts

@@ -135,3 +135,5 @@ export type PhaseSlotItem = z.infer<typeof phaseSlotItemSchema>;
 export type GetPhaseSlotsResponse = z.infer<typeof getPhaseSlotsResponseSchema>;
 export type GetCompanyRolesByEventIdParams = z.infer<typeof getCompanyRolesByEventIdParamsSchema>;
 export type GetCompanyRolesByEventIdResponse = z.infer<typeof getCompanyRolesByEventIdResponseSchema>;
+export { pointSchema, polygonCoordinatesSchema, rectangleGeometrySchema, geoJsonPolygonSchema, parkingAreaItemSchema, parkingAreaWithSchedulesSchema, getParkingAreasByEventIdParamsSchema, getParkingAreaByIdParamsSchema, createParkingAreaBodySchema, createParkingAreaDataSchema, createParkingAreaResponseSchema, bulkCreateParkingAreasBodySchema, bulkCreateParkingAreasDataSchema, bulkCreateParkingAreasResponseSchema, updateParkingAreaParamsSchema, updateParkingAreaBodySchema, updateParkingAreaDataSchema, updateParkingAreaResponseSchema, deleteParkingAreaParamsSchema, deleteParkingAreaDataSchema, deleteParkingAreaResponseSchema, getParkingAreasDataSchema, getParkingAreasResponseSchema, getParkingAreaDetailResponseSchema, parkingAreaScheduleSchema, upsertParkingAreaScheduleItemSchema, deleteParkingAreaScheduleItemSchema, upsertParkingAreaSchedulesBodySchema, upsertParkingAreaSchedulesDataSchema, upsertParkingAreaSchedulesResponseSchema, uploadSitePlanImageParamsSchema, uploadSitePlanImageDataSchema, uploadSitePlanImageResponseSchema, getAvailableParkingAreaSlotsQuerySchema, availableParkingAreaTimeSlotSchema, availableParkingAreaSlotsResponseSchema } from './parkingArea.js';
+export type { Point, PolygonCoordinates, RectangleGeometry, GeoJsonPolygon, ParkingAreaItem, ParkingAreaWithSchedules, GetParkingAreasByEventIdParams, GetParkingAreaByIdParams, CreateParkingAreaBody, CreateParkingAreaData, CreateParkingAreaResponse, BulkCreateParkingAreasBody, BulkCreateParkingAreasData, BulkCreateParkingAreasResponse, UpdateParkingAreaParams, UpdateParkingAreaBody, UpdateParkingAreaData, UpdateParkingAreaResponse, DeleteParkingAreaParams, DeleteParkingAreaData, DeleteParkingAreaResponse, GetParkingAreasData, GetParkingAreasResponse, GetParkingAreaDetailResponse, ParkingAreaSchedule, UpsertParkingAreaScheduleItem, DeleteParkingAreaScheduleItem, UpsertParkingAreaSchedulesBody, UpsertParkingAreaSchedulesData, UpsertParkingAreaSchedulesResponse, UploadSitePlanImageParams, UploadSitePlanImageData, UploadSitePlanImageResponse, GetAvailableParkingAreaSlotsQuery, AvailableParkingAreaTimeSlot, AvailableParkingAreaSlotsResponse } from './parkingArea.js';

package/dist/phaseSlot.js

@@ -259,3 +259,18 @@ export const getCompanyRolesByEventIdResponseSchema = z
     })
 })
     .openapi('GetCompanyRolesByEventIdResponse');
+// ======================================================================
+// RE-EXPORTS FROM parkingArea.ts
+// These provide convenient access to parking area schemas from this module
+// ======================================================================
+export { 
+// Geometry schemas
+pointSchema, polygonCoordinatesSchema, rectangleGeometrySchema, geoJsonPolygonSchema, 
+// Parking area schemas
+parkingAreaItemSchema, parkingAreaWithSchedulesSchema, getParkingAreasByEventIdParamsSchema, getParkingAreaByIdParamsSchema, createParkingAreaBodySchema, createParkingAreaDataSchema, createParkingAreaResponseSchema, bulkCreateParkingAreasBodySchema, bulkCreateParkingAreasDataSchema, bulkCreateParkingAreasResponseSchema, updateParkingAreaParamsSchema, updateParkingAreaBodySchema, updateParkingAreaDataSchema, updateParkingAreaResponseSchema, deleteParkingAreaParamsSchema, deleteParkingAreaDataSchema, deleteParkingAreaResponseSchema, getParkingAreasDataSchema, getParkingAreasResponseSchema, getParkingAreaDetailResponseSchema, 
+// Parking area schedule schemas
+parkingAreaScheduleSchema, upsertParkingAreaScheduleItemSchema, deleteParkingAreaScheduleItemSchema, upsertParkingAreaSchedulesBodySchema, upsertParkingAreaSchedulesDataSchema, upsertParkingAreaSchedulesResponseSchema, 
+// Site plan image upload
+uploadSitePlanImageParamsSchema, uploadSitePlanImageDataSchema, uploadSitePlanImageResponseSchema, 
+// Available slots (parking area version)
+getAvailableParkingAreaSlotsQuerySchema, availableParkingAreaTimeSlotSchema, availableParkingAreaSlotsResponseSchema } from './parkingArea.js';

package/package.json

@@ -1,67 +1,75 @@
-{
-  "name": "@venulog/phasing-engine-schemas",
-  "version": "0.3.0",
-  "description": "Shared schemas and types for Phasing Engine API",
-  "type": "module",
-  "main": "./dist/index.js",
-  "types": "./dist/index.d.ts",
-  "exports": {
-    ".": {
-      "types": "./dist/index.d.ts",
-      "import": "./dist/index.js"
-    },
-    "./auth": {
-      "types": "./dist/auth.d.ts",
-      "import": "./dist/auth.js"
-    },
-    "./common": {
-      "types": "./dist/common.d.ts",
-      "import": "./dist/common.js"
-    },
-    "./pagination": {
-      "types": "./dist/pagination.d.ts",
-      "import": "./dist/pagination.js"
-    },
-    "./phaseBooking": {
-      "types": "./dist/phaseBooking.d.ts",
-      "import": "./dist/phaseBooking.js"
-    },
-    "./phaseSlot": {
-      "types": "./dist/phaseSlot.d.ts",
-      "import": "./dist/phaseSlot.js"
-    },
-    "./event": {
-      "types": "./dist/event.d.ts",
-      "import": "./dist/event.js"
-    }
-  },
-  "files": [
-    "dist"
-  ],
-  "scripts": {
-    "build": "npm run clean && tsc",
-    "dev": "tsc --watch",
-    "clean": "rm -rf dist",
-    "prepublishOnly": "npm run build"
-  },
-  "keywords": [
-    "schemas",
-    "validation",
-    "types",
-    "zod",
-    "phasing-engine"
-  ],
-  "license": "MIT",
-  "dependencies": {
-    "@asteasolutions/zod-to-openapi": "^8.1.0",
-    "zod": "^4.1.13"
-  },
-  "devDependencies": {
-    "typescript": "^5.6.3"
-  },
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/manaty/phasing_engine.git",
-    "directory": "packages/phasing-schemas"
-  }
-}
+{
+  "name": "@venulog/phasing-engine-schemas",
+  "version": "0.3.1",
+  "description": "Shared schemas and types for Phasing Engine API",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./auth": {
+      "types": "./dist/auth.d.ts",
+      "import": "./dist/auth.js"
+    },
+    "./common": {
+      "types": "./dist/common.d.ts",
+      "import": "./dist/common.js"
+    },
+    "./pagination": {
+      "types": "./dist/pagination.d.ts",
+      "import": "./dist/pagination.js"
+    },
+    "./phaseBooking": {
+      "types": "./dist/phaseBooking.d.ts",
+      "import": "./dist/phaseBooking.js"
+    },
+    "./phaseSlot": {
+      "types": "./dist/phaseSlot.d.ts",
+      "import": "./dist/phaseSlot.js"
+    },
+    "./event": {
+      "types": "./dist/event.d.ts",
+      "import": "./dist/event.js"
+    },
+    "./parkingArea": {
+      "types": "./dist/parkingArea.d.ts",
+      "import": "./dist/parkingArea.js"
+    },
+    "./enums": {
+      "types": "./dist/enums/index.d.ts",
+      "import": "./dist/enums/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "npm run clean && tsc",
+    "dev": "tsc --watch",
+    "clean": "rm -rf dist",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "schemas",
+    "validation",
+    "types",
+    "zod",
+    "phasing-engine"
+  ],
+  "license": "MIT",
+  "dependencies": {
+    "@asteasolutions/zod-to-openapi": "^8.1.0",
+    "zod": "^4.1.13"
+  },
+  "devDependencies": {
+    "typescript": "^5.6.3"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/manaty/phasing_engine.git",
+    "directory": "packages/phasing-schemas"
+  }
+}