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

package/dist/enums/index.d.ts

@@ -1,4 +1,3 @@
 export * from './bookingStatus.js';
-export * from './phaseSlotScheduleType.js';
 export * from './parkingAreaScheduleType.js';
 export * from './vehicleType.js';

package/dist/enums/index.js

@@ -1,5 +1,4 @@
 // Enum exports
 export * from './bookingStatus.js';
-export * from './phaseSlotScheduleType.js';
 export * from './parkingAreaScheduleType.js';
 export * from './vehicleType.js';

package/dist/index.d.ts

@@ -1,12 +1,10 @@
 export * from './common.js';
 export * from './pagination.js';
 export * from './auth.js';
-export * from './phaseBooking.js';
-export * from './phaseSlot.js';
+export * from './parkingBooking.js';
 export * from './parkingArea.js';
 export * from './event.js';
 export * from './accessToken.js';
 export * from './enums/bookingStatus.js';
-export * from './enums/phaseSlotScheduleType.js';
 export * from './enums/parkingAreaScheduleType.js';
 export { z } from './zod.js';

package/dist/index.js

@@ -2,14 +2,12 @@
 export * from './common.js';
 export * from './pagination.js';
 export * from './auth.js';
-export * from './phaseBooking.js';
-export * from './phaseSlot.js';
+export * from './parkingBooking.js';
 export * from './parkingArea.js';
 export * from './event.js';
 export * from './accessToken.js';
 // Enum exports
 export * from './enums/bookingStatus.js';
-export * from './enums/phaseSlotScheduleType.js';
 export * from './enums/parkingAreaScheduleType.js';
 // Zod re-export for convenience
 export { z } from './zod.js';

package/dist/parkingArea.d.ts

@@ -550,6 +550,7 @@ export declare const getAvailableParkingAreaSlotsQuerySchema: z.ZodObject<{
     year: z.ZodPipe<z.ZodString, z.ZodTransform<number, string>>;
     month: z.ZodPipe<z.ZodString, z.ZodTransform<number, string>>;
     parking_area_id: z.ZodPipe<z.ZodString, z.ZodTransform<number, string>>;
+    company_role: z.ZodString;
     schedule_type: z.ZodOptional<z.ZodEnum<{
         assembly: "assembly";
         dismantling: "dismantling";
@@ -609,6 +610,69 @@ export declare const availableParkingAreaSlotsResponseSchema: z.ZodObject<{
     }, z.core.$strip>>;
     total_slots: z.ZodNumber;
 }, z.core.$strip>;
+export declare const getAvailableSlotsBodySchema: z.ZodObject<{
+    event_id: z.ZodNumber;
+    year: z.ZodNumber;
+    month: z.ZodNumber;
+    company_role: z.ZodString;
+    schedule_type: z.ZodOptional<z.ZodEnum<{
+        assembly: "assembly";
+        dismantling: "dismantling";
+    }>>;
+}, z.core.$strip>;
+export declare const availableTimeSlotSchema: z.ZodObject<{
+    parking_area_schedule_id: z.ZodNumber;
+    date: z.ZodString;
+    start_time: z.ZodString;
+    end_time: z.ZodString;
+    duration: z.ZodNumber;
+    schedule_type: z.ZodEnum<{
+        assembly: "assembly";
+        dismantling: "dismantling";
+    }>;
+    max_capacity: z.ZodNumber;
+    current_bookings: z.ZodNumber;
+    confirmed_bookings: z.ZodNumber;
+    available_capacity: z.ZodNumber;
+    is_available: z.ZodBoolean;
+}, z.core.$strip>;
+export declare const availableSlotsResponseSchema: z.ZodObject<{
+    event_id: z.ZodNumber;
+    event_code: z.ZodString;
+    event_name: z.ZodString;
+    company_role: z.ZodString;
+    year: z.ZodNumber;
+    month: z.ZodNumber;
+    available_slots: z.ZodArray<z.ZodObject<{
+        parking_area_schedule_id: z.ZodNumber;
+        date: z.ZodString;
+        start_time: z.ZodString;
+        end_time: z.ZodString;
+        duration: z.ZodNumber;
+        schedule_type: z.ZodEnum<{
+            assembly: "assembly";
+            dismantling: "dismantling";
+        }>;
+        max_capacity: z.ZodNumber;
+        current_bookings: z.ZodNumber;
+        confirmed_bookings: z.ZodNumber;
+        available_capacity: z.ZodNumber;
+        is_available: z.ZodBoolean;
+    }, z.core.$strip>>;
+    total_slots: z.ZodNumber;
+}, z.core.$strip>;
+export declare const getCompanyRolesByEventIdParamsSchema: z.ZodObject<{
+    eventId: z.ZodPipe<z.ZodString, z.ZodTransform<number, string>>;
+    scheduleType: z.ZodEnum<{
+        assembly: "assembly";
+        dismantling: "dismantling";
+    }>;
+}, z.core.$strip>;
+export declare const getCompanyRolesByEventIdResponseSchema: z.ZodObject<{
+    event_id: z.ZodNumber;
+    company_roles: z.ZodArray<z.ZodString>;
+    total_count: z.ZodNumber;
+}, z.core.$strip>;
 export type Point = z.infer<typeof pointSchema>;
 export type PolygonCoordinates = z.infer<typeof polygonCoordinatesSchema>;
 export type RectangleGeometry = z.infer<typeof rectangleGeometrySchema>;
@@ -645,3 +709,8 @@ export type UploadSitePlanImageResponse = z.infer<typeof uploadSitePlanImageResp
 export type GetAvailableParkingAreaSlotsQuery = z.infer<typeof getAvailableParkingAreaSlotsQuerySchema>;
 export type AvailableParkingAreaTimeSlot = z.infer<typeof availableParkingAreaTimeSlotSchema>;
 export type AvailableParkingAreaSlotsResponse = z.infer<typeof availableParkingAreaSlotsResponseSchema>;
+export type GetAvailableSlotsBody = z.infer<typeof getAvailableSlotsBodySchema>;
+export type AvailableTimeSlot = z.infer<typeof availableTimeSlotSchema>;
+export type AvailableSlotsResponse = z.infer<typeof availableSlotsResponseSchema>;
+export type GetCompanyRolesByEventIdParams = z.infer<typeof getCompanyRolesByEventIdParamsSchema>;
+export type GetCompanyRolesByEventIdResponse = z.infer<typeof getCompanyRolesByEventIdResponseSchema>;

package/dist/parkingArea.js

@@ -723,6 +723,10 @@ export const getAvailableParkingAreaSlotsQuerySchema = z
         description: 'The ID of the parking area',
         example: '1'
     }),
+    company_role: z.string().min(1, 'Company role is required').openapi({
+        description: 'Company role to filter schedules by',
+        example: 'exhibitor'
+    }),
     schedule_type: z.enum(['assembly', 'dismantling']).optional().openapi({
         description: 'Filter by schedule type',
         example: 'assembly'
@@ -830,3 +834,152 @@ export const availableParkingAreaSlotsResponseSchema = z
     })
 })
     .openapi('AvailableParkingAreaSlotsResponse');
+// ------------------------------
+// Parking Area Query Schemas
+// ------------------------------
+export const getAvailableSlotsBodySchema = z
+    .object({
+    event_id: z.number().positive().openapi({
+        description: 'The ID of the event',
+        example: 1
+    }),
+    year: z.number().min(2024).openapi({
+        description: 'Year for filtering slots (YYYY). Slots before today will be excluded.',
+        example: 2026
+    }),
+    month: z.number().min(1).max(12).openapi({
+        description: 'Month for filtering slots (1-12). Slots before today will be excluded.',
+        example: 6
+    }),
+    company_role: z.string().min(1, 'Company role is required').openapi({
+        description: 'Company role to filter schedules by',
+        example: 'exhibitor'
+    }),
+    schedule_type: z.enum(['assembly', 'dismantling']).optional().openapi({
+        description: 'Filter by schedule type',
+        example: 'assembly'
+    })
+})
+    .openapi('GetAvailableSlotsBody');
+// ------------------------------
+// Parking Area Response Schemas
+// ------------------------------
+export const availableTimeSlotSchema = z
+    .object({
+    parking_area_schedule_id: z.number().openapi({
+        description: 'Parking area schedule ID',
+        example: 1
+    }),
+    date: z.string().openapi({
+        description: 'Date of the time slot (YYYY-MM-DD)',
+        example: '2026-06-15'
+    }),
+    start_time: z.string().openapi({
+        description: 'Start time of the slot (HH:MM)',
+        example: '08:00'
+    }),
+    end_time: z.string().openapi({
+        description: 'End time of the slot (HH:MM)',
+        example: '08:30'
+    }),
+    duration: z.number().openapi({
+        description: 'Duration in minutes',
+        example: 30
+    }),
+    schedule_type: z.enum(['assembly', 'dismantling']).openapi({
+        description: 'Type of schedule',
+        example: 'assembly'
+    }),
+    max_capacity: z.number().openapi({
+        description: 'Maximum booking capacity for this slot',
+        example: 5
+    }),
+    current_bookings: z.number().openapi({
+        description: 'Number of current bookings',
+        example: 3
+    }),
+    confirmed_bookings: z.number().openapi({
+        description: 'Number of confirmed bookings',
+        example: 1
+    }),
+    available_capacity: z.number().openapi({
+        description: 'Remaining available capacity',
+        example: 2
+    }),
+    is_available: z.boolean().openapi({
+        description: 'Whether the slot is available for booking',
+        example: true
+    })
+})
+    .openapi('AvailableTimeSlot');
+export const availableSlotsResponseSchema = z
+    .object({
+    event_id: z.number().openapi({
+        description: 'ID of the event',
+        example: 1
+    }),
+    event_code: z.string().openapi({
+        description: 'Code of the event',
+        example: 'COEC2025'
+    }),
+    event_name: z.string().openapi({
+        description: 'Name of the event',
+        example: 'COEC 2025'
+    }),
+    company_role: z.string().openapi({
+        description: 'Company role that was used for filtering (returned for reference)',
+        example: 'exhibitor'
+    }),
+    year: z.number().openapi({
+        description: 'Year of the slots',
+        example: 2026
+    }),
+    month: z.number().openapi({
+        description: 'Month of the slots',
+        example: 6
+    }),
+    available_slots: z.array(availableTimeSlotSchema).openapi({
+        description: 'List of available time slots with capacity information'
+    }),
+    total_slots: z.number().openapi({
+        description: 'Total number of time slots in the period',
+        example: 48
+    })
+})
+    .openapi('AvailableSlotsResponse');
+// ------------------------------
+// Company Roles for Parking Area
+// ------------------------------
+export const getCompanyRolesByEventIdParamsSchema = 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 get company roles for',
+        example: '1'
+    }),
+    scheduleType: z.enum(['assembly', 'dismantling']).openapi({
+        description: 'Type of schedule',
+        example: 'assembly'
+    })
+})
+    .openapi('GetCompanyRolesByEventIdParams');
+export const getCompanyRolesByEventIdResponseSchema = z
+    .object({
+    event_id: z.number().openapi({
+        description: 'ID of the event',
+        example: 1
+    }),
+    company_roles: z.array(z.string()).openapi({
+        description: 'List of unique company roles for the event',
+        example: ['exhibitor', 'organizer', 'contractor']
+    }),
+    total_count: z.number().openapi({
+        description: 'Total number of unique company roles',
+        example: 3
+    })
+})
+    .openapi('GetCompanyRolesByEventIdResponse');