camstreamerlib 4.0.0-beta.9 → 4.0.0-beta.91

package/esm/types/PlaneTrackerAPI.js

@@ -0,0 +1,330 @@
+import { z } from 'zod';
+export const wsAliasResponseSchema = z.object({
+    alias: z.string(),
+    ws: z.string(),
+    ws_initial_message: z.string(),
+});
+export const connectionSchema = z.object({
+    protocol: z.union([z.literal('http'), z.literal('https'), z.literal('https_insecure')]),
+    ip: z.union([z.string().ip(), z.literal('')]),
+    port: z.number().positive().lt(65535),
+    user: z.string(),
+    pass: z.string(),
+});
+export const widgetSchema = z.object({
+    enabled: z.boolean().default(true),
+    coord: z.union([
+        z.literal('top_left'),
+        z.literal('top_right'),
+        z.literal('bottom_left'),
+        z.literal('bottom_right'),
+    ]),
+    posX: z.number().nonnegative(),
+    posY: z.number().nonnegative(),
+    scale: z.number().positive(),
+});
+const labelOptionsSchema = z.union([
+    z.literal('blank'),
+    z.literal('registration'),
+    z.literal('call_sign'),
+    z.literal('flight_number'),
+    z.literal('icao'),
+]);
+const identificationLabelSchema = z.object({
+    firstRow: labelOptionsSchema,
+    secondRow: labelOptionsSchema,
+    thirdRow: labelOptionsSchema,
+    fourthRow: labelOptionsSchema,
+    opacity: z.number().positive(),
+});
+export const cameraSettingsSchema = z.object({
+    units: z.union([z.literal('metric'), z.literal('imperial')]).default('imperial'),
+    adsbSource: z
+        .object({
+        ip: z.union([z.string().ip(), z.literal('')]),
+        port: z.number().positive().lt(65535),
+    })
+        .default({ ip: '', port: 30334 }),
+    camera: connectionSchema.default({
+        protocol: 'http',
+        ip: '127.0.0.1',
+        port: 80,
+        user: 'root',
+        pass: '',
+    }),
+    cameraCalibrationProcessConfig: z
+        .object({
+        nightSkyCalibrationEnabled: z.boolean(),
+        scheduleNightSkyCalibrationTimestamp: z.number(),
+        focusCalibrationPoints: z.string().default(''),
+    })
+        .default({
+        nightSkyCalibrationEnabled: false,
+        scheduleNightSkyCalibrationTimestamp: 0,
+        focusCalibrationPoints: '',
+    }),
+    cameraConfig: z
+        .object({
+        maxZoomLevel: z.number().optional(),
+        defaultCaptureSizeMeters: z.number().positive().default(120),
+        captureSizeExtensionMeters: z.number().positive().default(80),
+    })
+        .default({
+        maxZoomLevel: 30,
+        defaultCaptureSizeMeters: 120,
+        captureSizeExtensionMeters: 80,
+    }),
+    stream: z
+        .object({
+        width: z.number().positive(),
+        height: z.number().positive(),
+    })
+        .default({ width: 1920, height: 1080 }),
+    imageConfig: z
+        .object({
+        dayAperture: z.number().nonnegative().min(0).max(100),
+        nightAperture: z.number().nonnegative().min(0).max(100),
+        maxGain: z.number().nonnegative().min(0).max(100).default(100),
+    })
+        .default({ dayAperture: 50, nightAperture: 0, maxGain: 100 }),
+    airportConfig: z
+        .object({
+        icao: z.string().default(''),
+        centerLat: z.number(),
+        centerLon: z.number(),
+        radius: z.number().nonnegative().default(10000),
+    })
+        .default({
+        icao: '',
+        centerLat: 0,
+        centerLon: 0,
+        radius: 10000,
+    }),
+    trackingConfig: z
+        .object({
+        prioritizeEmergency: z.boolean(),
+        trackingZoneWeightIncrease: z.number().int().nonnegative().default(0),
+        guardTourEnabled: z.boolean().default(false),
+        guardTourId: z.number().int().nonnegative().default(0),
+    })
+        .default({ prioritizeEmergency: true, guardTourEnabled: false, guardTourId: 0 }),
+    overlayText: z
+        .object({
+        displayIcao: z.boolean().optional(),
+        displayRegistration: z.boolean().optional(),
+        displayFlightNumber: z.boolean().optional(),
+        displayAltitude: z.boolean().optional(),
+        displayVelocity: z.boolean().optional(),
+        displayDistance: z.boolean().optional(),
+        displayFOV: z.boolean().optional(),
+        displayPTError: z.boolean().optional(),
+        displayPTZSpeed: z.boolean().optional(),
+        displayVelocityData: z.boolean().optional(),
+        displaySignalQuality: z.boolean().optional(),
+        displayAutoTrackingInfo: z.boolean().optional(),
+        displayGPSCoords: z.boolean().optional(),
+        displayVapixQuery: z.boolean().optional(),
+        displayFocus: z.boolean().optional(),
+        displayAperture: z.boolean().optional(),
+        displaySunDistance: z.boolean().optional(),
+        displayTickTime: z.boolean().optional(),
+        displayAircraftInfo: z.boolean().optional(),
+    })
+        .optional(),
+    widget: widgetSchema.default({
+        enabled: true,
+        coord: 'top_right',
+        posX: 10,
+        posY: 10,
+        scale: 100,
+    }),
+    airportWidget: widgetSchema.default({
+        enabled: true,
+        coord: 'top_left',
+        posX: 10,
+        posY: 10,
+        scale: 100,
+    }),
+    fr24FlightInfoSource: z
+        .object({
+        enabled: z.boolean().default(false),
+        priority: z.number().int().positive().default(1),
+        apiToken: z.string().default(''),
+        validateFlights: z.boolean().default(true),
+    })
+        .default({
+        enabled: false,
+        priority: 1,
+        apiToken: '',
+        validateFlights: true,
+    }),
+    radarcapeFlightInfoSource: z
+        .object({
+        enabled: z.boolean().default(false),
+        priority: z.number().int().positive().default(2),
+        ip: z.union([z.string().ip(), z.literal('')]).default(''),
+        port: z.number().positive().lt(65535).default(80),
+    })
+        .default({
+        enabled: false,
+        priority: 2,
+        ip: '',
+        port: 80,
+    }),
+    identificationLabel: identificationLabelSchema.default({
+        firstRow: 'registration',
+        secondRow: 'blank',
+        thirdRow: 'blank',
+        fourthRow: 'blank',
+        opacity: 30,
+    }),
+    acs: connectionSchema
+        .extend({
+        enabled: z.boolean(),
+        sourceKey: z.string(),
+    })
+        .default({
+        enabled: false,
+        protocol: 'https_insecure',
+        ip: '',
+        port: 29204,
+        user: '',
+        pass: '',
+        sourceKey: '',
+    }),
+    genetec: connectionSchema
+        .extend({
+        enabled: z.boolean(),
+        baseUri: z.string().default(''),
+        appId: z.string().default(''),
+        cameraList: z.string().array().default([]),
+    })
+        .default({
+        enabled: false,
+        protocol: 'http',
+        ip: '',
+        port: 4590,
+        user: '',
+        pass: '',
+        baseUri: 'WebSdk',
+        appId: '',
+        cameraList: [],
+    }),
+    camstreamerIntegration: z
+        .object({
+        adPlacementEnabled: z.boolean(),
+        adMinIntervalSec: z.number().int().nonnegative(),
+        adShortDurationSec: z.number().int().nonnegative(),
+        adLongDurationSec: z.number().int().nonnegative(),
+    })
+        .default({
+        adPlacementEnabled: false,
+        adMinIntervalSec: 1800,
+        adShortDurationSec: 10,
+        adLongDurationSec: 30,
+    }),
+});
+export const serverSettingsSchema = z.object({
+    cameraCalibration: z
+        .object({
+        posLat: z.number(),
+        posLon: z.number(),
+        geoidHN: z.number(),
+        altitudeAmsl: z.number(),
+        rotationEast: z.number(),
+        rotationNorth: z.number(),
+        rotationUp: z.number(),
+        tiltTransformationCoefA: z.number(),
+        tiltCameraKnownPoint: z.number(),
+        tiltRealKnownPoint: z.number(),
+        panErrorCorrection: z
+            .array(z.object({
+            cameraPan: z.number(),
+            realPan: z.number(),
+        }))
+            .default([]),
+    })
+        .default({
+        posLat: 50,
+        posLon: 14,
+        geoidHN: 45,
+        altitudeAmsl: 372,
+        rotationEast: 0,
+        rotationNorth: 0,
+        rotationUp: 0,
+        tiltTransformationCoefA: 1.0,
+        tiltCameraKnownPoint: 90,
+        tiltRealKnownPoint: 90,
+        panErrorCorrection: [],
+    }),
+});
+export const getIcaoSchema = z.object({
+    icao: z.string(),
+});
+export const trackingModeSchema = z.object({
+    mode: z.union([z.literal('MANUAL'), z.literal('AUTOMATIC')]),
+});
+export const flightInfoSchema = z.object({
+    callsign: z.string().optional(),
+    flightNumber: z.string().optional(),
+    registration: z.string().optional(),
+    aircraftType: z.string().optional(),
+    airlines: z.string().optional(),
+    originAirport: z
+        .object({
+        icao: z.string().optional(),
+        iata: z.string().optional(),
+        city: z.string().optional(),
+    })
+        .optional(),
+    destinationAirport: z.object({
+        icao: z.string().optional(),
+        iata: z.string().optional(),
+        city: z.string().optional(),
+    }),
+    flightImages: z
+        .array(z.object({
+        src: z.string().optional(),
+        photographer: z.string().optional(),
+    }))
+        .optional(),
+});
+export const typePriorityListSchema = z.object({
+    typePriorityList: z.array(z.string()).default([]),
+});
+export const priorityListSchema = z.object({
+    priorityList: z.array(z.string()).default([]),
+});
+export const whiteListSchema = z.object({
+    whiteList: z.array(z.string()).default([]),
+});
+export const blackListSchema = z.object({
+    blackList: z.array(z.string()).default([]),
+});
+export const mapTypeSchema = z.enum(['roadmap', 'satellite']);
+export const mapInfoSchema = z.object({
+    minZoom: z.number().nonnegative(),
+    maxZoom: z.number().nonnegative(),
+    mapTypes: z.array(mapTypeSchema),
+    tileSize: z.number().nonnegative(),
+});
+export const zonesSchema = z.object({
+    zones: z
+        .array(z.object({
+        enabled: z.boolean().default(true),
+        name: z.string().optional(),
+        area: z
+            .array(z.object({
+            lat: z.number(),
+            lon: z.number(),
+        }))
+            .nonempty(),
+        minAltitudeAmsl: z.number().optional(),
+        maxAltitudeAmsl: z.number().optional(),
+        minSpeedKmph: z.number().optional(),
+        maxSpeedKmph: z.number().optional(),
+        flightDirection: z.enum(['all', 'arrival', 'departure']).default('all'),
+        weight: z.number(),
+    }))
+        .default([]),
+});

package/esm/types/VapixAPI.js

@@ -12,6 +12,19 @@ export const applicationSchema = z.object({
     VendorHomePage: z.string().optional(),
     LicenseName: z.string().optional(),
 });
+export const applicationListSchema = z.array(applicationSchema.extend({
+    appId: z
+        .union([
+        z.literal('CamStreamer'),
+        z.literal('CamSwitcher'),
+        z.literal('CamOverlay'),
+        z.literal('CamScripter'),
+        z.literal('PlaneTracker'),
+        z.literal('Ndihxplugin'),
+        z.literal('SportTracker'),
+    ])
+        .nullable(),
+}));
 export const APP_IDS = [
     'CamStreamer',
     'CamSwitcher',
@@ -21,14 +34,6 @@ export const APP_IDS = [
     'Ndihxplugin',
     'SportTracker',
 ];
-export const applicationListSchema = z.object({
-    reply: z.object({
-        $: z.object({ result: z.string() }),
-        application: z.array(z.object({
-            $: applicationSchema,
-        })),
-    }),
-});
 export const guardTourSchema = z.object({
     id: z.string(),
     camNbr: z.unknown(),
@@ -50,7 +55,12 @@ const audioSampleRatesSchema = z.object({
 });
 const audioSampleRatesOutSchema = audioSampleRatesSchema.transform(toCamelCaseDeep);
 export const sdCardWatchedStatuses = ['OK', 'connected', 'disconnected'];
-export const PtzOverviewSchema = z.record(z.number(), z.array(z.object({ id: z.number(), name: z.string() })));
+export const sdCardInfoSchema = z.object({
+    status: z.enum(sdCardWatchedStatuses),
+    totalSize: z.number(),
+    freeSize: z.number(),
+});
+export const ptzOverviewSchema = z.record(z.number(), z.array(z.object({ id: z.number(), name: z.string() })));
 export const cameraPTZItemDataSchema = z.object({
     pan: z.number().optional(),
     tilt: z.number().optional(),
@@ -115,9 +125,23 @@ export const dateTimeinfoSchema = z.object({
         dstEnabled: z.boolean(),
         localDateTime: z.string(),
         posixTimeZone: z.string(),
-        timeZone: z.string(),
+        timeZone: z.string().optional(),
     }),
 });
+export const timeZoneSchema = z.discriminatedUnion('status', [
+    z.object({
+        status: z.literal('success'),
+        data: z.object({
+            activeTimeZone: z.string(),
+        }),
+    }),
+    z.object({
+        status: z.literal('error'),
+        error: z.object({
+            message: z.string(),
+        }),
+    }),
+]);
 export const audioSampleRatesResponseSchema = z.object({
     data: z.object({
         encoders: z
@@ -128,3 +152,34 @@ export const audioSampleRatesResponseSchema = z.object({
             .partial(),
     }),
 });
+export const portStatusSchema = z.object({
+    port: z.string(),
+    state: z.enum(['open', 'closed']),
+    configurable: z.boolean(),
+    readonly: z.boolean().optional(),
+    usage: z.string(),
+    direction: z.enum(['input', 'output']),
+    name: z.string(),
+    normalState: z.enum(['open', 'closed']),
+});
+export const getPortsResponseSchema = z.object({
+    apiVersion: z.string(),
+    context: z.string(),
+    method: z.literal('getPorts'),
+    data: z.object({
+        numberOfPorts: z.number(),
+        items: z.array(portStatusSchema),
+    }),
+});
+export const portSetSchema = z.object({
+    port: z.string(),
+    state: z.enum(['open', 'closed']),
+    usage: z.string().optional(),
+    direction: z.enum(['input', 'output']).optional(),
+    name: z.string().optional(),
+    normalState: z.enum(['open', 'closed']).optional(),
+});
+export const portSequenceStateSchema = z.object({
+    state: z.enum(['open', 'closed']),
+    time: z.number().min(0).max(65535),
+});

package/esm/types/VapixEvents.js

@@ -0,0 +1 @@
+export {};

package/esm/types/common.js

@@ -1,8 +1,11 @@
 import { z } from 'zod';
+export const booleanSchema = z.union([z.literal(0), z.literal(1)]);
 export const audioChannelSchema = z.union([z.literal('mono'), z.literal('stereo')]);
 export const audioChannelCountSchema = z.union([z.literal(1), z.literal(2)]);
 export const h264ProfileSchema = z.union([z.literal('high'), z.literal('main'), z.literal('baseline')]);
-export const storageTypeSchema = z.union([z.literal('SD_DISK'), z.literal('FLASH')]);
+export const flashStorageTypeSchema = z.literal('FLASH');
+export const sdCardStorageTypeSchema = z.literal('SD_DISK');
+export const storageTypeSchema = z.union([sdCardStorageTypeSchema, flashStorageTypeSchema]);
 export const networkCameraListSchema = z.array(z.object({
     name: z.string(),
     ip: z.string(),

package/esm/types/ws/CamOverlayEvents.js

@@ -0,0 +1,16 @@
+import { z } from 'zod';
+const coEventsDataSchema = z.discriminatedUnion('type', [
+    z.object({ type: z.literal('authorization'), state: z.string() }),
+    z.object({
+        type: z.literal('ServiceStart'),
+        serviceId: z.number(),
+    }),
+    z.object({
+        type: z.literal('ServiceStop'),
+        serviceId: z.number(),
+    }),
+]);
+export const coEventsSchema = z.discriminatedUnion('type', [
+    z.object({ type: z.literal('init'), data: coEventsDataSchema }),
+    ...coEventsDataSchema.options,
+]);

package/esm/types/ws/CamStreamerEvents.js

@@ -0,0 +1,29 @@
+import { z } from 'zod';
+const csEventsDataSchema = z.discriminatedUnion('type', [
+    z.object({ type: z.literal('authorization'), state: z.string() }),
+    z.object({
+        type: z.literal('StreamState'),
+        streamID: z.number(),
+        enabled: z.union([z.literal(0), z.literal(1)]),
+        active: z.union([z.literal(0), z.literal(1)]),
+        automationState: z.union([z.literal(0), z.literal(1)]),
+        isStreaming: z.union([z.literal(0), z.literal(1)]),
+    }),
+    z.object({
+        type: z.literal('CS_API_SUCCESS'),
+        apiCall: z.string(),
+        message: z.string(),
+        streamID: z.string(),
+    }),
+    z.object({
+        type: z.literal('CS_API_ERROR'),
+        apiCall: z.string(),
+        message: z.string(),
+        streamID: z.string(),
+        code: z.string(),
+    }),
+]);
+export const csEventsSchema = z.discriminatedUnion('type', [
+    z.object({ type: z.literal('init'), data: csEventsDataSchema }),
+    ...csEventsDataSchema.options,
+]);

package/esm/types/ws/PlaneTrackerEvents.js

@@ -0,0 +1,204 @@
+import { z } from 'zod';
+import { trackingModeSchema, zonesSchema } from '../PlaneTrackerAPI';
+const apiFlightDataSchema = z.object({
+    icao: z.string(),
+    lat: z.number(),
+    lon: z.number(),
+    heading: z.number(),
+    groundSpeed: z.number(),
+    altitudeAMSL: z.number(),
+    cameraDistance: z.number(),
+    autoTrackingOrder: z.number(),
+    whiteListed: z.boolean(),
+    blackListed: z.boolean(),
+    priorityListed: z.boolean(),
+    typePriorityListed: z.boolean().default(false),
+    autoSelectionIgnored: z.boolean(),
+    signalQuality: z.number(),
+    emitterCategorySet: z.number().default(4),
+    emitterCategory: z.number().default(3),
+    emergencyState: z.boolean(),
+    emergencyStatusMessage: z.string(),
+});
+const apiUserSchema = z.object({
+    userId: z.string(),
+    userName: z.string(),
+    userPriority: z.number(),
+    ip: z.string(),
+});
+const apiStringUserSchema = z.object({
+    userId: z.string(),
+    userName: z.string(),
+    userPriority: z.string(),
+});
+export var PlaneTrackerWsEvents;
+(function (PlaneTrackerWsEvents) {
+    PlaneTrackerWsEvents["FLIGHT_LIST"] = "FLIGHT_LIST";
+    PlaneTrackerWsEvents["CAMERA_POSITION"] = "CAMERA_POSITION";
+    PlaneTrackerWsEvents["TRACKING_START"] = "TRACKING_START";
+    PlaneTrackerWsEvents["TRACKING_STOP"] = "TRACKING_STOP";
+    PlaneTrackerWsEvents["USER_ACTION"] = "USER_ACTION";
+    PlaneTrackerWsEvents["CONNECTED_USERS"] = "CONNECTED_USERS";
+    PlaneTrackerWsEvents["FORCE_TRACKING_STATUS"] = "FORCE_TRACKING_STATUS";
+})(PlaneTrackerWsEvents || (PlaneTrackerWsEvents = {}));
+export var PlaneTrackerUserActions;
+(function (PlaneTrackerUserActions) {
+    PlaneTrackerUserActions["TRACK_ICAO"] = "trackIcao.cgi";
+    PlaneTrackerUserActions["RESET_ICAO"] = "resetIcao.cgi";
+    PlaneTrackerUserActions["SET_PRIORITY_LIST"] = "setPriorityList.cgi";
+    PlaneTrackerUserActions["SET_TYPE_PRIORITY_LIST"] = "setTypePriorityList.cgi";
+    PlaneTrackerUserActions["SET_BLACK_LIST"] = "setBlackList.cgi";
+    PlaneTrackerUserActions["SET_WHITE_LIST"] = "setWhiteList.cgi";
+    PlaneTrackerUserActions["GO_TO_COORDINATES"] = "goToCoordinates.cgi";
+    PlaneTrackerUserActions["SET_TRACKING_MODE"] = "setTrackingMode.cgi";
+    PlaneTrackerUserActions["SET_ZONES"] = "setZones.cgi";
+    PlaneTrackerUserActions["RESET_PTZ_CALIBRATION"] = "resetPtzCalibration.cgi";
+    PlaneTrackerUserActions["LOCK_API"] = "lockApi.cgi";
+    PlaneTrackerUserActions["UNLOCK_API"] = "unlockApi.cgi";
+})(PlaneTrackerUserActions || (PlaneTrackerUserActions = {}));
+export const planeTrackerUserActionData = z.discriminatedUnion('cgi', [
+    z.object({
+        cgi: z.literal(PlaneTrackerUserActions.TRACK_ICAO),
+        ip: z.string(),
+        params: apiStringUserSchema.extend({
+            icao: z.string(),
+        }),
+    }),
+    z.object({
+        cgi: z.literal(PlaneTrackerUserActions.RESET_ICAO),
+        ip: z.string(),
+        params: apiStringUserSchema,
+    }),
+    z.object({
+        cgi: z.literal(PlaneTrackerUserActions.SET_PRIORITY_LIST),
+        ip: z.string(),
+        params: apiStringUserSchema,
+        postJsonBody: z.object({
+            priorityList: z.array(z.string()),
+        }),
+    }),
+    z.object({
+        cgi: z.literal(PlaneTrackerUserActions.SET_TYPE_PRIORITY_LIST),
+        ip: z.string(),
+        params: apiStringUserSchema,
+        postJsonBody: z.object({
+            typePriorityList: z.array(z.string()),
+        }),
+    }),
+    z.object({
+        cgi: z.literal(PlaneTrackerUserActions.SET_BLACK_LIST),
+        ip: z.string(),
+        params: apiStringUserSchema,
+        postJsonBody: z.object({
+            blackList: z.array(z.string()),
+        }),
+    }),
+    z.object({
+        cgi: z.literal(PlaneTrackerUserActions.SET_WHITE_LIST),
+        ip: z.string(),
+        params: apiStringUserSchema,
+        postJsonBody: z.object({
+            whiteList: z.array(z.string()),
+        }),
+    }),
+    z.object({
+        cgi: z.literal(PlaneTrackerUserActions.GO_TO_COORDINATES),
+        ip: z.string(),
+        params: apiStringUserSchema.extend({
+            lat: z.string(),
+            lon: z.string(),
+        }),
+    }),
+    z.object({
+        cgi: z.literal(PlaneTrackerUserActions.SET_TRACKING_MODE),
+        ip: z.string(),
+        params: apiStringUserSchema,
+        postJsonBody: trackingModeSchema,
+    }),
+    z.object({
+        cgi: z.literal(PlaneTrackerUserActions.SET_ZONES),
+        ip: z.string(),
+        params: apiStringUserSchema,
+        postJsonBody: zonesSchema,
+    }),
+    z.object({
+        cgi: z.literal(PlaneTrackerUserActions.RESET_PTZ_CALIBRATION),
+        ip: z.string(),
+        params: apiStringUserSchema,
+    }),
+    z.object({
+        cgi: z.literal(PlaneTrackerUserActions.LOCK_API),
+        ip: z.string(),
+        params: apiStringUserSchema.extend({
+            timeout: z.string(),
+        }),
+    }),
+    z.object({
+        cgi: z.literal(PlaneTrackerUserActions.UNLOCK_API),
+        ip: z.string(),
+        params: apiStringUserSchema,
+    }),
+]);
+const ptrEventsDataSchema = z.discriminatedUnion('type', [
+    z.object({
+        type: z.literal('CAMERA_POSITION'),
+        lat: z.number(),
+        lon: z.number(),
+        azimuth: z.number().min(0).max(360),
+        elevation: z.number().min(-90).max(90),
+        fov: z.number(),
+    }),
+    z.object({
+        type: z.literal('TRACKING_START'),
+        icao: z.string(),
+    }),
+    z.object({
+        type: z.literal('TRACKING_STOP'),
+    }),
+    z.object({
+        type: z.literal('FLIGHT_LIST'),
+        list: z.array(apiFlightDataSchema),
+    }),
+    z.object({
+        type: z.literal('USER_ACTION'),
+        ip: z.string(),
+        params: apiStringUserSchema.extend({
+            lat: z.string().optional(),
+            lon: z.string().optional(),
+            timeout: z.string().optional(),
+        }),
+        cgi: z.enum([
+            PlaneTrackerUserActions.TRACK_ICAO,
+            PlaneTrackerUserActions.RESET_ICAO,
+            PlaneTrackerUserActions.SET_PRIORITY_LIST,
+            PlaneTrackerUserActions.SET_TYPE_PRIORITY_LIST,
+            PlaneTrackerUserActions.SET_BLACK_LIST,
+            PlaneTrackerUserActions.SET_WHITE_LIST,
+            PlaneTrackerUserActions.GO_TO_COORDINATES,
+            PlaneTrackerUserActions.SET_TRACKING_MODE,
+            PlaneTrackerUserActions.SET_ZONES,
+            PlaneTrackerUserActions.RESET_PTZ_CALIBRATION,
+            PlaneTrackerUserActions.LOCK_API,
+            PlaneTrackerUserActions.UNLOCK_API,
+        ]),
+        postJsonBody: z.any(),
+    }),
+    z.object({
+        type: z.literal('CONNECTED_USERS'),
+        users: z.array(apiUserSchema),
+    }),
+    z.object({
+        type: z.literal('FORCE_TRACKING_STATUS'),
+        enabled: z.boolean(),
+        icao: z.string().optional(),
+    }),
+    z.object({
+        type: z.literal('API_LOCK_STATUS'),
+        isLocked: z.boolean(),
+        user: apiUserSchema.optional(),
+    }),
+]);
+export const ptrEventsSchema = z.discriminatedUnion('type', [
+    z.object({ type: z.literal('init'), data: ptrEventsDataSchema }),
+    ...ptrEventsDataSchema.options,
+]);