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

package/types/CamSwitcherAPI.d.ts

@@ -1,6 +1,6 @@
 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, THttpRequestOptions, TNetworkCamera, TProxyParams, TStorageType } from './types/common';
+import { TStreamSaveList, TTrackerSaveList, TClipSaveList, TPlaylistSaveList, TCameraOptions, TGlobalAudioSettings, TSecondaryAudioSettings } from './types/CamSwitcherAPI';
+import { TAudioChannel, THttpRequestOptions, TProxyParams, TStorageType } from './types/common';
 import { ProxyClient } from './internal/ProxyClient';
 export declare class CamSwitcherAPI<Client extends IClient<TResponse, any>> {
     client: Client;
@@ -10,26 +10,110 @@ export declare class CamSwitcherAPI<Client extends IClient<TResponse, any>> {
         new (form?: HTMLFormElement | undefined, submitter?: HTMLElement | null | undefined): FormData;
         prototype: FormData;
     });
-    static getProxyUrlPath: () => string;
-    static getWsEventsUrlPath: () => string;
-    static getClipPreviewUrlPath: (id: string, storage: TStorageType) => string;
+    static getProxyPath: () => string;
+    static getWsEventsPath: () => string;
+    static getClipPreviewPath: (id: string, storage: TStorageType) => string;
     getClient(proxyParams?: TProxyParams): Client | ProxyClient<Client>;
     generateSilence(sampleRate: number, channels: TAudioChannel, options?: THttpRequestOptions): Promise<void>;
     checkCameraTime(options?: THttpRequestOptions): Promise<boolean>;
-    getNetworkCameraList(options?: THttpRequestOptions): Promise<TNetworkCamera[]>;
+    getNetworkCameraList(options?: THttpRequestOptions): Promise<{
+        name: string;
+        ip: string;
+    }[]>;
     getMaxFps(source: number, options?: THttpRequestOptions): Promise<number>;
-    getStorageInfo(options?: THttpRequestOptions): Promise<TStorageInfo[]>;
+    getStorageInfo(options?: THttpRequestOptions): Promise<{
+        storage: "SD_DISK" | "FLASH";
+        writable: boolean;
+        size: number;
+        available: number;
+    }[]>;
     wsAuthorization(options?: THttpRequestOptions): Promise<string>;
-    getOutputInfo(options?: THttpRequestOptions): Promise<TOutputInfo>;
-    getAudioPushInfo(options?: THttpRequestOptions): Promise<TAudioPushInfo>;
-    getStreamSaveList(options?: THttpRequestOptions): Promise<TStreamSaveLoadList>;
-    getClipSaveList(options?: THttpRequestOptions): Promise<TClipSaveLoadList>;
-    getPlaylistSaveList(options?: THttpRequestOptions): Promise<TPlaylistSaveLoadList>;
-    getTrackerSaveList(options?: THttpRequestOptions): Promise<TrackerSaveLoadList>;
-    setStreamSaveList(data: TStreamSaveList, options?: THttpRequestOptions): Promise<boolean>;
-    setClipSaveList(data: TClipSaveList, options?: THttpRequestOptions): Promise<boolean>;
-    setPlaylistSaveList(data: TPlaylistSaveList, options?: THttpRequestOptions): Promise<boolean>;
-    setTrackerSaveList(data: TTrackerSaveList, options?: THttpRequestOptions): Promise<boolean>;
+    getOutputInfo(options?: THttpRequestOptions): Promise<{
+        rtspUrl: string;
+        ws: string;
+        wsInitialMessage: string;
+    }>;
+    getAudioPushInfo(options?: THttpRequestOptions): Promise<{
+        ws: string;
+        wsInitialMessage: string;
+    }>;
+    getStreamSaveList(options?: THttpRequestOptions): Promise<Record<string, {
+        ip?: string | undefined;
+        niceName?: string | undefined;
+        mdnsName?: string | undefined;
+        port?: number | undefined;
+        enabled?: boolean | undefined;
+        auth?: string | undefined;
+        query?: string | undefined;
+        channel?: "audio" | "video" | "av" | undefined;
+        keyboard?: Record<string, string | null> | undefined;
+        sortIndexOverview?: number | undefined;
+        viewNumber?: number | undefined;
+    }>>;
+    getClipSaveList(options?: THttpRequestOptions): Promise<Record<string, {
+        niceName?: string | undefined;
+        channel?: "audio" | "video" | "av" | undefined;
+        keyboard?: Record<string, string | null> | undefined;
+        sortIndexOverview?: number | undefined;
+    }>>;
+    getPlaylistSaveList(options?: THttpRequestOptions): Promise<Record<string, {
+        niceName?: string | undefined;
+        channel?: "audio" | "video" | "av" | undefined;
+        keyboard?: Record<string, string | null> | undefined;
+        sortIndexOverview?: number | undefined;
+        isFavourite?: boolean | undefined;
+        sortIndexFavourite?: 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?: {
+            repeat: number;
+            video: {
+                storage?: "SD_DISK" | "FLASH" | undefined;
+                stream_name?: string | undefined;
+                clip_name?: string | undefined;
+                tracker_name?: string | undefined;
+            };
+            id: string;
+            isTimeoutCustom: boolean;
+            ptz_preset_pos_name: string;
+            timeout: number;
+            audio?: {
+                storage?: "SD_DISK" | "FLASH" | undefined;
+                stream_name?: string | undefined;
+                clip_name?: string | undefined;
+                tracker_name?: string | undefined;
+            } | undefined;
+        }[] | undefined;
+    }>>;
+    getTrackerSaveList(options?: THttpRequestOptions): Promise<Record<string, {
+        name?: string | undefined;
+        channel?: "audio" | "video" | "av" | undefined;
+        keyboard?: Record<string, string | null> | undefined;
+        sortIndexOverview?: number | undefined;
+        viewNumber?: number | undefined;
+        id?: string | undefined;
+        previewId?: string | undefined;
+        duration?: number | 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;
+            overview: boolean;
+            zone: number[];
+            playlist_name: string;
+            ptz_preset_pos_no: number;
+        }[] | undefined;
+        camera_view_number?: number | undefined;
+    }>>;
+    setStreamSaveList(data: TStreamSaveList, options?: THttpRequestOptions): Promise<any>;
+    setClipSaveList(data: TClipSaveList, options?: THttpRequestOptions): Promise<any>;
+    setPlaylistSaveList(data: TPlaylistSaveList, options?: THttpRequestOptions): Promise<any>;
+    setTrackerSaveList(data: TTrackerSaveList, options?: THttpRequestOptions): Promise<any>;
     playlistSwitch(playlistName: string, options?: THttpRequestOptions): Promise<void>;
     playlistQueuePush(playlistName: string, options?: THttpRequestOptions): Promise<void>;
     playlistQueueClear(options?: THttpRequestOptions): Promise<void>;
@@ -37,18 +121,47 @@ export declare class CamSwitcherAPI<Client extends IClient<TResponse, any>> {
     playlistQueuePlayNext(options?: THttpRequestOptions): Promise<void>;
     addNewClip(file: any, clipType: 'video' | 'audio', storage: TStorageType, clipId: string, fileName?: string, options?: THttpRequestOptions): Promise<void>;
     removeClip(clipId: string, storage: TStorageType, options?: THttpRequestOptions): Promise<any>;
-    getClipList(options?: THttpRequestOptions): Promise<TClipList>;
+    getClipList(options?: THttpRequestOptions): Promise<Record<string, {
+        storage: "SD_DISK" | "FLASH";
+        stream_list: ({
+            type: "video";
+            width: number;
+            height: number;
+            fps: number;
+            sample_rate: number;
+            h264_profile: "high" | "main" | "baseline";
+            h264_level: "4.1";
+            gop: number;
+            bitrate: number;
+        } | {
+            type: "audio";
+            sample_rate: number;
+            channel_count: 1 | 2;
+        })[];
+        duration: number;
+    }>>;
     setCamSwitchOptions(data: TCameraOptions, cameraFWVersion: string, options?: THttpRequestOptions): Promise<void>;
     setGlobalAudioSettings(settings: TGlobalAudioSettings, options?: THttpRequestOptions): Promise<void>;
     setSecondaryAudioSettings(settings: TSecondaryAudioSettings, options?: THttpRequestOptions): Promise<void>;
     setDefaultPlaylist(playlistId: string, options?: THttpRequestOptions): Promise<void>;
     setPermanentRtspUrlToken(token: string, options?: THttpRequestOptions): Promise<void>;
-    getCamSwitchOptions(options?: THttpRequestOptions): Promise<Partial<TCameraOptions>>;
-    getGlobalAudioSettings(options?: THttpRequestOptions): Promise<TGlobalAudioSettings>;
-    getSecondaryAudioSettings(options?: THttpRequestOptions): Promise<TSecondaryAudioSettings>;
+    getCamSwitchOptions(options?: THttpRequestOptions): Promise<any>;
+    getGlobalAudioSettings(options?: THttpRequestOptions): Promise<{
+        type: "fromSource" | "source";
+        source: string;
+        storage?: string | undefined;
+    }>;
+    getSecondaryAudioSettings(options?: THttpRequestOptions): Promise<{
+        type: "CLIP" | "STREAM" | "NONE";
+        storage: "SD_DISK" | "FLASH";
+        secondaryAudioLevel: number;
+        masterAudioLevel: number;
+        streamName?: string | undefined;
+        clipName?: string | undefined;
+    }>;
     getPermanentRtspUrlToken(options?: THttpRequestOptions): Promise<string>;
-    private get;
-    private set;
+    private _getJson;
+    private _post;
     private setParamFromCameraJSON;
     private getParamFromCameraAndJSONParse;
 }

package/types/PlaneTrackerAPI.d.ts

@@ -1,43 +1,224 @@
 import { IClient, TBlobResponse, TParameters, TResponse } from './internal/types';
-import { ICAO, TApiUser, TExportDataType, TImportDataType } from './types/PlaneTrackerAPI';
+import { ICAO, TApiUser, TBlackList, TExportDataType, TImportDataType, TPriorityList, TTrackingMode, TWhiteList, TZones } from './types/PlaneTrackerAPI';
 import { THttpRequestOptions, TProxyParams } from './types/common';
 import { ProxyClient } from './internal/ProxyClient';
 export declare class PlaneTrackerAPI<Client extends IClient<TResponse, any>> {
     private client;
     private apiUser;
     constructor(client: Client, apiUser: TApiUser);
-    static getProxyUrlPath: () => string;
+    static getProxyPath: () => string;
     getClient(proxyParams?: TProxyParams): Client | ProxyClient<Client>;
     checkCameraTime(options?: THttpRequestOptions): Promise<boolean>;
     resetPtzCalibration(options?: THttpRequestOptions): Promise<TResponse>;
     resetFocusCalibration(options?: THttpRequestOptions): Promise<TResponse>;
     serverRunCheck(options?: THttpRequestOptions): Promise<TResponse>;
     getLiveViewAlias(rtspUrl: string, options?: THttpRequestOptions): Promise<TResponse>;
-    fetchCameraSettings(options?: THttpRequestOptions): Promise<any>;
-    setCameraSettings(settingsJsonString: string, options?: THttpRequestOptions): Promise<TResponse>;
-    fetchServerSettings(options?: THttpRequestOptions): Promise<any>;
+    fetchCameraSettings(options?: THttpRequestOptions): Promise<{
+        camera: {
+            ip: string;
+            port: number;
+            protocol: "https" | "http" | "https_insecure";
+            user: string;
+            pass: string;
+        };
+        units: "metric" | "imperial";
+        adsbSource: {
+            ip: string;
+            port: number;
+        };
+        cameraCalibrationProcessConfig: {
+            nightSkyCalibrationEnabled: boolean;
+            scheduleNightSkyCalibrationTimestamp: number;
+        };
+        cameraConfig: {
+            defaultCaptureSizeMeters: number;
+            captureSizeExtensionMeters: number;
+            maxZoomLevel?: number | undefined;
+        };
+        stream: {
+            width: number;
+            height: number;
+        };
+        imageConfig: {
+            dayAperture: number;
+            nightAperture: number;
+        };
+        airportConfig: {
+            icao: string;
+            centerLat: number;
+            centerLon: number;
+            radius: number;
+        };
+        trackingConfig: {
+            prioritizeEmergency: boolean;
+        };
+        widget: {
+            enabled: boolean;
+            scale: number;
+            coord: "top_left" | "top_right" | "bottom_left" | "bottom_right";
+            posX: number;
+            posY: number;
+        };
+        airportWidget: {
+            enabled: boolean;
+            scale: number;
+            coord: "top_left" | "top_right" | "bottom_left" | "bottom_right";
+            posX: number;
+            posY: number;
+        };
+        fr24FlightInfoSource: {
+            enabled: boolean;
+            priority: number;
+            apiToken: string;
+            validateFlights: boolean;
+        };
+        radarcapeFlightInfoSource: {
+            ip: string;
+            port: number;
+            enabled: boolean;
+            priority: number;
+        };
+        identificationLabel: {
+            firstRow: "blank" | "registration" | "call_sign" | "flight_number" | "icao";
+            secondRow: "blank" | "registration" | "call_sign" | "flight_number" | "icao";
+            thirdRow: "blank" | "registration" | "call_sign" | "flight_number" | "icao";
+            fourthRow: "blank" | "registration" | "call_sign" | "flight_number" | "icao";
+            opacity: number;
+        };
+        acs: {
+            ip: string;
+            port: number;
+            enabled: boolean;
+            protocol: "https" | "http" | "https_insecure";
+            user: string;
+            pass: string;
+            sourceKey: string;
+        };
+        genetec: {
+            ip: string;
+            port: number;
+            enabled: boolean;
+            cameraList: string[];
+            appId: string;
+            protocol: "https" | "http" | "https_insecure";
+            user: string;
+            pass: string;
+            baseUri: string;
+        };
+        overlayText?: {
+            displayIcao?: boolean | undefined;
+            displayRegistration?: boolean | undefined;
+            displayFlightNumber?: boolean | undefined;
+            displayAltitude?: boolean | undefined;
+            displayVelocity?: boolean | undefined;
+            displayDistance?: boolean | undefined;
+            displayFOV?: boolean | undefined;
+            displayPTError?: boolean | undefined;
+            displayPTZSpeed?: boolean | undefined;
+            displayVelocityData?: boolean | undefined;
+            displaySignalQuality?: boolean | undefined;
+            displayAutoTrackingInfo?: boolean | undefined;
+            displayGPSCoords?: boolean | undefined;
+            displayVapixQuery?: boolean | undefined;
+            displayFocus?: boolean | undefined;
+            displayAperture?: boolean | undefined;
+            displaySunDistance?: boolean | undefined;
+            displayTickTime?: boolean | undefined;
+            displayAircraftInfo?: boolean | undefined;
+        } | undefined;
+    }>;
+    setCameraSettings(settingsJsonString: string, options?: THttpRequestOptions): Promise<any>;
+    fetchServerSettings(options?: THttpRequestOptions): Promise<{
+        cameraCalibration: {
+            posLat: number;
+            posLon: number;
+            geoidHN: number;
+            altitudeAmsl: number;
+            rotationEast: number;
+            rotationNorth: number;
+            rotationUp: number;
+            tiltTransformationCoefA: number;
+            tiltCameraKnownPoint: number;
+            tiltRealKnownPoint: number;
+        };
+    }>;
     exportAppSettings(dataType: TExportDataType, options?: THttpRequestOptions): Promise<TBlobResponse<Client>>;
     importAppSettings(dataType: TImportDataType, formData: Parameters<Client['post']>[0]['data'], options?: THttpRequestOptions): Promise<TResponse>;
-    fetchFlightInfo(icao: ICAO, options?: THttpRequestOptions): Promise<any>;
-    getTrackingMode(options?: THttpRequestOptions): Promise<any>;
-    setTrackingMode(modeJsonString: string, options?: THttpRequestOptions): Promise<TResponse>;
+    fetchFlightInfo(icao: ICAO, options?: THttpRequestOptions): Promise<{
+        destinationAirport: {
+            icao?: string | undefined;
+            iata?: string | undefined;
+            city?: string | undefined;
+        };
+        registration?: string | undefined;
+        callsign?: string | undefined;
+        flightNumber?: string | undefined;
+        aircraftType?: string | undefined;
+        airlines?: string | undefined;
+        originAirport?: {
+            icao?: string | undefined;
+            iata?: string | undefined;
+            city?: string | undefined;
+        } | undefined;
+        flightImages?: {
+            src?: string | undefined;
+            photographer?: string | undefined;
+        }[] | undefined;
+    }>;
+    getTrackingMode(options?: THttpRequestOptions): Promise<{
+        mode: "MANUAL" | "AUTOMATIC";
+    }>;
+    setTrackingMode(mode: TTrackingMode['mode'], options?: THttpRequestOptions): Promise<any>;
     startTrackingPlane(icao: ICAO, options?: THttpRequestOptions): Promise<TResponse>;
     stopTrackingPlane(options?: THttpRequestOptions): Promise<TResponse>;
-    getPriorityList(options?: THttpRequestOptions): Promise<any>;
-    setPriorityList(priorityListJsonString: string, options?: THttpRequestOptions): Promise<TResponse>;
-    getWhiteList(options?: THttpRequestOptions): Promise<any>;
-    setWhiteList(whiteListJsonString: string, options?: THttpRequestOptions): Promise<TResponse>;
-    getBlackList(options?: THttpRequestOptions): Promise<any>;
-    setBlackList(blackListJsonString: string, options?: THttpRequestOptions): Promise<TResponse>;
-    fetchMapInfo(options?: THttpRequestOptions): Promise<any>;
-    getZones(options?: THttpRequestOptions): Promise<any>;
-    setZones(zonesJsonString: string, options?: THttpRequestOptions): Promise<TResponse>;
+    getPriorityList(options?: THttpRequestOptions): Promise<{
+        priorityList: string[];
+    }>;
+    setPriorityList(priorityList: TPriorityList['priorityList'], options?: THttpRequestOptions): Promise<any>;
+    getWhiteList(options?: THttpRequestOptions): Promise<{
+        whiteList: string[];
+    }>;
+    setWhiteList(whiteList: TWhiteList['whiteList'], options?: THttpRequestOptions): Promise<any>;
+    getBlackList(options?: THttpRequestOptions): Promise<{
+        blackList: string[];
+    }>;
+    setBlackList(blackList: TBlackList['blackList'], options?: THttpRequestOptions): Promise<any>;
+    fetchMapInfo(options?: THttpRequestOptions): Promise<{
+        minZoom: number;
+        maxZoom: number;
+        mapTypes: ("roadmap" | "satellite")[];
+        tileSize: number;
+    }>;
+    getZones(options?: THttpRequestOptions): Promise<{
+        zones: {
+            enabled: boolean;
+            area: [{
+                lat: number;
+                lon: number;
+            }, ...{
+                lat: number;
+                lon: number;
+            }[]];
+            weight: number;
+            name?: string | undefined;
+            minAltitudeAmsl?: number | undefined;
+            maxAltitudeAmsl?: number | undefined;
+            minSpeedKmph?: number | undefined;
+            maxSpeedKmph?: number | undefined;
+        }[];
+    }>;
+    setZones(zones: TZones['zones'], options?: THttpRequestOptions): Promise<any>;
     goToCoordinates(lat: number, lon: number, alt?: number, options?: THttpRequestOptions): Promise<TResponse>;
-    checkGenetecConnection(params: TParameters, options?: THttpRequestOptions): Promise<TResponse>;
-    getGenetecCameraList(params: TParameters, options?: THttpRequestOptions): Promise<any>;
+    checkGenetecConnection(params: TParameters, options?: THttpRequestOptions): Promise<any>;
+    getGenetecCameraList(params: TParameters, options?: THttpRequestOptions): Promise<{
+        value: string;
+        index: number;
+        label: string;
+    }[]>;
     private _getJson;
+    private _post;
     private _getBlob;
     private parseBlobResponse;
-    private _postJsonEncoded;
     private _postUrlEncoded;
+    private _postJsonEncoded;
 }

package/types/VapixAPI.d.ts

@@ -1,5 +1,5 @@
 import { IClient, TParameters, TResponse } from './internal/types';
-import { TAudioSampleRates, TSDCardInfo, TPtzOverview, TCameraPTZItem, TCameraPTZItemData, TAudioDevice, TPortSetSchema, TPortSequenceStateSchema } from './types/VapixAPI';
+import { TAudioDevice, TPortSetSchema, TPortSequenceStateSchema } from './types/VapixAPI';
 import { ProxyClient } from './internal/ProxyClient';
 import { TCameraImageConfig, THttpRequestOptions, TProxyParams } from './types/common';
 export declare class VapixAPI<Client extends IClient<TResponse, any>> {
@@ -14,9 +14,16 @@ export declare class VapixAPI<Client extends IClient<TResponse, any>> {
     postJson(path: string, jsonData: Record<string, any>, headers?: Record<string, string>, options?: THttpRequestOptions): Promise<TResponse>;
     getCameraImage(parameters: TCameraImageConfig, options?: THttpRequestOptions): Promise<ReturnType<Client["get"]>>;
     getEventDeclarations(options?: THttpRequestOptions): Promise<string>;
-    getSupportedAudioSampleRate(options?: THttpRequestOptions): Promise<TAudioSampleRates[]>;
+    getSupportedAudioSampleRate(options?: THttpRequestOptions): Promise<{
+        sampleRate: number;
+        bitRates: number[];
+    }[]>;
     performAutofocus(options?: THttpRequestOptions): Promise<void>;
-    checkSDCard(options?: THttpRequestOptions): Promise<TSDCardInfo>;
+    checkSDCard(options?: THttpRequestOptions): Promise<{
+        status: "OK" | "connected" | "disconnected";
+        totalSize: number;
+        freeSize: number;
+    }>;
     mountSDCard(options?: THttpRequestOptions): Promise<number>;
     unmountSDCard(options?: THttpRequestOptions): Promise<number>;
     private _doSDCardMountAction;
@@ -54,13 +61,28 @@ export declare class VapixAPI<Client extends IClient<TResponse, any>> {
         camNbr?: unknown;
         randomEnabled?: unknown;
         timeBetweenSequences?: unknown;
-    }[]>;
-    setGuardTourEnabled(guardTourID: string, enable: boolean, options?: THttpRequestOptions): Promise<void>;
+    }>;
+    setGuardTourEnabled(guardTourId: string, enable: boolean, options?: THttpRequestOptions): Promise<void>;
     getPTZPresetList(channel: number, options?: THttpRequestOptions): Promise<string[]>;
-    listPTZ(camera: number, options?: THttpRequestOptions): Promise<TCameraPTZItem[]>;
-    listPtzVideoSourceOverview(options?: THttpRequestOptions): Promise<TPtzOverview>;
+    listPTZ(camera: number, options?: THttpRequestOptions): Promise<{
+        name: string;
+        id: number;
+        data: {
+            pan?: number | undefined;
+            tilt?: number | undefined;
+            zoom?: number | undefined;
+        };
+    }[]>;
+    listPtzVideoSourceOverview(options?: THttpRequestOptions): Promise<Record<number, {
+        name: string;
+        id: number;
+    }[]>>;
     goToPreset(channel: number, presetName: string, options?: THttpRequestOptions): Promise<TResponse>;
-    getPtzPosition(camera: number, options?: THttpRequestOptions): Promise<TCameraPTZItemData>;
+    getPtzPosition(camera: number, options?: THttpRequestOptions): Promise<{
+        pan?: number | undefined;
+        tilt?: number | undefined;
+        zoom?: number | undefined;
+    }>;
     getPorts(options?: THttpRequestOptions): Promise<{
         name: string;
         port: string;
@@ -73,10 +95,22 @@ export declare class VapixAPI<Client extends IClient<TResponse, any>> {
     }[]>;
     setPorts(ports: TPortSetSchema[], options?: THttpRequestOptions): Promise<void>;
     setPortStateSequence(port: number, sequence: TPortSequenceStateSchema[], options?: THttpRequestOptions): Promise<void>;
-    getApplicationList(options?: THttpRequestOptions): Promise<any>;
-    startApplication(applicationID: string, options?: THttpRequestOptions): Promise<void>;
-    restartApplication(applicationID: string, options?: THttpRequestOptions): Promise<void>;
-    stopApplication(applicationID: string, options?: THttpRequestOptions): Promise<void>;
+    getApplicationList(options?: THttpRequestOptions): Promise<{
+        Name: string;
+        NiceName: string;
+        Vendor: string;
+        Version: string;
+        License: string;
+        Status: string;
+        appId: "CamStreamer" | "CamSwitcher" | "CamOverlay" | "CamScripter" | "PlaneTracker" | "Ndihxplugin" | "SportTracker" | null;
+        ApplicationID?: string | undefined;
+        ConfigurationPage?: string | undefined;
+        VendorHomePage?: string | undefined;
+        LicenseName?: string | undefined;
+    }[]>;
+    startApplication(applicationId: string, options?: THttpRequestOptions): Promise<void>;
+    restartApplication(applicationId: string, options?: THttpRequestOptions): Promise<void>;
+    stopApplication(applicationId: string, options?: THttpRequestOptions): Promise<void>;
     installApplication(data: Parameters<typeof FormData.prototype.append>[1], fileName: string, options?: THttpRequestOptions): Promise<void>;
     private static parseParameters;
     private static parseCameraPtzResponse;

package/types/bin/CreatePackage.d.ts

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

package/types/{CamOverlayDrawingAPI.d.ts → node/CamOverlayDrawingAPI.d.ts}

@@ -2,7 +2,7 @@
 /// <reference types="node" />
 /// <reference types="node" />
 import EventEmitter from 'events';
-import { CamOverlayDrawingOptions, TCairoCreateResponse, TCairoResponse, TUploadImageResponse, TWriteTextParams } from './types/CamOverlayDrawingAPI';
+import { CamOverlayDrawingOptions, TCairoCreateResponse, TCairoResponse, TUploadImageResponse, TWriteTextParams } from '../types/CamOverlayDrawingAPI';
 export declare class CamOverlayDrawingAPI extends EventEmitter {
     private tls;
     private tlsInsecure;

package/types/{CamOverlayPainter → node/CamOverlayPainter}/Frame.d.ts

@@ -1,9 +1,9 @@
 /// <reference types="node" />
 import { EventEmitter } from 'events';
 import { CamOverlayDrawingAPI } from '../CamOverlayDrawingAPI';
-import { TAlign, TCairoCreateResponse, TUploadImageResponse } from '../types/CamOverlayDrawingAPI';
+import { TAlign, TCairoCreateResponse, TUploadImageResponse } from '../../types/CamOverlayDrawingAPI';
 import { ResourceManager } from './ResourceManager';
-import { TBg, TBorder, TDrawingCallback, TFrame, TFrameOptions, TObjectFitType, TRgb, TRgba, TText, TTmf } from '../types/CamOverlayPainter';
+import { TBg, TBorder, TDrawingCallback, TFrame, TFrameOptions, TObjectFitType, TRgb, TRgba, TText, TTmf } from '../../types/CamOverlayPainter';
 export declare class Frame extends EventEmitter {
     protected enabled: boolean;
     protected posX: number;

package/types/{CamOverlayPainter → node/CamOverlayPainter}/Painter.d.ts

@@ -1,19 +1,8 @@
 import { CamOverlayDrawingAPI } from '../CamOverlayDrawingAPI';
-import { CamOverlayDrawingOptions } from '../types/CamOverlayDrawingAPI';
+import { CamOverlayDrawingOptions } from '../../types/CamOverlayDrawingAPI';
 import { ResourceManager } from './ResourceManager';
 import { Frame } from './Frame';
-import { TCoAlignment, TPainterOptions } from '../types/CamOverlayPainter';
-export declare const COORD: {
-    readonly top_left: readonly [-1, -1];
-    readonly center_left: readonly [-1, 0];
-    readonly bottom_left: readonly [-1, 1];
-    readonly top_center: readonly [0, -1];
-    readonly center: readonly [0, 0];
-    readonly bottom_center: readonly [0, 1];
-    readonly top_right: readonly [1, -1];
-    readonly center_right: readonly [1, 0];
-    readonly bottom_right: readonly [1, 1];
-};
+import { TCoAlignment, TPainterOptions } from '../../types/CamOverlayPainter';
 export declare class Painter extends Frame {
     private screenWidth;
     private screenHeight;

package/types/{CamOverlayPainter → node/CamOverlayPainter}/ResourceManager.d.ts

@@ -1,5 +1,5 @@
 import { CamOverlayDrawingAPI } from '../CamOverlayDrawingAPI';
-import { TUploadImageResponse, TCairoCreateResponse } from '../types/CamOverlayDrawingAPI';
+import { TUploadImageResponse, TCairoCreateResponse } from '../../types/CamOverlayDrawingAPI';
 export declare class ResourceManager {
     private co;
     private imgFileNames;

package/types/node/CamScripterAPICameraEventsGenerator.d.ts

@@ -0,0 +1,31 @@
+/// <reference types="node" />
+import EventEmitter from 'events';
+import { WsOptions } from '../internal/types';
+import { TCamScripterEvent, TEventDeclaration, TEventUndeclaration, TCamScripterResponse } from '../types/CamScripterAPICameraEventsGenerator';
+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?: WsOptions);
+    connect(): void;
+    disconnect(): void;
+    declareEvent(eventDeclaration: TEventDeclaration): Promise<TCamScripterResponse>;
+    undeclareEvent(eventUndeclaration: TEventUndeclaration): Promise<TCamScripterResponse>;
+    sendEvent(event: TCamScripterEvent): Promise<TCamScripterResponse>;
+    private createWsClient;
+    private incomingWsMessageHandler;
+    private sendMessage;
+    private startMsgsTimeoutCheck;
+    private stopMsgsTimeoutCheck;
+    private reconnectWithError;
+    private reportErr;
+    private reportClose;
+}

package/types/node/VapixEvents.d.ts

@@ -0,0 +1,16 @@
+import { EventEmitter2 as EventEmitter } from 'eventemitter2';
+import { WsOptions } from '../internal/types';
+export declare class VapixEvents extends EventEmitter {
+    private tls;
+    private tlsInsecure;
+    private ip;
+    private port;
+    private user;
+    private pass;
+    private ws;
+    constructor(options?: WsOptions);
+    connect(): void;
+    disconnect(): void;
+    private createWsClient;
+    private isReservedEventName;
+}