@venulog/phasing-engine-schemas 0.2.0-alpha.0 → 0.2.0-alpha.2

package/dist/phaseSlot.d.ts

@@ -1,82 +1,85 @@
 import { z } from './zod.js';
-import { SlotStatus } from './enums/slotStatus.js';
 export declare const getAvailableSlotsQuerySchema: z.ZodObject<{
+    event_id: z.ZodPipe<z.ZodString, z.ZodTransform<number, string>>;
+    year: z.ZodPipe<z.ZodString, z.ZodTransform<number, string>>;
+    month: z.ZodPipe<z.ZodString, z.ZodTransform<number, string>>;
+    phase_slot_id: z.ZodPipe<z.ZodString, z.ZodTransform<number, string>>;
+    schedule_type: z.ZodOptional<z.ZodEnum<{
+        assembly: "assembly";
+        dismantling: "dismantling";
+    }>>;
+}, z.core.$strip>;
+export declare const availableTimeSlotSchema: z.ZodObject<{
+    phase_slot_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;
-    provider_id: z.ZodPipe<z.ZodOptional<z.ZodString>, z.ZodTransform<number | undefined, string | undefined>>;
-    vehicle_type_id: z.ZodPipe<z.ZodOptional<z.ZodString>, z.ZodTransform<number | undefined, string | undefined>>;
-    min_priority: z.ZodPipe<z.ZodOptional<z.ZodString>, z.ZodTransform<number | undefined, string | undefined>>;
-    page: z.ZodOptional<z.ZodDefault<z.ZodCoercedNumber<unknown>>>;
-    limit: z.ZodOptional<z.ZodDefault<z.ZodCoercedNumber<unknown>>>;
-    sort: z.ZodOptional<z.ZodArray<z.ZodObject<{
-        column: z.ZodString;
-        direction: z.ZodEnum<{
-            asc: "asc";
-            desc: "desc";
+    event_name: z.ZodString;
+    company_role: z.ZodNullable<z.ZodString>;
+    year: z.ZodNumber;
+    month: z.ZodNumber;
+    available_slots: z.ZodArray<z.ZodObject<{
+        phase_slot_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";
         }>;
-    }, z.core.$strip>>>;
+        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 extendedVehicleTypeSchema: z.ZodObject<{
-    id: z.ZodNumber;
-    name: z.ZodString;
-    code: z.ZodString;
-    height: z.ZodString;
-    surface_area_side: z.ZodNumber;
-    surface_aread_back: z.ZodNumber;
-    loading_duration: z.ZodNumber;
+export declare const getPhaseSlotsByEventIdParamsSchema: z.ZodObject<{
+    eventId: z.ZodPipe<z.ZodString, z.ZodTransform<number, string>>;
 }, z.core.$strip>;
-export declare const availablePhaseSlotSchema: z.ZodObject<{
+export declare const phaseSlotItemSchema: z.ZodObject<{
     id: z.ZodNumber;
     event_id: z.ZodNumber;
-    slot_number: z.ZodNumber;
-    vehicle_type_id: z.ZodNullable<z.ZodNumber>;
     company_role: z.ZodNullable<z.ZodString>;
-    status: z.ZodEnum<typeof SlotStatus>;
     is_active: z.ZodBoolean;
     created_at: z.ZodString;
     updated_at: z.ZodString;
-    vehicle_type: z.ZodOptional<z.ZodNullable<z.ZodObject<{
-        id: z.ZodNumber;
-        name: z.ZodString;
-        code: z.ZodString;
-        height: z.ZodString;
-        surface_area_side: z.ZodNumber;
-        surface_aread_back: z.ZodNumber;
-        loading_duration: z.ZodNumber;
-    }, z.core.$strip>>>;
+    created_by: z.ZodNullable<z.ZodString>;
+    updated_by: z.ZodNullable<z.ZodString>;
 }, z.core.$strip>;
-export declare const availableSlotsResponseSchema: z.ZodObject<{
+export declare const getPhaseSlotsResponseSchema: z.ZodObject<{
     event_id: z.ZodNumber;
-    event_name: z.ZodString;
-    phase_status: z.ZodString;
-    available_slots: z.ZodArray<z.ZodObject<{
+    slots: z.ZodArray<z.ZodObject<{
         id: z.ZodNumber;
         event_id: z.ZodNumber;
-        slot_number: z.ZodNumber;
-        vehicle_type_id: z.ZodNullable<z.ZodNumber>;
         company_role: z.ZodNullable<z.ZodString>;
-        status: z.ZodEnum<typeof SlotStatus>;
         is_active: z.ZodBoolean;
         created_at: z.ZodString;
         updated_at: z.ZodString;
-        vehicle_type: z.ZodOptional<z.ZodNullable<z.ZodObject<{
-            id: z.ZodNumber;
-            name: z.ZodString;
-            code: z.ZodString;
-            height: z.ZodString;
-            surface_area_side: z.ZodNumber;
-            surface_aread_back: z.ZodNumber;
-            loading_duration: z.ZodNumber;
-        }, z.core.$strip>>>;
+        created_by: z.ZodNullable<z.ZodString>;
+        updated_by: z.ZodNullable<z.ZodString>;
     }, z.core.$strip>>;
     total_count: z.ZodNumber;
 }, z.core.$strip>;
-export declare const availableSlotsFiltersSchema: z.ZodObject<{
-    provider_id: z.ZodOptional<z.ZodNumber>;
-    vehicle_type_id: z.ZodOptional<z.ZodNumber>;
-    min_priority: z.ZodOptional<z.ZodNumber>;
-}, z.core.$strip>;
 export type GetAvailableSlotsQuery = z.infer<typeof getAvailableSlotsQuerySchema>;
-export type AvailablePhaseSlot = z.infer<typeof availablePhaseSlotSchema>;
+export type AvailableTimeSlot = z.infer<typeof availableTimeSlotSchema>;
 export type AvailableSlotsResponse = z.infer<typeof availableSlotsResponseSchema>;
-export type GetAvailableSlotsFilters = z.infer<typeof availableSlotsFiltersSchema>;
-export type ExtendedVehicleType = z.infer<typeof extendedVehicleTypeSchema>;
+export type GetPhaseSlotsByEventIdParams = z.infer<typeof getPhaseSlotsByEventIdParamsSchema>;
+export type PhaseSlotItem = z.infer<typeof phaseSlotItemSchema>;
+export type GetPhaseSlotsResponse = z.infer<typeof getPhaseSlotsResponseSchema>;

package/dist/phaseSlot.js

@@ -1,74 +1,206 @@
 // packages/phasing-schemas/src/phaseSlot.ts
 import { z } from './zod.js';
-import { paginationSchema } from './pagination.js';
-import { vehicleTypeSchema } from './phaseBooking.js';
-import { SlotStatus } from './enums/slotStatus.js';
 // ------------------------------
 // Query parameters schema
 // ------------------------------
 export const getAvailableSlotsQuerySchema = z
     .object({
-    event_code: z.string().min(1, 'Event code is required'),
-    provider_id: z
+    event_id: z
         .string()
-        .optional()
-        .transform(val => (val ? parseInt(val, 10) : undefined))
-        .refine(val => val === undefined || (!isNaN(val) && val > 0), {
-        message: 'Provider ID must be a positive number'
+        .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'
+    }),
+    year: z
+        .string()
+        .regex(/^\d{4}$/, 'Year must be in YYYY format')
+        .transform(val => parseInt(val, 10))
+        .openapi({
+        description: 'Year for filtering slots (YYYY). Slots before today will be excluded.',
+        example: '2026'
     }),
-    vehicle_type_id: z
+    month: z
         .string()
-        .optional()
-        .transform(val => (val ? parseInt(val, 10) : undefined))
-        .refine(val => val === undefined || (!isNaN(val) && val > 0), {
-        message: 'Vehicle type ID must be a positive number'
+        .regex(/^(0?[1-9]|1[0-2])$/, 'Month must be between 1 and 12')
+        .transform(val => parseInt(val, 10))
+        .openapi({
+        description: 'Month for filtering slots (1-12). Slots before today will be excluded.',
+        example: '6'
     }),
-    min_priority: z
+    phase_slot_id: z
         .string()
-        .optional()
-        .transform(val => (val ? parseInt(val, 10) : undefined))
-        .refine(val => val === undefined || !isNaN(val), {
-        message: 'Min priority must be a number'
+        .min(1)
+        .transform(val => parseInt(val, 10))
+        .refine(val => !isNaN(val) && val > 0, {
+        message: 'Phase slot ID must be a positive number'
+    })
+        .openapi({
+        description: 'The ID of the phase slot',
+        example: '1'
+    }),
+    schedule_type: z.enum(['assembly', 'dismantling']).optional().openapi({
+        description: 'Filter by schedule type',
+        example: 'assembly'
     })
 })
-    .extend(paginationSchema.shape);
-// ------------------------------
-// Extended vehicle type schema for available slots
-// ------------------------------
-export const extendedVehicleTypeSchema = vehicleTypeSchema.extend({
-    code: z.string(),
-    height: z.string(),
-    surface_area_side: z.number(),
-    surface_aread_back: z.number(),
-    loading_duration: z.number()
-});
+    .openapi('GetAvailableSlotsQuery');
 // ------------------------------
 // Response schemas
 // ------------------------------
-export const availablePhaseSlotSchema = z.object({
-    id: z.number(),
-    event_id: z.number(),
-    slot_number: z.number(),
-    vehicle_type_id: z.number().nullable(),
-    company_role: z.string().nullable(),
-    status: z.enum(SlotStatus),
-    is_active: z.boolean(),
-    created_at: z.string(),
-    updated_at: z.string(),
-    vehicle_type: extendedVehicleTypeSchema.nullable().optional()
-});
-export const availableSlotsResponseSchema = z.object({
-    event_id: z.number(),
-    event_name: z.string(),
-    phase_status: z.string(),
-    available_slots: z.array(availablePhaseSlotSchema),
-    total_count: z.number()
-});
+export const availableTimeSlotSchema = z
+    .object({
+    phase_slot_schedule_id: z.number().openapi({
+        description: 'Phase slot 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().nullable().openapi({
+        description: 'Company role for the phase slots',
+        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');
 // ------------------------------
-// Filters type
+// Get Phase Slots by Event ID
 // ------------------------------
-export const availableSlotsFiltersSchema = z.object({
-    provider_id: z.number().optional(),
-    vehicle_type_id: z.number().optional(),
-    min_priority: z.number().optional()
-});
+export const getPhaseSlotsByEventIdParamsSchema = 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('GetPhaseSlotsByEventIdParams');
+export const phaseSlotItemSchema = z
+    .object({
+    id: z.number().openapi({
+        description: 'Phase slot ID',
+        example: 1
+    }),
+    event_id: z.number().openapi({
+        description: 'Event ID',
+        example: 1
+    }),
+    company_role: z.string().nullable().openapi({
+        description: 'Company role for this slot',
+        example: 'exhibitor'
+    }),
+    is_active: z.boolean().openapi({
+        description: 'Whether the slot is active',
+        example: true
+    }),
+    created_at: z.string().openapi({
+        description: 'Creation timestamp',
+        example: '2025-12-16T10:30:00Z'
+    }),
+    updated_at: z.string().openapi({
+        description: 'Last update timestamp',
+        example: '2025-12-16T10:30:00Z'
+    }),
+    created_by: z.string().nullable().openapi({
+        description: 'User ID who created the slot',
+        example: 'user-uuid-123'
+    }),
+    updated_by: z.string().nullable().openapi({
+        description: 'User ID who last updated the slot',
+        example: 'user-uuid-123'
+    })
+})
+    .openapi('PhaseSlotItem');
+export const getPhaseSlotsResponseSchema = z
+    .object({
+    event_id: z.number().openapi({
+        description: 'ID of the event',
+        example: 1
+    }),
+    slots: z.array(phaseSlotItemSchema).openapi({
+        description: 'List of phase slots for the event'
+    }),
+    total_count: z.number().openapi({
+        description: 'Total number of phase slots',
+        example: 10
+    })
+})
+    .openapi('GetPhaseSlotsResponse');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@venulog/phasing-engine-schemas",
-  "version": "0.2.0-alpha.0",
+  "version": "0.2.0-alpha.2",
   "description": "Shared schemas and types for Phasing Engine API",
   "type": "module",
   "main": "./dist/index.js",
@@ -29,6 +29,10 @@
     "./phaseSlot": {
       "types": "./dist/phaseSlot.d.ts",
       "import": "./dist/phaseSlot.js"
+    },
+    "./event": {
+      "types": "./dist/event.d.ts",
+      "import": "./dist/event.js"
     }
   },
   "files": [

package/dist/enums/slotStatus.d.ts

@@ -1,5 +0,0 @@
-export declare enum SlotStatus {
-    AVAILABLE = "available",
-    TAKEN = "taken",
-    RESERVED = "reserved"
-}

package/dist/enums/slotStatus.js

@@ -1,6 +0,0 @@
-export var SlotStatus;
-(function (SlotStatus) {
-    SlotStatus["AVAILABLE"] = "available";
-    SlotStatus["TAKEN"] = "taken";
-    SlotStatus["RESERVED"] = "reserved";
-})(SlotStatus || (SlotStatus = {}));