camstreamerlib 4.0.0-beta.2 → 4.0.0-beta.20

package/esm/CamScripterAPICameraEventsGenerator.d.ts

@@ -0,0 +1,74 @@
+/// <reference types="node" />
+import * as EventEmitter from 'events';
+import { WsOptions } from './internal/types';
+export type CamScripterOptions = WsOptions;
+export type TDeclaration = {
+    type?: '' | 'SOURCE' | 'DATA';
+    namespace: string;
+    key: string;
+    value: string | boolean | number;
+    value_type: 'STRING' | 'INT' | 'BOOL' | 'DOUBLE';
+    key_nice_name?: string;
+    value_nice_name?: string;
+};
+export type TEventDeclaration = {
+    declaration_id: string;
+    stateless: boolean;
+    declaration: TDeclaration[];
+};
+export type TEventUndeclaration = {
+    declaration_id: string;
+};
+export type TEventData = {
+    namespace: string;
+    key: string;
+    value: string | boolean | number;
+    value_type: 'STRING' | 'INT' | 'BOOL' | 'DOUBLE';
+};
+export type TEvent = {
+    declaration_id: string;
+    event_data: TEventData[];
+};
+export type TResponse = {
+    call_id: number;
+    message: string;
+};
+export type TErrorResponse = {
+    error: string;
+    call_id?: number;
+};
+export interface CamScripterAPICameraEventsGenerator {
+    on(event: 'open', listener: () => void): this;
+    on(event: 'close', listener: () => void): this;
+    on(event: 'error', listener: (err: Error) => void): this;
+    emit(event: 'open'): boolean;
+    emit(event: 'close'): boolean;
+    emit(event: 'error', err: Error): boolean;
+}
+export declare class CamScripterAPICameraEventsGenerator extends EventEmitter {
+    private tls;
+    private tlsInsecure;
+    private ip;
+    private port;
+    private user;
+    private pass;
+    private callId;
+    private sendMessages;
+    private timeoutCheckTimer;
+    private wsConnected;
+    private ws;
+    constructor(options?: CamScripterOptions);
+    connect(): void;
+    disconnect(): void;
+    declareEvent(eventDeclaration: TEventDeclaration): Promise<TResponse>;
+    undeclareEvent(eventUndeclaration: TEventUndeclaration): Promise<TResponse>;
+    sendEvent(event: TEvent): Promise<TResponse>;
+    private createWsClient;
+    private incomingWsMessageHandler;
+    private sendMessage;
+    private startMsgsTimeoutCheck;
+    private stopMsgsTimeoutCheck;
+    private reconnectWithError;
+    private reportErr;
+    private reportClose;
+}

package/{CamScripterAPICameraEventsGenerator.js → esm/CamScripterAPICameraEventsGenerator.js}

@@ -88,10 +88,10 @@ export class CamScripterAPICameraEventsGenerator extends EventEmitter {
         }
         if (dataJSON.call_id !== undefined) {
             if (errorResponse !== undefined) {
-                this.sendMessages[dataJSON.call_id].reject(new Error(errorResponse.error));
+                this.sendMessages[dataJSON.call_id]?.reject(new Error(errorResponse.error));
             }
             else {
-                this.sendMessages[dataJSON.call_id].resolve(dataJSON);
+                this.sendMessages[dataJSON.call_id]?.resolve(dataJSON);
             }
             delete this.sendMessages[dataJSON.call_id];
         }
@@ -124,6 +124,9 @@ export class CamScripterAPICameraEventsGenerator extends EventEmitter {
             const now = Date.now();
             for (const callId in this.sendMessages) {
                 const msg = this.sendMessages[callId];
+                if (!msg) {
+                    continue;
+                }
                 if (now - msg.sentTimestamp > 10000) {
                     reconnect = true;
                     msg.reject(new Error('Message timeout'));
@@ -147,7 +150,7 @@ export class CamScripterAPICameraEventsGenerator extends EventEmitter {
     }
     reportClose() {
         for (const callId in this.sendMessages) {
-            this.sendMessages[callId].reject(new Error('Connection lost'));
+            this.sendMessages[callId]?.reject(new Error('Connection lost'));
         }
         this.sendMessages = {};
         this.emit('close');

package/esm/CamStreamerAPI.d.ts

@@ -0,0 +1,16 @@
+import { IClient, TResponse } from './internal/types';
+import { TStreamAttributes, TStreamList } from './types/CamStreamerAPI';
+export declare class CamStreamerAPI<Client extends IClient<TResponse> = IClient<TResponse>> {
+    client: Client;
+    constructor(client: Client);
+    getStreamList(): Promise<TStreamList>;
+    getStream(streamID: string): Promise<TStreamAttributes>;
+    getStreamParameter(streamID: string, paramName: string): Promise<string>;
+    setStream(streamID: string, params: Partial<TStreamAttributes>): Promise<void>;
+    setStreamParameter(streamID: string, paramName: string, value: string): Promise<void>;
+    isStreaming(streamID: string): Promise<boolean>;
+    deleteStream(streamID: string): Promise<void>;
+    wsAutoratization(): Promise<string>;
+    getUtcTime(): Promise<number>;
+    private get;
+}

package/{CamStreamerAPI.js → esm/CamStreamerAPI.js}

@@ -1,15 +1,9 @@
-import { isClient, responseStringify } from './internal/common';
-import { DefaultClient } from './node/DefaultClient';
-import { streamAttributesSchema, streamListSchema, } from './types/CamStreamerAPI';
+import { responseStringify } from './internal/utils';
+import { streamAttributesSchema, streamListSchema } from './types/CamStreamerAPI';
 export class CamStreamerAPI {
     client;
-    constructor(options = {}) {
-        if (isClient(options)) {
-            this.client = options;
-        }
-        else {
-            this.client = new DefaultClient(options);
-        }
+    constructor(client) {
+        this.client = client;
     }
     async getStreamList() {
         const streamListRes = await this.get('/local/camstreamer/stream/list.cgi');

package/esm/CamSwitcherAPI.d.ts

@@ -0,0 +1,52 @@
+import { IClient, TResponse } from './internal/types';
+import { TAudioPushInfo, TOutputInfo, TStorageInfo, TStreamSaveList, TClipList, TStreamSaveLoadList, TClipSaveLoadList, TPlaylistSaveLoadList, TTrackerSaveList, TrackerSaveLoadList, TClipSaveList, TPlaylistSaveList, TCameraOptions, TGlobalAudioSettings, TSecondaryAudioSettings } from './types/CamSwitcherAPI';
+import { TAudioChannel, TNetworkCamera, TStorageType } from './types/common';
+export declare class CamSwitcherAPI<Client extends IClient<TResponse> = IClient<TResponse>> {
+    client: Client;
+    private CustomFormData;
+    private vapixAgent;
+    constructor(client: Client, CustomFormData?: {
+        new (form?: HTMLFormElement | undefined, submitter?: HTMLElement | null | undefined): FormData;
+        prototype: FormData;
+    });
+    static getProxyUrlPath: () => string;
+    static getWsEventsUrlPath: () => string;
+    static getClipPreviewUrlPath: (id: string, storage: TStorageType) => string;
+    generateSilence(sampleRate: number, channels: TAudioChannel): Promise<void>;
+    checkCameraTime(): Promise<boolean>;
+    getIpListFromNetworkCheck(): Promise<TNetworkCamera[]>;
+    getMaxFps(source: number): Promise<number>;
+    getStorageInfo(): Promise<TStorageInfo[]>;
+    wsAuthorization(): Promise<string>;
+    getOutputInfo(): Promise<TOutputInfo>;
+    getAudioPushInfo(): Promise<TAudioPushInfo>;
+    getStreamSaveList(): Promise<TStreamSaveLoadList>;
+    getClipSaveList(): Promise<TClipSaveLoadList>;
+    getPlaylistSaveList(): Promise<TPlaylistSaveLoadList>;
+    getTrackerSaveList(): Promise<TrackerSaveLoadList>;
+    setStreamSaveList(data: TStreamSaveList): Promise<boolean>;
+    setClipSaveList(data: TClipSaveList): Promise<boolean>;
+    setPlaylistSaveList(data: TPlaylistSaveList): Promise<boolean>;
+    setTrackerSaveList(data: TTrackerSaveList): Promise<boolean>;
+    playlistSwitch(playlistName: string): Promise<void>;
+    playlistQueuePush(playlistName: string): Promise<void>;
+    playlistQueueClear(): Promise<void>;
+    playlistQueueList(): Promise<string[]>;
+    playlistQueuePlayNext(): Promise<void>;
+    addNewClip(file: any, clipType: 'video' | 'audio', storage: TStorageType, id: string, fileName?: string): Promise<void>;
+    removeClip(id: string, storage: TStorageType): Promise<any>;
+    getClipList(): Promise<TClipList>;
+    setCamSwitchOptions(data: TCameraOptions, cameraFWVersion: string): Promise<boolean>;
+    setGlobalAudioSettings(settings: TGlobalAudioSettings): Promise<boolean>;
+    setSecondaryAudioSettings(settings: TSecondaryAudioSettings): Promise<boolean>;
+    setDefaultPlaylist(id: string): Promise<boolean>;
+    setPermanentRtspUrlToken(token: string): Promise<boolean>;
+    getCamSwitchOptions(): Promise<Partial<TCameraOptions>>;
+    getGlobalAudioSettings(): Promise<TGlobalAudioSettings>;
+    getSecondaryAudioSettings(): Promise<TSecondaryAudioSettings>;
+    getPermanentRtspUrlToken(): Promise<string>;
+    private get;
+    private set;
+    private setParamFromCameraJSON;
+    private getParamFromCameraAndJSONParse;
+}

package/{CamSwitcherAPI.js → esm/CamSwitcherAPI.js}

@@ -1,23 +1,24 @@
 import { z } from 'zod';
 import { AddNewClipError } from './errors/errors';
-import { isNullish, responseStringify } from './internal/common';
+import { isClip, isNullish, responseStringify } from './internal/utils';
 import { storageInfoListSchema, outputInfoSchema, audioPushInfoSchema, clipListSchema, playlistQueueSchema, streamSaveLoadSchema, clipSaveLoadSchema, playlistSaveLoadSchema, trackerSaveLoadSchema, } from './types/CamSwitcherAPI';
 import { networkCameraListSchema } from './types/common';
 import { VapixAPI } from './VapixAPI';
 import { isFirmwareVersionAtLeast } from './internal/versionCompare';
-import { isClip } from './internal/utils';
 import { FIRMWARE_WITH_BITRATE_MODES_SUPPORT } from './internal/constants';
 const baseUrl = '/local/camswitcher/api';
 export class CamSwitcherAPI {
     client;
+    CustomFormData;
     vapixAgent;
-    constructor(client) {
+    constructor(client, CustomFormData = FormData) {
         this.client = client;
+        this.CustomFormData = CustomFormData;
         this.vapixAgent = new VapixAPI(client, () => '');
     }
-    static getProxyUrl = () => `${baseUrl}/proxy.cgi`;
-    static getWsEventsUrl = () => `/local/camswitcher/events`;
-    static getClipPreview = (id, storage) => `${baseUrl}/clip_preview.cgi?clip_name=${id}&storage=${storage}`;
+    static getProxyUrlPath = () => `${baseUrl}/proxy.cgi`;
+    static getWsEventsUrlPath = () => `/local/camswitcher/events`;
+    static getClipPreviewUrlPath = (id, storage) => `${baseUrl}/clip_preview.cgi?clip_name=${id}&storage=${storage}`;
     async generateSilence(sampleRate, channels) {
         await this.client.get(`${baseUrl}/generate_silence.cgi`, {
             sample_rate: sampleRate.toString(),
@@ -99,7 +100,7 @@ export class CamSwitcherAPI {
         await this.get(`${baseUrl}/playlist_queue_play_next.cgi`);
     }
     async addNewClip(file, clipType, storage, id, fileName) {
-        const formData = new FormData();
+        const formData = new this.CustomFormData();
         formData.append('clip_name', id);
         formData.append('clip_type', clipType);
         formData.append('file', file, fileName);
@@ -292,16 +293,12 @@ const parseBitrateOptionsToBitrateVapixParams = (firmWareVersion, bitrateMode, c
     if (bitrateMode === null) {
         return '';
     }
-    if (bitrateMode === 'VBR') {
-        return 'videobitratemode=vbr';
-    }
-    if (bitrateMode === 'MBR') {
-        return `videobitratemode=mbr&videomaxbitrate=${cameraOptions.maximumBitRate}`;
-    }
-    if (bitrateMode === 'ABR') {
-        return `videobitratemode=abr&videoabrtargetbitrate=${cameraOptions.maximumBitRate}&videoabrretentiontime=${cameraOptions.retentionTime}&videoabrmaxbitrate=${cameraOptions.bitRateLimit}`;
-    }
-    throw new Error('Unknown bitrateMode param in getVapixParams method.');
+    const data = {
+        VBR: 'videobitratemode=vbr',
+        MBR: `videobitratemode=mbr&videomaxbitrate=${cameraOptions.maximumBitRate}`,
+        ABR: `videobitratemode=abr&videoabrtargetbitrate=${cameraOptions.maximumBitRate}&videoabrretentiontime=${cameraOptions.retentionTime}&videoabrmaxbitrate=${cameraOptions.bitRateLimit}`,
+    };
+    return data[bitrateMode];
 };
 const parseVapixParamsToBitrateOptions = (bitrateVapixParams) => {
     const params = {};
@@ -312,7 +309,7 @@ const parseVapixParamsToBitrateOptions = (bitrateVapixParams) => {
     const bitrateMode = params['videobitratemode'] !== undefined ? params['videobitratemode'].toUpperCase() : undefined;
     const hasLowerFw = bitrateMode === undefined && params['videomaxbitrate'] !== undefined;
     if (hasLowerFw) {
-        const maximumBitRate = parseInt(params['videomaxbitrate'], 10);
+        const maximumBitRate = parseInt(params['videomaxbitrate'] ?? '0', 10);
         return {
             bitrateMode: 'MBR',
             maximumBitRate: maximumBitRate,
@@ -321,19 +318,19 @@ const parseVapixParamsToBitrateOptions = (bitrateVapixParams) => {
         };
     }
     if (bitrateMode === 'ABR') {
-        const maximumBitRate = parseInt(params['videoabrtargetbitrate'], 10);
-        const retentionTime = parseInt(params['videoabrretentiontime'], 10);
-        const bitrateLimit = parseInt(params['videoabrmaxbitrate'], 10);
+        const maximumBitRate = parseInt(params['videoabrtargetbitrate'] ?? '0', 10);
+        const retentionTime = parseInt(params['videoabrretentiontime'] ?? '0', 10);
+        const bitRateLimit = parseInt(params['videoabrmaxbitrate'] ?? '0', 10);
         return {
-            bitrateMode: bitrateMode,
-            maximumBitRate: maximumBitRate,
-            retentionTime: retentionTime,
-            bitRateLimit: bitrateLimit,
+            bitrateMode,
+            maximumBitRate,
+            retentionTime,
+            bitRateLimit,
         };
     }
     else if (bitrateMode === 'MBR') {
-        const maximumBitRate = parseInt(params['videomaxbitrate'], 10);
-        const oldMaximumBitrateParamValue = parseInt(params['videombrmaxbitrate'], 10);
+        const maximumBitRate = params['videomaxbitrate'] !== undefined ? parseInt(params['videomaxbitrate'], 10) : null;
+        const oldMaximumBitrateParamValue = parseInt(params['videombrmaxbitrate'] ?? '0', 10);
         return {
             bitrateMode: bitrateMode,
             maximumBitRate: maximumBitRate ?? oldMaximumBitrateParamValue,

package/esm/CamSwitcherEvents.d.ts

@@ -0,0 +1,18 @@
+import { IWebsocket } from './internal/types';
+import { TCamSwitcherEventOfType, TCamSwitcherEventType } from './types/CamSwitcherEvents';
+type TListenerFunction<T extends TCamSwitcherEventType> = (data: TCamSwitcherEventOfType<T>, isInit: boolean) => void;
+export declare class CamSwitcherEvents<Event extends {
+    data: string;
+}> {
+    isDestroyed: boolean;
+    private ws;
+    private listeners;
+    setWebsocket(ws: IWebsocket<Event>): void;
+    resendInitData(): void;
+    addListener<T extends TCamSwitcherEventType>(type: T, listener: TListenerFunction<T>, id: string): void;
+    removeListener<T extends TCamSwitcherEventType>(type: T, id: string): void;
+    private onMessage;
+    private processMessage;
+    destroy(): void;
+}
+export {};

package/{CamSwitcherEvents.js → esm/CamSwitcherEvents.js}

@@ -1,4 +1,4 @@
-import { cswEventsSchema, } from './types/CamswitcherEvents';
+import { cswEventsSchema, } from './types/CamSwitcherEvents';
 export class CamSwitcherEvents {
     isDestroyed = false;
     ws = null;

package/esm/CreatePackage.d.ts

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

package/esm/PlaneTrackerAPI.d.ts

@@ -0,0 +1,47 @@
+import { IClient, TBlobResponse, TParameters, TResponse } from './internal/types';
+import { TExportDataType, TImportDataType } from './types/PlaneTrackerAPI';
+export type TApiUser = {
+    userId: string;
+    userName: string;
+    userPriority: number;
+};
+type ICAO = string;
+export declare const BASE_URL = "/local/planetracker";
+export declare class PlaneTrackerAPI<Client extends IClient<TResponse> = IClient<TResponse>> {
+    private client;
+    private apiUser;
+    private _apiUserQuery;
+    constructor(client: Client, apiUser: TApiUser);
+    static getProxyUrlPath: () => string;
+    checkCameraTime(): Promise<boolean>;
+    fetchCameraSettings: () => Promise<any>;
+    setCameraSettings: (settingsJsonString: string) => Promise<TResponse>;
+    fetchServerSettings: () => Promise<any>;
+    fetchMapInfo: () => Promise<any>;
+    fetchFlightInfo: (icao: ICAO) => Promise<any>;
+    getZones: () => Promise<any>;
+    setZones: (zonesJsonString: string) => Promise<TResponse>;
+    getPriorityList: () => Promise<any>;
+    setPriorityList: (priorityListJsonString: string) => Promise<TResponse>;
+    getWhiteList: () => Promise<any>;
+    setWhiteList: (whiteListJsonString: string) => Promise<TResponse>;
+    getBlackList: () => Promise<any>;
+    setBlackList: (blackListJsonString: string) => Promise<TResponse>;
+    getTrackingMode: () => Promise<any>;
+    setTrackingMode: (modeJsonString: string) => Promise<TResponse>;
+    startTrackingPlane: (icao: ICAO) => Promise<TResponse>;
+    stopTrackingPlane: () => Promise<TResponse>;
+    goToCoordinates: (lat: number, lon: number, alt?: number) => Promise<TResponse>;
+    exportAppSettings: (dataType: TExportDataType) => Promise<TBlobResponse<Client>>;
+    importAppSettings: (dataType: TImportDataType, formData: FormData) => Promise<TResponse>;
+    resetPtzCalibration: () => Promise<TResponse>;
+    checkGenetecConnection: (params: TParameters) => Promise<TResponse>;
+    getGenetecCameraList: (params: TParameters) => Promise<any>;
+    serverRunCheck: () => Promise<TResponse>;
+    private _getJson;
+    private _getBlob;
+    private parseBlobResponse;
+    private _postJsonEncoded;
+    private _postUrlEncoded;
+}
+export {};

package/esm/PlaneTrackerAPI.js

@@ -0,0 +1,172 @@
+import { z } from 'zod';
+import { paramToUrl, responseStringify } from './internal/utils';
+import { ParsingBlobError } from './errors/errors';
+export const BASE_URL = '/local/planetracker';
+export class PlaneTrackerAPI {
+    client;
+    apiUser;
+    _apiUserQuery;
+    constructor(client, apiUser) {
+        this.client = client;
+        this.apiUser = apiUser;
+        this._apiUserQuery = paramToUrl(this.apiUser);
+    }
+    static getProxyUrlPath = () => `${BASE_URL}/proxy.cgi`;
+    async checkCameraTime() {
+        const responseSchema = z.discriminatedUnion('state', [
+            z.object({
+                state: z.literal(true),
+                code: z.number(),
+            }),
+            z.object({
+                state: z.literal(false),
+                code: z.number(),
+                reason: z.union([
+                    z.literal('INVALID_TIME'),
+                    z.literal('COULDNT_RESOLVE_HOST'),
+                    z.literal('CONNECTION_ERROR'),
+                ]),
+                message: z.string(),
+            }),
+        ]);
+        const response = await this._getJson(`${BASE_URL}/camera_time.cgi`);
+        const cameraTime = responseSchema.parse(response);
+        if (!cameraTime.state) {
+            console.error(`Camera time check failed: ${cameraTime.reason} - ${cameraTime.message}`);
+        }
+        return cameraTime.state;
+    }
+    fetchCameraSettings = async () => {
+        return await this._getJson(`${BASE_URL}/package_camera_settings.cgi`, { action: 'get' });
+    };
+    setCameraSettings = async (settingsJsonString) => {
+        return await this._postJsonEncoded(`${BASE_URL}/package_camera_settings.cgi`, settingsJsonString, {
+            action: 'set',
+        });
+    };
+    fetchServerSettings = async () => {
+        return await this._getJson(`${BASE_URL}/package_server_settings.cgi`, { action: 'get' });
+    };
+    fetchMapInfo = async () => {
+        return await this._getJson(`${BASE_URL}/package/getMapInfo.cgi`);
+    };
+    fetchFlightInfo = async (icao) => {
+        return await this._getJson(`${BASE_URL}/package/flightInfo.cgi`, { icao: encodeURIComponent(icao) });
+    };
+    getZones = async () => {
+        return await this._getJson(`${BASE_URL}/package/getZones.cgi`);
+    };
+    setZones = async (zonesJsonString) => {
+        return await this._postJsonEncoded(`${BASE_URL}/package/setZones.cgi?${this._apiUserQuery}`, zonesJsonString);
+    };
+    getPriorityList = async () => {
+        return await this._getJson(`${BASE_URL}/package/getPriorityList.cgi`);
+    };
+    setPriorityList = async (priorityListJsonString) => {
+        return await this._postJsonEncoded(`${BASE_URL}/package/setPriorityList.cgi?${this._apiUserQuery}`, priorityListJsonString);
+    };
+    getWhiteList = async () => {
+        return await this._getJson(`${BASE_URL}/package/getWhiteList.cgi`);
+    };
+    setWhiteList = async (whiteListJsonString) => {
+        return await this._postJsonEncoded(`${BASE_URL}/package/setWhiteList.cgi?${this._apiUserQuery}`, whiteListJsonString);
+    };
+    getBlackList = async () => {
+        return await this._getJson(`${BASE_URL}/package/getBlackList.cgi`);
+    };
+    setBlackList = async (blackListJsonString) => {
+        return await this._postJsonEncoded(`${BASE_URL}/package/setBlackList.cgi?${this._apiUserQuery}`, blackListJsonString);
+    };
+    getTrackingMode = async () => {
+        return await this._getJson(`${BASE_URL}/package/getTrackingMode.cgi`);
+    };
+    setTrackingMode = async (modeJsonString) => {
+        return await this._postJsonEncoded(`${BASE_URL}/package/setTrackingMode.cgi?${this._apiUserQuery}`, modeJsonString);
+    };
+    startTrackingPlane = async (icao) => {
+        return await this.client.get(`${BASE_URL}/package/trackIcao.cgi`, {
+            icao: encodeURIComponent(icao),
+            userId: encodeURIComponent(this.apiUser.userId),
+            userName: encodeURIComponent(this.apiUser.userName),
+            userPriority: this.apiUser.userPriority,
+        });
+    };
+    stopTrackingPlane = async () => {
+        return await this.client.get(`${BASE_URL}/package/resetIcao.cgi?${this._apiUserQuery}`);
+    };
+    goToCoordinates = async (lat, lon, alt) => {
+        const url = `${BASE_URL}/package/goToCoordinates.cgi?lat=${lat}&lon=${lon}&${this._apiUserQuery}`;
+        return await this.client.get(`${url}${alt !== undefined ? `&alt=${alt}` : ''}`);
+    };
+    exportAppSettings = async (dataType) => {
+        return await this._getBlob(`${BASE_URL}/package_data.cgi`, { action: 'EXPORT', dataType });
+    };
+    importAppSettings = async (dataType, formData) => {
+        return await this.client.post(`${BASE_URL}/package_data.cgi`, formData, { action: 'IMPORT', dataType });
+    };
+    resetPtzCalibration = async () => {
+        return await this.client.get(`${BASE_URL}/package/resetPtzCalibration.cgi`, {
+            userId: encodeURIComponent(this.apiUser.userId),
+            userName: encodeURIComponent(this.apiUser.userName),
+            userPriority: this.apiUser.userPriority,
+        });
+    };
+    checkGenetecConnection = async (params) => {
+        return await this._postUrlEncoded(`${BASE_URL}/package/checkGenetecConnection.cgi`, params);
+    };
+    getGenetecCameraList = async (params) => {
+        const res = await this._postUrlEncoded(`${BASE_URL}/package/getGenetecCameraList.cgi`, params);
+        return await res.json();
+    };
+    serverRunCheck = async () => {
+        return await this.client.get(`${BASE_URL}/package/serverRunCheck.cgi`);
+    };
+    async _getJson(...args) {
+        const res = await this.client.get(...args);
+        if (res.ok) {
+            return await res.json();
+        }
+        else {
+            throw new Error(await responseStringify(res));
+        }
+    }
+    async _getBlob(...args) {
+        const res = await this.client.get(...args);
+        if (res.ok) {
+            return await this.parseBlobResponse(res);
+        }
+        else {
+            throw new Error(await responseStringify(res));
+        }
+    }
+    async parseBlobResponse(response) {
+        try {
+            return (await response.blob());
+        }
+        catch (err) {
+            throw new ParsingBlobError(err);
+        }
+    }
+    async _postJsonEncoded(...args) {
+        const [path, data, params, headers] = args;
+        const baseHeaders = { 'Accept': 'application/json', 'Content-Type': 'application/json' };
+        const res = await this.client.post(path, data, params, { ...baseHeaders, ...headers });
+        if (res.ok) {
+            return res;
+        }
+        else {
+            throw new Error(await responseStringify(res));
+        }
+    }
+    async _postUrlEncoded(path, params, headers) {
+        const data = paramToUrl(params);
+        const baseHeaders = { 'Content-Type': 'application/x-www-form-urlencoded' };
+        const res = await this.client.post(path, data, {}, { ...baseHeaders, ...headers });
+        if (res.ok) {
+            return res;
+        }
+        else {
+            throw new Error(await responseStringify(res));
+        }
+    }
+}

package/esm/VapixAPI.d.ts

@@ -0,0 +1,78 @@
+import { IClient, TParameters, TResponse } from './internal/types';
+import { TAudioSampleRates, TSDCardInfo, TPtzOverview, TCameraPTZItem, TCameraPTZItemData, TAudioDevice } from './types/VapixAPI';
+import { ProxyClient } from './internal/ProxyClient';
+import { TCameraImageConfig, TProxyParam } from './types/common';
+export declare class VapixAPI<Client extends IClient<TResponse> = IClient<TResponse>> {
+    client: ProxyClient<Client>;
+    constructor(client: Client, getProxyUrl: () => string);
+    getUrlEncoded(proxy: TProxyParam, path: string, parameters?: TParameters, headers?: Record<string, string>): Promise<TResponse>;
+    postJson(proxy: TProxyParam, path: string, jsonData: Record<string, any>, headers?: Record<string, string>): Promise<TResponse>;
+    getCameraImage(params: TCameraImageConfig, proxy?: TProxyParam): Promise<TResponse>;
+    getEventDeclarations(proxy?: TProxyParam): Promise<string>;
+    getSupportedAudioSampleRate(proxy?: TProxyParam): Promise<TAudioSampleRates[]>;
+    performAutofocus(proxy?: TProxyParam): Promise<void>;
+    checkSDCard(proxy?: TProxyParam): Promise<TSDCardInfo>;
+    mountSDCard(proxy?: TProxyParam): Promise<number>;
+    unmountSDCard(proxy?: TProxyParam): Promise<number>;
+    private _doSDCardMountAction;
+    fetchSDCardJobProgress(jobId: number, proxy?: TProxyParam): Promise<number>;
+    downloadCameraReport(proxy?: TProxyParam): Promise<TResponse>;
+    getSystemLog(proxy?: TProxyParam): Promise<TResponse>;
+    getMaxFps(channel: number, proxy?: TProxyParam): Promise<number>;
+    getTimezone(proxy?: TProxyParam): Promise<string>;
+    getDateTimeInfo(proxy?: TProxyParam): Promise<{
+        data: {
+            dateTime: string;
+            dstEnabled: boolean;
+            localDateTime: string;
+            posixTimeZone: string;
+            timeZone?: string | undefined;
+        };
+    }>;
+    getDevicesSettings(proxy?: TProxyParam): Promise<TAudioDevice[]>;
+    fetchRemoteDeviceInfo<T extends Record<string, any>>(payload: T, proxy?: TProxyParam): Promise<any>;
+    getHeaders(proxy?: TProxyParam): Promise<Record<string, string>>;
+    setHeaders(headers: Record<string, string>, proxy?: TProxyParam): Promise<TResponse>;
+    getParameter(paramNames: string | string[], proxy?: TProxyParam): Promise<Record<string, string>>;
+    setParameter(params: Record<string, string | number | boolean>, proxy?: TProxyParam): Promise<boolean>;
+    getGuardTourList(proxy?: TProxyParam): Promise<{
+        name: string;
+        id: string;
+        running: string;
+        tour: {
+            moveSpeed?: unknown;
+            position?: unknown;
+            presetNbr?: unknown;
+            waitTime?: unknown;
+            waitTimeViewType?: unknown;
+        }[];
+        camNbr?: unknown;
+        randomEnabled?: unknown;
+        timeBetweenSequences?: unknown;
+    }[]>;
+    setGuardTourEnabled(guardTourID: string, enable: boolean, proxy?: TProxyParam): Promise<boolean>;
+    getPTZPresetList(channel: number, proxy?: TProxyParam): Promise<string[]>;
+    listPTZ(camera: number, proxy?: TProxyParam): Promise<TCameraPTZItem[]>;
+    listPtzVideoSourceOverview(proxy?: TProxyParam): Promise<TPtzOverview>;
+    goToPreset(channel: number, presetName: string, proxy?: TProxyParam): Promise<TResponse>;
+    getPtzPosition(camera: number, proxy?: TProxyParam): Promise<TCameraPTZItemData>;
+    getInputState(port: number, proxy?: TProxyParam): Promise<boolean>;
+    setOutputState(port: number, active: boolean, proxy?: TProxyParam): Promise<TResponse>;
+    getApplicationList(proxy?: TProxyParam): Promise<{
+        appId: "CamStreamer" | "CamSwitcher" | "CamOverlay" | "CamScripter" | "PlaneTracker" | "Ndihxplugin" | "SportTracker" | null;
+        Name: string;
+        NiceName: string;
+        Vendor: string;
+        Version: string;
+        License: string;
+        Status: string;
+        ApplicationID?: string | undefined;
+        ConfigurationPage?: string | undefined;
+        VendorHomePage?: string | undefined;
+        LicenseName?: string | undefined;
+    }[]>;
+    startApplication(applicationID: string, proxy?: TProxyParam): Promise<void>;
+    restartApplication(applicationID: string, proxy?: TProxyParam): Promise<void>;
+    stopApplication(applicationID: string, proxy?: TProxyParam): Promise<void>;
+    installApplication(data: Blob, fileName: string): Promise<void>;
+}