@venulog/phasing-engine-schemas 0.3.0-alpha.0 → 0.4.0-alpha.0

package/dist/parkingArea.js

@@ -0,0 +1,796 @@
+// packages/phasing-schemas/src/parkingArea.ts
+import { z } from './zod.js';
+import { createSuccessResponseSchema, createMessageDataResponseSchema } from './common.js';
+import { ParkingAreaScheduleType } from './enums/parkingAreaScheduleType.js';
+// ------------------------------
+// Geometry Schemas
+// ------------------------------
+/**
+ * A point in 2D space using percentage-based coordinates (0-100)
+ * relative to the site plan image dimensions
+ */
+export const pointSchema = z
+    .object({
+    x: z.number().min(0).max(100).openapi({
+        description: 'X coordinate as percentage of image width (0-100)',
+        example: 25.5
+    }),
+    y: z.number().min(0).max(100).openapi({
+        description: 'Y coordinate as percentage of image height (0-100)',
+        example: 30.2
+    })
+})
+    .openapi('Point');
+/**
+ * A polygon defined by 4 vertices (for rotated rectangles)
+ * Points should be in clockwise or counter-clockwise order
+ */
+export const polygonCoordinatesSchema = z
+    .array(pointSchema)
+    .min(3, 'Polygon must have at least 3 points')
+    .max(100, 'Polygon cannot have more than 100 points')
+    .openapi('PolygonCoordinates');
+/**
+ * Rectangle geometry for parking areas
+ * Includes center, dimensions, and rotation angle
+ */
+export const rectangleGeometrySchema = z
+    .object({
+    center: pointSchema.openapi({
+        description: 'Center point of the rectangle'
+    }),
+    width: z.number().positive().openapi({
+        description: 'Width of the rectangle as percentage of image width',
+        example: 15.0
+    }),
+    height: z.number().positive().openapi({
+        description: 'Height of the rectangle as percentage of image height',
+        example: 10.0
+    }),
+    angle: z.number().min(-180).max(180).default(0).openapi({
+        description: 'Rotation angle in degrees (-180 to 180)',
+        example: 45
+    })
+})
+    .openapi('RectangleGeometry');
+/**
+ * GeoJSON-compatible geometry for PostGIS storage
+ * Uses percentage-based coordinates that can be converted to actual coordinates
+ */
+export const geoJsonPolygonSchema = z
+    .object({
+    type: z.literal('Polygon').openapi({
+        description: 'GeoJSON geometry type',
+        example: 'Polygon'
+    }),
+    coordinates: z
+        .array(z.array(z.tuple([z.number(), z.number()])))
+        .openapi({
+        description: 'GeoJSON polygon coordinates (array of rings, first ring is outer boundary)',
+        example: [[[0, 0], [100, 0], [100, 100], [0, 100], [0, 0]]]
+    })
+})
+    .openapi('GeoJsonPolygon');
+// ------------------------------
+// Parking Area Schemas
+// ------------------------------
+/**
+ * Core parking area item schema matching database structure
+ */
+export const parkingAreaItemSchema = z
+    .object({
+    id: z.number().int().positive().openapi({
+        description: 'Parking area ID',
+        example: 1
+    }),
+    event_id: z.number().int().positive().openapi({
+        description: 'Event ID this parking area belongs to',
+        example: 1
+    }),
+    name: z.string().nullable().openapi({
+        description: 'Name of the parking area',
+        example: 'Zone A - Main Entrance'
+    }),
+    geometry: geoJsonPolygonSchema.nullable().openapi({
+        description: 'GeoJSON polygon geometry for the parking area'
+    }),
+    site_plan_image_url: z.string().url().nullable().openapi({
+        description: 'URL to the site plan image',
+        example: 'https://storage.example.com/site-plans/event-123/floor-1.png'
+    }),
+    surface_area_sqm: z.number().nonnegative().nullable().openapi({
+        description: 'Surface area in square meters',
+        example: 150.5
+    }),
+    is_active: z.boolean().openapi({
+        description: 'Whether the parking area is active',
+        example: true
+    }),
+    created_at: z.string().openapi({
+        description: 'Creation timestamp (ISO 8601)',
+        example: '2025-12-20T10:30:00Z'
+    }),
+    updated_at: z.string().openapi({
+        description: 'Last update timestamp (ISO 8601)',
+        example: '2025-12-20T10:30:00Z'
+    }),
+    created_by: z.string().uuid().nullable().openapi({
+        description: 'UUID of user who created this parking area',
+        example: '550e8400-e29b-41d4-a716-446655440000'
+    }),
+    updated_by: z.string().uuid().nullable().openapi({
+        description: 'UUID of user who last updated this parking area',
+        example: '550e8400-e29b-41d4-a716-446655440000'
+    })
+})
+    .openapi('ParkingAreaItem');
+/**
+ * Parking area with schedule information (for list views)
+ */
+export const parkingAreaWithSchedulesSchema = parkingAreaItemSchema
+    .extend({
+    schedules: z
+        .array(z.object({
+        id: z.number().int().positive(),
+        date: z.string(),
+        start_time: z.string(),
+        end_time: z.string(),
+        duration: z.number(),
+        parking_area_schedule_type: z.enum([
+            ParkingAreaScheduleType.ASSEMBLY,
+            ParkingAreaScheduleType.DISMANTLING
+        ]),
+        company_role: z.string().nullable()
+    }))
+        .optional()
+        .openapi({
+        description: 'Associated schedules for this parking area'
+    })
+})
+    .openapi('ParkingAreaWithSchedules');
+// ------------------------------
+// Query Schemas
+// ------------------------------
+export const getParkingAreasByEventIdParamsSchema = 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('GetParkingAreasByEventIdParams');
+export const getParkingAreaByIdParamsSchema = z
+    .object({
+    areaId: z
+        .string()
+        .min(1)
+        .transform(val => parseInt(val, 10))
+        .refine(val => !isNaN(val) && val > 0, {
+        message: 'Parking area ID must be a positive number'
+    })
+        .openapi({
+        description: 'The ID of the parking area',
+        example: '1'
+    })
+})
+    .openapi('GetParkingAreaByIdParams');
+// ------------------------------
+// Create Parking Area Schemas
+// ------------------------------
+export const createParkingAreaBodySchema = 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 parking area',
+        example: 'Zone A - Main Entrance'
+    }),
+    geometry: geoJsonPolygonSchema.optional().openapi({
+        description: 'GeoJSON polygon geometry for the parking area'
+    }),
+    site_plan_image_url: z.string().url().optional().openapi({
+        description: 'URL to the site plan image',
+        example: 'https://storage.example.com/site-plans/event-123/floor-1.png'
+    }),
+    surface_area_sqm: z.number().nonnegative().optional().openapi({
+        description: 'Surface area in square meters',
+        example: 150.5
+    })
+})
+    .openapi('CreateParkingAreaBody');
+export const createParkingAreaDataSchema = z
+    .object({
+    parking_area_id: z.number().openapi({
+        description: 'ID of the created parking area',
+        example: 123
+    }),
+    event_id: z.number().openapi({
+        description: 'ID of the event',
+        example: 1
+    }),
+    name: z.string().nullable().openapi({
+        description: 'Name of the parking area',
+        example: 'Zone A - Main Entrance'
+    }),
+    geometry: geoJsonPolygonSchema.nullable().openapi({
+        description: 'GeoJSON polygon geometry'
+    }),
+    site_plan_image_url: z.string().nullable().openapi({
+        description: 'URL to the site plan image',
+        example: 'https://storage.example.com/site-plans/event-123/floor-1.png'
+    }),
+    surface_area_sqm: z.number().nullable().openapi({
+        description: 'Surface area in square meters',
+        example: 150.5
+    }),
+    is_active: z.boolean().openapi({
+        description: 'Whether the parking area is active',
+        example: true
+    }),
+    created_at: z.string().openapi({
+        description: 'Timestamp when parking area was created',
+        example: '2025-12-20T10:30:00.000Z'
+    }),
+    created_by: z.string().nullable().openapi({
+        description: 'ID of the user who created the parking area',
+        example: 'user-123'
+    })
+})
+    .openapi('CreateParkingAreaData');
+export const createParkingAreaResponseSchema = createMessageDataResponseSchema(createParkingAreaDataSchema, 'CreateParkingAreaResponse', 'Parking area created successfully', 'Details of the created parking area');
+// ------------------------------
+// Bulk Create Parking Areas Schemas
+// ------------------------------
+export const bulkCreateParkingAreasBodySchema = z
+    .object({
+    event_id: z.number().int().positive().openapi({
+        description: 'ID of the event',
+        example: 1
+    }),
+    parking_areas: z
+        .array(z.object({
+        name: z.string().min(1).max(255).openapi({
+            description: 'Name of the parking area',
+            example: 'Zone A'
+        }),
+        geometry: geoJsonPolygonSchema.optional(),
+        surface_area_sqm: z.number().nonnegative().optional()
+    }))
+        .min(1, 'At least one parking area must be provided')
+        .openapi({
+        description: 'Array of parking areas to create'
+    }),
+    site_plan_image_url: z.string().url().optional().openapi({
+        description: 'URL to the site plan image (shared by all areas in this batch)',
+        example: 'https://storage.example.com/site-plans/event-123/floor-1.png'
+    })
+})
+    .openapi('BulkCreateParkingAreasBody');
+export const bulkCreateParkingAreasDataSchema = z
+    .object({
+    event_id: z.number().openapi({
+        description: 'ID of the event',
+        example: 1
+    }),
+    total_created: z.number().openapi({
+        description: 'Total number of parking areas successfully created',
+        example: 5
+    }),
+    created_areas: z.array(createParkingAreaDataSchema).openapi({
+        description: 'Array of successfully created parking areas'
+    }),
+    failed_areas: z
+        .array(z.object({
+        index: z.number().openapi({
+            description: 'Index of the parking area in the request that failed',
+            example: 2
+        }),
+        name: z.string().openapi({
+            description: 'Name of the parking area that failed',
+            example: 'Zone C'
+        }),
+        error: z.string().openapi({
+            description: 'Error message explaining the failure',
+            example: 'Invalid geometry coordinates'
+        })
+    }))
+        .openapi({
+        description: 'Array of parking areas that failed to create'
+    })
+})
+    .openapi('BulkCreateParkingAreasData');
+export const bulkCreateParkingAreasResponseSchema = createMessageDataResponseSchema(bulkCreateParkingAreasDataSchema, 'BulkCreateParkingAreasResponse', 'Bulk parking areas operation completed', 'Details of the bulk creation operation');
+// ------------------------------
+// Update Parking Area Schemas
+// ------------------------------
+export const updateParkingAreaParamsSchema = z
+    .object({
+    areaId: z
+        .string()
+        .min(1)
+        .transform(val => parseInt(val, 10))
+        .refine(val => !isNaN(val) && val > 0, {
+        message: 'Parking area ID must be a positive number'
+    })
+        .openapi({
+        description: 'The ID of the parking area to update',
+        example: '123'
+    })
+})
+    .openapi('UpdateParkingAreaParams');
+export const updateParkingAreaBodySchema = z
+    .object({
+    name: z.string().min(1).max(255).optional().openapi({
+        description: 'New name for the parking area',
+        example: 'Zone B - Loading Dock'
+    }),
+    geometry: geoJsonPolygonSchema.nullable().optional().openapi({
+        description: 'New GeoJSON polygon geometry'
+    }),
+    site_plan_image_url: z.string().url().nullable().optional().openapi({
+        description: 'New site plan image URL',
+        example: 'https://storage.example.com/site-plans/event-123/floor-2.png'
+    }),
+    surface_area_sqm: z.number().nonnegative().nullable().optional().openapi({
+        description: 'New surface area in square meters',
+        example: 200.0
+    }),
+    is_active: z.boolean().optional().openapi({
+        description: 'Whether the parking area is active',
+        example: true
+    })
+})
+    .refine(data => Object.keys(data).length > 0, {
+    message: 'At least one field must be provided for update'
+})
+    .openapi('UpdateParkingAreaBody');
+export const updateParkingAreaDataSchema = z
+    .object({
+    parking_area_id: z.number().openapi({
+        description: 'ID of the updated parking area',
+        example: 123
+    }),
+    event_id: z.number().openapi({
+        description: 'ID of the event',
+        example: 1
+    }),
+    name: z.string().nullable().openapi({
+        description: 'Updated name',
+        example: 'Zone B - Loading Dock'
+    }),
+    geometry: geoJsonPolygonSchema.nullable().openapi({
+        description: 'Updated GeoJSON polygon geometry'
+    }),
+    site_plan_image_url: z.string().nullable().openapi({
+        description: 'Updated site plan image URL'
+    }),
+    surface_area_sqm: z.number().nullable().openapi({
+        description: 'Updated surface area in square meters',
+        example: 200.0
+    }),
+    is_active: z.boolean().openapi({
+        description: 'Whether the parking area is active',
+        example: true
+    }),
+    updated_at: z.string().openapi({
+        description: 'Timestamp when parking area was updated',
+        example: '2025-12-20T11:00:00.000Z'
+    }),
+    updated_by: z.string().nullable().openapi({
+        description: 'ID of the user who updated the parking area',
+        example: 'user-123'
+    })
+})
+    .openapi('UpdateParkingAreaData');
+export const updateParkingAreaResponseSchema = createMessageDataResponseSchema(updateParkingAreaDataSchema, 'UpdateParkingAreaResponse', 'Parking area updated successfully', 'Details of the updated parking area');
+// ------------------------------
+// Delete Parking Area Schemas
+// ------------------------------
+export const deleteParkingAreaParamsSchema = z
+    .object({
+    areaId: z
+        .string()
+        .min(1)
+        .transform(val => parseInt(val, 10))
+        .refine(val => !isNaN(val) && val > 0, {
+        message: 'Parking area ID must be a positive number'
+    })
+        .openapi({
+        description: 'The ID of the parking area to delete',
+        example: '123'
+    })
+})
+    .openapi('DeleteParkingAreaParams');
+export const deleteParkingAreaDataSchema = z
+    .object({
+    parking_area_id: z.number().openapi({
+        description: 'ID of the deleted parking area',
+        example: 123
+    }),
+    deleted_at: z.string().openapi({
+        description: 'Timestamp when parking area was deleted',
+        example: '2025-12-20T12:00:00.000Z'
+    })
+})
+    .openapi('DeleteParkingAreaData');
+export const deleteParkingAreaResponseSchema = createMessageDataResponseSchema(deleteParkingAreaDataSchema, 'DeleteParkingAreaResponse', 'Parking area deleted successfully', 'Details of the deleted parking area');
+// ------------------------------
+// Get Parking Areas Response Schemas
+// ------------------------------
+export const getParkingAreasDataSchema = z
+    .object({
+    event_id: z.number().openapi({
+        description: 'ID of the event',
+        example: 1
+    }),
+    parking_areas: z.array(parkingAreaItemSchema).openapi({
+        description: 'List of parking areas for the event'
+    }),
+    total_count: z.number().openapi({
+        description: 'Total number of parking areas',
+        example: 10
+    })
+})
+    .openapi('GetParkingAreasData');
+export const getParkingAreasResponseSchema = createSuccessResponseSchema(getParkingAreasDataSchema, 'GetParkingAreasResponse', 'Parking areas for the event');
+export const getParkingAreaDetailResponseSchema = createSuccessResponseSchema(parkingAreaWithSchedulesSchema, 'GetParkingAreaDetailResponse', 'Parking area details with schedules');
+// ------------------------------
+// Parking Area Schedule Schemas
+// ------------------------------
+export const parkingAreaScheduleSchema = 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('ParkingAreaSchedule');
+// ------------------------------
+// Upsert Parking Area Schedules Schemas
+// ------------------------------
+export const upsertParkingAreaScheduleItemSchema = z
+    .object({
+    id: z.number().int().positive().optional().openapi({
+        description: 'Unique identifier for existing schedule (required for updates)',
+        example: 1
+    }),
+    parking_area_id: z.number().int().positive().openapi({
+        description: 'ID of the associated parking area',
+        example: 101
+    }),
+    date: z
+        .string()
+        .regex(/^\d{4}-\d{2}-\d{2}$/, 'Date must be in YYYY-MM-DD format')
+        .openapi({
+        description: 'Date of the schedule (YYYY-MM-DD format)',
+        example: '2025-12-15'
+    }),
+    start_time: z
+        .string()
+        .regex(/^\d{2}:\d{2}$/, 'Time must be in HH:MM format')
+        .default('06:00')
+        .openapi({
+        description: 'Start time (HH:MM format)',
+        example: '06:00'
+    }),
+    end_time: z
+        .string()
+        .regex(/^\d{2}:\d{2}$/, 'Time must be in HH:MM format')
+        .default('09:00')
+        .openapi({
+        description: 'End time (HH:MM format)',
+        example: '09:00'
+    }),
+    duration: z.number().positive().default(60).openapi({
+        description: 'Duration in minutes',
+        example: 180
+    }),
+    parking_area_schedule_type: z
+        .enum([ParkingAreaScheduleType.ASSEMBLY, ParkingAreaScheduleType.DISMANTLING])
+        .openapi({
+        description: 'Type of schedule',
+        example: ParkingAreaScheduleType.ASSEMBLY
+    }),
+    company_role: z.string().nullable().optional().openapi({
+        description: 'Company role allowed for this schedule',
+        example: 'exhibitor'
+    })
+})
+    .openapi('UpsertParkingAreaScheduleItem');
+export const deleteParkingAreaScheduleItemSchema = z
+    .object({
+    id: z.number().int().positive().openapi({
+        description: 'ID of the schedule to delete',
+        example: 1
+    })
+})
+    .openapi('DeleteParkingAreaScheduleItem');
+export const upsertParkingAreaSchedulesBodySchema = z
+    .object({
+    upsert: z
+        .array(upsertParkingAreaScheduleItemSchema)
+        .optional()
+        .openapi({
+        description: 'Array of schedules to create or update'
+    }),
+    delete: z
+        .array(deleteParkingAreaScheduleItemSchema)
+        .optional()
+        .openapi({
+        description: 'Array of schedule IDs to delete'
+    })
+})
+    .refine(data => (data.upsert && data.upsert.length > 0) || (data.delete && data.delete.length > 0), {
+    message: 'At least one upsert or delete operation is required'
+})
+    .openapi('UpsertParkingAreaSchedulesBody');
+export const upsertParkingAreaSchedulesDataSchema = z
+    .object({
+    total_upserted: z.number().int().nonnegative().openapi({
+        description: 'Total number of schedules successfully upserted',
+        example: 3
+    }),
+    total_deleted: z.number().int().nonnegative().openapi({
+        description: 'Total number of schedules successfully deleted',
+        example: 1
+    }),
+    upserted_schedules: z.array(parkingAreaScheduleSchema).openapi({
+        description: 'Array of successfully upserted schedules'
+    }),
+    deleted_schedules: z
+        .array(z.object({
+        id: z.number().int().positive()
+    }))
+        .openapi({
+        description: 'Array of successfully deleted schedule IDs'
+    }),
+    failed_operations: z
+        .array(z.object({
+        operation: z.enum(['upsert', 'delete']),
+        error: z.string(),
+        data: z.union([upsertParkingAreaScheduleItemSchema, deleteParkingAreaScheduleItemSchema])
+    }))
+        .openapi({
+        description: 'Array of operations that failed to process'
+    })
+})
+    .openapi('UpsertParkingAreaSchedulesData');
+export const upsertParkingAreaSchedulesResponseSchema = createMessageDataResponseSchema(upsertParkingAreaSchedulesDataSchema, 'UpsertParkingAreaSchedulesResponse', 'Parking area schedules operation completed', 'Results of the upsert/delete operations');
+// ------------------------------
+// Site Plan Image Upload Schemas
+// ------------------------------
+export const uploadSitePlanImageParamsSchema = 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('UploadSitePlanImageParams');
+export const uploadSitePlanImageDataSchema = z
+    .object({
+    image_url: z.string().url().openapi({
+        description: 'URL of the uploaded site plan image',
+        example: 'https://storage.example.com/site-plans/event-123/floor-1.png'
+    }),
+    file_name: z.string().openapi({
+        description: 'Original file name',
+        example: 'floor-plan.png'
+    }),
+    file_size: z.number().openapi({
+        description: 'File size in bytes',
+        example: 1024000
+    }),
+    mime_type: z.string().openapi({
+        description: 'MIME type of the uploaded file',
+        example: 'image/png'
+    }),
+    uploaded_at: z.string().openapi({
+        description: 'Timestamp when the image was uploaded',
+        example: '2025-12-20T10:30:00.000Z'
+    })
+})
+    .openapi('UploadSitePlanImageData');
+export const uploadSitePlanImageResponseSchema = createMessageDataResponseSchema(uploadSitePlanImageDataSchema, 'UploadSitePlanImageResponse', 'Site plan image uploaded successfully', 'Details of the uploaded image');
+// ------------------------------
+// Available Time Slots (Parking Area version)
+// ------------------------------
+export const getAvailableParkingAreaSlotsQuerySchema = z
+    .object({
+    event_id: 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'
+    }),
+    year: z
+        .string()
+        .regex(/^\d{4}$/, 'Year must be in YYYY format')
+        .transform(val => parseInt(val, 10))
+        .openapi({
+        description: 'Year for filtering slots (YYYY)',
+        example: '2026'
+    }),
+    month: z
+        .string()
+        .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)',
+        example: '6'
+    }),
+    parking_area_id: z
+        .string()
+        .min(1)
+        .transform(val => parseInt(val, 10))
+        .refine(val => !isNaN(val) && val > 0, {
+        message: 'Parking area ID must be a positive number'
+    })
+        .openapi({
+        description: 'The ID of the parking area',
+        example: '1'
+    }),
+    schedule_type: z.enum(['assembly', 'dismantling']).optional().openapi({
+        description: 'Filter by schedule type',
+        example: 'assembly'
+    })
+})
+    .openapi('GetAvailableParkingAreaSlotsQuery');
+export const availableParkingAreaTimeSlotSchema = 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'
+    }),
+    company_role: z.string().nullable().openapi({
+        description: 'Company role allowed for this schedule',
+        example: 'exhibitor'
+    }),
+    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('AvailableParkingAreaTimeSlot');
+export const availableParkingAreaSlotsResponseSchema = 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'
+    }),
+    parking_area_id: z.number().openapi({
+        description: 'ID of the parking area',
+        example: 1
+    }),
+    parking_area_name: z.string().nullable().openapi({
+        description: 'Name of the parking area',
+        example: 'Zone A - Main Entrance'
+    }),
+    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(availableParkingAreaTimeSlotSchema).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('AvailableParkingAreaSlotsResponse');