camstreamerlib 4.0.37 → 5.0.0-54e362c

package/cjs/CamStreamerAPI.js

@@ -101,7 +101,7 @@ class CamStreamerAPI extends BasicAPI_1.BasicAPI {
         if (newStream.success) {
             return newStream.data;
         }
-        const oldStream = oldStreamSchema_1.oldStringStreamSchema.passthrough().parse(res.data);
+        const oldStream = oldStreamSchema_1.oldStringStreamSchema.loose().parse(res.data);
         throw new errors_1.MigrationError([], [{ streamId, ...(0, exports.parseCameraStreamResponse)(oldStream) }], [], []);
     }
     async setStream(streamId, streamData, options) {

package/cjs/CamSwitcherAPI.d.ts

@@ -21,27 +21,27 @@ export declare class CamSwitcherAPI<Client extends IClient<TResponse, any>> exte
     generateSilence(sampleRate: number, channels: TAudioChannel, options?: THttpRequestOptions): Promise<void>;
     getMaxFps(source: number, options?: THttpRequestOptions): Promise<number>;
     getStorageInfo(options?: THttpRequestOptions): Promise<{
-        size: number;
         storage: "FLASH" | "SD_DISK";
         writable: boolean;
+        size: number;
         available: number;
     }[]>;
     wsAuthorization(options?: THttpRequestOptions): Promise<string>;
     getOutputInfo(options?: THttpRequestOptions): Promise<{
+        rtspUrl: string;
         ws: string;
         wsInitialMessage: string;
-        rtspUrl: string;
     }>;
     getAudioPushInfo(options?: THttpRequestOptions): Promise<{
         ws: string;
         wsInitialMessage: string;
     }>;
     getStreamSaveList(options?: THttpRequestOptions): Promise<Record<string, {
-        ip?: string | undefined;
-        enabled?: boolean | undefined;
-        port?: number | undefined;
         niceName?: string | undefined;
+        ip?: string | undefined;
         mdnsName?: string | undefined;
+        port?: number | undefined;
+        enabled?: boolean | undefined;
         auth?: string | undefined;
         query?: string | undefined;
         channel?: "video" | "audio" | "av" | undefined;
@@ -56,57 +56,57 @@ export declare class CamSwitcherAPI<Client extends IClient<TResponse, any>> exte
         sortIndexOverview?: number | undefined;
     }>>;
     getPlaylistSaveList(options?: THttpRequestOptions): Promise<Record<string, {
-        niceName?: string | undefined;
         channel?: "video" | "audio" | "av" | undefined;
-        keyboard?: Record<string, string | null> | undefined;
-        sortIndexOverview?: number | undefined;
         isFavourite?: boolean | undefined;
+        keyboard?: Record<string, string | null> | undefined;
+        niceName?: string | undefined;
         sortIndexFavourite?: number | undefined;
+        sortIndexOverview?: number | undefined;
         play_type?: "PLAY_ALL" | "PLAY_ALL_LOOP" | "PLAY_ALL_SHUFFLED" | "PLAY_ALL_LOOP_SHUFFLED" | "PLAY_ONE_RANDOM" | undefined;
         default?: boolean | undefined;
         stream_list?: {
+            id: string;
+            isTimeoutCustom: boolean;
+            ptz_preset_pos_name: string;
             repeat: number;
+            timeout: number;
             video: {
-                storage?: "FLASH" | "SD_DISK" | undefined;
                 stream_name?: string | undefined;
                 clip_name?: string | undefined;
                 tracker_name?: string | undefined;
+                storage?: "FLASH" | "SD_DISK" | undefined;
             };
-            id: string;
-            isTimeoutCustom: boolean;
-            ptz_preset_pos_name: string;
-            timeout: number;
             audio?: {
-                storage?: "FLASH" | "SD_DISK" | undefined;
                 stream_name?: string | undefined;
                 clip_name?: string | undefined;
                 tracker_name?: string | undefined;
+                storage?: "FLASH" | "SD_DISK" | undefined;
             } | undefined;
         }[] | undefined;
     }>>;
     getTrackerSaveList(options?: THttpRequestOptions): Promise<Record<string, {
-        name?: string | undefined;
-        fps?: number | undefined;
         id?: string | undefined;
-        width?: number | undefined;
-        height?: number | undefined;
+        name?: string | undefined;
+        previewId?: string | undefined;
         duration?: number | undefined;
-        channel?: "video" | "audio" | "av" | undefined;
         keyboard?: Record<string, string | null> | undefined;
+        channel?: "video" | "audio" | "av" | undefined;
         sortIndexOverview?: number | undefined;
-        viewNumber?: number | undefined;
-        previewId?: string | undefined;
+        width?: number | undefined;
+        height?: number | undefined;
+        fps?: number | undefined;
         motion_history_frames?: number | undefined;
         include_zone?: number[][] | undefined;
         include_node_ids?: string[] | undefined;
         camera_list?: {
-            name: string;
             id: string;
+            name: string;
             overview: boolean;
             zone: number[];
             playlist_name: string;
             ptz_preset_pos_no: number;
         }[] | undefined;
+        viewNumber?: number | undefined;
         camera_view_number?: number | undefined;
     }>>;
     setStreamSaveList(data: TStreamSaveList, options?: THttpRequestOptions): Promise<void>;
@@ -125,13 +125,13 @@ export declare class CamSwitcherAPI<Client extends IClient<TResponse, any>> exte
         duration: number;
         stream_list: ({
             type: "video";
-            fps: number;
             width: number;
             height: number;
             sample_rate: number;
             h264_profile: "high" | "main" | "baseline";
             h264_level: "4.1";
             gop: number;
+            fps: number;
             bitrate: number;
         } | {
             type: "audio";
@@ -145,22 +145,23 @@ export declare class CamSwitcherAPI<Client extends IClient<TResponse, any>> exte
     setDefaultPlaylist(playlistId: string, options?: THttpRequestOptions): Promise<void>;
     setPermanentRtspUrlToken(token: string, options?: THttpRequestOptions): Promise<void>;
     getCamSwitchOptions(options?: THttpRequestOptions): Promise<{
-        resolution?: string | undefined;
-        compression?: number | undefined;
         bitrateMode?: "VBR" | "MBR" | "ABR" | undefined;
         maximumBitRate?: number | undefined;
         retentionTime?: number | undefined;
         bitRateLimit?: number | undefined;
+        resolution?: string | undefined;
+        h264Profile?: "high" | "main" | "baseline" | undefined;
         fps?: number | undefined;
+        compression?: number | undefined;
         govLength?: number | undefined;
-        h264Profile?: "high" | "main" | "baseline" | undefined;
-        keyboard?: {
-            none: string | null;
-            fromSource: string | null;
-        } | undefined;
         bitrateVapixParams?: string | null | undefined;
         audioSampleRate?: number | undefined;
         audioChannelCount?: 1 | 2 | undefined;
+        audioBitrate?: number | undefined;
+        keyboard?: {
+            fromSource: string | null;
+            none: string | null;
+        } | undefined;
     } | undefined>;
     getGlobalAudioSettings(options?: THttpRequestOptions): Promise<{
         type: "source" | "fromSource";

package/cjs/CamSwitcherAPI.js

@@ -156,6 +156,7 @@ class CamSwitcherAPI extends BasicAPI_1.BasicAPI {
             audio: {
                 sampleRate: data.audioSampleRate,
                 channelCount: data.audioChannelCount,
+                bitrate: data.audioBitrate,
             },
             keyboard: data.keyboard,
         };
@@ -207,6 +208,7 @@ class CamSwitcherAPI extends BasicAPI_1.BasicAPI {
         const settings = {
             audioSampleRate: saveData.audio?.sampleRate,
             audioChannelCount: saveData.audio?.channelCount,
+            audioBitrate: saveData.audio?.bitrate,
             keyboard: saveData.keyboard,
             fps: saveData.video.fps,
             resolution: saveData.video.resolution,

package/cjs/PlaneTrackerAPI.d.ts

@@ -1,3 +1,4 @@
+import { z } from 'zod';
 import { IClient, TResponse } from './internal/types';
 import { ICAO, TBlackList, TCameraSettings, TConnection, TExportDataType, TGetIcaoByOption, TImportDataType, TMilestoneCameraOption, TPriorityList, TTrackingMode, TWhiteList, TZones } from './types/PlaneTrackerAPI';
 import { THttpRequestOptions } from './types/common';
@@ -20,23 +21,23 @@ export declare class PlaneTrackerAPI<Client extends IClient<TResponse, any>> ext
     resetFocusCalibration(options?: THttpRequestOptions): Promise<void>;
     triggerFocusReview(options?: THttpRequestOptions): Promise<void>;
     fetchCameraSettings(options?: THttpRequestOptions): Promise<{
-        camera: {
-            ip: string;
-            port: number;
-            pass: string;
-            user: string;
-            protocol: "https" | "http" | "https_insecure";
-        };
         units: "metric" | "imperial";
         adsbSource: {
-            ip: string;
             enabled: boolean;
+            ip: string;
             port: number;
             useSystemTime: boolean;
         };
         dronetagSource: {
             enabled: boolean;
         };
+        camera: {
+            protocol: "https" | "http" | "https_insecure";
+            ip: string;
+            port: number;
+            user: string;
+            pass: string;
+        };
         cameraCalibrationProcessConfig: {
             nightSkyCalibrationEnabled: boolean;
             scheduleNightSkyCalibrationTimestamp: number;
@@ -86,21 +87,21 @@ export declare class PlaneTrackerAPI<Client extends IClient<TResponse, any>> ext
         };
         widget: {
             enabled: boolean;
-            scale: number;
-            units: "rotate" | "metric" | "imperial";
             coord: "top_left" | "top_right" | "bottom_left" | "bottom_right";
             posX: number;
             posY: number;
+            scale: number;
+            units: "rotate" | "metric" | "imperial";
         };
         airportWidget: {
             enabled: boolean;
-            scale: number;
-            weatherLocationName: string;
             coord: "top_left" | "top_right" | "bottom_left" | "bottom_right";
             posX: number;
             posY: number;
+            scale: number;
             showWeather: boolean;
             weatherLocationKey: string;
+            weatherLocationName: string;
             windSpeedUnits: "rotate" | "metric" | "imperial";
             temperatureUnits: "rotate" | "metric" | "imperial";
         };
@@ -111,10 +112,10 @@ export declare class PlaneTrackerAPI<Client extends IClient<TResponse, any>> ext
             validateFlights: boolean;
         };
         radarcapeFlightInfoSource: {
-            ip: string;
             enabled: boolean;
-            port: number;
             priority: number;
+            ip: string;
+            port: number;
         };
         identificationLabel: {
             aircraft: {
@@ -142,22 +143,22 @@ export declare class PlaneTrackerAPI<Client extends IClient<TResponse, any>> ext
             };
         };
         acs: {
+            protocol: "https" | "http" | "https_insecure";
             ip: string;
-            enabled: boolean;
             port: number;
-            pass: string;
             user: string;
-            protocol: "https" | "http" | "https_insecure";
+            pass: string;
+            enabled: boolean;
             sourceKey: string;
         };
         milestone: {
+            protocol: "https" | "http" | "https_insecure";
             ip: string;
-            enabled: boolean;
             port: number;
-            cameraList: string[];
-            pass: string;
             user: string;
-            protocol: "https" | "http" | "https_insecure";
+            pass: string;
+            enabled: boolean;
+            cameraList: string[];
         };
         camstreamerIntegration: {
             adPlacementEnabled: boolean;
@@ -215,13 +216,34 @@ export declare class PlaneTrackerAPI<Client extends IClient<TResponse, any>> ext
     }>;
     exportAppSettings(dataType: TExportDataType, options?: THttpRequestOptions): Promise<ReturnType<Awaited<ReturnType<Client["get"]>>["blob"]>>;
     importAppSettings(dataType: TImportDataType, formData: Parameters<Client['post']>[0]['data'], options?: THttpRequestOptions): Promise<void>;
-    getDomainList(options?: THttpRequestOptions): Promise<Partial<Record<"adsb" | "remoteId", {
+    getDomainList(options?: THttpRequestOptions): Promise<Partial<Record<z.core.$InferEnumOutput<{
+        adsb: "adsb";
+        remoteId: "remoteId";
+    }>, {
         uiName: string;
-        icon: "unknown" | "small" | "drone" | "large" | "heavy" | "helicopter" | "operator" | "vehicle";
+        icon: z.core.$InferEnumOutput<{
+            unknown: "unknown";
+            small: "small";
+            drone: "drone";
+            large: "large";
+            heavy: "heavy";
+            helicopter: "helicopter";
+            operator: "operator";
+            vehicle: "vehicle";
+        }>;
         categoryList: {
             categoryId: string;
             uiName: string;
-            icon: "unknown" | "small" | "drone" | "large" | "heavy" | "helicopter" | "operator" | "vehicle";
+            icon: z.core.$InferEnumOutput<{
+                unknown: "unknown";
+                small: "small";
+                drone: "drone";
+                large: "large";
+                heavy: "heavy";
+                helicopter: "helicopter";
+                operator: "operator";
+                vehicle: "vehicle";
+            }>;
         }[];
     }>>>;
     fetchFlightInfo(targetId: string, options?: THttpRequestOptions): Promise<{
@@ -230,9 +252,9 @@ export declare class PlaneTrackerAPI<Client extends IClient<TResponse, any>> ext
             iata?: string | undefined;
             city?: string | undefined;
         };
-        registration?: string | undefined;
         callsign?: string | undefined;
         flightNumber?: string | undefined;
+        registration?: string | undefined;
         aircraftType?: string | undefined;
         airlines?: string | undefined;
         originAirport?: {
@@ -256,25 +278,52 @@ export declare class PlaneTrackerAPI<Client extends IClient<TResponse, any>> ext
     getIcao(by: TGetIcaoByOption, value: string, options?: THttpRequestOptions): Promise<string>;
     getPriorityList(options?: THttpRequestOptions): Promise<{
         list: {
-            priority: number;
-            domain: "adsb" | "remoteId";
-            idType: "icao" | "type_icao" | "drone_mac" | "operator_mac" | "category";
+            domain: z.core.$InferEnumOutput<{
+                adsb: "adsb";
+                remoteId: "remoteId";
+            }>;
+            idType: z.core.$InferEnumOutput<{
+                icao: "icao";
+                type_icao: "type_icao";
+                drone_mac: "drone_mac";
+                operator_mac: "operator_mac";
+                category: "category";
+            }>;
             idValue: string;
+            priority: number;
         }[];
     }>;
     setPriorityList(priorityList: TPriorityList, options?: THttpRequestOptions): Promise<void>;
     getWhiteList(options?: THttpRequestOptions): Promise<{
         list: {
-            domain: "adsb" | "remoteId";
-            idType: "icao" | "type_icao" | "drone_mac" | "operator_mac" | "category";
+            domain: z.core.$InferEnumOutput<{
+                adsb: "adsb";
+                remoteId: "remoteId";
+            }>;
+            idType: z.core.$InferEnumOutput<{
+                icao: "icao";
+                type_icao: "type_icao";
+                drone_mac: "drone_mac";
+                operator_mac: "operator_mac";
+                category: "category";
+            }>;
             idValue: string;
         }[];
     }>;
     setWhiteList(whiteList: TWhiteList, options?: THttpRequestOptions): Promise<void>;
     getBlackList(options?: THttpRequestOptions): Promise<{
         list: {
-            domain: "adsb" | "remoteId";
-            idType: "icao" | "type_icao" | "drone_mac" | "operator_mac" | "category";
+            domain: z.core.$InferEnumOutput<{
+                adsb: "adsb";
+                remoteId: "remoteId";
+            }>;
+            idType: z.core.$InferEnumOutput<{
+                icao: "icao";
+                type_icao: "type_icao";
+                drone_mac: "drone_mac";
+                operator_mac: "operator_mac";
+                category: "category";
+            }>;
             idValue: string;
         }[];
     }>;
@@ -282,23 +331,34 @@ export declare class PlaneTrackerAPI<Client extends IClient<TResponse, any>> ext
     fetchMapInfo(options?: THttpRequestOptions): Promise<{
         minZoom: number;
         maxZoom: number;
-        mapTypes: ("roadmap" | "satellite")[];
+        mapTypes: z.core.$InferEnumOutput<{
+            roadmap: "roadmap";
+            satellite: "satellite";
+        }>[];
         tileSize: number;
     }>;
     getZones(options?: THttpRequestOptions): Promise<{
         zones: {
             enabled: boolean;
-            area: [{
+            area: {
                 lat: number;
                 lon: number;
-            }, ...{
-                lat: number;
-                lon: number;
-            }[]];
-            flightDirection: "all" | "arrival" | "departure";
+            }[];
+            flightDirection: z.core.$InferEnumOutput<{
+                all: "all";
+                arrival: "arrival";
+                departure: "departure";
+            }>;
             weight: number;
-            perimeter: "none" | "outer" | "inner";
-            trackingDomains: ("adsb" | "remoteId")[];
+            perimeter: z.core.$InferEnumOutput<{
+                none: "none";
+                outer: "outer";
+                inner: "inner";
+            }>;
+            trackingDomains: z.core.$InferEnumOutput<{
+                adsb: "adsb";
+                remoteId: "remoteId";
+            }>[];
             name?: string | undefined;
             minAltitudeAmsl?: number | undefined;
             maxAltitudeAmsl?: number | undefined;

package/cjs/VapixAPI.d.ts

@@ -1,6 +1,7 @@
 import { IClient, TParameters, TResponse } from './internal/types';
 import { TAudioDevice, TPortSetSchema, TPortSequenceStateSchema } from './types/VapixAPI';
 import { TCameraImageConfig, THttpRequestOptions } from './types/common';
+import { z } from 'zod';
 import { BasicAPI } from './internal/BasicAPI';
 export declare class VapixAPI<Client extends IClient<TResponse, any>> extends BasicAPI<Client> {
     private CustomFormData;
@@ -46,7 +47,11 @@ export declare class VapixAPI<Client extends IClient<TResponse, any>> extends Ba
     getHeaders(options?: THttpRequestOptions): Promise<Record<string, string>>;
     setHeaders(headers: Record<string, string>, options?: THttpRequestOptions): Promise<void>;
     checkSDCard(options?: THttpRequestOptions): Promise<{
-        status: "OK" | "connected" | "disconnected";
+        status: z.core.$InferEnumOutput<{
+            OK: "OK";
+            connected: "connected";
+            disconnected: "disconnected";
+        }>;
         totalSize: number;
         freeSize: number;
     }>;
@@ -57,34 +62,34 @@ export declare class VapixAPI<Client extends IClient<TResponse, any>> extends Ba
     getParameter(paramNames: string | string[], options?: THttpRequestOptions): Promise<Record<string, string>>;
     setParameter(params: Record<string, string | number | boolean>, options?: THttpRequestOptions): Promise<void>;
     getGuardTourList(options?: THttpRequestOptions): Promise<{
-        name: string;
         id: string;
+        camNbr: unknown;
+        name: string;
+        randomEnabled: unknown;
         running: string;
+        timeBetweenSequences: unknown;
         tour: {
-            position?: unknown;
-            moveSpeed?: unknown;
-            presetNbr?: unknown;
-            waitTime?: unknown;
-            waitTimeViewType?: unknown;
+            moveSpeed: unknown;
+            position: unknown;
+            presetNbr: unknown;
+            waitTime: unknown;
+            waitTimeViewType: unknown;
         }[];
-        camNbr?: unknown;
-        randomEnabled?: unknown;
-        timeBetweenSequences?: unknown;
     }>;
     setGuardTourEnabled(guardTourId: string, enable: boolean, options?: THttpRequestOptions): Promise<void>;
     getPTZPresetList(channel: number, options?: THttpRequestOptions): Promise<string[]>;
     listPTZ(camera: number, options?: THttpRequestOptions): Promise<{
         name: string;
+        id: number;
         data: {
             pan?: number | undefined;
             tilt?: number | undefined;
             zoom?: number | undefined;
         };
-        id: number;
     }[]>;
     listPtzVideoSourceOverview(options?: THttpRequestOptions): Promise<Record<number, {
-        name: string;
         id: number;
+        name: string;
     }[]>>;
     goToPreset(channel: number, presetName: string, options?: THttpRequestOptions): Promise<void>;
     getPtzPosition(camera: number, options?: THttpRequestOptions): Promise<{
@@ -93,13 +98,22 @@ export declare class VapixAPI<Client extends IClient<TResponse, any>> extends Ba
         zoom?: number | undefined;
     }>;
     getPorts(options?: THttpRequestOptions): Promise<{
-        name: string;
         port: string;
-        direction: "output" | "input";
-        state: "open" | "closed";
+        state: z.core.$InferEnumOutput<{
+            open: "open";
+            closed: "closed";
+        }>;
         configurable: boolean;
         usage: string;
-        normalState: "open" | "closed";
+        direction: z.core.$InferEnumOutput<{
+            output: "output";
+            input: "input";
+        }>;
+        name: string;
+        normalState: z.core.$InferEnumOutput<{
+            open: "open";
+            closed: "closed";
+        }>;
         readonly?: boolean | undefined;
     }[]>;
     setPorts(ports: TPortSetSchema[], options?: THttpRequestOptions): Promise<void>;
@@ -108,9 +122,9 @@ export declare class VapixAPI<Client extends IClient<TResponse, any>> extends Ba
     getCameraUsers(options?: THttpRequestOptions): Promise<string[]>;
     editCameraUser(username: string, pass: string, options?: THttpRequestOptions): Promise<void>;
     getRecordingRuleList(options?: THttpRequestOptions): Promise<{
-        options: Record<string, string>;
         diskid: string;
         eventid: string;
+        options: Record<string, string>;
         profile: string;
     }[]>;
     addRecordingRule(params: Record<string, string>, options?: THttpRequestOptions): Promise<string | null>;

package/cjs/VapixAPI.js

@@ -199,7 +199,7 @@ class VapixAPI extends BasicAPI_1.BasicAPI {
     async getHeaders(options) {
         const data = { apiVersion: '1.0', method: 'list' };
         const res = await this._postJsonEncoded('/axis-cgi/customhttpheader.cgi', data, undefined, options);
-        return zod_1.z.object({ data: zod_1.z.record(zod_1.z.string()) }).parse(await res.json()).data;
+        return zod_1.z.object({ data: zod_1.z.record(zod_1.z.string(), zod_1.z.string()) }).parse(await res.json()).data;
     }
     async setHeaders(headers, options) {
         const data = { apiVersion: '1.0', method: 'set', params: headers };

package/cjs/internal/versionCompare.d.ts

@@ -1,6 +1,6 @@
 export declare const assertVersionString: (s: string, msg?: string) => void;
 export declare const isFirmwareVersionAtLeast: (version: string, compareVersion: string) => boolean;
 export declare const isVersionAtLeast: (version: string, compareVersion: string) => boolean;
-export declare const firmwareVersionCompare: (a: string, b: string) => 1 | 0 | -1;
-export declare const versionCompare: (a: string, b: string) => 1 | 0 | -1;
+export declare const firmwareVersionCompare: (a: string, b: string) => 0 | 1 | -1;
+export declare const versionCompare: (a: string, b: string) => 0 | 1 | -1;
 export declare const fixVersionToDots: (version: string) => string;