camstreamerlib 4.0.0-beta.37 → 4.0.0-beta.39

package/esm/types/PlaneTrackerAPI.js

@@ -1 +1,276 @@
-export {};
+import { z } from 'zod';
+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(),
+    })
+        .default({ nightSkyCalibrationEnabled: false, scheduleNightSkyCalibrationTimestamp: 0 }),
+    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),
+    })
+        .default({ dayAperture: 50, nightAperture: 0 }),
+    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(),
+    })
+        .default({ prioritizeEmergency: true }),
+    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: [],
+    }),
+});
+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(),
+    }),
+});
+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 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(),
+        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',
@@ -42,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(),

package/esm/types/VapixEvents.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "camstreamerlib",
-    "version": "4.0.0-beta.37",
+    "version": "4.0.0-beta.39",
     "description": "Helper library for CamStreamer ACAP applications.",
     "prettier": "@camstreamer/prettier-config",
     "engine": {

package/types/CamOverlayAPI.d.ts

@@ -1,7 +1,7 @@
 import { IClient, TBlobResponse, TResponse } from './internal/types';
-import { THttpRequestOptions, TProxyParams, TNetworkCamera } from './types/common';
+import { THttpRequestOptions, TProxyParams } from './types/common';
 import { ProxyClient } from './internal/ProxyClient';
-import { ImageType, TCoordinates, TField, TFile, TFileList, TFileType, TStorage, TStorageDataList, TService } from './types/CamOverlayAPI';
+import { ImageType, TCoordinates, TField, TFile, TFileType, TStorage, TService } from './types/CamOverlayAPI';
 export declare class CamOverlayAPI<Client extends IClient<TResponse, any>> {
     private client;
     constructor(client: Client);
@@ -10,13 +10,23 @@ export declare class CamOverlayAPI<Client extends IClient<TResponse, any>> {
     static getFilePreviewPath: (path: string) => string;
     getClient(proxyParams?: TProxyParams): Client | ProxyClient<Client>;
     checkCameraTime(options?: THttpRequestOptions): Promise<boolean>;
-    getNetworkCameraList(options?: THttpRequestOptions): Promise<TNetworkCamera[]>;
+    getNetworkCameraList(options?: THttpRequestOptions): Promise<{
+        name: string;
+        ip: string;
+    }[]>;
     wsAuthorization(options?: THttpRequestOptions): Promise<string>;
     getMjpegStreamImage(mjpegUrl: string, options?: THttpRequestOptions): Promise<TBlobResponse<Client>>;
-    listFiles(fileType: TFileType, options?: THttpRequestOptions): Promise<TFileList>;
+    listFiles(fileType: TFileType, options?: THttpRequestOptions): Promise<{
+        path: string;
+        name: string;
+        storage: "url" | "flash" | "SD0" | "ftp" | "samba";
+    }[]>;
     uploadFile(fileType: TFileType, formData: Parameters<Client['post']>[0]['data'], storage: TStorage, options?: THttpRequestOptions): Promise<void>;
     removeFile(fileType: TFileType, fileParams: TFile, options?: THttpRequestOptions): Promise<void>;
-    getFileStorage(fileType: TFileType, options?: THttpRequestOptions): Promise<TStorageDataList>;
+    getFileStorage(fileType: TFileType, options?: THttpRequestOptions): Promise<{
+        type: "url" | "flash" | "SD0" | "ftp" | "samba";
+        state: string;
+    }[]>;
     getFilePreviewFromCamera(path: string, options?: THttpRequestOptions): Promise<TBlobResponse<Client>>;
     updateInfoticker(serviceId: number, text: string, options?: THttpRequestOptions): Promise<void>;
     setEnabled(serviceId: number, enabled: boolean, options?: THttpRequestOptions): Promise<void>;
@@ -324,7 +334,7 @@ export declare class CamOverlayAPI<Client extends IClient<TResponse, any>> {
         pos_y: number;
         coordSystem: "top_left" | "top" | "top_right" | "left" | "center" | "right" | "bottom_left" | "bottom" | "bottom_right";
         scale: number;
-        font: "classic" | (string & {});
+        font: string;
         teamHomeShortname: string;
         teamGuestShortname: string;
         teamHomeBackgroundColor: string;
@@ -354,7 +364,7 @@ export declare class CamOverlayAPI<Client extends IClient<TResponse, any>> {
         pos_y: number;
         coordSystem: "top_left" | "top" | "top_right" | "left" | "center" | "right" | "bottom_left" | "bottom" | "bottom_right";
         scale: number;
-        font: "classic" | (string & {});
+        font: string;
         teamHomeShortname: string;
         teamGuestShortname: string;
         teamHomeBackgroundColor: string;
@@ -387,7 +397,7 @@ export declare class CamOverlayAPI<Client extends IClient<TResponse, any>> {
         cameraList: number[];
         zIndex: number;
         scale: number;
-        font: "classic" | (string & {});
+        font: string;
         teamHomeBackgroundColor: string;
         teamGuestBackgroundColor: string;
         teamHomeTextColor: string;
@@ -427,7 +437,7 @@ export declare class CamOverlayAPI<Client extends IClient<TResponse, any>> {
         teamGuestName: string;
         scoreVisible: boolean;
         description: string;
-        textFont: "classic" | (string & {});
+        textFont: string;
         scoreFont: "classic";
     }>;
     getServices(options?: THttpRequestOptions): Promise<({
@@ -733,7 +743,7 @@ export declare class CamOverlayAPI<Client extends IClient<TResponse, any>> {
         pos_y: number;
         coordSystem: "top_left" | "top" | "top_right" | "left" | "center" | "right" | "bottom_left" | "bottom" | "bottom_right";
         scale: number;
-        font: "classic" | (string & {});
+        font: string;
         teamHomeShortname: string;
         teamGuestShortname: string;
         teamHomeBackgroundColor: string;
@@ -763,7 +773,7 @@ export declare class CamOverlayAPI<Client extends IClient<TResponse, any>> {
         pos_y: number;
         coordSystem: "top_left" | "top" | "top_right" | "left" | "center" | "right" | "bottom_left" | "bottom" | "bottom_right";
         scale: number;
-        font: "classic" | (string & {});
+        font: string;
         teamHomeShortname: string;
         teamGuestShortname: string;
         teamHomeBackgroundColor: string;
@@ -796,7 +806,7 @@ export declare class CamOverlayAPI<Client extends IClient<TResponse, any>> {
         cameraList: number[];
         zIndex: number;
         scale: number;
-        font: "classic" | (string & {});
+        font: string;
         teamHomeBackgroundColor: string;
         teamGuestBackgroundColor: string;
         teamHomeTextColor: string;
@@ -836,7 +846,7 @@ export declare class CamOverlayAPI<Client extends IClient<TResponse, any>> {
         teamGuestName: string;
         scoreVisible: boolean;
         description: string;
-        textFont: "classic" | (string & {});
+        textFont: string;
         scoreFont: "classic";
     })[]>;
     updateSingleService(service: TService, options?: THttpRequestOptions): Promise<void>;
@@ -846,7 +856,7 @@ export declare class CamOverlayAPI<Client extends IClient<TResponse, any>> {
     updateCGImage(serviceId: number, path: string, coordinates?: TCoordinates, x?: number, y?: number, options?: THttpRequestOptions): Promise<void>;
     updateCGImageFromData(serviceId: number, imageType: ImageType, imageData: Parameters<Client['post']>[0]['data'], coordinates?: TCoordinates, x?: number, y?: number, options?: THttpRequestOptions): Promise<void>;
     private promiseCGUpdate;
-    private _get;
+    private _getJson;
     private _post;
     private _getBlob;
     private parseBlobResponse;

package/types/CamScripterAPI.d.ts

@@ -1,16 +1,39 @@
 import { ProxyClient } from './internal/ProxyClient';
 import { IClient, TResponse } from './internal/types';
-import { TNodeState, TPackageInfoList, TStorage, TStorageType } from './types/CamScripterAPI';
-import { THttpRequestOptions, TNetworkCamera, TProxyParams } from './types/common';
+import { TStorageType } from './types/CamScripterAPI';
+import { THttpRequestOptions, TProxyParams } from './types/common';
 export declare class CamScripterAPI<Client extends IClient<TResponse, any>> {
     client: Client;
     constructor(client: Client);
-    static getProxyUrlPath: () => string;
+    static getProxyPath: () => string;
     getClient(proxyParams?: TProxyParams): Client | ProxyClient<Client>;
     checkCameraTime(options?: THttpRequestOptions): Promise<boolean>;
-    getNetworkCameraList(options?: THttpRequestOptions): Promise<TNetworkCamera[]>;
-    getStorageInfo(options?: THttpRequestOptions): Promise<TStorage>;
-    getPackageList(options?: THttpRequestOptions): Promise<TPackageInfoList>;
+    getNetworkCameraList(options?: THttpRequestOptions): Promise<{
+        name: string;
+        ip: string;
+    }[]>;
+    getStorageInfo(options?: THttpRequestOptions): Promise<[{
+        type: "INTERNAL";
+        capacity_mb: number;
+    }, {
+        type: "SD_CARD";
+        capacity_mb: number;
+    }] | [{
+        type: "INTERNAL";
+        capacity_mb: number;
+    }]>;
+    getPackageList(options?: THttpRequestOptions): Promise<{
+        storage: "INTERNAL" | "SD_CARD";
+        manifest: {
+            package_name: string;
+            package_menu_name: string;
+            package_version: string;
+            vendor: string;
+            ui_link: string;
+            required_camscripter_version?: string | undefined;
+            required_camscripter_rbi_version?: string | undefined;
+        };
+    }[]>;
     installPackages(formData: Parameters<Client['post']>[0]['data'], storage: TStorageType, options?: THttpRequestOptions): Promise<{
         status: number;
         message: string;
@@ -27,11 +50,13 @@ export declare class CamScripterAPI<Client extends IClient<TResponse, any>> {
         status: number;
         message: string;
     }>;
-    getNodejsStatus(options?: THttpRequestOptions): Promise<TNodeState>;
+    getNodejsStatus(options?: THttpRequestOptions): Promise<{
+        node_state: "OK" | "NOT_INSTALLED" | "NOT_FOUND";
+    }>;
     installNodejs(storage: TStorageType, options?: THttpRequestOptions): Promise<{
         status: number;
         message: string;
     }>;
-    private get;
-    private post;
+    private _getJson;
+    private _post;
 }

package/types/CamStreamerAPI.d.ts

@@ -6,6 +6,8 @@ export declare class CamStreamerAPI<Client extends IClient<TResponse, any>> {
     client: Client;
     constructor(client: Client);
     getClient(proxyParams?: TProxyParams): Client | ProxyClient<Client>;
+    wsAuthorization(options?: THttpRequestOptions): Promise<string>;
+    getUtcTime(options?: THttpRequestOptions): Promise<number>;
     getStreamList(options?: THttpRequestOptions): Promise<Record<number, {
         enabled: 0 | 1;
         schedule: string;
@@ -15,7 +17,7 @@ export declare class CamStreamerAPI<Client extends IClient<TResponse, any>> {
         internalVapixParameters: string;
         userVapixParameters: string;
         outputParameters: string;
-        outputType: "video" | "images" | "none";
+        outputType: "video" | "none" | "images";
         mediaServerUrl: string;
         inputType: "RTSP_URL" | "CSw" | "CRS";
         inputUrl: string;
@@ -29,7 +31,29 @@ export declare class CamStreamerAPI<Client extends IClient<TResponse, any>> {
         startTime: number | null;
         stopTime: number | null;
     }>>;
-    getStream(streamId: number, options?: THttpRequestOptions): Promise<TStream>;
+    getStream(streamId: number, options?: THttpRequestOptions): Promise<{
+        enabled: 0 | 1;
+        schedule: string;
+        active: 0 | 1;
+        audioSource: string;
+        avSyncMsec: number;
+        internalVapixParameters: string;
+        userVapixParameters: string;
+        outputParameters: string;
+        outputType: "video" | "none" | "images";
+        mediaServerUrl: string;
+        inputType: "RTSP_URL" | "CSw" | "CRS";
+        inputUrl: string;
+        forceStereo: 0 | 1;
+        streamDelay: number | null;
+        statusLed: number;
+        statusPort: string;
+        callApi: number;
+        trigger: string;
+        prepareAhead: number;
+        startTime: number | null;
+        stopTime: number | null;
+    }>;
     getStreamParameter(streamId: number, paramName: string, options?: THttpRequestOptions): Promise<string>;
     setStream(streamId: number, params: Partial<TStream>, options?: THttpRequestOptions): Promise<{
         message: string;
@@ -41,8 +65,6 @@ export declare class CamStreamerAPI<Client extends IClient<TResponse, any>> {
     }>;
     isStreaming(streamId: number, options?: THttpRequestOptions): Promise<boolean>;
     deleteStream(streamId: number, options?: THttpRequestOptions): Promise<boolean>;
-    getWsAuthorization(options?: THttpRequestOptions): Promise<string>;
-    getUtcTime(options?: THttpRequestOptions): Promise<number>;
-    private get;
+    private _getJson;
 }
 export declare const parseCameraStreamResponse: (cameraStreamData: TCameraStream) => TStream;