@venulog/phasing-engine-schemas 0.7.5 → 0.7.6

package/dist/simulation.d.ts

@@ -0,0 +1,171 @@
+import { z } from './zod.js';
+import { SimulationMode, SimulationStatus } from './enums/simulationMode.js';
+export declare const simulationModeSchema: z.ZodEnum<{
+    entry: SimulationMode.ENTRY;
+    exit: SimulationMode.EXIT;
+    both: SimulationMode.BOTH;
+}>;
+export declare const simulationStatusSchema: z.ZodEnum<{
+    running: SimulationStatus.RUNNING;
+    stopped: SimulationStatus.STOPPED;
+    completed: SimulationStatus.COMPLETED;
+}>;
+export declare const startSimulationBodySchema: z.ZodObject<{
+    event_id: z.ZodNumber;
+    booking_ids: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+    speed_kmh: z.ZodDefault<z.ZodNumber>;
+    update_interval_ms: z.ZodDefault<z.ZodNumber>;
+    mode: z.ZodDefault<z.ZodEnum<{
+        entry: SimulationMode.ENTRY;
+        exit: SimulationMode.EXIT;
+        both: SimulationMode.BOTH;
+    }>>;
+}, z.core.$strip>;
+export type StartSimulationBody = z.infer<typeof startSimulationBodySchema>;
+export declare const startSimulationDataSchema: z.ZodObject<{
+    session_id: z.ZodString;
+    event_id: z.ZodNumber;
+    booking_ids: z.ZodArray<z.ZodNumber>;
+    speed_kmh: z.ZodNumber;
+    update_interval_ms: z.ZodNumber;
+    mode: z.ZodEnum<{
+        entry: SimulationMode.ENTRY;
+        exit: SimulationMode.EXIT;
+        both: SimulationMode.BOTH;
+    }>;
+    started_at: z.ZodString;
+}, z.core.$strip>;
+export type StartSimulationData = z.infer<typeof startSimulationDataSchema>;
+export declare const startSimulationResponseSchema: z.ZodObject<{
+    success: z.ZodBoolean;
+    message: z.ZodString;
+    data: z.ZodObject<{
+        session_id: z.ZodString;
+        event_id: z.ZodNumber;
+        booking_ids: z.ZodArray<z.ZodNumber>;
+        speed_kmh: z.ZodNumber;
+        update_interval_ms: z.ZodNumber;
+        mode: z.ZodEnum<{
+            entry: SimulationMode.ENTRY;
+            exit: SimulationMode.EXIT;
+            both: SimulationMode.BOTH;
+        }>;
+        started_at: z.ZodString;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type StartSimulationResponse = z.infer<typeof startSimulationResponseSchema>;
+export declare const stopSimulationBodySchema: z.ZodObject<{
+    session_id: z.ZodOptional<z.ZodString>;
+    event_id: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export type StopSimulationBody = z.infer<typeof stopSimulationBodySchema>;
+export declare const stopSimulationDataSchema: z.ZodObject<{
+    sessions_stopped: z.ZodNumber;
+    session_ids: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+export type StopSimulationData = z.infer<typeof stopSimulationDataSchema>;
+export declare const stopSimulationResponseSchema: z.ZodObject<{
+    success: z.ZodBoolean;
+    message: z.ZodString;
+    data: z.ZodObject<{
+        sessions_stopped: z.ZodNumber;
+        session_ids: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type StopSimulationResponse = z.infer<typeof stopSimulationResponseSchema>;
+export declare const simulationSessionSchema: z.ZodObject<{
+    id: z.ZodString;
+    event_id: z.ZodNumber;
+    speed_kmh: z.ZodNumber;
+    update_interval_ms: z.ZodNumber;
+    mode: z.ZodEnum<{
+        entry: SimulationMode.ENTRY;
+        exit: SimulationMode.EXIT;
+        both: SimulationMode.BOTH;
+    }>;
+    booking_ids: z.ZodArray<z.ZodNumber>;
+    status: z.ZodEnum<{
+        running: SimulationStatus.RUNNING;
+        stopped: SimulationStatus.STOPPED;
+        completed: SimulationStatus.COMPLETED;
+    }>;
+    started_at: z.ZodString;
+    stopped_at: z.ZodNullable<z.ZodString>;
+    positions_generated: z.ZodNumber;
+}, z.core.$strip>;
+export type SimulationSession = z.infer<typeof simulationSessionSchema>;
+export declare const getSimulationStatusQuerySchema: z.ZodObject<{
+    event_id: z.ZodOptional<z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<number, string>>, z.ZodNumber>>;
+    include_completed: z.ZodPipe<z.ZodDefault<z.ZodOptional<z.ZodString>>, z.ZodTransform<boolean, string>>;
+}, z.core.$strip>;
+export type GetSimulationStatusQuery = z.infer<typeof getSimulationStatusQuerySchema>;
+export declare const simulationStatusDataSchema: z.ZodObject<{
+    active: z.ZodBoolean;
+    sessions: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        event_id: z.ZodNumber;
+        speed_kmh: z.ZodNumber;
+        update_interval_ms: z.ZodNumber;
+        mode: z.ZodEnum<{
+            entry: SimulationMode.ENTRY;
+            exit: SimulationMode.EXIT;
+            both: SimulationMode.BOTH;
+        }>;
+        booking_ids: z.ZodArray<z.ZodNumber>;
+        status: z.ZodEnum<{
+            running: SimulationStatus.RUNNING;
+            stopped: SimulationStatus.STOPPED;
+            completed: SimulationStatus.COMPLETED;
+        }>;
+        started_at: z.ZodString;
+        stopped_at: z.ZodNullable<z.ZodString>;
+        positions_generated: z.ZodNumber;
+    }, z.core.$strip>>;
+    total_active: z.ZodNumber;
+}, z.core.$strip>;
+export type SimulationStatusData = z.infer<typeof simulationStatusDataSchema>;
+export declare const getSimulationStatusResponseSchema: z.ZodObject<{
+    success: z.ZodBoolean;
+    data: z.ZodObject<{
+        active: z.ZodBoolean;
+        sessions: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            event_id: z.ZodNumber;
+            speed_kmh: z.ZodNumber;
+            update_interval_ms: z.ZodNumber;
+            mode: z.ZodEnum<{
+                entry: SimulationMode.ENTRY;
+                exit: SimulationMode.EXIT;
+                both: SimulationMode.BOTH;
+            }>;
+            booking_ids: z.ZodArray<z.ZodNumber>;
+            status: z.ZodEnum<{
+                running: SimulationStatus.RUNNING;
+                stopped: SimulationStatus.STOPPED;
+                completed: SimulationStatus.COMPLETED;
+            }>;
+            started_at: z.ZodString;
+            stopped_at: z.ZodNullable<z.ZodString>;
+            positions_generated: z.ZodNumber;
+        }, z.core.$strip>>;
+        total_active: z.ZodNumber;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type GetSimulationStatusResponse = z.infer<typeof getSimulationStatusResponseSchema>;
+export declare const pathPointSchema: z.ZodObject<{
+    x: z.ZodNumber;
+    y: z.ZodNumber;
+    distance_from_start: z.ZodNumber;
+}, z.core.$strip>;
+export type PathPoint = z.infer<typeof pathPointSchema>;
+export declare const simulatedPathSchema: z.ZodObject<{
+    booking_id: z.ZodNumber;
+    points: z.ZodArray<z.ZodObject<{
+        x: z.ZodNumber;
+        y: z.ZodNumber;
+        distance_from_start: z.ZodNumber;
+    }, z.core.$strip>>;
+    total_distance: z.ZodNumber;
+    estimated_duration: z.ZodNumber;
+}, z.core.$strip>;
+export type SimulatedPath = z.infer<typeof simulatedPathSchema>;

package/dist/simulation.js

@@ -0,0 +1,231 @@
+import { z } from './zod.js';
+import { SimulationMode, SimulationStatus } from './enums/simulationMode.js';
+import { createSuccessResponseSchema, createMessageDataResponseSchema } from './common.js';
+// ============================================================================
+// Enums as Zod schemas
+// ============================================================================
+export const simulationModeSchema = z.enum([
+    SimulationMode.ENTRY,
+    SimulationMode.EXIT,
+    SimulationMode.BOTH
+]);
+export const simulationStatusSchema = z.enum([
+    SimulationStatus.RUNNING,
+    SimulationStatus.STOPPED,
+    SimulationStatus.COMPLETED
+]);
+// ============================================================================
+// Start Simulation Request
+// ============================================================================
+export const startSimulationBodySchema = z
+    .object({
+    event_id: z.number().int().positive().openapi({
+        description: 'Event ID to simulate',
+        example: 1
+    }),
+    booking_ids: z
+        .array(z.number().int().positive())
+        .optional()
+        .openapi({
+        description: 'Specific booking IDs to simulate. If omitted, simulates all active bookings.',
+        example: [123, 124, 125]
+    }),
+    speed_kmh: z.number().min(5).max(50).default(20).openapi({
+        description: 'Simulated vehicle speed in km/h',
+        example: 20
+    }),
+    update_interval_ms: z.number().int().min(500).max(5000).default(1000).openapi({
+        description: 'Position update interval in milliseconds',
+        example: 1000
+    }),
+    mode: simulationModeSchema.default(SimulationMode.BOTH).openapi({
+        description: 'Which movements to simulate',
+        example: 'both'
+    })
+})
+    .openapi('StartSimulationBody');
+// ============================================================================
+// Start Simulation Response
+// ============================================================================
+export const startSimulationDataSchema = z
+    .object({
+    session_id: z.string().uuid().openapi({
+        description: 'Simulation session UUID',
+        example: '550e8400-e29b-41d4-a716-446655440000'
+    }),
+    event_id: z.number().int().positive().openapi({
+        description: 'Event ID',
+        example: 1
+    }),
+    booking_ids: z.array(z.number().int().positive()).openapi({
+        description: 'Booking IDs being simulated',
+        example: [123, 124, 125]
+    }),
+    speed_kmh: z.number().openapi({
+        description: 'Simulation speed',
+        example: 20
+    }),
+    update_interval_ms: z.number().int().openapi({
+        description: 'Update interval',
+        example: 1000
+    }),
+    mode: simulationModeSchema.openapi({
+        description: 'Simulation mode'
+    }),
+    started_at: z.string().datetime().openapi({
+        description: 'When simulation started',
+        example: '2026-01-04T12:34:56Z'
+    })
+})
+    .openapi('StartSimulationData');
+export const startSimulationResponseSchema = createMessageDataResponseSchema(startSimulationDataSchema, 'StartSimulationResponse', 'Simulation started successfully', 'Simulation session details');
+// ============================================================================
+// Stop Simulation Request
+// ============================================================================
+export const stopSimulationBodySchema = z
+    .object({
+    session_id: z.string().uuid().optional().openapi({
+        description: 'Specific session to stop. If omitted, stops all sessions for event.',
+        example: '550e8400-e29b-41d4-a716-446655440000'
+    }),
+    event_id: z.number().int().positive().optional().openapi({
+        description: 'Stop all simulations for this event',
+        example: 1
+    })
+})
+    .refine((data) => data.session_id || data.event_id, {
+    message: 'Either session_id or event_id must be provided'
+})
+    .openapi('StopSimulationBody');
+// ============================================================================
+// Stop Simulation Response
+// ============================================================================
+export const stopSimulationDataSchema = z
+    .object({
+    sessions_stopped: z.number().int().min(0).openapi({
+        description: 'Number of sessions stopped',
+        example: 1
+    }),
+    session_ids: z.array(z.string().uuid()).openapi({
+        description: 'IDs of stopped sessions',
+        example: ['550e8400-e29b-41d4-a716-446655440000']
+    })
+})
+    .openapi('StopSimulationData');
+export const stopSimulationResponseSchema = createMessageDataResponseSchema(stopSimulationDataSchema, 'StopSimulationResponse', 'Simulation stopped successfully', 'Stopped session details');
+// ============================================================================
+// Simulation Session (for status display)
+// ============================================================================
+export const simulationSessionSchema = z
+    .object({
+    id: z.string().uuid().openapi({
+        description: 'Session UUID'
+    }),
+    event_id: z.number().int().positive().openapi({
+        description: 'Event ID'
+    }),
+    speed_kmh: z.number().openapi({
+        description: 'Simulation speed'
+    }),
+    update_interval_ms: z.number().int().openapi({
+        description: 'Update interval'
+    }),
+    mode: simulationModeSchema.openapi({
+        description: 'Simulation mode'
+    }),
+    booking_ids: z.array(z.number().int().positive()).openapi({
+        description: 'Bookings being simulated'
+    }),
+    status: simulationStatusSchema.openapi({
+        description: 'Current status'
+    }),
+    started_at: z.string().datetime().openapi({
+        description: 'Start time'
+    }),
+    stopped_at: z.string().datetime().nullable().openapi({
+        description: 'Stop time (if stopped)'
+    }),
+    positions_generated: z.number().int().min(0).openapi({
+        description: 'Number of position updates generated'
+    })
+})
+    .openapi('SimulationSession');
+// ============================================================================
+// Get Simulation Status Query
+// ============================================================================
+export const getSimulationStatusQuerySchema = z
+    .object({
+    event_id: z
+        .string()
+        .transform((val) => parseInt(val, 10))
+        .pipe(z.number().int().positive())
+        .optional()
+        .openapi({
+        description: 'Filter by event ID',
+        example: '1'
+    }),
+    include_completed: z
+        .string()
+        .optional()
+        .default('false')
+        .transform((val) => val === 'true')
+        .openapi({
+        description: 'Include completed sessions',
+        example: 'false'
+    })
+})
+    .openapi('GetSimulationStatusQuery');
+// ============================================================================
+// Get Simulation Status Response
+// ============================================================================
+export const simulationStatusDataSchema = z
+    .object({
+    active: z.boolean().openapi({
+        description: 'Whether any simulations are running',
+        example: true
+    }),
+    sessions: z.array(simulationSessionSchema).openapi({
+        description: 'List of simulation sessions'
+    }),
+    total_active: z.number().int().min(0).openapi({
+        description: 'Total number of active sessions',
+        example: 2
+    })
+})
+    .openapi('SimulationStatusData');
+export const getSimulationStatusResponseSchema = createSuccessResponseSchema(simulationStatusDataSchema, 'GetSimulationStatusResponse', 'Simulation status');
+// ============================================================================
+// Path Point (for path calculation)
+// ============================================================================
+export const pathPointSchema = z
+    .object({
+    x: z.number().min(0).max(100).openapi({
+        description: 'X coordinate on site plan (0-100%)'
+    }),
+    y: z.number().min(0).max(100).openapi({
+        description: 'Y coordinate on site plan (0-100%)'
+    }),
+    distance_from_start: z.number().min(0).openapi({
+        description: 'Distance from path start in meters'
+    })
+})
+    .openapi('PathPoint');
+// ============================================================================
+// Simulated Path
+// ============================================================================
+export const simulatedPathSchema = z
+    .object({
+    booking_id: z.number().int().positive().openapi({
+        description: 'Booking ID'
+    }),
+    points: z.array(pathPointSchema).openapi({
+        description: 'Path waypoints'
+    }),
+    total_distance: z.number().min(0).openapi({
+        description: 'Total path distance in meters'
+    }),
+    estimated_duration: z.number().min(0).openapi({
+        description: 'Estimated duration in seconds at configured speed'
+    })
+})
+    .openapi('SimulatedPath');

package/dist/vehiclePosition.d.ts

@@ -0,0 +1,216 @@
+import { z } from './zod.js';
+import { PositionSource } from './enums/positionSource.js';
+import { VehicleState } from './enums/vehicleState.js';
+import { VehicleType } from './enums/vehicleType.js';
+export declare const positionSourceSchema: z.ZodEnum<{
+    gps: PositionSource.GPS;
+    simulated: PositionSource.SIMULATED;
+    inferred: PositionSource.INFERRED;
+    manual: PositionSource.MANUAL;
+}>;
+export declare const vehicleStateSchema: z.ZodEnum<{
+    booked: VehicleState.BOOKED;
+    approaching: VehicleState.APPROACHING;
+    at_gate: VehicleState.AT_GATE;
+    entering: VehicleState.ENTERING;
+    parked: VehicleState.PARKED;
+    departing: VehicleState.DEPARTING;
+    at_exit: VehicleState.AT_EXIT;
+    exited: VehicleState.EXITED;
+    historical: VehicleState.HISTORICAL;
+}>;
+export declare const sitePlanPositionSchema: z.ZodObject<{
+    x: z.ZodNumber;
+    y: z.ZodNumber;
+    heading: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export type SitePlanPosition = z.infer<typeof sitePlanPositionSchema>;
+export declare const gpsCoordinatesSchema: z.ZodObject<{
+    latitude: z.ZodNumber;
+    longitude: z.ZodNumber;
+}, z.core.$strip>;
+export type GpsCoordinates = z.infer<typeof gpsCoordinatesSchema>;
+export declare const reportPositionBodySchema: z.ZodObject<{
+    booking_id: z.ZodNumber;
+    access_token: z.ZodString;
+    latitude: z.ZodNumber;
+    longitude: z.ZodNumber;
+    heading: z.ZodOptional<z.ZodNumber>;
+    speed_kmh: z.ZodOptional<z.ZodNumber>;
+    accuracy_meters: z.ZodOptional<z.ZodNumber>;
+    timestamp: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type ReportPositionBody = z.infer<typeof reportPositionBodySchema>;
+export declare const reportPositionDataSchema: z.ZodObject<{
+    position_id: z.ZodString;
+    received_at: z.ZodString;
+    site_plan_position: z.ZodOptional<z.ZodObject<{
+        x: z.ZodNumber;
+        y: z.ZodNumber;
+        heading: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type ReportPositionData = z.infer<typeof reportPositionDataSchema>;
+export declare const reportPositionResponseSchema: z.ZodObject<{
+    success: z.ZodBoolean;
+    data: z.ZodObject<{
+        position_id: z.ZodString;
+        received_at: z.ZodString;
+        site_plan_position: z.ZodOptional<z.ZodObject<{
+            x: z.ZodNumber;
+            y: z.ZodNumber;
+            heading: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type ReportPositionResponse = z.infer<typeof reportPositionResponseSchema>;
+export declare const vehiclePositionSchema: z.ZodObject<{
+    booking_id: z.ZodNumber;
+    license_plate: z.ZodString;
+    vehicle_type: z.ZodEnum<{
+        PL: VehicleType.PL;
+        VUL: VehicleType.VUL;
+        VL: VehicleType.VL;
+    }>;
+    company_name: z.ZodString;
+    stand_number: z.ZodOptional<z.ZodString>;
+    state: z.ZodEnum<{
+        booked: VehicleState.BOOKED;
+        approaching: VehicleState.APPROACHING;
+        at_gate: VehicleState.AT_GATE;
+        entering: VehicleState.ENTERING;
+        parked: VehicleState.PARKED;
+        departing: VehicleState.DEPARTING;
+        at_exit: VehicleState.AT_EXIT;
+        exited: VehicleState.EXITED;
+        historical: VehicleState.HISTORICAL;
+    }>;
+    position: z.ZodObject<{
+        x: z.ZodNumber;
+        y: z.ZodNumber;
+        heading: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>;
+    speed_kmh: z.ZodOptional<z.ZodNumber>;
+    parking_area_id: z.ZodOptional<z.ZodNumber>;
+    parking_area_name: z.ZodOptional<z.ZodString>;
+    entry_time: z.ZodNullable<z.ZodString>;
+    last_updated: z.ZodString;
+    source: z.ZodEnum<{
+        gps: PositionSource.GPS;
+        simulated: PositionSource.SIMULATED;
+        inferred: PositionSource.INFERRED;
+        manual: PositionSource.MANUAL;
+    }>;
+}, z.core.$strip>;
+export type VehiclePosition = z.infer<typeof vehiclePositionSchema>;
+export declare const getVehiclePositionsQuerySchema: z.ZodObject<{
+    since: z.ZodOptional<z.ZodString>;
+    include_historical: z.ZodPipe<z.ZodDefault<z.ZodOptional<z.ZodString>>, z.ZodTransform<boolean, string>>;
+    state: z.ZodOptional<z.ZodEnum<{
+        booked: VehicleState.BOOKED;
+        approaching: VehicleState.APPROACHING;
+        at_gate: VehicleState.AT_GATE;
+        entering: VehicleState.ENTERING;
+        parked: VehicleState.PARKED;
+        departing: VehicleState.DEPARTING;
+        at_exit: VehicleState.AT_EXIT;
+        exited: VehicleState.EXITED;
+        historical: VehicleState.HISTORICAL;
+    }>>;
+}, z.core.$strip>;
+export type GetVehiclePositionsQuery = z.infer<typeof getVehiclePositionsQuerySchema>;
+export declare const vehiclePositionsDataSchema: z.ZodObject<{
+    event_id: z.ZodNumber;
+    positions: z.ZodArray<z.ZodObject<{
+        booking_id: z.ZodNumber;
+        license_plate: z.ZodString;
+        vehicle_type: z.ZodEnum<{
+            PL: VehicleType.PL;
+            VUL: VehicleType.VUL;
+            VL: VehicleType.VL;
+        }>;
+        company_name: z.ZodString;
+        stand_number: z.ZodOptional<z.ZodString>;
+        state: z.ZodEnum<{
+            booked: VehicleState.BOOKED;
+            approaching: VehicleState.APPROACHING;
+            at_gate: VehicleState.AT_GATE;
+            entering: VehicleState.ENTERING;
+            parked: VehicleState.PARKED;
+            departing: VehicleState.DEPARTING;
+            at_exit: VehicleState.AT_EXIT;
+            exited: VehicleState.EXITED;
+            historical: VehicleState.HISTORICAL;
+        }>;
+        position: z.ZodObject<{
+            x: z.ZodNumber;
+            y: z.ZodNumber;
+            heading: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>;
+        speed_kmh: z.ZodOptional<z.ZodNumber>;
+        parking_area_id: z.ZodOptional<z.ZodNumber>;
+        parking_area_name: z.ZodOptional<z.ZodString>;
+        entry_time: z.ZodNullable<z.ZodString>;
+        last_updated: z.ZodString;
+        source: z.ZodEnum<{
+            gps: PositionSource.GPS;
+            simulated: PositionSource.SIMULATED;
+            inferred: PositionSource.INFERRED;
+            manual: PositionSource.MANUAL;
+        }>;
+    }, z.core.$strip>>;
+    total_count: z.ZodNumber;
+    timestamp: z.ZodString;
+}, z.core.$strip>;
+export type VehiclePositionsData = z.infer<typeof vehiclePositionsDataSchema>;
+export declare const getVehiclePositionsResponseSchema: z.ZodObject<{
+    success: z.ZodBoolean;
+    data: z.ZodObject<{
+        event_id: z.ZodNumber;
+        positions: z.ZodArray<z.ZodObject<{
+            booking_id: z.ZodNumber;
+            license_plate: z.ZodString;
+            vehicle_type: z.ZodEnum<{
+                PL: VehicleType.PL;
+                VUL: VehicleType.VUL;
+                VL: VehicleType.VL;
+            }>;
+            company_name: z.ZodString;
+            stand_number: z.ZodOptional<z.ZodString>;
+            state: z.ZodEnum<{
+                booked: VehicleState.BOOKED;
+                approaching: VehicleState.APPROACHING;
+                at_gate: VehicleState.AT_GATE;
+                entering: VehicleState.ENTERING;
+                parked: VehicleState.PARKED;
+                departing: VehicleState.DEPARTING;
+                at_exit: VehicleState.AT_EXIT;
+                exited: VehicleState.EXITED;
+                historical: VehicleState.HISTORICAL;
+            }>;
+            position: z.ZodObject<{
+                x: z.ZodNumber;
+                y: z.ZodNumber;
+                heading: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strip>;
+            speed_kmh: z.ZodOptional<z.ZodNumber>;
+            parking_area_id: z.ZodOptional<z.ZodNumber>;
+            parking_area_name: z.ZodOptional<z.ZodString>;
+            entry_time: z.ZodNullable<z.ZodString>;
+            last_updated: z.ZodString;
+            source: z.ZodEnum<{
+                gps: PositionSource.GPS;
+                simulated: PositionSource.SIMULATED;
+                inferred: PositionSource.INFERRED;
+                manual: PositionSource.MANUAL;
+            }>;
+        }, z.core.$strip>>;
+        total_count: z.ZodNumber;
+        timestamp: z.ZodString;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type GetVehiclePositionsResponse = z.infer<typeof getVehiclePositionsResponseSchema>;
+export declare const eventIdParamsSchema: z.ZodObject<{
+    eventId: z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<number, string>>, z.ZodNumber>;
+}, z.core.$strip>;
+export type EventIdParams = z.infer<typeof eventIdParamsSchema>;