camstreamerlib 4.0.0-beta.62 → 4.0.0-beta.64

package/cjs/PlaneTrackerAPI.js

@@ -45,7 +45,7 @@ class PlaneTrackerAPI {
             timeout: options?.timeout,
         });
         if (!res.ok) {
-            throw new errors_1.ResetCalibrationError('PTZ', await (0, utils_1.responseStringify)(res));
+            throw new errors_1.ResetCalibrationError('PTZ', res);
         }
     }
     async resetFocusCalibration(options) {
@@ -56,7 +56,7 @@ class PlaneTrackerAPI {
             timeout: options?.timeout,
         });
         if (!res.ok) {
-            throw new errors_1.ResetCalibrationError('FOCUS', await (0, utils_1.responseStringify)(res));
+            throw new errors_1.ResetCalibrationError('FOCUS', res);
         }
     }
     async fetchCameraSettings(options) {
@@ -84,7 +84,7 @@ class PlaneTrackerAPI {
             timeout: options?.timeout,
         });
         if (!res.ok) {
-            throw new errors_1.ImportSettingsError(await (0, utils_1.responseStringify)(res));
+            throw new errors_1.ImportSettingsError(res);
         }
     }
     async fetchFlightInfo(icao, options) {
@@ -168,7 +168,7 @@ class PlaneTrackerAPI {
                 throw new errors_1.InvalidAltitudeError();
             }
             if (res.status === 400) {
-                throw new errors_1.BadRequestError(await (0, utils_1.responseStringify)(res));
+                throw new errors_1.BadRequestError(res);
             }
             if (res.status === 500) {
                 throw new errors_1.ServerError();
@@ -189,7 +189,7 @@ class PlaneTrackerAPI {
             return await res.json();
         }
         else {
-            throw new errors_1.GeneralResponseNotOKError(await (0, utils_1.responseStringify)(res));
+            throw new errors_1.ErrorWithResponse(res);
         }
     }
     async _getBlob(path, parameters, options) {
@@ -199,7 +199,7 @@ class PlaneTrackerAPI {
             return await this.parseBlobResponse(res);
         }
         else {
-            throw new errors_1.GeneralResponseNotOKError(await (0, utils_1.responseStringify)(res));
+            throw new errors_1.ErrorWithResponse(res);
         }
     }
     async parseBlobResponse(response) {
@@ -224,7 +224,7 @@ class PlaneTrackerAPI {
             return res;
         }
         else {
-            throw new errors_1.GeneralResponseNotOKError(await (0, utils_1.responseStringify)(res));
+            throw new errors_1.ErrorWithResponse(res);
         }
     }
     async _postUrlEncoded(path, params, options) {
@@ -240,7 +240,7 @@ class PlaneTrackerAPI {
             return res;
         }
         else {
-            throw new errors_1.GeneralResponseNotOKError(await (0, utils_1.responseStringify)(res));
+            throw new errors_1.ErrorWithResponse(res);
         }
     }
 }

package/cjs/VapixAPI.d.ts

@@ -0,0 +1,118 @@
+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;
+    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>;
+    getCameraImage(parameters: TCameraImageConfig, options?: THttpRequestOptions): Promise<ReturnType<Client["get"]>>;
+    getEventDeclarations(options?: THttpRequestOptions): Promise<string>;
+    getSupportedAudioSampleRate(options?: THttpRequestOptions): Promise<{
+        sampleRate: number;
+        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>;
+    getMaxFps(channel: number, options?: THttpRequestOptions): Promise<number>;
+    getTimezone(options?: THttpRequestOptions): Promise<string>;
+    getDateTimeInfo(options?: THttpRequestOptions): Promise<{
+        data: {
+            dateTime: string;
+            dstEnabled: boolean;
+            localDateTime: string;
+            posixTimeZone: string;
+            timeZone?: string | undefined;
+        };
+    }>;
+    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>;
+    getParameter(paramNames: string | string[], options?: THttpRequestOptions): Promise<Record<string, string>>;
+    setParameter(params: Record<string, string | number | boolean>, options?: THttpRequestOptions): Promise<void>;
+    getGuardTourList(options?: THttpRequestOptions): Promise<{
+        name: string;
+        id: string;
+        running: string;
+        tour: {
+            moveSpeed?: unknown;
+            position?: unknown;
+            presetNbr?: unknown;
+            waitTime?: unknown;
+            waitTimeViewType?: unknown;
+        }[];
+        camNbr?: unknown;
+        randomEnabled?: unknown;
+        timeBetweenSequences?: unknown;
+    }>;
+    setGuardTourEnabled(guardTourId: string, enable: boolean, options?: THttpRequestOptions): Promise<void>;
+    getPTZPresetList(channel: number, options?: THttpRequestOptions): Promise<string[]>;
+    listPTZ(camera: number, options?: THttpRequestOptions): Promise<{
+        name: string;
+        id: number;
+        data: {
+            pan?: number | undefined;
+            tilt?: number | undefined;
+            zoom?: number | undefined;
+        };
+    }[]>;
+    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<{
+        pan?: number | undefined;
+        tilt?: number | undefined;
+        zoom?: number | undefined;
+    }>;
+    getPorts(options?: THttpRequestOptions): Promise<{
+        name: string;
+        port: string;
+        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>;
+    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;
+    private static parsePtz;
+}

package/cjs/VapixAPI.js

@@ -23,7 +23,7 @@ class VapixAPI {
         const agent = this.getClient(options?.proxyParams);
         const res = await agent.post({ path, data, headers: head, timeout: options?.timeout });
         if (!res.ok) {
-            throw new errors_1.GeneralResponseNotOKError(await (0, utils_1.responseStringify)(res));
+            throw new errors_1.ErrorWithResponse(res);
         }
         return res;
     }
@@ -33,7 +33,7 @@ class VapixAPI {
         const agent = this.getClient(options?.proxyParams);
         const res = await agent.post({ path, data, headers: head, timeout: options?.timeout });
         if (!res.ok) {
-            throw new errors_1.GeneralResponseNotOKError(await (0, utils_1.responseStringify)(res));
+            throw new errors_1.ErrorWithResponse(res);
         }
         return res;
     }
@@ -59,7 +59,7 @@ class VapixAPI {
             headers: { 'Content-Type': 'application/soap+xml' },
         });
         if (!res.ok) {
-            throw new errors_1.GeneralResponseNotOKError(await (0, utils_1.responseStringify)(res));
+            throw new errors_1.ErrorWithResponse(res);
         }
         return await res.text();
     }
@@ -136,7 +136,7 @@ class VapixAPI {
         const result = parser.parse(textXml);
         const job = result.root.job;
         if (job.result !== 'OK') {
-            throw new errors_1.SDCardActionError(action, await (0, utils_1.responseStringify)(res));
+            throw new errors_1.SDCardActionError(action, job.description);
         }
         return Number(job.jobid);
     }
@@ -153,7 +153,7 @@ class VapixAPI {
         });
         const job = parser.parse(textXml).root.job;
         if (job.result !== 'OK') {
-            throw new errors_1.SDCardJobError();
+            throw new errors_1.SDCardJobError(job.description);
         }
         return Number(job.progress);
     }
@@ -190,7 +190,7 @@ class VapixAPI {
             const agent = this.getClient(options?.proxyParams);
             const resV2 = await agent.get({ path: '/config/rest/time/v2/timeZone', timeout: options?.timeout });
             if (!resV2.ok) {
-                throw new errors_1.GeneralResponseNotOKError(await (0, utils_1.responseStringify)(resV2));
+                throw new errors_1.ErrorWithResponse(resV2);
             }
             const json = await resV2.json();
             const data = VapixAPI_1.timeZoneSchema.parse(json);
@@ -429,7 +429,7 @@ class VapixAPI {
         });
         const text = (await res.text()).trim().toLowerCase();
         if (text !== 'ok' && !(text.startsWith('error:') && text.substring(7) === '6')) {
-            throw new errors_1.ApplicationAPIError('START', await (0, utils_1.responseStringify)(res));
+            throw new errors_1.ApplicationAPIError('START', text);
         }
     }
     async restartApplication(applicationId, options) {
@@ -444,7 +444,7 @@ class VapixAPI {
         });
         const text = (await res.text()).trim().toLowerCase();
         if (text !== 'ok') {
-            throw new errors_1.ApplicationAPIError('RESTART', await (0, utils_1.responseStringify)(res));
+            throw new errors_1.ApplicationAPIError('RESTART', text);
         }
     }
     async stopApplication(applicationId, options) {
@@ -459,7 +459,7 @@ class VapixAPI {
         });
         const text = (await res.text()).trim().toLowerCase();
         if (text !== 'ok' && !(text.startsWith('error:') && text.substring(7) === '6')) {
-            throw new errors_1.ApplicationAPIError('STOP', await (0, utils_1.responseStringify)(res));
+            throw new errors_1.ApplicationAPIError('STOP', text);
         }
     }
     async installApplication(data, fileName, options) {
@@ -475,7 +475,7 @@ class VapixAPI {
             timeout: options?.timeout ?? 120000,
         });
         if (!res.ok) {
-            throw new errors_1.GeneralResponseNotOKError(await (0, utils_1.responseStringify)(res));
+            throw new errors_1.ErrorWithResponse(res);
         }
         const text = await res.text();
         if (text.length > 5) {

package/cjs/bin/CreatePackage.d.ts

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

package/cjs/errors/errors.d.ts

@@ -0,0 +1,91 @@
+import { TResponse } from '../internal/types';
+export declare class ErrorWithResponse<T extends TResponse> extends Error {
+    res: T;
+    constructor(res: T);
+}
+export declare class ServiceUnavailableError extends Error {
+    constructor();
+}
+export declare class ServiceNotFoundError extends Error {
+    constructor();
+}
+export declare class ParsingBlobError extends Error {
+    constructor(err: unknown);
+}
+export declare class JsonParseError extends Error {
+    constructor(paramName: string, data: unknown);
+}
+export declare class ParameterNotFoundError extends Error {
+    constructor(paramName: string);
+}
+export declare class SettingParameterError extends Error {
+    constructor(message: string);
+}
+type TApplicationAPIAction = 'START' | 'RESTART' | 'STOP' | 'INSTALL';
+export declare class ApplicationAPIError extends Error {
+    action: TApplicationAPIAction;
+    constructor(action: TApplicationAPIAction, reason: string);
+}
+type TSDCardAction = 'MOUNT' | 'UNMOUNT';
+export declare class SDCardActionError extends Error {
+    action: TSDCardAction;
+    constructor(action: TSDCardAction, reason: string);
+}
+export declare class SDCardJobError extends Error {
+    constructor(reason: string);
+}
+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 declare class PtzNotSupportedError extends Error {
+    constructor();
+}
+export declare class StorageDataFetchError extends Error {
+    constructor(err: unknown);
+}
+export declare class WsAuthorizationError extends Error {
+    constructor(message: string);
+}
+export declare class UtcTimeFetchError extends Error {
+    constructor(message: string);
+}
+export declare class TimezoneNotSetupError extends Error {
+    constructor();
+}
+export declare class TimezoneFetchError extends Error {
+    constructor(err: unknown);
+}
+type TCalibrationType = 'PTZ' | 'FOCUS';
+export declare class ResetCalibrationError<T extends TResponse> extends ErrorWithResponse<T> {
+    type: TCalibrationType;
+    constructor(type: TCalibrationType, res: T);
+}
+export declare class ImportSettingsError<T extends TResponse> extends ErrorWithResponse<T> {
+    constructor(res: T);
+}
+export declare class CannotSetCoordsInAutoModeError extends Error {
+    constructor();
+}
+export declare class InvalidLatLngError extends Error {
+    constructor();
+}
+export declare class InvalidAltitudeError extends Error {
+    constructor();
+}
+export declare class ServerError extends Error {
+    constructor();
+}
+export declare class BadRequestError<T extends TResponse> extends ErrorWithResponse<T> {
+    constructor(res: T);
+}
+export {};

package/cjs/errors/errors.js

@@ -1,7 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.GeneralResponseNotOKError = exports.BadRequestError = exports.ServerError = exports.InvalidAltitudeError = exports.InvalidLatLngError = exports.CannotSetCoordsInAutoModeError = exports.ImportSettingsError = exports.ResetCalibrationError = exports.TimezoneFetchError = exports.TimezoneNotSetupError = exports.UtcTimeFetchError = exports.WsAuthorizationError = exports.StorageDataFetchError = exports.PtzNotSupportedError = exports.AddNewClipError = exports.FetchDeviceInfoError = exports.NoDeviceInfoError = exports.MaxFPSError = exports.SDCardJobError = exports.SDCardActionError = exports.ApplicationAPIError = exports.SettingParameterError = exports.ParameterNotFoundError = exports.JsonParseError = exports.ParsingBlobError = exports.ServiceNotFoundError = exports.ServiceUnavailableError = void 0;
-const utils_1 = require("../internal/utils");
+exports.BadRequestError = exports.ServerError = exports.InvalidAltitudeError = exports.InvalidLatLngError = exports.CannotSetCoordsInAutoModeError = exports.ImportSettingsError = exports.ResetCalibrationError = exports.TimezoneFetchError = exports.TimezoneNotSetupError = exports.UtcTimeFetchError = exports.WsAuthorizationError = exports.StorageDataFetchError = exports.PtzNotSupportedError = exports.AddNewClipError = exports.FetchDeviceInfoError = exports.NoDeviceInfoError = exports.MaxFPSError = exports.SDCardJobError = exports.SDCardActionError = exports.ApplicationAPIError = exports.SettingParameterError = exports.ParameterNotFoundError = exports.JsonParseError = exports.ParsingBlobError = exports.ServiceNotFoundError = exports.ServiceUnavailableError = exports.ErrorWithResponse = void 0;
+class ErrorWithResponse extends Error {
+    res;
+    constructor(res) {
+        super(res.statusText);
+        this.res = res;
+        this.name = 'ErrorWithResponse';
+    }
+}
+exports.ErrorWithResponse = ErrorWithResponse;
 class ServiceUnavailableError extends Error {
     constructor() {
         super('Service is unavailable.');
@@ -45,22 +53,26 @@ class SettingParameterError extends Error {
 }
 exports.SettingParameterError = SettingParameterError;
 class ApplicationAPIError extends Error {
-    constructor(action, res) {
-        super(`[APP ${action}] Error: ` + res);
+    action;
+    constructor(action, reason) {
+        super(`Error performing application action '${action}': ${reason}`);
+        this.action = action;
         this.name = 'ApplicationAPIError';
     }
 }
 exports.ApplicationAPIError = ApplicationAPIError;
 class SDCardActionError extends Error {
-    constructor(action, res) {
-        super(`[SD_CARD ${action}] Error: ` + res);
+    action;
+    constructor(action, reason) {
+        super(`Error performing SD card action '${action}': ${reason}`);
+        this.action = action;
         this.name = 'SDCardActionError';
     }
 }
 exports.SDCardActionError = SDCardActionError;
 class SDCardJobError extends Error {
-    constructor() {
-        super('Error while fetching SD card job progress');
+    constructor(reason) {
+        super(`Error while fetching SD card job progress: ${reason}`);
         this.name = 'SDCardJobError';
     }
 }
@@ -141,16 +153,18 @@ class TimezoneFetchError extends Error {
     }
 }
 exports.TimezoneFetchError = TimezoneFetchError;
-class ResetCalibrationError extends Error {
-    constructor(type, err) {
-        super('Error resetting ' + type.toLowerCase() + ' calibration: ' + err);
+class ResetCalibrationError extends ErrorWithResponse {
+    type;
+    constructor(type, res) {
+        super(res);
+        this.type = type;
         this.name = 'ResetCalibrationError';
     }
 }
 exports.ResetCalibrationError = ResetCalibrationError;
-class ImportSettingsError extends Error {
-    constructor(err) {
-        super('Error importing settings: ' + err);
+class ImportSettingsError extends ErrorWithResponse {
+    constructor(res) {
+        super(res);
         this.name = 'ImportSettingsError';
     }
 }
@@ -183,18 +197,10 @@ class ServerError extends Error {
     }
 }
 exports.ServerError = ServerError;
-class BadRequestError extends Error {
-    constructor(err) {
-        super('An unknown error occurred: ' + err);
-        this.name = 'UnknownError';
+class BadRequestError extends ErrorWithResponse {
+    constructor(res) {
+        super(res);
+        this.name = 'BadRequestError';
     }
 }
 exports.BadRequestError = BadRequestError;
-class GeneralResponseNotOKError extends Error {
-    static messageSchema = utils_1.stringifiedResponseSchema;
-    constructor(stringifiedRes) {
-        super(stringifiedRes);
-        this.name = 'GeneralResponseNotOKError';
-    }
-}
-exports.GeneralResponseNotOKError = GeneralResponseNotOKError;

package/cjs/index.d.ts

@@ -0,0 +1,27 @@
+export * from './errors/errors';
+export * from './internal/types';
+export * from './internal/constants';
+export * from './internal/utils';
+export * from './internal/versionCompare';
+export * from './internal/ProxyClient';
+export * from './types/common';
+export { CamStreamerAPI } from './CamStreamerAPI';
+export * from './types/CamStreamerAPI';
+export { CamStreamerEvents } from './ws/CamStreamerEvents';
+export * from './types/ws/CamStreamerEvents';
+export { CamOverlayAPI } from './CamOverlayAPI';
+export * from './types/CamOverlayAPI';
+export { CamOverlayEvents } from './ws/CamOverlayEvents';
+export * from './types/ws/CamOverlayEvents';
+export { CamSwitcherAPI } from './CamSwitcherAPI';
+export * from './types/CamSwitcherAPI';
+export { CamSwitcherEvents } from './ws/CamSwitcherEvents';
+export * from './types/ws/CamSwitcherEvents';
+export { PlaneTrackerAPI } from './PlaneTrackerAPI';
+export * from './types/PlaneTrackerAPI';
+export { PlaneTrackerEvents } from './ws/PlaneTrackerEvents';
+export * from './types/ws/PlaneTrackerEvents';
+export { CamScripterAPI } from './CamScripterAPI';
+export * from './types/CamScripterAPI';
+export { VapixAPI } from './VapixAPI';
+export * from './types/VapixAPI';

package/cjs/internal/ProxyClient.d.ts

@@ -0,0 +1,10 @@
+import { IClient, TGetParams, TResponse } from './types';
+import { TProxyParams } from '../types/common';
+export declare class ProxyClient<Client extends IClient<TResponse, any>> {
+    private client;
+    private proxyParams;
+    constructor(client: Client, proxyParams: TProxyParams);
+    get(params: TGetParams): ReturnType<Client["get"]>;
+    post(params: Parameters<Client['post']>[0]): ReturnType<Client["post"]>;
+    private getReal;
+}

package/cjs/internal/WsEvents.d.ts

@@ -0,0 +1,37 @@
+import { IWsClient } from './types';
+type TEventType<T extends {
+    type: string;
+}> = T extends {
+    type: infer Type;
+} ? Type : never;
+type TEvent<T extends {
+    type: string;
+}, Type extends TEventType<T>> = T extends {
+    type: Type;
+} ? T : never;
+type TValidate<T extends {
+    type: string;
+}> = (data: string) => {
+    type: 'init';
+    data: TEvent<T, TEventType<T>>;
+} | TEvent<T, TEventType<T>>;
+type TListenerFunction<T extends {
+    type: string;
+}, Type extends TEventType<T>> = (data: TEvent<T, Type>, isInit: boolean) => void;
+export declare class WsEvents<T extends {
+    type: string;
+}> {
+    private validate;
+    ws: IWsClient;
+    private _isDestroyed;
+    private listeners;
+    constructor(validate: TValidate<T>, ws: IWsClient);
+    get isDestroyed(): boolean;
+    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;
+    private onMessage;
+    private processMessage;
+    destroy(): void;
+}
+export {};

package/cjs/internal/constants.d.ts

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

package/cjs/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/cjs/internal/types.d.ts

@@ -0,0 +1,47 @@
+export type Options = {
+    ip?: string;
+    port?: number;
+    user?: string;
+    pass?: string;
+    tls?: boolean;
+    tlsInsecure?: boolean;
+};
+export type HttpOptions = Options & {
+    keepAlive?: boolean;
+};
+export type TParameters = Record<string, string | number | boolean | null | undefined>;
+export type TResponse = {
+    json: () => Promise<any>;
+    text: () => Promise<string>;
+    blob: () => Promise<unknown>;
+    status: number;
+    ok: boolean;
+    statusText: string;
+};
+export type TGetParams = {
+    path: string;
+    parameters?: TParameters;
+    headers?: Record<string, string>;
+    timeout?: number;
+};
+export type TPostParams<Data> = {
+    path: string;
+    data: string | Data;
+    parameters?: TParameters;
+    headers?: Record<string, string>;
+    timeout?: number;
+};
+export interface IClient<TRes extends TResponse, Data> {
+    get: (params: TGetParams) => Promise<TRes>;
+    post: (params: TPostParams<Data>) => Promise<TRes>;
+}
+export type TBlobResponse<Client extends IClient<TResponse, any>> = Awaited<ReturnType<Awaited<ReturnType<Client['get']>>['blob']>>;
+export interface IWsClient {
+    onMessage: null | ((data: ArrayBuffer | string) => void);
+    onOpen: () => void;
+    onClose: () => void;
+    onError: (error: Error) => void;
+    send: (data: ArrayBuffer | string) => void;
+    reconnect: () => void;
+    destroy: () => void;
+}

package/cjs/internal/utils.d.ts

@@ -0,0 +1,13 @@
+import { TPlaylistPlayType } from '../types/CamSwitcherAPI';
+import { TParameters } from './types';
+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;
+export declare function pad(num: number, size: number): string;
+export declare function isNullish<T>(value: T | undefined | null): value is undefined | null;

package/cjs/internal/utils.js

@@ -1,10 +1,6 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isNullish = exports.pad = exports.stringifiedResponseSchema = exports.responseStringify = exports.isLoopPlayType = exports.isPlaylist = exports.isTracker = exports.isClip = exports.isStream = exports.isCamera = exports.arrayToUrl = exports.paramToUrl = exports.addParametersToPath = void 0;
-const zod_1 = __importDefault(require("zod"));
+exports.isNullish = exports.pad = exports.isLoopPlayType = exports.isPlaylist = exports.isTracker = exports.isClip = exports.isStream = exports.isCamera = exports.arrayToUrl = exports.paramToUrl = exports.addParametersToPath = void 0;
 const addParametersToPath = (path, params) => {
     if (params === undefined || Object.keys(params).length === 0) {
         return path;
@@ -47,17 +43,6 @@ const isPlaylist = (id) => id?.charAt(0) === 'p';
 exports.isPlaylist = isPlaylist;
 const isLoopPlayType = (playType) => playType.includes('LOOP');
 exports.isLoopPlayType = isLoopPlayType;
-async function responseStringify(res) {
-    return JSON.stringify({
-        status: res.status,
-        body: await res.text(),
-    });
-}
-exports.responseStringify = responseStringify;
-exports.stringifiedResponseSchema = zod_1.default.object({
-    status: zod_1.default.number(),
-    body: zod_1.default.string(),
-});
 function pad(num, size) {
     const sign = Math.sign(num) === -1 ? '-' : '';
     return (sign +

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