camstreamerlib 4.0.0-beta.16 → 4.0.0-beta.161

package/esm/types/PlaneTrackerAPI.js

@@ -0,0 +1,333 @@
+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({
+    trackingDomain: z.union([z.literal('adsb'), z.literal('dronetag')]).default('adsb'),
+    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(),
+        displayAdsbVelocityData: 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(),
+        displayAircraftInfo: z.boolean().optional(),
+        displaySunDistance: z.boolean().optional(),
+        displayTickTime: z.boolean().optional(),
+        displaySystemInfo: 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')]).default('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,20 @@ 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'),
+        z.literal('CamOverlayHtmlplugin'),
+    ])
+        .nullable(),
+}));
 export const APP_IDS = [
     'CamStreamer',
     'CamSwitcher',
@@ -19,8 +33,8 @@ export const APP_IDS = [
     'CamScripter',
     'PlaneTracker',
     'Ndihxplugin',
-    'SportTracker',
 ];
+export const ALL_APP_IDS = [...APP_IDS, 'SportTracker', 'CamOverlayHtmlplugin'];
 export const guardTourSchema = z.object({
     id: z.string(),
     camNbr: z.unknown(),
@@ -42,7 +56,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(),
@@ -107,9 +126,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
@@ -120,3 +153,40 @@ 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).optional(),
+    }),
+});
+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),
+});
+export const recordingConfigItemSchema = z.object({
+    diskid: z.string(),
+    eventid: z.string(),
+    options: z.record(z.string()),
+    profile: z.string(),
+});

package/esm/types/VapixEvents.js

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

package/esm/types/common.js

@@ -1,11 +1,26 @@
 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(),
 }));
 export const keyboardShortcutSchema = z.string().nullable();
 export const keyboardShortcutsSchema = z.record(keyboardShortcutSchema);
+export const bitrateModeSchema = z.union([z.literal('VBR'), z.literal('MBR'), z.literal('ABR')]);
+export const bitrateVapixParamsSchema = z.object({
+    bitrateMode: bitrateModeSchema,
+    maximumBitRate: z.number(),
+    retentionTime: z.number(),
+    bitRateLimit: z.number(),
+});
+export const fileSchema = typeof File !== 'undefined'
+    ? z.instanceof(File)
+    : z.custom((val) => {
+        return val !== null && typeof val === 'object' && 'name' in val && 'size' in val && 'type' in val;
+    });

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,33 @@
+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.string(),
+        isStreaming: z.boolean(),
+        active: z.boolean(),
+        enabled: z.boolean(),
+    }),
+    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(),
+    }),
+    z.object({
+        type: z.literal('PortChanged'),
+        port: z.number(),
+        value: z.boolean(),
+    }),
+]);
+export const csEventsSchema = z.discriminatedUnion('type', [
+    z.object({ type: z.literal('init'), data: csEventsDataSchema }),
+    ...csEventsDataSchema.options,
+]);