camstreamerlib 4.0.0-beta.7 → 4.0.0-beta.70

package/types/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/types/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/types/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/types/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/types/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/{esm → types}/internal/utils.d.ts

@@ -1,5 +1,5 @@
 import { TPlaylistPlayType } from '../types/CamSwitcherAPI';
-import { TParameters } from './common';
+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;
@@ -9,3 +9,5 @@ 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/{esm → 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) => 1 | -1 | 0;
-export declare const versionCompare: (a: string, b: string) => 1 | -1 | 0;
+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;

package/types/node/CamOverlayDrawingAPI.d.ts

@@ -0,0 +1,41 @@
+/// <reference types="node" />
+/// <reference types="node" />
+/// <reference types="node" />
+import { EventEmitter } from 'events';
+import { CamOverlayDrawingOptions, TCairoCreateResponse, TCairoResponse, TUploadImageResponse, TWriteTextParams } from '../types/CamOverlayDrawingAPI';
+export declare class CamOverlayDrawingAPI extends EventEmitter {
+    private tls;
+    private tlsInsecure;
+    private ip;
+    private port;
+    private user;
+    private pass;
+    private cameraList;
+    private zIndex;
+    private callId;
+    private sendMessages;
+    private timeoutCheckTimer;
+    private wsConnected;
+    private ws;
+    constructor(options?: CamOverlayDrawingOptions);
+    connect(): void;
+    disconnect(): void;
+    isConnected(): boolean;
+    cairo(command: string, ...params: unknown[]): Promise<TCairoResponse | TCairoCreateResponse>;
+    writeText(...params: TWriteTextParams): Promise<TCairoResponse>;
+    uploadImageData(imgBuffer: Buffer): Promise<TUploadImageResponse>;
+    uploadFontData(fontBuffer: Buffer): Promise<TCairoCreateResponse>;
+    showCairoImage(cairoImage: string, posX: number, posY: number): Promise<TCairoResponse>;
+    showCairoImageAbsolute(cairoImage: string, posX: number, posY: number, width: number, height: number): Promise<TCairoResponse>;
+    removeImage(): Promise<TCairoResponse>;
+    private createWsClient;
+    private incomingWsMessageHandler;
+    private sendMessage;
+    private sendBinaryMessage;
+    private startMsgsTimeoutCheck;
+    private stopMsgsTimeoutCheck;
+    private reconnectWithError;
+    private reportMessage;
+    private reportError;
+    private reportClose;
+}

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

@@ -1,42 +1,9 @@
 /// <reference types="node" />
 import { EventEmitter } from 'events';
-import { CamOverlayDrawingAPI, TAlign, TCairoCreateResponse, TUploadImageResponse } from '../CamOverlayDrawingAPI';
-import ResourceManager from './ResourceManager';
-export type TRgb = [number, number, number];
-export type TRgba = [number, number, number, number];
-export type TTmf = 'TFM_OVERFLOW' | 'TFM_SCALE' | 'TFM_TRUNCATE';
-export type TObjectFitType = 'fill' | 'fit' | 'none';
-export type TFrameOptions = {
-    enabled?: boolean;
-    x: number;
-    y: number;
-    width: number;
-    height: number;
-    text?: string;
-    fontColor?: TRgb;
-    font?: string;
-    bgColor?: TRgba;
-    bgImage?: string;
-    bgType?: TObjectFitType;
-    borderRadius?: number;
-    borderWidth?: number;
-    borderColor?: TRgba;
-    customDraw?: TDrawingCallback;
-    layer?: number;
-};
-export type TFrameInfo = {
-    width: number;
-    height: number;
-};
-export type TDrawingCallback = (cod: CamOverlayDrawingAPI, cairo: string, info: TFrameInfo) => Promise<void>;
-export interface Frame {
-    on(event: 'open', listener: () => void): this;
-    on(event: 'close', listener: () => void): this;
-    on(event: 'layoutChanged', listener: () => void): this;
-    emit(event: 'open'): boolean;
-    emit(event: 'close'): boolean;
-    emit(event: 'layoutChanged'): boolean;
-}
+import { CamOverlayDrawingAPI } from '../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';
 export declare class Frame extends EventEmitter {
     protected enabled: boolean;
     protected posX: number;
@@ -64,17 +31,21 @@ export declare class Frame extends EventEmitter {
     disable(): void;
     setFramePosition(x: number, y: number): void;
     setFrameSize(width: number, height: number): void;
+    getFrameInfo(): TFrame;
     setText(text: string, align: TAlign, textType?: TTmf, fontColor?: TRgb): void;
     setFontColor(fontColor: TRgb): void;
     setFont(fontName: string): void;
     setFontData(fontData: TCairoCreateResponse): void;
+    getTextInfo(): TText;
     setBgColor(color: TRgba): void;
     setBgImage(imageName: string, type?: TObjectFitType): void;
     setBgImageData(imageData: TUploadImageResponse, type?: TObjectFitType): void;
     setBgType(type: TObjectFitType): void;
+    getBgInfo(): TBg;
     setBorderRadius(radius: number): void;
     setBorderWidth(width: number): void;
     setBorderColor(color: TRgba): void;
+    getBorderInfo(): TBorder;
     setCustomDraw(customDraw: TDrawingCallback): void;
     resetFont(): void;
     resetBgColor(): void;

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

@@ -1,23 +1,8 @@
-import { CamOverlayDrawingAPI, CamOverlayDrawingOptions } from '../CamOverlayDrawingAPI';
-import ResourceManager from './ResourceManager';
-import { Frame, TFrameOptions } from './Frame';
-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];
-};
-type TCoAlignment = keyof typeof COORD;
-export type TPainterOptions = TFrameOptions & {
-    screenWidth: number;
-    screenHeight: number;
-    coAlignment: TCoAlignment;
-};
+import { CamOverlayDrawingAPI } from '../CamOverlayDrawingAPI';
+import { CamOverlayDrawingOptions } from '../../types/CamOverlayDrawingAPI';
+import { ResourceManager } from './ResourceManager';
+import { Frame } from './Frame';
+import { TCoAlignment, TPainterOptions } from '../../types/CamOverlayPainter';
 export declare class Painter extends Frame {
     private screenWidth;
     private screenHeight;
@@ -45,4 +30,3 @@ export declare class Painter extends Frame {
     private cleanupSurface;
     private positionConvertor;
 }
-export { Frame, TFrameOptions as FrameOptions, ResourceManager, CamOverlayDrawingOptions };

package/types/node/CamOverlayPainter/ResourceManager.d.ts

@@ -0,0 +1,15 @@
+import { CamOverlayDrawingAPI } from '../CamOverlayDrawingAPI';
+import { TUploadImageResponse, TCairoCreateResponse } from '../../types/CamOverlayDrawingAPI';
+export declare class ResourceManager {
+    private co;
+    private imgFileNames;
+    private fontFileNames;
+    private images;
+    private fonts;
+    constructor(co: CamOverlayDrawingAPI);
+    registerImage(moniker: string, fileName: string): void;
+    registerFont(moniker: string, fileName: string): void;
+    image(moniker: string): Promise<TUploadImageResponse | undefined>;
+    font(moniker: string): Promise<TCairoCreateResponse | undefined>;
+    clear(): void;
+}

package/types/node/CamScripterAPICameraEventsGenerator.d.ts

@@ -0,0 +1,31 @@
+/// <reference types="node" />
+import { EventEmitter } from 'events';
+import { Options } 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?: Options);
+    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/DefaultClient.d.ts

@@ -0,0 +1,16 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import { IClient, HttpOptions, TGetParams, TPostParams } from '../internal/types';
+import { FormData as UndiciFormData, Response as UndiciResponse } from 'undici';
+export declare class DefaultClient implements IClient<UndiciResponse, UndiciFormData | Buffer> {
+    private tls;
+    private ip;
+    private port;
+    private user;
+    private pass;
+    private httpRequestSender;
+    constructor(opt?: HttpOptions);
+    get(params: TGetParams): Promise<UndiciResponse>;
+    post(params: TPostParams<UndiciFormData | Buffer>): Promise<UndiciResponse>;
+    private getBaseConnectionParams;
+}

package/types/node/Digest.test.d.ts

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

package/{esm → types}/node/HttpRequestSender.d.ts

@@ -1,4 +1,5 @@
 /// <reference types="node" />
+/// <reference types="node" />
 import { FormData as UndiciFormData, Response as UndiciResponse } from 'undici';
 export type HttpRequestOptions = {
     method?: string;

package/{esm → types}/node/HttpServer.d.ts

@@ -1,7 +1,7 @@
 /// <reference types="node" />
 /// <reference types="node" />
 import * as http from 'http';
-import * as EventEmitter from 'events';
+import { EventEmitter } from 'events';
 export type HttpServerOptions = {
     host?: string;
     port?: number;

package/types/node/TimeZoneDaemon.d.ts

@@ -0,0 +1,6 @@
+export declare class TimeZoneDaemon {
+    private checkTimer?;
+    constructor(checkInterval?: number);
+    stop(): void;
+    private checkAndUpdateTimeZone;
+}

package/types/node/VapixEvents.d.ts

@@ -0,0 +1,16 @@
+import { EventEmitter2 as EventEmitter } from 'eventemitter2';
+import { Options } 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?: Options);
+    connect(): void;
+    disconnect(): void;
+    private createWsClient;
+    private isReservedEventName;
+}

package/types/node/WsClient.d.ts

@@ -0,0 +1,30 @@
+import { IWsClient, Options } from '../internal/types';
+export type WsClientOptions = Options & {
+    address: string;
+    headers?: Record<string, string>;
+    pingInterval?: number;
+    protocol?: string;
+};
+export declare class WsClient implements IWsClient {
+    private user;
+    private pass;
+    private address;
+    private protocol?;
+    private pingInterval;
+    private wsOptions;
+    private digestAddress;
+    private isAlive;
+    private pingTimer?;
+    private ws?;
+    private isClosed;
+    constructor(options: WsClientOptions);
+    open(wwwAuthenticateHeader?: string): void;
+    onMessage: (_: ArrayBuffer | string) => void;
+    onOpen: () => void;
+    onClose: () => void;
+    onError: (error: Error) => void;
+    send(data: ArrayBuffer | string): void;
+    destroy(): void;
+    reconnect(): void;
+    private closeWsConnection;
+}

package/types/node/events/AxisCameraStationEvents.d.ts

@@ -0,0 +1,12 @@
+import { HttpOptions } from '../../internal/types';
+import { ProxyClient } from '../../internal/ProxyClient';
+import { THttpRequestOptions, TProxyParams } from '../../types/common';
+import { DefaultClient } from '../DefaultClient';
+export declare class AxisCameraStationEvents {
+    private sourceKey;
+    private client;
+    constructor(clientOptions: HttpOptions, sourceKey: string);
+    getClient(proxyParams?: TProxyParams): DefaultClient | ProxyClient<DefaultClient>;
+    sendEvent(data: Record<string, string>, eventType: string, options?: THttpRequestOptions): Promise<void>;
+    private getDate;
+}

package/types/node/events/GenetecAgent.d.ts

@@ -0,0 +1,16 @@
+import { GenetecAgentOptions, TCameraDetail, TCameraGuidsResponse, TParams } from '../../types/GenetecAgent';
+export declare class GenetecAgent {
+    private settings;
+    private baseUrl;
+    private credentials;
+    constructor(options?: GenetecAgentOptions);
+    checkConnection(): Promise<void>;
+    getAllCameraGuids(): Promise<TCameraGuidsResponse>;
+    getCameraDetails(guids: {
+        Guid: string;
+    }[], parameters: TParams): Promise<TCameraDetail[]>;
+    sendBookmark(guids: string[], bookmarkText: string): Promise<void>;
+    private getRequestOptions;
+    private getTimeStamp;
+    private fetchWithTimeout;
+}

package/types/node/index.d.ts

@@ -0,0 +1,18 @@
+export * from './DefaultClient';
+export * from './WsClient';
+export * from './HttpServer';
+export * from './HttpRequestSender';
+export * from './events/AxisCameraStationEvents';
+export * from './TimeZoneDaemon';
+export * from './events/GenetecAgent';
+export * from '../types/GenetecAgent';
+export { ResourceManager } from './CamOverlayPainter/ResourceManager';
+export { Painter } from './CamOverlayPainter/Painter';
+export { Frame } from './CamOverlayPainter/Frame';
+export * from '../types/CamOverlayPainter';
+export { CamOverlayDrawingAPI } from './CamOverlayDrawingAPI';
+export * from '../types/CamOverlayDrawingAPI';
+export { CamScripterAPICameraEventsGenerator } from './CamScripterAPICameraEventsGenerator';
+export * from '../types/CamScripterAPICameraEventsGenerator';
+export { VapixEvents } from './VapixEvents';
+export * from '../types/VapixEvents';