camstreamerlib 4.0.0-beta.99 → 4.0.2

package/types/CamSwitcherAPI.d.ts

@@ -1,9 +1,8 @@
 import { IClient, TResponse } from './internal/types';
 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>> {
-    private client;
+import { TAudioChannel, THttpRequestOptions, TStorageType } from './types/common';
+import { BasicAPI } from './internal/BasicAPI';
+export declare class CamSwitcherAPI<Client extends IClient<TResponse, any>> extends BasicAPI<Client> {
     private CustomFormData;
     private vapixAgent;
     constructor(client: Client, CustomFormData?: {
@@ -13,7 +12,7 @@ export declare class CamSwitcherAPI<Client extends IClient<TResponse, any>> {
     static getProxyPath: () => string;
     static getWsEventsPath: () => string;
     static getClipPreviewPath: (clipId: string, storage: TStorageType) => string;
-    getClient(proxyParams?: TProxyParams): Client | ProxyClient<Client>;
+    checkAPIAvailable(options?: THttpRequestOptions): Promise<void>;
     checkCameraTime(options?: THttpRequestOptions): Promise<boolean>;
     getNetworkCameraList(options?: THttpRequestOptions): Promise<{
         name: string;
@@ -22,9 +21,9 @@ export declare class CamSwitcherAPI<Client extends IClient<TResponse, any>> {
     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>;
@@ -39,26 +38,26 @@ export declare class CamSwitcherAPI<Client extends IClient<TResponse, any>> {
     }>;
     getStreamSaveList(options?: THttpRequestOptions): Promise<Record<string, {
         ip?: string | undefined;
+        enabled?: boolean | undefined;
+        port?: number | undefined;
         niceName?: string | undefined;
         mdnsName?: string | undefined;
-        port?: number | undefined;
-        enabled?: boolean | undefined;
         auth?: string | undefined;
         query?: string | undefined;
-        channel?: "audio" | "video" | "av" | undefined;
+        channel?: "video" | "audio" | "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;
+        channel?: "video" | "audio" | "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;
+        channel?: "video" | "audio" | "av" | undefined;
         keyboard?: Record<string, string | null> | undefined;
         sortIndexOverview?: number | undefined;
         isFavourite?: boolean | undefined;
@@ -87,16 +86,16 @@ export declare class CamSwitcherAPI<Client extends IClient<TResponse, any>> {
     }>>;
     getTrackerSaveList(options?: THttpRequestOptions): Promise<Record<string, {
         name?: string | undefined;
-        channel?: "audio" | "video" | "av" | undefined;
+        fps?: number | undefined;
+        id?: string | undefined;
+        width?: number | undefined;
+        height?: number | undefined;
+        duration?: number | undefined;
+        channel?: "video" | "audio" | "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;
@@ -123,11 +122,12 @@ export declare class CamSwitcherAPI<Client extends IClient<TResponse, any>> {
     removeClip(clipId: string, storage: TStorageType, options?: THttpRequestOptions): Promise<void>;
     getClipList(options?: THttpRequestOptions): Promise<Record<string, {
         storage: "FLASH" | "SD_DISK";
+        duration: number;
         stream_list: ({
             type: "video";
+            fps: number;
             width: number;
             height: number;
-            fps: number;
             sample_rate: number;
             h264_profile: "high" | "main" | "baseline";
             h264_level: "4.1";
@@ -138,7 +138,6 @@ export declare class CamSwitcherAPI<Client extends IClient<TResponse, any>> {
             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>;
@@ -147,7 +146,7 @@ export declare class CamSwitcherAPI<Client extends IClient<TResponse, any>> {
     setPermanentRtspUrlToken(token: string, options?: THttpRequestOptions): Promise<void>;
     getCamSwitchOptions(options?: THttpRequestOptions): Promise<any>;
     getGlobalAudioSettings(options?: THttpRequestOptions): Promise<{
-        type: "fromSource" | "source";
+        type: "source" | "fromSource";
         source: string;
         storage?: string | undefined;
     }>;
@@ -160,8 +159,10 @@ export declare class CamSwitcherAPI<Client extends IClient<TResponse, any>> {
         clipName?: string | undefined;
     }>;
     getPermanentRtspUrlToken(options?: THttpRequestOptions): Promise<string>;
-    private _getJson;
-    private _post;
+    downloadReport(options?: THttpRequestOptions): Promise<string>;
     private setParamFromCameraJSON;
     private getParamFromCameraAndJSONParse;
+    getUploadedFileList(clipName: string, storage: TStorageType, options?: THttpRequestOptions): Promise<string[]>;
+    downloadClipFile(fileName: string, storage: TStorageType, options?: THttpRequestOptions): Promise<ReturnType<Awaited<ReturnType<Client["get"]>>["blob"]>>;
+    uploadClipFiles(files: File[], storage: TStorageType, options?: THttpRequestOptions): Promise<void>;
 }

package/types/PlaneTrackerAPI.d.ts

@@ -1,16 +1,15 @@
-import { IClient, TBlobResponse, TParameters, TResponse } from './internal/types';
+import { IClient, TParameters, TResponse } from './internal/types';
 import { ICAO, TApiUser, TBlackList, TCameraSettings, TExportDataType, TGetIcaoByOption, TImportDataType, TPriorityList, TTrackingMode, TTypePriorityList, 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;
+import { THttpRequestOptions } from './types/common';
+import { BasicAPI } from './internal/BasicAPI';
+export declare class PlaneTrackerAPI<Client extends IClient<TResponse, any>> extends BasicAPI<Client> {
     private apiUser;
     constructor(client: Client, apiUser: TApiUser);
     static getProxyPath: () => string;
     static getWsEventsPath: () => string;
-    getClient(proxyParams?: TProxyParams): Client | ProxyClient<Client>;
+    checkAPIAvailable(options?: THttpRequestOptions): Promise<void>;
     checkCameraTime(options?: THttpRequestOptions): Promise<boolean>;
-    serverRunCheck(options?: THttpRequestOptions): Promise<TResponse>;
+    serverRunCheck(options?: THttpRequestOptions): Promise<boolean>;
     getLiveViewAlias(rtspUrl: string, options?: THttpRequestOptions): Promise<{
         ws: string;
         ws_initial_message: string;
@@ -22,15 +21,19 @@ export declare class PlaneTrackerAPI<Client extends IClient<TResponse, any>> {
         camera: {
             ip: string;
             port: number;
-            protocol: "https" | "http" | "https_insecure";
-            user: string;
             pass: string;
+            user: string;
+            protocol: "https" | "http" | "https_insecure";
         };
         units: "metric" | "imperial";
         adsbSource: {
             ip: string;
+            enabled: boolean;
             port: number;
         };
+        dronetagSource: {
+            enabled: boolean;
+        };
         cameraCalibrationProcessConfig: {
             nightSkyCalibrationEnabled: boolean;
             scheduleNightSkyCalibrationTimestamp: number;
@@ -39,7 +42,6 @@ export declare class PlaneTrackerAPI<Client extends IClient<TResponse, any>> {
         cameraConfig: {
             defaultCaptureSizeMeters: number;
             captureSizeExtensionMeters: number;
-            maxZoomLevel?: number | undefined;
         };
         stream: {
             width: number;
@@ -84,8 +86,8 @@ export declare class PlaneTrackerAPI<Client extends IClient<TResponse, any>> {
         };
         radarcapeFlightInfoSource: {
             ip: string;
-            port: number;
             enabled: boolean;
+            port: number;
             priority: number;
         };
         identificationLabel: {
@@ -97,22 +99,22 @@ export declare class PlaneTrackerAPI<Client extends IClient<TResponse, any>> {
         };
         acs: {
             ip: string;
-            port: number;
             enabled: boolean;
-            protocol: "https" | "http" | "https_insecure";
-            user: string;
+            port: number;
             pass: string;
+            user: string;
+            protocol: "https" | "http" | "https_insecure";
             sourceKey: string;
         };
         genetec: {
             ip: string;
-            port: number;
             enabled: boolean;
+            port: number;
             cameraList: string[];
+            pass: string;
             appId: string;
-            protocol: "https" | "http" | "https_insecure";
             user: string;
-            pass: string;
+            protocol: "https" | "http" | "https_insecure";
             baseUri: string;
         };
         camstreamerIntegration: {
@@ -132,18 +134,20 @@ export declare class PlaneTrackerAPI<Client extends IClient<TResponse, any>> {
             displayPTError?: boolean | undefined;
             displayPTZSpeed?: boolean | undefined;
             displayVelocityData?: boolean | undefined;
+            displayAdsbVelocityData?: boolean | undefined;
             displaySignalQuality?: boolean | undefined;
             displayAutoTrackingInfo?: boolean | undefined;
             displayGPSCoords?: boolean | undefined;
             displayVapixQuery?: boolean | undefined;
             displayFocus?: boolean | undefined;
             displayAperture?: boolean | undefined;
+            displayAircraftInfo?: boolean | undefined;
             displaySunDistance?: boolean | undefined;
             displayTickTime?: boolean | undefined;
-            displayAircraftInfo?: boolean | undefined;
+            displaySystemInfo?: boolean | undefined;
         } | undefined;
     }>;
-    setCameraSettings(settings: TCameraSettings, options?: THttpRequestOptions): Promise<TResponse>;
+    setCameraSettings(settings: TCameraSettings, options?: THttpRequestOptions): Promise<void>;
     fetchServerSettings(options?: THttpRequestOptions): Promise<{
         cameraCalibration: {
             posLat: number;
@@ -162,7 +166,7 @@ export declare class PlaneTrackerAPI<Client extends IClient<TResponse, any>> {
             }[];
         };
     }>;
-    exportAppSettings(dataType: TExportDataType, options?: THttpRequestOptions): Promise<TBlobResponse<Client>>;
+    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>;
     fetchFlightInfo(icao: ICAO, options?: THttpRequestOptions): Promise<{
         destinationAirport: {
@@ -193,13 +197,13 @@ export declare class PlaneTrackerAPI<Client extends IClient<TResponse, any>> {
     stopTrackingPlane(options?: THttpRequestOptions): Promise<void>;
     getIcao(by: TGetIcaoByOption, value: string, options?: THttpRequestOptions): Promise<string>;
     getPriorityList(options?: THttpRequestOptions): Promise<string[]>;
-    setPriorityList(priorityList: TPriorityList['priorityList'], options?: THttpRequestOptions): Promise<TResponse>;
+    setPriorityList(priorityList: TPriorityList['priorityList'], options?: THttpRequestOptions): Promise<void>;
     getTypePriorityList(options?: THttpRequestOptions): Promise<string[]>;
-    setTypePriorityList(typePriorityList: TTypePriorityList['typePriorityList'], options?: THttpRequestOptions): Promise<TResponse>;
+    setTypePriorityList(typePriorityList: TTypePriorityList['typePriorityList'], options?: THttpRequestOptions): Promise<void>;
     getWhiteList(options?: THttpRequestOptions): Promise<string[]>;
-    setWhiteList(whiteList: TWhiteList['whiteList'], options?: THttpRequestOptions): Promise<TResponse>;
+    setWhiteList(whiteList: TWhiteList['whiteList'], options?: THttpRequestOptions): Promise<void>;
     getBlackList(options?: THttpRequestOptions): Promise<string[]>;
-    setBlackList(blackList: TBlackList['blackList'], options?: THttpRequestOptions): Promise<TResponse>;
+    setBlackList(blackList: TBlackList['blackList'], options?: THttpRequestOptions): Promise<void>;
     fetchMapInfo(options?: THttpRequestOptions): Promise<{
         minZoom: number;
         maxZoom: number;
@@ -227,15 +231,11 @@ export declare class PlaneTrackerAPI<Client extends IClient<TResponse, any>> {
     }>;
     setZones(zones: TZones, options?: THttpRequestOptions): Promise<void>;
     goToCoordinates(lat: number, lon: number, alt?: number, options?: THttpRequestOptions): Promise<void>;
-    checkGenetecConnection(params: TParameters, options?: THttpRequestOptions): Promise<TResponse>;
+    downloadReport(options?: THttpRequestOptions): Promise<string>;
+    checkGenetecConnection(params: TParameters, options?: THttpRequestOptions): Promise<boolean>;
     getGenetecCameraList(params: TParameters, options?: THttpRequestOptions): Promise<{
         value: string;
-        index: number;
         label: string;
+        index: number;
     }[]>;
-    private _getJson;
-    private _getBlob;
-    private parseBlobResponse;
-    private _postJsonEncoded;
-    private _postUrlEncoded;
 }

package/types/VapixAPI.d.ts

@@ -1,17 +1,15 @@
 import { IClient, TParameters, TResponse } from './internal/types';
 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>> {
-    private client;
+import { TCameraImageConfig, THttpRequestOptions } from './types/common';
+import { BasicAPI } from './internal/BasicAPI';
+export declare class VapixAPI<Client extends IClient<TResponse, any>> extends BasicAPI<Client> {
     private CustomFormData;
     constructor(client: Client, CustomFormData?: {
         new (form?: HTMLFormElement | undefined, submitter?: HTMLElement | null | undefined): FormData;
         prototype: FormData;
     });
-    getClient(proxyParams?: TProxyParams): Client | ProxyClient<Client>;
     postUrlEncoded(path: string, parameters?: TParameters, headers?: Record<string, string>, options?: THttpRequestOptions): Promise<TResponse>;
-    postJson(path: string, jsonData: Record<string, any>, headers?: Record<string, string>, options?: THttpRequestOptions): Promise<TResponse>;
+    postJson(path: string, data: 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<{
@@ -19,17 +17,8 @@ export declare class VapixAPI<Client extends IClient<TResponse, any>> {
         bitRates: number[];
     }[]>;
     performAutofocus(options?: THttpRequestOptions): Promise<void>;
-    checkSDCard(options?: THttpRequestOptions): Promise<{
-        status: "OK" | "connected" | "disconnected";
-        totalSize: number;
-        freeSize: number;
-    }>;
-    mountSDCard(options?: THttpRequestOptions): Promise<number>;
-    unmountSDCard(options?: THttpRequestOptions): Promise<number>;
-    private _doSDCardMountAction;
-    fetchSDCardJobProgress(jobId: number, options?: THttpRequestOptions): Promise<number>;
-    downloadCameraReport(options?: THttpRequestOptions): Promise<TResponse>;
-    getSystemLog(options?: THttpRequestOptions): Promise<TResponse>;
+    downloadCameraReport(options?: THttpRequestOptions): Promise<string>;
+    getSystemLog(options?: THttpRequestOptions): Promise<string>;
     getMaxFps(channel: number, options?: THttpRequestOptions): Promise<number>;
     getTimezone(options?: THttpRequestOptions): Promise<string>;
     getDateTimeInfo(options?: THttpRequestOptions): Promise<{
@@ -44,7 +33,16 @@ export declare class VapixAPI<Client extends IClient<TResponse, any>> {
     getDevicesSettings(options?: THttpRequestOptions): Promise<TAudioDevice[]>;
     fetchRemoteDeviceInfo<T extends Record<string, any>>(payload: T, options?: THttpRequestOptions): Promise<any>;
     getHeaders(options?: THttpRequestOptions): Promise<Record<string, string>>;
-    setHeaders(headers: Record<string, string>, options?: THttpRequestOptions): Promise<TResponse>;
+    setHeaders(headers: Record<string, string>, options?: THttpRequestOptions): Promise<void>;
+    checkSDCard(options?: THttpRequestOptions): Promise<{
+        status: "OK" | "connected" | "disconnected";
+        totalSize: number;
+        freeSize: number;
+    }>;
+    mountSDCard(options?: THttpRequestOptions): Promise<number>;
+    unmountSDCard(options?: THttpRequestOptions): Promise<number>;
+    private _doSDCardMountAction;
+    fetchSDCardJobProgress(jobId: number, options?: THttpRequestOptions): Promise<number>;
     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<{
@@ -52,8 +50,8 @@ export declare class VapixAPI<Client extends IClient<TResponse, any>> {
         id: string;
         running: string;
         tour: {
-            moveSpeed?: unknown;
             position?: unknown;
+            moveSpeed?: unknown;
             presetNbr?: unknown;
             waitTime?: unknown;
             waitTimeViewType?: unknown;
@@ -66,18 +64,18 @@ export declare class VapixAPI<Client extends IClient<TResponse, any>> {
     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;
     }[]>>;
-    goToPreset(channel: number, presetName: string, options?: THttpRequestOptions): Promise<TResponse>;
+    goToPreset(channel: number, presetName: string, options?: THttpRequestOptions): Promise<void>;
     getPtzPosition(camera: number, options?: THttpRequestOptions): Promise<{
         pan?: number | undefined;
         tilt?: number | undefined;
@@ -86,15 +84,27 @@ export declare class VapixAPI<Client extends IClient<TResponse, any>> {
     getPorts(options?: THttpRequestOptions): Promise<{
         name: string;
         port: string;
+        direction: "output" | "input";
         state: "open" | "closed";
         configurable: boolean;
         usage: string;
-        direction: "input" | "output";
         normalState: "open" | "closed";
         readonly?: boolean | undefined;
     }[]>;
     setPorts(ports: TPortSetSchema[], options?: THttpRequestOptions): Promise<void>;
     setPortStateSequence(port: number, sequence: TPortSequenceStateSchema[], options?: THttpRequestOptions): Promise<void>;
+    addCameraUser(username: string, pass: string, sgrp: string, comment?: string, options?: THttpRequestOptions): Promise<void>;
+    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;
+        profile: string;
+    }[]>;
+    addRecordingRule(params: Record<string, string>, options?: THttpRequestOptions): Promise<string | null>;
+    removeRecordingRule(profileId: string, options?: THttpRequestOptions): Promise<void>;
+    getDiskInfo(diskId?: string, options?: THttpRequestOptions): Promise<boolean>;
     getApplicationList(options?: THttpRequestOptions): Promise<{
         Name: string;
         NiceName: string;
@@ -102,7 +112,7 @@ export declare class VapixAPI<Client extends IClient<TResponse, any>> {
         Version: string;
         License: string;
         Status: string;
-        appId: "CamStreamer" | "CamSwitcher" | "CamOverlay" | "CamScripter" | "PlaneTracker" | "Ndihxplugin" | "SportTracker" | null;
+        appId: "CamStreamer" | "CamSwitcher" | "CamOverlay" | "CamScripter" | "PlaneTracker" | "Ndihxplugin" | "SportTracker" | "CamOverlayHtmlplugin" | null;
         ApplicationID?: string | undefined;
         ConfigurationPage?: string | undefined;
         VendorHomePage?: string | undefined;
@@ -112,7 +122,10 @@ export declare class VapixAPI<Client extends IClient<TResponse, any>> {
     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 parseQueryString;
+    private static checkTextResponseForError;
     private static parseParameters;
     private static parseCameraPtzResponse;
     private static parsePtz;
+    private static parseXmlResponse;
 }

package/types/errors/errors.d.ts

@@ -92,11 +92,17 @@ export declare class BadRequestError<T extends TResponse> extends ErrorWithRespo
 }
 export declare class MigrationError extends Error {
     readonly valid: TStream[];
-    readonly invalid: (TOldStream & {
-        id: number;
+    readonly old: (TOldStream & {
+        streamId: string;
     })[];
-    constructor(valid: TStream[], invalid: (TOldStream & {
-        id: number;
-    })[]);
+    readonly invalid: any[];
+    readonly unknown: {
+        platform: string;
+    }[];
+    constructor(valid: TStream[], old: (TOldStream & {
+        streamId: string;
+    })[], invalid?: any[], unknown?: {
+        platform: string;
+    }[]);
 }
 export {};

package/types/index.d.ts

@@ -1,6 +1,7 @@
 export * from './errors/errors';
 export * from './internal/types';
 export * from './internal/constants';
+export * from './internal/convertors';
 export * from './internal/utils';
 export * from './internal/versionCompare';
 export * from './internal/ProxyClient';

package/types/internal/BasicAPI.d.ts

@@ -0,0 +1,15 @@
+import { THttpRequestOptions, TProxyParams } from '../types/common';
+import { ProxyClient } from './ProxyClient';
+import { IClient, TBlobResponse, TParameters, TResponse } from './types';
+export declare class BasicAPI<Client extends IClient<TResponse, any>> {
+    protected client: Client;
+    constructor(client: Client);
+    getClient(proxyParams?: TProxyParams): Client | ProxyClient<Client>;
+    protected _getJson(path: string, parameters?: TParameters, options?: THttpRequestOptions): Promise<any>;
+    protected _getText(path: string, parameters?: TParameters, options?: THttpRequestOptions): Promise<string>;
+    protected _getBlob(path: string, parameters?: TParameters, options?: THttpRequestOptions): Promise<TBlobResponse<Client>>;
+    private parseBlobResponse;
+    protected _post(path: string, data: string | Parameters<Client['post']>[0]['data'], parameters?: TParameters, options?: THttpRequestOptions, headers?: Record<string, string>): Promise<any>;
+    protected _postJsonEncoded(path: string, data: string | Parameters<Client['post']>[0]['data'], parameters?: TParameters, options?: THttpRequestOptions): Promise<TResponse>;
+    protected _postUrlEncoded(path: string, data: TParameters, options?: THttpRequestOptions): Promise<TResponse>;
+}

package/types/internal/WsEvents.d.ts

@@ -30,6 +30,7 @@ export declare class WsEvents<T extends {
     resendInitData(): void;
     addListener<Type extends TEventType<T>>(type: Type, listener: TListenerFunction<T, Type>, id: string): void;
     removeListener<Type extends TEventType<T>>(type: Type, id: string): void;
+    removeAllListenersForId(id: string): void;
     private onMessage;
     private processMessage;
     destroy(): void;

package/types/internal/constants.d.ts

@@ -1 +1,2 @@
 export declare const FIRMWARE_WITH_BITRATE_MODES_SUPPORT = "11.11.73";
+export declare const FIRMWARE_WITH_OVERLAYS_SUPPORT = "10.7.0";

package/types/internal/convertors.d.ts

@@ -0,0 +1,6 @@
+import { TInternalVapixParameters } from '../types/CamStreamerAPI';
+import { TBitrateMode, TBitrateVapixParams } from '../types/common';
+export declare const parseBitrateOptionsToVapixParams: (firmWareVersion: string, bitrateMode: TBitrateMode | undefined, cameraOptions: Partial<TBitrateVapixParams>) => string;
+export declare const parseVapixParamsToBitrateOptions: (bitrateVapixParams: string) => TBitrateVapixParams;
+export declare const parseVideoOptionsToVapixParams: (firmWareVersion: string, video: TInternalVapixParameters) => string;
+export declare const parseVapixParamsToVideoOptions: (internalVapixParams: string) => TInternalVapixParameters;

package/types/internal/types.d.ts

@@ -17,6 +17,9 @@ export type TResponse = {
     status: number;
     ok: boolean;
     statusText: string;
+    headers: {
+        get: (name: string) => string | null;
+    };
 };
 export type TGetParams = {
     path: string;

package/types/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) => 0 | 1 | -1;
-export declare const versionCompare: (a: string, b: string) => 0 | 1 | -1;
+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 fixVersionToDots: (version: string) => string;