@venulog/phasing-engine-schemas 0.13.3 → 0.13.4-alpha.1

package/dist/enums/accessEventType.d.ts

@@ -3,6 +3,8 @@ export declare enum AccessEventType {
     SCAN = "scan",// QR/badge scanned
     ENTRY = "entry",// Vehicle entered through gate
     EXIT = "exit",// Vehicle exited through gate
-    DENIED = "denied"
+    DENIED = "denied",// Access denied (invalid badge, wrong time, etc.)
+    PARKED = "parked",// Vehicle parked in assigned spot
+    DEPARTED = "departed"
 }
 export declare const ACCESS_EVENT_TYPE_LABELS: Record<AccessEventType, string>;

package/dist/enums/accessEventType.js

@@ -6,12 +6,16 @@ export var AccessEventType;
     AccessEventType["SCAN"] = "scan";
     AccessEventType["ENTRY"] = "entry";
     AccessEventType["EXIT"] = "exit";
-    AccessEventType["DENIED"] = "denied"; // Access denied (invalid badge, wrong time, etc.)
+    AccessEventType["DENIED"] = "denied";
+    AccessEventType["PARKED"] = "parked";
+    AccessEventType["DEPARTED"] = "departed"; // Vehicle departed from the site
 })(AccessEventType || (AccessEventType = {}));
 export const ACCESS_EVENT_TYPE_LABELS = {
     [AccessEventType.APPROACH]: 'Approach Detected',
     [AccessEventType.SCAN]: 'Badge Scanned',
     [AccessEventType.ENTRY]: 'Entry Confirmed',
     [AccessEventType.EXIT]: 'Exit Confirmed',
-    [AccessEventType.DENIED]: 'Access Denied'
+    [AccessEventType.DENIED]: 'Access Denied',
+    [AccessEventType.PARKED]: 'Parked in Spot',
+    [AccessEventType.DEPARTED]: 'Departed from the Site'
 };

package/dist/enums/index.d.ts

@@ -7,3 +7,4 @@ export * from './accessEventType.js';
 export * from './positionSource.js';
 export * from './cameraTrigger.js';
 export * from './simulationMode.js';
+export * from './vehicleAccessAction.js';

package/dist/enums/index.js

@@ -8,3 +8,4 @@ export * from './accessEventType.js';
 export * from './positionSource.js';
 export * from './cameraTrigger.js';
 export * from './simulationMode.js';
+export * from './vehicleAccessAction.js';

package/dist/enums/vehicleAccessAction.d.ts

@@ -0,0 +1,7 @@
+export declare enum VehicleAccessAction {
+    ENTERING_BUFFER = "entering_buffer",// PL vehicle enters Buffer Parking
+    EXIT_BUFFER = "exit_buffer",// PL vehicle exits Buffer Parking
+    ENTERING_EVENT_SITE = "entering_event_site",// PL vehicle enters the Event Site
+    EXIT_EVENT_SITE = "exit_event_site"
+}
+export declare const VEHICLE_ACCESS_ACTION_LABELS: Record<VehicleAccessAction, string>;

package/dist/enums/vehicleAccessAction.js

@@ -0,0 +1,15 @@
+// Vehicle access action enumeration for PL vehicle tracking
+// Defines the different checkpoint actions for heavy vehicles (PL) during event logistics
+export var VehicleAccessAction;
+(function (VehicleAccessAction) {
+    VehicleAccessAction["ENTERING_BUFFER"] = "entering_buffer";
+    VehicleAccessAction["EXIT_BUFFER"] = "exit_buffer";
+    VehicleAccessAction["ENTERING_EVENT_SITE"] = "entering_event_site";
+    VehicleAccessAction["EXIT_EVENT_SITE"] = "exit_event_site"; // PL vehicle exits the Event Site
+})(VehicleAccessAction || (VehicleAccessAction = {}));
+export const VEHICLE_ACCESS_ACTION_LABELS = {
+    [VehicleAccessAction.ENTERING_BUFFER]: 'Entering Buffer Parking',
+    [VehicleAccessAction.EXIT_BUFFER]: 'Exit Buffer Parking',
+    [VehicleAccessAction.ENTERING_EVENT_SITE]: 'Entering Event Site',
+    [VehicleAccessAction.EXIT_EVENT_SITE]: 'Exit Event Site'
+};

package/dist/eventPhase.d.ts

@@ -0,0 +1,101 @@
+import { z } from './zod.js';
+/**
+ * Core event phase item schema matching database structure
+ */
+export declare const eventPhaseItemSchema: z.ZodObject<{
+    id: z.ZodNumber;
+    event_id: z.ZodNumber;
+    layer_id: z.ZodNumber;
+    parking_area_id: z.ZodNumber;
+    name: z.ZodNullable<z.ZodString>;
+    is_active: z.ZodBoolean;
+    created_at: z.ZodString;
+    updated_at: z.ZodString;
+    created_by: z.ZodNullable<z.ZodString>;
+    updated_by: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+export declare const getEventPhasesDataSchema: z.ZodObject<{
+    event_id: z.ZodNumber;
+    phases: z.ZodArray<z.ZodObject<{
+        id: z.ZodNumber;
+        event_id: z.ZodNumber;
+        layer_id: z.ZodNumber;
+        parking_area_id: z.ZodNumber;
+        name: z.ZodNullable<z.ZodString>;
+        is_active: z.ZodBoolean;
+        created_at: z.ZodString;
+        updated_at: z.ZodString;
+        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 getEventPhasesResponseSchema: z.ZodObject<{
+    success: z.ZodBoolean;
+    data: z.ZodObject<{
+        event_id: z.ZodNumber;
+        phases: z.ZodArray<z.ZodObject<{
+            id: z.ZodNumber;
+            event_id: z.ZodNumber;
+            layer_id: z.ZodNumber;
+            parking_area_id: z.ZodNumber;
+            name: z.ZodNullable<z.ZodString>;
+            is_active: z.ZodBoolean;
+            created_at: z.ZodString;
+            updated_at: z.ZodString;
+            created_by: z.ZodNullable<z.ZodString>;
+            updated_by: z.ZodNullable<z.ZodString>;
+        }, z.core.$strip>>;
+        total_count: z.ZodNumber;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export declare const bulkUpsertEventPhasesBodySchema: z.ZodObject<{
+    event_id: z.ZodNumber;
+    phases: z.ZodArray<z.ZodObject<{
+        layer_id: z.ZodNumber;
+        parking_area_id: z.ZodNumber;
+        name: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const bulkUpsertEventPhasesDataSchema: z.ZodObject<{
+    event_id: z.ZodNumber;
+    total_upserted: z.ZodNumber;
+    upserted_phases: z.ZodArray<z.ZodObject<{
+        id: z.ZodNumber;
+        event_id: z.ZodNumber;
+        layer_id: z.ZodNumber;
+        parking_area_id: z.ZodNumber;
+        name: z.ZodNullable<z.ZodString>;
+        is_active: z.ZodBoolean;
+        created_at: z.ZodString;
+        updated_at: z.ZodString;
+        created_by: z.ZodNullable<z.ZodString>;
+        updated_by: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const bulkUpsertEventPhasesResponseSchema: z.ZodObject<{
+    success: z.ZodBoolean;
+    message: z.ZodString;
+    data: z.ZodObject<{
+        event_id: z.ZodNumber;
+        total_upserted: z.ZodNumber;
+        upserted_phases: z.ZodArray<z.ZodObject<{
+            id: z.ZodNumber;
+            event_id: z.ZodNumber;
+            layer_id: z.ZodNumber;
+            parking_area_id: z.ZodNumber;
+            name: z.ZodNullable<z.ZodString>;
+            is_active: z.ZodBoolean;
+            created_at: z.ZodString;
+            updated_at: z.ZodString;
+            created_by: z.ZodNullable<z.ZodString>;
+            updated_by: z.ZodNullable<z.ZodString>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type EventPhaseItem = z.infer<typeof eventPhaseItemSchema>;
+export type GetEventPhasesData = z.infer<typeof getEventPhasesDataSchema>;
+export type GetEventPhasesResponse = z.infer<typeof getEventPhasesResponseSchema>;
+export type BulkUpsertEventPhasesBody = z.infer<typeof bulkUpsertEventPhasesBodySchema>;
+export type BulkUpsertEventPhasesData = z.infer<typeof bulkUpsertEventPhasesDataSchema>;
+export type BulkUpsertEventPhasesResponse = z.infer<typeof bulkUpsertEventPhasesResponseSchema>;

package/dist/eventPhase.js

@@ -0,0 +1,117 @@
+// packages/phasing-schemas/src/eventPhase.ts
+import { z } from './zod.js';
+import { createSuccessResponseSchema, createMessageDataResponseSchema } from './common.js';
+// ------------------------------
+// Event Phase Schemas
+// ------------------------------
+/**
+ * Core event phase item schema matching database structure
+ */
+export const eventPhaseItemSchema = z
+    .object({
+    id: z.number().int().positive().openapi({
+        description: 'Event phase ID',
+        example: 1
+    }),
+    event_id: z.number().int().positive().openapi({
+        description: 'Event ID this phase belongs to',
+        example: 1
+    }),
+    layer_id: z.number().int().positive().openapi({
+        description: 'Parking area layer ID linked to this phase',
+        example: 2
+    }),
+    parking_area_id: z.number().int().positive().openapi({
+        description: 'Parking area ID linked to this phase',
+        example: 12
+    }),
+    name: z.string().nullable().openapi({
+        description: 'Optional label for this phase link',
+        example: 'Arrival Wave'
+    }),
+    is_active: z.boolean().openapi({
+        description: 'Whether the phase link is active',
+        example: true
+    }),
+    created_at: z.string().openapi({
+        description: 'Creation timestamp (ISO 8601)',
+        example: '2026-01-06T10:30:00Z'
+    }),
+    updated_at: z.string().openapi({
+        description: 'Last update timestamp (ISO 8601)',
+        example: '2026-01-06T10:30:00Z'
+    }),
+    created_by: z.string().uuid().nullable().openapi({
+        description: 'UUID of user who created this phase link',
+        example: '550e8400-e29b-41d4-a716-446655440000'
+    }),
+    updated_by: z.string().uuid().nullable().openapi({
+        description: 'UUID of user who last updated this phase link',
+        example: '550e8400-e29b-41d4-a716-446655440000'
+    })
+})
+    .openapi('EventPhaseItem');
+// ------------------------------
+// Get Event Phases Response Schemas
+// ------------------------------
+export const getEventPhasesDataSchema = z
+    .object({
+    event_id: z.number().openapi({
+        description: 'ID of the event',
+        example: 1
+    }),
+    phases: z.array(eventPhaseItemSchema).openapi({
+        description: 'List of phase links for the event'
+    }),
+    total_count: z.number().openapi({
+        description: 'Total number of phase links',
+        example: 3
+    })
+})
+    .openapi('GetEventPhasesData');
+export const getEventPhasesResponseSchema = createSuccessResponseSchema(getEventPhasesDataSchema, 'GetEventPhasesResponse', 'Event phases for the event');
+// ------------------------------
+// Bulk Upsert Event Phases Schemas
+// ------------------------------
+export const bulkUpsertEventPhasesBodySchema = z
+    .object({
+    event_id: z.number().int().positive().openapi({
+        description: 'ID of the event',
+        example: 1
+    }),
+    phases: z
+        .array(z.object({
+        layer_id: z.number().int().positive().openapi({
+            description: 'Parking area layer ID',
+            example: 2
+        }),
+        parking_area_id: z.number().int().positive().openapi({
+            description: 'Parking area ID',
+            example: 12
+        }),
+        name: z.string().max(255).nullable().optional().openapi({
+            description: 'Optional label for this phase link',
+            example: 'Arrival Wave'
+        })
+    }))
+        .openapi({
+        description: 'Array of event phase links to create'
+    })
+})
+    .openapi('BulkUpsertEventPhasesBody');
+export const bulkUpsertEventPhasesDataSchema = z
+    .object({
+    event_id: z.number().openapi({
+        description: 'ID of the event',
+        example: 1
+    }),
+    total_upserted: z.number().openapi({
+        description: 'Total number of phase links successfully upserted',
+        example: 3
+    }),
+    upserted_phases: z.array(eventPhaseItemSchema).openapi({
+        description: 'Array of successfully upserted phase links'
+    })
+})
+    .openapi('BulkUpsertEventPhasesData');
+export const bulkUpsertEventPhasesResponseSchema = createMessageDataResponseSchema(bulkUpsertEventPhasesDataSchema, 'BulkUpsertEventPhasesResponse', 'Event phases upserted successfully', 'Details of the upserted phase links');

package/dist/eventSitePlanCalibration.d.ts

@@ -0,0 +1,118 @@
+import { z } from './zod.js';
+export declare const eventSitePlanCalibrationAnchorSchema: z.ZodObject<{
+    id: z.ZodNumber;
+    event_id: z.ZodNumber;
+    name: z.ZodString;
+    latitude: z.ZodNumber;
+    longitude: z.ZodNumber;
+    site_plan_x: z.ZodNumber;
+    site_plan_y: z.ZodNumber;
+    is_active: z.ZodBoolean;
+    created_at: z.ZodString;
+    updated_at: z.ZodString;
+    created_by: z.ZodNullable<z.ZodString>;
+    updated_by: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+export declare const getEventSitePlanCalibrationsQuerySchema: z.ZodObject<{
+    eventId: z.ZodPipe<z.ZodString, z.ZodTransform<number, string>>;
+}, z.core.$strip>;
+export declare const getEventSitePlanCalibrationsDataSchema: z.ZodObject<{
+    event_id: z.ZodNumber;
+    anchors: z.ZodArray<z.ZodObject<{
+        id: z.ZodNumber;
+        event_id: z.ZodNumber;
+        name: z.ZodString;
+        latitude: z.ZodNumber;
+        longitude: z.ZodNumber;
+        site_plan_x: z.ZodNumber;
+        site_plan_y: z.ZodNumber;
+        is_active: z.ZodBoolean;
+        created_at: z.ZodString;
+        updated_at: z.ZodString;
+        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 getEventSitePlanCalibrationsResponseSchema: z.ZodObject<{
+    success: z.ZodBoolean;
+    data: z.ZodObject<{
+        event_id: z.ZodNumber;
+        anchors: z.ZodArray<z.ZodObject<{
+            id: z.ZodNumber;
+            event_id: z.ZodNumber;
+            name: z.ZodString;
+            latitude: z.ZodNumber;
+            longitude: z.ZodNumber;
+            site_plan_x: z.ZodNumber;
+            site_plan_y: z.ZodNumber;
+            is_active: z.ZodBoolean;
+            created_at: z.ZodString;
+            updated_at: z.ZodString;
+            created_by: z.ZodNullable<z.ZodString>;
+            updated_by: z.ZodNullable<z.ZodString>;
+        }, z.core.$strip>>;
+        total_count: z.ZodNumber;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export declare const bulkUpsertEventSitePlanCalibrationsBodySchema: z.ZodObject<{
+    event_id: z.ZodNumber;
+    anchors: z.ZodArray<z.ZodObject<{
+        id: z.ZodOptional<z.ZodNumber>;
+        name: z.ZodString;
+        latitude: z.ZodNumber;
+        longitude: z.ZodNumber;
+        site_plan_x: z.ZodNumber;
+        site_plan_y: z.ZodNumber;
+    }, z.core.$strip>>;
+    deleted_anchor_ids: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodNumber>>>;
+}, z.core.$strip>;
+export declare const bulkUpsertEventSitePlanCalibrationsDataSchema: z.ZodObject<{
+    event_id: z.ZodNumber;
+    total_upserted: z.ZodNumber;
+    total_deactivated: z.ZodNumber;
+    upserted_anchors: z.ZodArray<z.ZodObject<{
+        id: z.ZodNumber;
+        event_id: z.ZodNumber;
+        name: z.ZodString;
+        latitude: z.ZodNumber;
+        longitude: z.ZodNumber;
+        site_plan_x: z.ZodNumber;
+        site_plan_y: z.ZodNumber;
+        is_active: z.ZodBoolean;
+        created_at: z.ZodString;
+        updated_at: z.ZodString;
+        created_by: z.ZodNullable<z.ZodString>;
+        updated_by: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const bulkUpsertEventSitePlanCalibrationsResponseSchema: z.ZodObject<{
+    success: z.ZodBoolean;
+    message: z.ZodString;
+    data: z.ZodObject<{
+        event_id: z.ZodNumber;
+        total_upserted: z.ZodNumber;
+        total_deactivated: z.ZodNumber;
+        upserted_anchors: z.ZodArray<z.ZodObject<{
+            id: z.ZodNumber;
+            event_id: z.ZodNumber;
+            name: z.ZodString;
+            latitude: z.ZodNumber;
+            longitude: z.ZodNumber;
+            site_plan_x: z.ZodNumber;
+            site_plan_y: z.ZodNumber;
+            is_active: z.ZodBoolean;
+            created_at: z.ZodString;
+            updated_at: z.ZodString;
+            created_by: z.ZodNullable<z.ZodString>;
+            updated_by: z.ZodNullable<z.ZodString>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type EventSitePlanCalibrationAnchor = z.infer<typeof eventSitePlanCalibrationAnchorSchema>;
+export type GetEventSitePlanCalibrationsQuery = z.infer<typeof getEventSitePlanCalibrationsQuerySchema>;
+export type GetEventSitePlanCalibrationsData = z.infer<typeof getEventSitePlanCalibrationsDataSchema>;
+export type GetEventSitePlanCalibrationsResponse = z.infer<typeof getEventSitePlanCalibrationsResponseSchema>;
+export type BulkUpsertEventSitePlanCalibrationsBody = z.infer<typeof bulkUpsertEventSitePlanCalibrationsBodySchema>;
+export type BulkUpsertEventSitePlanCalibrationsData = z.infer<typeof bulkUpsertEventSitePlanCalibrationsDataSchema>;
+export type BulkUpsertEventSitePlanCalibrationsResponse = z.infer<typeof bulkUpsertEventSitePlanCalibrationsResponseSchema>;

package/dist/eventSitePlanCalibration.js

@@ -0,0 +1,148 @@
+// packages/phasing-schemas/src/eventSitePlanCalibration.ts
+import { z } from './zod.js';
+import { createSuccessResponseSchema, createMessageDataResponseSchema } from './common.js';
+export const eventSitePlanCalibrationAnchorSchema = z
+    .object({
+    id: z.number().int().positive().openapi({
+        description: 'Calibration anchor ID',
+        example: 12
+    }),
+    event_id: z.number().int().positive().openapi({
+        description: 'Event ID this anchor belongs to',
+        example: 77
+    }),
+    name: z.string().min(1).openapi({
+        description: 'Readable anchor name (e.g., Gate A)',
+        example: 'Gate A'
+    }),
+    latitude: z.number().min(-90).max(90).openapi({
+        description: 'Latitude in decimal degrees',
+        example: 48.86245
+    }),
+    longitude: z.number().min(-180).max(180).openapi({
+        description: 'Longitude in decimal degrees',
+        example: 2.28791
+    }),
+    site_plan_x: z.number().min(0).max(100).openapi({
+        description: 'Horizontal position on the site plan (0-100%)',
+        example: 6.25
+    }),
+    site_plan_y: z.number().min(0).max(100).openapi({
+        description: 'Vertical position on the site plan (0-100%)',
+        example: 52.1
+    }),
+    is_active: z.boolean().openapi({
+        description: 'Whether this anchor is active',
+        example: true
+    }),
+    created_at: z.string().openapi({
+        description: 'Creation timestamp (ISO 8601)'
+    }),
+    updated_at: z.string().openapi({
+        description: 'Last update timestamp (ISO 8601)'
+    }),
+    created_by: z.string().uuid().nullable().openapi({
+        description: 'User who created the anchor',
+        example: '550e8400-e29b-41d4-a716-446655440000'
+    }),
+    updated_by: z.string().uuid().nullable().openapi({
+        description: 'User who last updated the anchor',
+        example: '550e8400-e29b-41d4-a716-446655440000'
+    })
+})
+    .openapi('EventSitePlanCalibrationAnchor');
+export const getEventSitePlanCalibrationsQuerySchema = 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: 'Event ID',
+        example: '77'
+    })
+})
+    .openapi('GetEventSitePlanCalibrationsQuery');
+export const getEventSitePlanCalibrationsDataSchema = z
+    .object({
+    event_id: z.number().int().positive().openapi({
+        description: 'ID of the event',
+        example: 77
+    }),
+    anchors: z.array(eventSitePlanCalibrationAnchorSchema).openapi({
+        description: 'List of calibration anchors for the event'
+    }),
+    total_count: z.number().int().nonnegative().openapi({
+        description: 'Total anchors returned',
+        example: 3
+    })
+})
+    .openapi('GetEventSitePlanCalibrationsData');
+export const getEventSitePlanCalibrationsResponseSchema = createSuccessResponseSchema(getEventSitePlanCalibrationsDataSchema, 'GetEventSitePlanCalibrationsResponse', 'Event site plan calibration anchors');
+const calibrationAnchorInputSchema = z.object({
+    id: z.number().int().positive().optional().openapi({
+        description: 'Existing anchor ID (omit for new anchors)'
+    }),
+    name: z.string().min(1, 'Name is required').max(255).openapi({
+        description: 'Anchor name',
+        example: 'Gate A'
+    }),
+    latitude: z.number().min(-90).max(90).openapi({
+        description: 'Latitude in decimal degrees',
+        example: 48.86245
+    }),
+    longitude: z.number().min(-180).max(180).openapi({
+        description: 'Longitude in decimal degrees',
+        example: 2.28791
+    }),
+    site_plan_x: z.number().min(0).max(100).openapi({
+        description: 'Horizontal percentage on the site plan',
+        example: 6.2
+    }),
+    site_plan_y: z.number().min(0).max(100).openapi({
+        description: 'Vertical percentage on the site plan',
+        example: 52.0
+    })
+});
+export const bulkUpsertEventSitePlanCalibrationsBodySchema = z
+    .object({
+    event_id: z.number().int().positive().openapi({
+        description: 'ID of the event',
+        example: 77
+    }),
+    anchors: z.array(calibrationAnchorInputSchema).min(0).openapi({
+        description: 'Anchors to create or update'
+    }),
+    deleted_anchor_ids: z
+        .array(z.number().int().positive())
+        .optional()
+        .default([])
+        .openapi({
+        description: 'IDs of anchors to deactivate',
+        example: [3, 5]
+    })
+})
+    .openapi('BulkUpsertEventSitePlanCalibrationsBody');
+export const bulkUpsertEventSitePlanCalibrationsDataSchema = z
+    .object({
+    event_id: z.number().int().positive().openapi({
+        description: 'Event ID',
+        example: 77
+    }),
+    total_upserted: z.number().int().nonnegative().openapi({
+        description: 'Anchors created or updated',
+        example: 2
+    }),
+    total_deactivated: z.number().int().nonnegative().openapi({
+        description: 'Anchors deactivated',
+        example: 1
+    }),
+    upserted_anchors: z.array(eventSitePlanCalibrationAnchorSchema).openapi({
+        description: 'Details of anchors returned from Supabase'
+    })
+})
+    .openapi('BulkUpsertEventSitePlanCalibrationsData');
+export const bulkUpsertEventSitePlanCalibrationsResponseSchema = createMessageDataResponseSchema(bulkUpsertEventSitePlanCalibrationsDataSchema, 'BulkUpsertEventSitePlanCalibrationsResponse', 'Calibration anchors upserted successfully', 'Details about the upserted calibration anchors');

package/dist/index.d.ts

@@ -5,6 +5,8 @@ export * from './parkingBooking.js';
 export * from './parkingArea.js';
 export * from './parkingAreaLayer.js';
 export * from './parkingAreaAccess.js';
+export * from './eventSitePlanCalibration.js';
+export * from './eventPhase.js';
 export * from './event.js';
 export * from './accessToken.js';
 export * from './vehiclePosition.js';

package/dist/index.js

@@ -6,6 +6,8 @@ export * from './parkingBooking.js';
 export * from './parkingArea.js';
 export * from './parkingAreaLayer.js';
 export * from './parkingAreaAccess.js';
+export * from './eventSitePlanCalibration.js';
+export * from './eventPhase.js';
 export * from './event.js';
 export * from './accessToken.js';
 export * from './vehiclePosition.js';