camstreamerlib 4.0.0-beta.32 → 4.0.0-beta.34

package/esm/types/CamOverlayAPI/scoreBoardSchema.js

@@ -0,0 +1,124 @@
+import { z } from 'zod';
+import { coordinateSystemSchema } from './widgetCommonTypes';
+export const sportFontSchema = z.union([z.literal('classic'), z.intersection(z.string(), z.object({}))]);
+export const scoreBoardSchema = z.object({
+    id: z.number().nonnegative(),
+    enabled: z.union([z.literal(0), z.literal(1)]),
+    schedule: z.string().optional(),
+    cameraList: z.array(z.number()),
+    zIndex: z.number().nonnegative(),
+    name: z.literal('scoreBoard'),
+    pos_x: z.number(),
+    pos_y: z.number(),
+    coordSystem: coordinateSystemSchema,
+    width: z.number(),
+    height: z.number(),
+    scale: z.number(),
+    teamHomeShortname: z.string(),
+    teamGuestShortname: z.string(),
+    teamHomeBackgroundColor: z.string(),
+    teamGuestBackgroundColor: z.string(),
+    teamHomeTextColor: z.string(),
+    teamGuestTextColor: z.string(),
+    teamHomeImgPath: z.string(),
+    teamGuestImgPath: z.string(),
+    teamHomeCurrentScore: z.number(),
+    teamGuestCurrentScore: z.number(),
+    baseTimeTimestamp: z.number(),
+    baseTimePlaytime: z.number(),
+    currentPeriodPlaytime: z.number(),
+    timeIsRunning: z.boolean(),
+    currentPeriodLength: z.number(),
+    currentPeriod: z.number(),
+    font: sportFontSchema.default('classic'),
+});
+export const baseballScoreBoardSchema = z.object({
+    id: z.number().nonnegative(),
+    enabled: z.union([z.literal(0), z.literal(1)]),
+    schedule: z.string().optional(),
+    cameraList: z.array(z.number()),
+    zIndex: z.number().nonnegative(),
+    name: z.literal('baseballScoreBoard'),
+    pos_x: z.number(),
+    pos_y: z.number(),
+    coordSystem: coordinateSystemSchema,
+    width: z.number(),
+    height: z.number(),
+    scale: z.number(),
+    matchFinished: z.boolean(),
+    bases: z.tuple([z.boolean(), z.boolean(), z.boolean()]),
+    homeInning: z.boolean(),
+    inning: z.number().nonnegative(),
+    outs: z.number().nonnegative(),
+    balls: z.number().nonnegative(),
+    strikes: z.number().nonnegative(),
+    baseTimeTimestamp: z.number(),
+    baseTimePlaytime: z.number(),
+    timeIsRunning: z.boolean(),
+    teamHomeShortname: z.string(),
+    teamGuestShortname: z.string(),
+    teamHomeBackgroundColor: z.string(),
+    teamGuestBackgroundColor: z.string(),
+    teamHomeTextColor: z.string(),
+    teamGuestTextColor: z.string(),
+    teamHomeCurrentScore: z.number(),
+    teamGuestCurrentScore: z.number(),
+    footerImgPath: z.string().optional(),
+    footerText: z.string().optional(),
+    footerBackgroundColor: z.string().optional(),
+    footerTextColor: z.string().optional(),
+    font: sportFontSchema.default('classic'),
+});
+export const baseballScoreBoardAutomaticSchema = z.object({
+    id: z.number().nonnegative(),
+    enabled: z.union([z.literal(0), z.literal(1)]),
+    schedule: z.string().optional(),
+    cameraList: z.array(z.number()),
+    zIndex: z.number().nonnegative(),
+    name: z.literal('myBallBaseballWidgets'),
+    width: z.number(),
+    height: z.number(),
+    scale: z.number(),
+    matchDetailLink: z.string(),
+    matchListLink: z.string(),
+    mirrored: z.boolean(),
+    pregameWidgetText: z.string(),
+    teamHomeBackgroundColor: z.string(),
+    teamGuestBackgroundColor: z.string(),
+    teamHomeTextColor: z.string(),
+    teamGuestTextColor: z.string(),
+    homeLogoPath: z.string(),
+    guestLogoPath: z.string(),
+    footerImgPath: z.string().optional(),
+    footerText: z.string().optional(),
+    footerBackgroundColor: z.string().optional(),
+    footerTextColor: z.string().optional(),
+    font: sportFontSchema.default('classic'),
+});
+export const scoreOverviewSchema = z.object({
+    id: z.number().nonnegative(),
+    enabled: z.union([z.literal(0), z.literal(1)]),
+    cameraList: z.array(z.number()),
+    zIndex: z.number().nonnegative(),
+    name: z.literal('scoreOverview'),
+    pos_x: z.number(),
+    pos_y: z.number(),
+    coordSystem: coordinateSystemSchema,
+    width: z.number(),
+    height: z.number(),
+    scale: z.number(),
+    teamHomeName: z.string(),
+    teamGuestName: z.string(),
+    teamHomeBackgroundColor: z.string(),
+    teamGuestBackgroundColor: z.string(),
+    teamHomeTextColor: z.string(),
+    teamGuestTextColor: z.string(),
+    teamHomeImgPath: z.string(),
+    teamGuestImgPath: z.string(),
+    teamHomeCurrentScore: z.number(),
+    teamGuestCurrentScore: z.number(),
+    scoreVisible: z.boolean(),
+    description: z.string(),
+    textFont: sportFontSchema.default('classic'),
+    scoreFont: z.literal('classic'),
+});

package/esm/types/CamStreamerAPI.js

@@ -1,5 +1,5 @@
 import { z } from 'zod';
-export const streamAttributesSchema = z.object({
+export const cameraStreamSchema = z.object({
     enabled: z.string(),
     active: z.string(),
     audioSource: z.string(),
@@ -22,7 +22,34 @@ export const streamAttributesSchema = z.object({
     startTime: z.string(),
     stopTime: z.string(),
 });
-export const streamListSchema = z.record(z.string(), streamAttributesSchema);
+export const streamSchema = z.object({
+    enabled: z.union([z.literal(0), z.literal(1)]),
+    active: z.union([z.literal(0), z.literal(1)]),
+    audioSource: z.string(),
+    avSyncMsec: z.number().int(),
+    internalVapixParameters: z.string(),
+    userVapixParameters: z.string(),
+    outputParameters: z.string(),
+    outputType: z.union([z.literal('video'), z.literal('images'), z.literal('none')]),
+    mediaServerUrl: z.string(),
+    inputType: z.union([z.literal('CSw'), z.literal('CRS'), z.literal('RTSP_URL')]),
+    inputUrl: z.string(),
+    forceStereo: z.union([z.literal(0), z.literal(1)]),
+    streamDelay: z.number().nullable(),
+    statusLed: z.number(),
+    statusPort: z.string(),
+    callApi: z.number().int(),
+    trigger: z.string(),
+    schedule: z.string(),
+    prepareAhead: z.number().int(),
+    startTime: z.number().nullable(),
+    stopTime: z.number().nullable(),
+});
+export const cameraStreamResponseSchema = z.object({
+    data: cameraStreamSchema,
+    code: z.number(),
+    message: z.string(),
+});
 export const camstreamerServerResponseSchema = z.object({
     code: z.number(),
     message: z.string(),

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "camstreamerlib",
-    "version": "4.0.0-beta.32",
+    "version": "4.0.0-beta.34",
     "description": "Helper library for CamStreamer ACAP applications.",
     "prettier": "@camstreamer/prettier-config",
     "engine": {
@@ -11,7 +11,6 @@
         "eventemitter2": "^5.0.1",
         "fast-xml-parser": "^5.2.5",
         "lodash": "^4.17.21",
-        "prettify-xml": "^1.2.0",
         "type-fest": "^4.41.0",
         "undici": "^6.21.3",
         "ws": "^8.18.0",
@@ -55,6 +54,27 @@
         "/**/*.js",
         "/**/*.ts"
     ],
+    "type": "module",
+    "main": "./cjs/index.js",
+    "module": "./esm/index.js",
+    "types": "types/index.d.ts",
+    "exports": {
+        ".": {
+            "import": "./esm/index.js",
+            "require": "./cjs/index.js",
+            "types": "./types/index.d.ts"
+        },
+        "./web": {
+            "import": "./esm/web/index.js",
+            "require": "./cjs/web/index.js",
+            "types": "./types/web/index.d.ts"
+        },
+        "./node": {
+            "import": "./esm/node/index.js",
+            "require": "./cjs/node/index.js",
+            "types": "./types/node/index.d.ts"
+        }
+    },
     "repository": {
         "type": "git",
         "url": "git+https://github.com/CamStreamer/CamStreamerLib.git"

package/{cjs → types}/CamOverlayAPI.d.ts

@@ -1,10 +1,8 @@
-/// <reference types="node" />
-/// <reference types="node" />
 import { IClient, TBlobResponse, TResponse } from './internal/types';
 import { THttpRequestOptions, TProxyParams, TNetworkCamera } from './types/common';
 import { ProxyClient } from './internal/ProxyClient';
 import { ImageType, TCoordinates, TField, TFile, TFileList, TFileType, TStorage, TStorageDataList, TWidget } from './types/CamOverlayAPI';
-export declare class CamOverlayAPI<Client extends IClient<TResponse> = IClient<TResponse>> {
+export declare class CamOverlayAPI<Client extends IClient<TResponse, any>> {
     private client;
     constructor(client: Client);
     static getBasePath: () => string;
@@ -16,7 +14,7 @@ export declare class CamOverlayAPI<Client extends IClient<TResponse> = IClient<T
     wsAuthorization(options?: THttpRequestOptions): Promise<string>;
     getMjpegStreamImage(mjpegUrl: string, options?: THttpRequestOptions): Promise<TBlobResponse<Client>>;
     listFiles(fileType: TFileType, options?: THttpRequestOptions): Promise<TFileList>;
-    uploadFile(fileType: TFileType, formData: FormData, storage: TStorage, options?: THttpRequestOptions): Promise<void>;
+    uploadFile(fileType: TFileType, formData: Parameters<Client['post']>[0]['data'], storage: TStorage, options?: THttpRequestOptions): Promise<void>;
     removeFile(fileType: TFileType, fileParams: TFile, options?: THttpRequestOptions): Promise<void>;
     getFileStorage(fileType: TFileType, options?: THttpRequestOptions): Promise<TStorageDataList>;
     getFilePreviewFromCamera(path: string, options?: THttpRequestOptions): Promise<TBlobResponse<Client>>;
@@ -30,7 +28,7 @@ export declare class CamOverlayAPI<Client extends IClient<TResponse> = IClient<T
     updateCGText(serviceId: number, fields: TField[], options?: THttpRequestOptions): Promise<void>;
     updateCGImagePos(serviceId: number, coordinates?: TCoordinates, x?: number, y?: number, options?: THttpRequestOptions): Promise<void>;
     updateCGImage(serviceId: number, path: string, coordinates?: TCoordinates, x?: number, y?: number, options?: THttpRequestOptions): Promise<void>;
-    updateCGImageFromData(serviceId: number, imageType: ImageType, imageData: Buffer, coordinates?: TCoordinates, x?: number, y?: number, options?: THttpRequestOptions): Promise<void>;
+    updateCGImageFromData(serviceId: number, imageType: ImageType, imageData: Parameters<Client['post']>[0]['data'], coordinates?: TCoordinates, x?: number, y?: number, options?: THttpRequestOptions): Promise<void>;
     private promiseCGUpdate;
     private _get;
     private _post;

package/{esm → types}/CamScripterAPI.d.ts

@@ -2,7 +2,7 @@ import { ProxyClient } from './internal/ProxyClient';
 import { IClient, TResponse } from './internal/types';
 import { TNodeState, TPackageInfoList, TStorage, TStorageType } from './types/CamScripterAPI';
 import { THttpRequestOptions, TNetworkCamera, TProxyParams } from './types/common';
-export declare class CamScripterAPI<Client extends IClient<TResponse> = IClient<TResponse>> {
+export declare class CamScripterAPI<Client extends IClient<TResponse, any>> {
     client: Client;
     constructor(client: Client);
     static getProxyUrlPath: () => string;
@@ -11,7 +11,7 @@ export declare class CamScripterAPI<Client extends IClient<TResponse> = IClient<
     getNetworkCameraList(options?: THttpRequestOptions): Promise<TNetworkCamera[]>;
     getStorageInfo(options?: THttpRequestOptions): Promise<TStorage>;
     getPackageList(options?: THttpRequestOptions): Promise<TPackageInfoList>;
-    installPackages(formData: FormData, storage: TStorageType, options?: THttpRequestOptions): Promise<{
+    installPackages(formData: Parameters<Client['post']>[0]['data'], storage: TStorageType, options?: THttpRequestOptions): Promise<{
         status: number;
         message: string;
     }>;
@@ -19,11 +19,11 @@ export declare class CamScripterAPI<Client extends IClient<TResponse> = IClient<
         status: number;
         message: string;
     }>;
-    importSettings(packageId: string, formData: FormData, options?: THttpRequestOptions): Promise<{
+    importSettings(packageId: string, formData: Parameters<Client['post']>[0]['data'], options?: THttpRequestOptions): Promise<{
         status: number;
         message: string;
     }>;
-    exportSettings(packageId: string, formData: FormData, options?: THttpRequestOptions): Promise<{
+    exportSettings(packageId: string, formData: Parameters<Client['post']>[0]['data'], options?: THttpRequestOptions): Promise<{
         status: number;
         message: string;
     }>;

package/types/CamStreamerAPI.d.ts

@@ -0,0 +1,48 @@
+import { ProxyClient } from './internal/ProxyClient';
+import { IClient, TResponse } from './internal/types';
+import { TCameraStream, TStream } from './types/CamStreamerAPI';
+import { THttpRequestOptions, TProxyParams } from './types/common';
+export declare class CamStreamerAPI<Client extends IClient<TResponse, any>> {
+    client: Client;
+    constructor(client: Client);
+    getClient(proxyParams?: TProxyParams): Client | ProxyClient<Client>;
+    getStreamList(options?: THttpRequestOptions): Promise<Record<number, {
+        enabled: 0 | 1;
+        schedule: string;
+        active: 0 | 1;
+        audioSource: string;
+        avSyncMsec: number;
+        internalVapixParameters: string;
+        userVapixParameters: string;
+        outputParameters: string;
+        outputType: "video" | "images" | "none";
+        mediaServerUrl: string;
+        inputType: "RTSP_URL" | "CSw" | "CRS";
+        inputUrl: string;
+        forceStereo: 0 | 1;
+        streamDelay: number | null;
+        statusLed: number;
+        statusPort: string;
+        callApi: number;
+        trigger: string;
+        prepareAhead: number;
+        startTime: number | null;
+        stopTime: number | null;
+    }>>;
+    getStream(streamId: number, options?: THttpRequestOptions): Promise<TStream>;
+    getStreamParameter(streamId: number, paramName: string, options?: THttpRequestOptions): Promise<string>;
+    setStream(streamId: number, params: Partial<TStream>, options?: THttpRequestOptions): Promise<{
+        message: string;
+        status: number;
+    }>;
+    setStreamParameter(streamId: number, paramName: string, value: string, options?: THttpRequestOptions): Promise<{
+        message: string;
+        status: number;
+    }>;
+    isStreaming(streamId: number, options?: THttpRequestOptions): Promise<boolean>;
+    deleteStream(streamId: number, options?: THttpRequestOptions): Promise<boolean>;
+    getWsAuthorization(options?: THttpRequestOptions): Promise<string>;
+    getUtcTime(options?: THttpRequestOptions): Promise<number>;
+    private get;
+}
+export declare const parseCameraStreamResponse: (cameraStreamData: TCameraStream) => TStream;

package/{esm → types}/CamSwitcherAPI.d.ts

@@ -2,7 +2,7 @@ import { IClient, TResponse } from './internal/types';
 import { TAudioPushInfo, TOutputInfo, TStorageInfo, TStreamSaveList, TClipList, TStreamSaveLoadList, TClipSaveLoadList, TPlaylistSaveLoadList, TTrackerSaveList, TrackerSaveLoadList, TClipSaveList, TPlaylistSaveList, TCameraOptions, TGlobalAudioSettings, TSecondaryAudioSettings } from './types/CamSwitcherAPI';
 import { TAudioChannel, THttpRequestOptions, TNetworkCamera, TProxyParams, TStorageType } from './types/common';
 import { ProxyClient } from './internal/ProxyClient';
-export declare class CamSwitcherAPI<Client extends IClient<TResponse> = IClient<TResponse>> {
+export declare class CamSwitcherAPI<Client extends IClient<TResponse, any>> {
     client: Client;
     private CustomFormData;
     private vapixAgent;
@@ -35,14 +35,14 @@ export declare class CamSwitcherAPI<Client extends IClient<TResponse> = IClient<
     playlistQueueClear(options?: THttpRequestOptions): Promise<void>;
     playlistQueueList(options?: THttpRequestOptions): Promise<string[]>;
     playlistQueuePlayNext(options?: THttpRequestOptions): Promise<void>;
-    addNewClip(file: any, clipType: 'video' | 'audio', storage: TStorageType, id: string, fileName?: string, options?: THttpRequestOptions): Promise<void>;
-    removeClip(id: string, storage: TStorageType, options?: THttpRequestOptions): Promise<any>;
+    addNewClip(file: any, clipType: 'video' | 'audio', storage: TStorageType, clipId: string, fileName?: string, options?: THttpRequestOptions): Promise<void>;
+    removeClip(clipId: string, storage: TStorageType, options?: THttpRequestOptions): Promise<any>;
     getClipList(options?: THttpRequestOptions): Promise<TClipList>;
-    setCamSwitchOptions(data: TCameraOptions, cameraFWVersion: string, options?: THttpRequestOptions): Promise<boolean>;
-    setGlobalAudioSettings(settings: TGlobalAudioSettings, options?: THttpRequestOptions): Promise<boolean>;
-    setSecondaryAudioSettings(settings: TSecondaryAudioSettings, options?: THttpRequestOptions): Promise<boolean>;
-    setDefaultPlaylist(id: string, options?: THttpRequestOptions): Promise<boolean>;
-    setPermanentRtspUrlToken(token: string, options?: THttpRequestOptions): Promise<boolean>;
+    setCamSwitchOptions(data: TCameraOptions, cameraFWVersion: string, options?: THttpRequestOptions): Promise<void>;
+    setGlobalAudioSettings(settings: TGlobalAudioSettings, options?: THttpRequestOptions): Promise<void>;
+    setSecondaryAudioSettings(settings: TSecondaryAudioSettings, options?: THttpRequestOptions): Promise<void>;
+    setDefaultPlaylist(playlistId: string, options?: THttpRequestOptions): Promise<void>;
+    setPermanentRtspUrlToken(token: string, options?: THttpRequestOptions): Promise<void>;
     getCamSwitchOptions(options?: THttpRequestOptions): Promise<Partial<TCameraOptions>>;
     getGlobalAudioSettings(options?: THttpRequestOptions): Promise<TGlobalAudioSettings>;
     getSecondaryAudioSettings(options?: THttpRequestOptions): Promise<TSecondaryAudioSettings>;

package/types/CamSwitcherEvents.d.ts

@@ -0,0 +1,8 @@
+import { IWebsocket } from './internal/types';
+import { WsEvents } from './internal/WsEvents';
+import { TCamSwitcherEvent } from './types/CamSwitcherEvents';
+export declare class CamSwitcherEvents<Event extends {
+    data: string;
+}> extends WsEvents<TCamSwitcherEvent, Event> {
+    constructor(ws: IWebsocket<Event>);
+}

package/types/PlaneTrackerAPI.d.ts

@@ -0,0 +1,43 @@
+import { IClient, TBlobResponse, TParameters, TResponse } from './internal/types';
+import { ICAO, TApiUser, TExportDataType, TImportDataType } from './types/PlaneTrackerAPI';
+import { THttpRequestOptions, TProxyParams } from './types/common';
+import { ProxyClient } from './internal/ProxyClient';
+export declare class PlaneTrackerAPI<Client extends IClient<TResponse, any>> {
+    private client;
+    private apiUser;
+    constructor(client: Client, apiUser: TApiUser);
+    static getProxyUrlPath: () => string;
+    getClient(proxyParams?: TProxyParams): Client | ProxyClient<Client>;
+    checkCameraTime(options?: THttpRequestOptions): Promise<boolean>;
+    resetPtzCalibration(options?: THttpRequestOptions): Promise<TResponse>;
+    resetFocusCalibration(options?: THttpRequestOptions): Promise<TResponse>;
+    serverRunCheck(options?: THttpRequestOptions): Promise<TResponse>;
+    getLiveViewAlias(rtspUrl: string, options?: THttpRequestOptions): Promise<TResponse>;
+    fetchCameraSettings(options?: THttpRequestOptions): Promise<any>;
+    setCameraSettings(settingsJsonString: string, options?: THttpRequestOptions): Promise<TResponse>;
+    fetchServerSettings(options?: THttpRequestOptions): Promise<any>;
+    exportAppSettings(dataType: TExportDataType, options?: THttpRequestOptions): Promise<TBlobResponse<Client>>;
+    importAppSettings(dataType: TImportDataType, formData: Parameters<Client['post']>[0]['data'], options?: THttpRequestOptions): Promise<TResponse>;
+    fetchFlightInfo(icao: ICAO, options?: THttpRequestOptions): Promise<any>;
+    getTrackingMode(options?: THttpRequestOptions): Promise<any>;
+    setTrackingMode(modeJsonString: string, options?: THttpRequestOptions): Promise<TResponse>;
+    startTrackingPlane(icao: ICAO, options?: THttpRequestOptions): Promise<TResponse>;
+    stopTrackingPlane(options?: THttpRequestOptions): Promise<TResponse>;
+    getPriorityList(options?: THttpRequestOptions): Promise<any>;
+    setPriorityList(priorityListJsonString: string, options?: THttpRequestOptions): Promise<TResponse>;
+    getWhiteList(options?: THttpRequestOptions): Promise<any>;
+    setWhiteList(whiteListJsonString: string, options?: THttpRequestOptions): Promise<TResponse>;
+    getBlackList(options?: THttpRequestOptions): Promise<any>;
+    setBlackList(blackListJsonString: string, options?: THttpRequestOptions): Promise<TResponse>;
+    fetchMapInfo(options?: THttpRequestOptions): Promise<any>;
+    getZones(options?: THttpRequestOptions): Promise<any>;
+    setZones(zonesJsonString: string, options?: THttpRequestOptions): Promise<TResponse>;
+    goToCoordinates(lat: number, lon: number, alt?: number, options?: THttpRequestOptions): Promise<TResponse>;
+    checkGenetecConnection(params: TParameters, options?: THttpRequestOptions): Promise<TResponse>;
+    getGenetecCameraList(params: TParameters, options?: THttpRequestOptions): Promise<any>;
+    private _getJson;
+    private _getBlob;
+    private parseBlobResponse;
+    private _postJsonEncoded;
+    private _postUrlEncoded;
+}

package/{cjs → types}/VapixAPI.d.ts

@@ -2,13 +2,17 @@ import { IClient, TParameters, TResponse } from './internal/types';
 import { TAudioSampleRates, TSDCardInfo, TPtzOverview, TCameraPTZItem, TCameraPTZItemData, 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> = IClient<TResponse>> {
-    private client;
-    constructor(client: Client);
+export declare class VapixAPI<Client extends IClient<TResponse, any>> {
+    client: 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<TResponse>;
+    getCameraImage(parameters: TCameraImageConfig, options?: THttpRequestOptions): Promise<ReturnType<Client["get"]>>;
     getEventDeclarations(options?: THttpRequestOptions): Promise<string>;
     getSupportedAudioSampleRate(options?: THttpRequestOptions): Promise<TAudioSampleRates[]>;
     performAutofocus(options?: THttpRequestOptions): Promise<void>;
@@ -35,7 +39,7 @@ export declare class VapixAPI<Client extends IClient<TResponse> = IClient<TRespo
     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<boolean>;
+    setParameter(params: Record<string, string | number | boolean>, options?: THttpRequestOptions): Promise<void>;
     getGuardTourList(options?: THttpRequestOptions): Promise<{
         name: string;
         id: string;
@@ -51,7 +55,7 @@ export declare class VapixAPI<Client extends IClient<TResponse> = IClient<TRespo
         randomEnabled?: unknown;
         timeBetweenSequences?: unknown;
     }[]>;
-    setGuardTourEnabled(guardTourID: string, enable: boolean, options?: THttpRequestOptions): Promise<boolean>;
+    setGuardTourEnabled(guardTourID: string, enable: boolean, options?: THttpRequestOptions): Promise<void>;
     getPTZPresetList(channel: number, options?: THttpRequestOptions): Promise<string[]>;
     listPTZ(camera: number, options?: THttpRequestOptions): Promise<TCameraPTZItem[]>;
     listPtzVideoSourceOverview(options?: THttpRequestOptions): Promise<TPtzOverview>;
@@ -73,7 +77,7 @@ export declare class VapixAPI<Client extends IClient<TResponse> = IClient<TRespo
     startApplication(applicationID: string, options?: THttpRequestOptions): Promise<void>;
     restartApplication(applicationID: string, options?: THttpRequestOptions): Promise<void>;
     stopApplication(applicationID: string, options?: THttpRequestOptions): Promise<void>;
-    installApplication(data: Blob, fileName: 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 → types}/index.d.ts

@@ -2,6 +2,7 @@ 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 { CamSwitcherAPI } from './CamSwitcherAPI';
 export { CamSwitcherEvents } from './CamSwitcherEvents';
@@ -15,9 +16,3 @@ export * from './types/CamSwitcherAPI';
 export * from './types/VapixAPI';
 export * from './types/CamOverlayAPI';
 export * from './types/PlaneTrackerAPI';
-export { Frame } from './CamOverlayPainter/Frame';
-export { Painter } from './CamOverlayPainter/Painter';
-export { ResourceManager } from './CamOverlayPainter/ResourceManager';
-export * from './types/CamOverlayPainter';
-export { CamOverlayDrawingAPI } from './CamOverlayDrawingAPI';
-export * from './types/CamOverlayDrawingAPI';

package/{esm → types}/internal/ProxyClient.d.ts

@@ -1,10 +1,10 @@
-import { IClient, TGetParams, TPostParams, TResponse } from './types';
+import { IClient, TGetParams, TResponse } from './types';
 import { TProxyParams } from '../types/common';
-export declare class ProxyClient<Client extends IClient<TResponse> = IClient<TResponse>> {
+export declare class ProxyClient<Client extends IClient<TResponse, any>> {
     private client;
     private proxyParams;
     constructor(client: Client, proxyParams: TProxyParams);
-    get: (params: TGetParams) => Promise<TResponse>;
-    post: (params: TPostParams) => Promise<TResponse>;
+    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,41 @@
+import { IWebsocket } 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 TZodSchema<T extends {
+    type: string;
+}> = {
+    parse: (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;
+}, Event extends {
+    data: string;
+}> {
+    private zodSchema;
+    ws: IWebsocket<Event>;
+    private _isDestroyed;
+    private listeners;
+    constructor(zodSchema: TZodSchema<T>, ws: IWebsocket<Event>);
+    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/{esm → types}/internal/types.d.ts

@@ -1,6 +1,3 @@
-/// <reference types="node" />
-/// <reference types="node" />
-import { Response as UndiciResponse } from 'undici';
 export type Options = {
     ip?: string;
     port?: number;
@@ -14,25 +11,31 @@ export type HttpOptions = Options & {
 };
 export type WsOptions = Options;
 export type TParameters = Record<string, string | number | boolean | null | undefined>;
-export type TResponse = Response | UndiciResponse;
+export type TResponse = {
+    json: () => Promise<any>;
+    text: () => Promise<string>;
+    blob: () => Promise<unknown>;
+    status: number;
+    ok: boolean;
+};
 export type TGetParams = {
     path: string;
     parameters?: TParameters;
     headers?: Record<string, string>;
     timeout?: number;
 };
-export type TPostParams = {
+export type TPostParams<Data> = {
     path: string;
-    data: string | Buffer | FormData;
+    data: string | Data;
     parameters?: TParameters;
     headers?: Record<string, string>;
     timeout?: number;
 };
-export interface IClient<TRes extends TResponse> {
+export interface IClient<TRes extends TResponse, Data> {
     get: (params: TGetParams) => Promise<TRes>;
-    post: (params: TPostParams) => Promise<TRes>;
+    post: (params: TPostParams<Data>) => Promise<TRes>;
 }
-export type TBlobResponse<Client extends IClient<TResponse>> = Awaited<ReturnType<Awaited<ReturnType<Client['get']>>['blob']>>;
+export type TBlobResponse<Client extends IClient<TResponse, any>> = Awaited<ReturnType<Awaited<ReturnType<Client['get']>>['blob']>>;
 export interface IWebsocket<Event extends {
     readonly data: string;
 }> {

package/{cjs → types}/node/DefaultClient.d.ts

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

package/{esm → types/node}/events/AxisCameraStationEvents.d.ts

@@ -1,7 +1,7 @@
-import { HttpOptions } from '../internal/types';
-import { THttpRequestOptions, TProxyParams } from '../types/common';
-import { ProxyClient } from '../internal/ProxyClient';
-import { DefaultClient } from '../node';
+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;