camstreamerlib 4.0.0-beta.1 → 4.0.0-beta.3

package/esm/CamScripterAPICameraEventsGenerator.d.ts

@@ -0,0 +1,74 @@
+/// <reference types="node" />
+import * as EventEmitter from 'events';
+import { WsOptions } from './internal/common';
+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/esm/CamStreamerAPI.d.ts

@@ -0,0 +1,16 @@
+import { IClient } from './internal/common';
+import { CamStreamerAPIOptions, TStreamAttributes, TStreamList } from './types/CamStreamerAPI';
+export declare class CamStreamerAPI {
+    private client;
+    constructor(options?: CamStreamerAPIOptions | IClient);
+    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/esm/CamSwitcherAPI.d.ts

@@ -0,0 +1,48 @@
+import { IClient } from './internal/common';
+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 = IClient> {
+    client: Client;
+    private vapixAgent;
+    constructor(client: Client);
+    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}

@@ -15,9 +15,9 @@ export class CamSwitcherAPI {
         this.client = client;
         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(),

package/esm/CamSwitcherEvents.d.ts

@@ -0,0 +1,18 @@
+import { IWebsocket } from './internal/common';
+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/VapixAPI.d.ts

@@ -0,0 +1,66 @@
+import { IClient, TParameters, TResponse } from './internal/common';
+import { TApplication, 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 = IClient> {
+    client: ProxyClient<Client>;
+    constructor(client: Client, getProxyUrl: () => string);
+    getUrlEncoded(proxy: TProxyParam | undefined, path: string, parameters?: TParameters, headers?: Record<string, string>): Promise<TResponse>;
+    postJson(proxy: TProxyParam | undefined, 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;
+        };
+    }>;
+    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<TApplication[]>;
+    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>;
+}

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

@@ -158,11 +158,10 @@ export class VapixAPI {
         if (captureMode === undefined) {
             throw new MaxFPSError('CAPTURE_MODE_NOT_FOUND');
         }
-        const maxFps = parseInt(captureMode.maxFPS, 10);
-        if (isNaN(maxFps)) {
+        if (isNullish(captureMode.maxFPS)) {
             throw new MaxFPSError('FPS_NOT_SPECIFIED');
         }
-        return maxFps;
+        return captureMode.maxFPS;
     }
     async getTimezone(proxy = null) {
         const data = { apiVersion: '1.0', method: 'getDateTimeInfo' };

package/esm/VapixEvents.d.ts

@@ -0,0 +1,43 @@
+import { EventEmitter2 as EventEmitter } from 'eventemitter2';
+import { WsOptions } from './internal/common';
+export type VapixEventsOptions = WsOptions;
+type TEventMessage = {
+    apiVersion: string;
+    method: string;
+    params: {
+        notification: {
+            timestamp: number;
+            topic: string;
+            message: {
+                source: Record<string, string>;
+                data: Record<string, string>;
+                key: Record<string, string>;
+            };
+        };
+    };
+};
+export interface VapixEvents {
+    on(event: 'open', listener: () => void): this;
+    on(event: 'close', listener: () => void): this;
+    on(event: 'error', listener: (err: Error) => void): this;
+    on(event: string, listener: (data: TEventMessage) => void): this;
+    emit(event: 'open'): boolean;
+    emit(event: 'close'): boolean;
+    emit(event: 'error', err: Error): boolean;
+    emit(event: string, msg: TEventMessage): boolean;
+}
+export declare class VapixEvents extends EventEmitter {
+    private tls;
+    private tlsInsecure;
+    private ip;
+    private port;
+    private user;
+    private pass;
+    private ws;
+    constructor(options?: VapixEventsOptions);
+    connect(): void;
+    disconnect(): void;
+    private createWsClient;
+    private isReservedEventName;
+}
+export {};

package/esm/errors/errors.d.ts

@@ -0,0 +1,34 @@
+export declare class ServiceUnavailableError extends Error {
+    constructor();
+}
+export declare class ServiceNotFoundError extends Error {
+    constructor();
+}
+export declare class ParsingBlobError extends Error {
+    constructor(err: unknown);
+}
+type TApplicationAPIAction = 'START' | 'RESTART' | 'STOP';
+export declare class ApplicationAPIError extends Error {
+    constructor(action: TApplicationAPIAction, res: string);
+}
+type TSDCardAction = 'MOUNT' | 'UNMOUNT';
+export declare class SDCardActionError extends Error {
+    constructor(action: TSDCardAction, res: string);
+}
+export declare class SDCardJobError extends Error {
+    constructor();
+}
+type TMaxFPSErrorType = 'MALFORMED_REPLY' | 'CHANNEL_NOT_FOUND' | 'CAPTURE_MODE_NOT_FOUND' | 'FPS_NOT_SPECIFIED';
+export declare class MaxFPSError extends Error {
+    constructor(state: TMaxFPSErrorType);
+}
+export declare class NoDeviceInfoError extends Error {
+    constructor();
+}
+export declare class FetchDeviceInfoError extends Error {
+    constructor(err: unknown);
+}
+export declare class AddNewClipError extends Error {
+    constructor(message: string);
+}
+export {};

package/esm/events/AxisCameraStationEvents.d.ts

@@ -0,0 +1,9 @@
+import { IClient, HttpOptions } from '../internal/common';
+export type AcsEventsOptions = HttpOptions;
+export declare class AxisCameraStationEvents {
+    private sourceKey;
+    private client;
+    constructor(sourceKey: string, opt?: AcsEventsOptions | IClient);
+    sendEvent(data: Record<string, string>, eventType: string): Promise<void>;
+    private getDate;
+}

package/esm/events/GenetecAgent.d.ts

@@ -0,0 +1,174 @@
+import { z } from 'zod';
+declare const cameraGuidsResponseSchema: z.ZodObject<{
+    Rsp: z.ZodObject<{
+        Status: z.ZodString;
+        Result: z.ZodArray<z.ZodObject<{
+            Guid: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            Guid: string;
+        }, {
+            Guid: string;
+        }>, "many">;
+    }, "strip", z.ZodTypeAny, {
+        Status: string;
+        Result: {
+            Guid: string;
+        }[];
+    }, {
+        Status: string;
+        Result: {
+            Guid: string;
+        }[];
+    }>;
+}, "strip", z.ZodTypeAny, {
+    Rsp: {
+        Status: string;
+        Result: {
+            Guid: string;
+        }[];
+    };
+}, {
+    Rsp: {
+        Status: string;
+        Result: {
+            Guid: string;
+        }[];
+    };
+}>;
+export type TCameraGuidsResponse = z.infer<typeof cameraGuidsResponseSchema>;
+declare const connectionResponseSchema: z.ZodObject<{
+    Rsp: z.ZodObject<{
+        Status: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        Status: string;
+    }, {
+        Status: string;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    Rsp: {
+        Status: string;
+    };
+}, {
+    Rsp: {
+        Status: string;
+    };
+}>;
+export type TConnectionResponse = z.infer<typeof connectionResponseSchema>;
+export declare const cameraDetailSchema: z.ZodObject<{
+    Guid: z.ZodOptional<z.ZodString>;
+    Name: z.ZodOptional<z.ZodString>;
+    EntityType: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    Name?: string | undefined;
+    Guid?: string | undefined;
+    EntityType?: string | undefined;
+}, {
+    Name?: string | undefined;
+    Guid?: string | undefined;
+    EntityType?: string | undefined;
+}>;
+export declare const cameraDetailsResponseSchema: z.ZodObject<{
+    Rsp: z.ZodObject<{
+        Status: z.ZodString;
+        Result: z.ZodUnion<[z.ZodArray<z.ZodObject<{
+            Guid: z.ZodOptional<z.ZodString>;
+            Name: z.ZodOptional<z.ZodString>;
+            EntityType: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            Name?: string | undefined;
+            Guid?: string | undefined;
+            EntityType?: string | undefined;
+        }, {
+            Name?: string | undefined;
+            Guid?: string | undefined;
+            EntityType?: string | undefined;
+        }>, "many">, z.ZodObject<{
+            Guid: z.ZodOptional<z.ZodString>;
+            Name: z.ZodOptional<z.ZodString>;
+            EntityType: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            Name?: string | undefined;
+            Guid?: string | undefined;
+            EntityType?: string | undefined;
+        }, {
+            Name?: string | undefined;
+            Guid?: string | undefined;
+            EntityType?: string | undefined;
+        }>]>;
+    }, "strip", z.ZodTypeAny, {
+        Status: string;
+        Result: {
+            Name?: string | undefined;
+            Guid?: string | undefined;
+            EntityType?: string | undefined;
+        } | {
+            Name?: string | undefined;
+            Guid?: string | undefined;
+            EntityType?: string | undefined;
+        }[];
+    }, {
+        Status: string;
+        Result: {
+            Name?: string | undefined;
+            Guid?: string | undefined;
+            EntityType?: string | undefined;
+        } | {
+            Name?: string | undefined;
+            Guid?: string | undefined;
+            EntityType?: string | undefined;
+        }[];
+    }>;
+}, "strip", z.ZodTypeAny, {
+    Rsp: {
+        Status: string;
+        Result: {
+            Name?: string | undefined;
+            Guid?: string | undefined;
+            EntityType?: string | undefined;
+        } | {
+            Name?: string | undefined;
+            Guid?: string | undefined;
+            EntityType?: string | undefined;
+        }[];
+    };
+}, {
+    Rsp: {
+        Status: string;
+        Result: {
+            Name?: string | undefined;
+            Guid?: string | undefined;
+            EntityType?: string | undefined;
+        } | {
+            Name?: string | undefined;
+            Guid?: string | undefined;
+            EntityType?: string | undefined;
+        }[];
+    };
+}>;
+export type TCameraDetailsResponse = z.infer<typeof cameraDetailsResponseSchema>;
+export type TCameraDetail = z.infer<typeof cameraDetailSchema>;
+export type TParams = Array<'Guid' | 'Name' | 'EntityType'>;
+export type GenetecAgentOptions = {
+    protocol?: 'http' | 'https' | 'https_insecure';
+    ip?: string;
+    port?: number;
+    base_uri?: string;
+    user?: string;
+    pass?: string;
+    app_id?: string;
+};
+export declare class GenetecAgent {
+    private settings;
+    private baseUrl;
+    private credentials;
+    constructor(options?: GenetecAgentOptions);
+    checkConnection(): Promise<TConnectionResponse>;
+    getAllCameraGuids(): Promise<TCameraGuidsResponse>;
+    getCameraDetails(guids: {
+        Guid: string;
+    }[], parameters: TParams): Promise<TCameraDetail[]>;
+    sendBookmark(guids: string[], bookmarkText: string): Promise<Response>;
+    private getRequestOptions;
+    private getTimeStamp;
+}
+export {};

package/esm/index.d.ts

@@ -0,0 +1,11 @@
+export * from './internal/common';
+export * from './internal/constants';
+export * from './internal/utils';
+export * from './internal/versionCompare';
+export * from './types/common';
+export { CamSwitcherAPI } from './CamSwitcherAPI';
+export { CamSwitcherEvents } from './CamSwitcherEvents';
+export { VapixAPI } from './VapixAPI';
+export * from './types/CamSwitcherEvents';
+export * from './types/CamSwitcherAPI';
+export * from './types/VapixAPI';

package/esm/index.js

@@ -0,0 +1,11 @@
+export * from './internal/common';
+export * from './internal/constants';
+export * from './internal/utils';
+export * from './internal/versionCompare';
+export * from './types/common';
+export { CamSwitcherAPI } from './CamSwitcherAPI';
+export { CamSwitcherEvents } from './CamSwitcherEvents';
+export { VapixAPI } from './VapixAPI';
+export * from './types/CamSwitcherEvents';
+export * from './types/CamSwitcherAPI';
+export * from './types/VapixAPI';

package/esm/internal/Digest.d.ts

@@ -0,0 +1,4 @@
+export declare class Digest {
+    private nonceCount;
+    getAuthHeader(user: string, pass: string, method: string, uri: string, wwwAuthenticateHeader: string): string;
+}

package/esm/internal/ProxyClient.d.ts

@@ -0,0 +1,11 @@
+/// <reference types="node" />
+import { IClient, TParameters } from './common';
+import { TProxyParam } from '../types/common';
+export declare class ProxyClient<Client extends IClient = IClient> {
+    client: Client;
+    getProxyUrl: () => string;
+    constructor(client: Client, getProxyUrl: () => string);
+    get: (proxy: TProxyParam, path: string, parameters?: TParameters, headers?: Record<string, string>) => Promise<import("./common").TResponse>;
+    post: (proxy: TProxyParam, path: string, data: string | Buffer | FormData, parameters?: TParameters, headers?: Record<string, string>) => Promise<import("./common").TResponse>;
+    private getReal;
+}

package/esm/internal/common.d.ts

@@ -0,0 +1,39 @@
+/// <reference types="node" />
+type Options = {
+    ip?: string;
+    port?: number;
+    user?: string;
+    pass?: string;
+    tls?: boolean;
+    tlsInsecure?: boolean;
+};
+export type HttpOptions = Options & {
+    keepAlive?: boolean;
+};
+export type WsOptions = Options;
+export type TResponse = {
+    ok: boolean;
+    json: () => Promise<any>;
+    text: () => Promise<string>;
+    status: number;
+    body: any | null;
+};
+export type TParameters = Record<string, string | number | boolean | null | undefined>;
+export type TGetFunction = (url: string, parameters?: TParameters, headers?: Record<string, string>) => Promise<TResponse>;
+export type TPostFunction = (url: string, data: string | Buffer | FormData, parameters?: TParameters, headers?: Record<string, string>) => Promise<TResponse>;
+export interface IClient {
+    get: TGetFunction;
+    post: TPostFunction;
+}
+export interface IWebsocket<Event extends {
+    readonly data: string;
+}> {
+    destroy: () => void;
+    onmessage: null | ((event: Event) => void);
+    send: (data: string) => void;
+}
+export declare function isClient(arg?: Options | IClient): arg is IClient;
+export declare function responseStringify(res: TResponse): Promise<string>;
+export declare function pad(num: number, size: number): string;
+export declare function isNullish<T>(value: T | undefined | null): value is undefined | null;
+export {};

package/{internal → esm/internal}/common.js

@@ -1,9 +1,6 @@
 export function isClient(arg = {}) {
     return 'get' in arg && 'post' in arg;
 }
-export function isBrowserEnvironment() {
-    return typeof process === 'undefined' || !process.versions.node;
-}
 export async function responseStringify(res) {
     return JSON.stringify({
         status: res.status,

package/esm/internal/constants.d.ts

@@ -0,0 +1 @@
+export declare const FIRMWARE_WITH_BITRATE_MODES_SUPPORT = "11.11.73";

package/esm/internal/transformers.d.ts

@@ -0,0 +1,5 @@
+import type { CamelCasedProperties, CamelCasedPropertiesDeep, SnakeCasedProperties, SnakeCasedPropertiesDeep } from 'type-fest';
+export declare const toCamelCase: <T extends object>(o: T) => CamelCasedProperties<T>;
+export declare const toCamelCaseDeep: <T extends object>(o: T) => CamelCasedPropertiesDeep<T>;
+export declare const toSnakeCase: <T extends object>(o: T) => SnakeCasedProperties<T>;
+export declare const toSnakeCaseDeep: <T extends object>(o: T) => SnakeCasedPropertiesDeep<T>;

package/esm/internal/utils.d.ts

@@ -0,0 +1,11 @@
+import { TPlaylistPlayType } from '../types/CamSwitcherAPI';
+import { TParameters } from './common';
+export declare const addParametersToPath: (path: string, params?: TParameters) => string;
+export declare const paramToUrl: (params?: TParameters) => string;
+export declare const arrayToUrl: (arr: string | string[]) => string;
+export declare const isCamera: (id?: string) => boolean;
+export declare const isStream: (id?: string) => boolean;
+export declare const isClip: (id?: string) => boolean;
+export declare const isTracker: (id?: string) => boolean;
+export declare const isPlaylist: (id?: string) => boolean;
+export declare const isLoopPlayType: (playType: TPlaylistPlayType) => boolean;

package/{internal → esm/internal}/utils.js

@@ -1,6 +1,6 @@
 import { isNullish } from './common';
 export const addParametersToPath = (path, params) => {
-    if (params === undefined) {
+    if (params === undefined || Object.keys(params).length === 0) {
         return path;
     }
     const joinChar = path.indexOf('?') === -1 ? '?' : '&';

package/esm/internal/versionCompare.d.ts

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