camstreamerlib 4.0.0-beta.2 → 4.0.0-beta.4

package/cjs/types/CamSwitcherEvents.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cswEventsSchema = void 0;
+const zod_1 = require("zod");
+const cswEventsDataSchema = zod_1.z.discriminatedUnion('type', [
+    zod_1.z.object({ type: zod_1.z.literal('authorization'), state: zod_1.z.string() }),
+    zod_1.z.object({
+        type: zod_1.z.literal('PlaylistSwitch'),
+        playlist_name: zod_1.z.string(),
+    }),
+    zod_1.z.object({
+        type: zod_1.z.literal('StreamAvailable'),
+        stream_name: zod_1.z.string(),
+        state: zod_1.z.boolean(),
+    }),
+    zod_1.z.object({
+        type: zod_1.z.literal('StreamSwitchAudio'),
+        stream_name: zod_1.z.string().optional(),
+        clip_name: zod_1.z.string().optional(),
+        master_audio: zod_1.z.boolean(),
+    }),
+    zod_1.z.object({
+        type: zod_1.z.literal('StreamSwitchAudioError'),
+        stream_name: zod_1.z.string().optional(),
+        clip_name: zod_1.z.string().optional(),
+        master_audio: zod_1.z.boolean(),
+    }),
+    zod_1.z.object({
+        type: zod_1.z.literal('StreamSwitchVideo'),
+        playlist_active_stream: zod_1.z.number(),
+        stream_name: zod_1.z.string().optional(),
+        playlist_name: zod_1.z.string().optional(),
+        clip_name: zod_1.z.string().optional(),
+    }),
+    zod_1.z.object({
+        type: zod_1.z.literal('PlaylistQueueChange'),
+        queue: zod_1.z.array(zod_1.z.string()),
+    }),
+    zod_1.z.object({
+        type: zod_1.z.literal('ClipUpload'),
+        clip_name: zod_1.z.string().optional(),
+    }),
+    zod_1.z.object({
+        type: zod_1.z.literal('SwitcherStop'),
+        default_playlist_id: zod_1.z.string().optional(),
+    }),
+    zod_1.z.object({
+        type: zod_1.z.literal('SwitcherStart'),
+        default_playlist_id: zod_1.z.string().optional(),
+    }),
+    zod_1.z.object({
+        type: zod_1.z.literal('MediaServerStarted'),
+    }),
+    zod_1.z.object({
+        type: zod_1.z.literal('ClipRemove'),
+        clip_name: zod_1.z.string(),
+    }),
+]);
+exports.cswEventsSchema = zod_1.z.discriminatedUnion('type', [
+    zod_1.z.object({ type: zod_1.z.literal('init'), data: cswEventsDataSchema }),
+    ...cswEventsDataSchema.options,
+]);

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

@@ -1509,7 +1509,7 @@ export declare const audioDeviceRequestSchema: z.ZodObject<{
 }>;
 export type TAudioDeviceFromRequest = z.infer<typeof audioDeviceFromRequestSchema>;
 export declare const maxFpsResponseSchema: z.ZodObject<{
-    data: z.ZodArray<z.ZodObject<{
+    data: z.ZodOptional<z.ZodArray<z.ZodObject<{
         channel: z.ZodNumber;
         captureMode: z.ZodArray<z.ZodObject<{
             enabled: z.ZodBoolean;
@@ -1533,23 +1533,23 @@ export declare const maxFpsResponseSchema: z.ZodObject<{
             enabled: boolean;
             maxFPS?: number | undefined;
         }[];
-    }>, "many">;
+    }>, "many">>;
 }, "strip", z.ZodTypeAny, {
-    data: {
+    data?: {
         channel: number;
         captureMode: {
             enabled: boolean;
             maxFPS?: number | undefined;
         }[];
-    }[];
+    }[] | undefined;
 }, {
-    data: {
+    data?: {
         channel: number;
         captureMode: {
             enabled: boolean;
             maxFPS?: number | undefined;
         }[];
-    }[];
+    }[] | undefined;
 }>;
 export declare const dateTimeinfoSchema: z.ZodObject<{
     data: z.ZodObject<{
@@ -1590,8 +1590,8 @@ export declare const dateTimeinfoSchema: z.ZodObject<{
 }>;
 export declare const audioSampleRatesResponseSchema: z.ZodObject<{
     data: z.ZodObject<{
-        encoders: z.ZodUnion<[z.ZodObject<{
-            aac: z.ZodArray<z.ZodObject<{
+        encoders: z.ZodObject<{
+            aac: z.ZodOptional<z.ZodArray<z.ZodObject<{
                 sample_rate: z.ZodNumber;
                 bit_rates: z.ZodArray<z.ZodNumber, "many">;
             }, "strip", z.ZodTypeAny, {
@@ -1600,22 +1600,8 @@ export declare const audioSampleRatesResponseSchema: z.ZodObject<{
             }, {
                 sample_rate: number;
                 bit_rates: number[];
-            }>, "many">;
-            AAC: z.ZodUndefined;
-        }, "strip", z.ZodTypeAny, {
-            aac: {
-                sample_rate: number;
-                bit_rates: number[];
-            }[];
-            AAC?: undefined;
-        }, {
-            aac: {
-                sample_rate: number;
-                bit_rates: number[];
-            }[];
-            AAC?: undefined;
-        }>, z.ZodObject<{
-            AAC: z.ZodArray<z.ZodObject<{
+            }>, "many">>;
+            AAC: z.ZodOptional<z.ZodArray<z.ZodObject<{
                 sample_rate: z.ZodNumber;
                 bit_rates: z.ZodArray<z.ZodNumber, "many">;
             }, "strip", z.ZodTypeAny, {
@@ -1624,80 +1610,73 @@ export declare const audioSampleRatesResponseSchema: z.ZodObject<{
             }, {
                 sample_rate: number;
                 bit_rates: number[];
-            }>, "many">;
-            aac: z.ZodUndefined;
+            }>, "many">>;
         }, "strip", z.ZodTypeAny, {
-            AAC: {
+            aac?: {
                 sample_rate: number;
                 bit_rates: number[];
-            }[];
-            aac?: undefined;
+            }[] | undefined;
+            AAC?: {
+                sample_rate: number;
+                bit_rates: number[];
+            }[] | undefined;
         }, {
-            AAC: {
+            aac?: {
                 sample_rate: number;
                 bit_rates: number[];
-            }[];
-            aac?: undefined;
-        }>]>;
+            }[] | undefined;
+            AAC?: {
+                sample_rate: number;
+                bit_rates: number[];
+            }[] | undefined;
+        }>;
     }, "strip", z.ZodTypeAny, {
         encoders: {
-            aac: {
+            aac?: {
                 sample_rate: number;
                 bit_rates: number[];
-            }[];
-            AAC?: undefined;
-        } | {
-            AAC: {
+            }[] | undefined;
+            AAC?: {
                 sample_rate: number;
                 bit_rates: number[];
-            }[];
-            aac?: undefined;
+            }[] | undefined;
         };
     }, {
         encoders: {
-            aac: {
+            aac?: {
                 sample_rate: number;
                 bit_rates: number[];
-            }[];
-            AAC?: undefined;
-        } | {
-            AAC: {
+            }[] | undefined;
+            AAC?: {
                 sample_rate: number;
                 bit_rates: number[];
-            }[];
-            aac?: undefined;
+            }[] | undefined;
         };
     }>;
 }, "strip", z.ZodTypeAny, {
     data: {
         encoders: {
-            aac: {
+            aac?: {
                 sample_rate: number;
                 bit_rates: number[];
-            }[];
-            AAC?: undefined;
-        } | {
-            AAC: {
+            }[] | undefined;
+            AAC?: {
                 sample_rate: number;
                 bit_rates: number[];
-            }[];
-            aac?: undefined;
+            }[] | undefined;
         };
     };
 }, {
     data: {
         encoders: {
-            aac: {
+            aac?: {
                 sample_rate: number;
                 bit_rates: number[];
-            }[];
-            AAC?: undefined;
-        } | {
-            AAC: {
+            }[] | undefined;
+            AAC?: {
                 sample_rate: number;
                 bit_rates: number[];
-            }[];
-            aac?: undefined;
+            }[] | undefined;
         };
     };
 }>;

package/cjs/types/VapixAPI.js

@@ -0,0 +1,130 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.audioSampleRatesResponseSchema = exports.dateTimeinfoSchema = exports.maxFpsResponseSchema = exports.audioDeviceRequestSchema = exports.audioDeviceSchema = exports.audioDeviceInputOutputSchema = exports.audioDeviceConnectionTypeSchema = exports.audioDeviceSignalingTypeSchema = exports.audioDeviceSignalingChannelTypeSchema = exports.cameraPTZItemSchema = exports.cameraPTZItemDataSchema = exports.PtzOverviewSchema = exports.sdCardWatchedStatuses = exports.guardTourSchema = exports.applicationListSchema = exports.APP_IDS = exports.applicationSchema = void 0;
+const zod_1 = require("zod");
+const transformers_1 = require("../internal/transformers");
+exports.applicationSchema = zod_1.z.object({
+    Name: zod_1.z.string(),
+    NiceName: zod_1.z.string(),
+    Vendor: zod_1.z.string(),
+    Version: zod_1.z.string(),
+    ApplicationID: zod_1.z.string().optional(),
+    License: zod_1.z.string(),
+    Status: zod_1.z.string(),
+    ConfigurationPage: zod_1.z.string().optional(),
+    VendorHomePage: zod_1.z.string().optional(),
+    LicenseName: zod_1.z.string().optional(),
+});
+exports.APP_IDS = [
+    'CamStreamer',
+    'CamSwitcher',
+    'CamOverlay',
+    'CamScripter',
+    'PlaneTracker',
+    'Ndihxplugin',
+];
+exports.applicationListSchema = zod_1.z.object({
+    reply: zod_1.z.object({
+        $: zod_1.z.object({ result: zod_1.z.string() }),
+        application: zod_1.z.array(zod_1.z.object({
+            $: exports.applicationSchema,
+        })),
+    }),
+});
+exports.guardTourSchema = zod_1.z.object({
+    id: zod_1.z.string(),
+    camNbr: zod_1.z.unknown(),
+    name: zod_1.z.string(),
+    randomEnabled: zod_1.z.unknown(),
+    running: zod_1.z.string(),
+    timeBetweenSequences: zod_1.z.unknown(),
+    tour: zod_1.z.array(zod_1.z.object({
+        moveSpeed: zod_1.z.unknown(),
+        position: zod_1.z.unknown(),
+        presetNbr: zod_1.z.unknown(),
+        waitTime: zod_1.z.unknown(),
+        waitTimeViewType: zod_1.z.unknown(),
+    })),
+});
+const audioSampleRatesSchema = zod_1.z.object({
+    sample_rate: zod_1.z.number(),
+    bit_rates: zod_1.z.array(zod_1.z.number()),
+});
+const audioSampleRatesOutSchema = audioSampleRatesSchema.transform(transformers_1.toCamelCaseDeep);
+exports.sdCardWatchedStatuses = ['OK', 'connected', 'disconnected'];
+exports.PtzOverviewSchema = zod_1.z.record(zod_1.z.number(), zod_1.z.array(zod_1.z.object({ id: zod_1.z.number(), name: zod_1.z.string() })));
+exports.cameraPTZItemDataSchema = zod_1.z.object({
+    pan: zod_1.z.number().optional(),
+    tilt: zod_1.z.number().optional(),
+    zoom: zod_1.z.number().optional(),
+});
+exports.cameraPTZItemSchema = zod_1.z.object({
+    name: zod_1.z.string(),
+    id: zod_1.z.number(),
+    data: exports.cameraPTZItemDataSchema,
+});
+exports.audioDeviceSignalingChannelTypeSchema = zod_1.z.object({
+    id: zod_1.z.string(),
+    gain: zod_1.z.number(),
+    mute: zod_1.z.boolean(),
+});
+exports.audioDeviceSignalingTypeSchema = zod_1.z.object({
+    id: zod_1.z.string(),
+    powerType: zod_1.z.string(),
+    channels: zod_1.z.array(exports.audioDeviceSignalingChannelTypeSchema),
+});
+exports.audioDeviceConnectionTypeSchema = zod_1.z.object({
+    id: zod_1.z.string(),
+    signalingTypeSelected: zod_1.z.string(),
+    signalingTypes: zod_1.z.array(exports.audioDeviceSignalingTypeSchema),
+});
+exports.audioDeviceInputOutputSchema = zod_1.z.object({
+    id: zod_1.z.string(),
+    name: zod_1.z.string(),
+    enabled: zod_1.z.boolean(),
+    connectionTypes: zod_1.z.array(exports.audioDeviceConnectionTypeSchema),
+    connectionTypeSelected: zod_1.z.string(),
+});
+exports.audioDeviceSchema = zod_1.z.object({
+    id: zod_1.z.string(),
+    name: zod_1.z.string(),
+    inputs: zod_1.z.array(exports.audioDeviceInputOutputSchema),
+    outputs: zod_1.z.array(exports.audioDeviceInputOutputSchema),
+});
+const audioDeviceFromRequestSchema = zod_1.z.object({
+    id: zod_1.z.string(),
+    name: zod_1.z.string(),
+    inputs: zod_1.z.array(exports.audioDeviceInputOutputSchema).optional(),
+    outputs: zod_1.z.array(exports.audioDeviceInputOutputSchema).optional(),
+});
+exports.audioDeviceRequestSchema = zod_1.z.object({ devices: zod_1.z.array(audioDeviceFromRequestSchema) });
+exports.maxFpsResponseSchema = zod_1.z.object({
+    data: zod_1.z
+        .array(zod_1.z.object({
+        channel: zod_1.z.number(),
+        captureMode: zod_1.z.array(zod_1.z.object({
+            enabled: zod_1.z.boolean(),
+            maxFPS: zod_1.z.number().optional(),
+        })),
+    }))
+        .optional(),
+});
+exports.dateTimeinfoSchema = zod_1.z.object({
+    data: zod_1.z.object({
+        dateTime: zod_1.z.string(),
+        dstEnabled: zod_1.z.boolean(),
+        localDateTime: zod_1.z.string(),
+        posixTimeZone: zod_1.z.string(),
+        timeZone: zod_1.z.string(),
+    }),
+});
+exports.audioSampleRatesResponseSchema = zod_1.z.object({
+    data: zod_1.z.object({
+        encoders: zod_1.z
+            .object({
+            aac: zod_1.z.array(audioSampleRatesSchema),
+            AAC: zod_1.z.array(audioSampleRatesSchema),
+        })
+            .partial(),
+    }),
+});

package/cjs/types/common.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.keyboardShortcutsSchema = exports.keyboardShortcutSchema = exports.networkCameraListSchema = exports.storageTypeSchema = exports.h264ProfileSchema = exports.audioChannelCountSchema = exports.audioChannelSchema = void 0;
+const zod_1 = require("zod");
+exports.audioChannelSchema = zod_1.z.union([zod_1.z.literal('mono'), zod_1.z.literal('stereo')]);
+exports.audioChannelCountSchema = zod_1.z.union([zod_1.z.literal(1), zod_1.z.literal(2)]);
+exports.h264ProfileSchema = zod_1.z.union([zod_1.z.literal('high'), zod_1.z.literal('main'), zod_1.z.literal('baseline')]);
+exports.storageTypeSchema = zod_1.z.union([zod_1.z.literal('SD_DISK'), zod_1.z.literal('FLASH')]);
+exports.networkCameraListSchema = zod_1.z.array(zod_1.z.object({
+    name: zod_1.z.string(),
+    ip: zod_1.z.string(),
+}));
+exports.keyboardShortcutSchema = zod_1.z.string().nullable();
+exports.keyboardShortcutsSchema = zod_1.z.record(exports.keyboardShortcutSchema);

package/cjs/web/DefaultClient.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DefaultClient = void 0;
+const utils_1 = require("../internal/utils");
+class DefaultClient {
+    get(url, parameters, headers) {
+        return fetch((0, utils_1.addParametersToPath)(url, parameters), {
+            method: 'GET',
+            headers: headers,
+        });
+    }
+    post(url, data, parameters, headers) {
+        return fetch((0, utils_1.addParametersToPath)(url, parameters), {
+            method: 'POST',
+            body: data,
+            headers: headers,
+        });
+    }
+}
+exports.DefaultClient = DefaultClient;

package/cjs/web/WsClient.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WsClient = void 0;
+const REFRESH_TIMEOUT = 5_000;
+class WsClient {
+    getUrl;
+    getAuthToken;
+    isDestroyed = false;
+    ws = null;
+    restartTimeout = null;
+    constructor(getUrl, getAuthToken) {
+        this.getUrl = getUrl;
+        this.getAuthToken = getAuthToken;
+    }
+    init() {
+        if (this.isDestroyed) {
+            return;
+        }
+        this.destroyWebsocket();
+        const ws = new WebSocket(this.getUrl(), 'events');
+        ws.onopen = async () => {
+            try {
+                const token = await this.getAuthToken();
+                ws.send(JSON.stringify({ authorization: token }));
+            }
+            catch (error) {
+                console.error('Error sending auth token:', error);
+                ws.close();
+            }
+        };
+        ws.onmessage = (e) => this.onmessage(e);
+        ws.onclose = () => {
+            this.restartTimeout = setTimeout(() => this.init(), REFRESH_TIMEOUT);
+        };
+        this.ws = ws;
+    }
+    send = (msg) => {
+        this.ws?.send(msg);
+    };
+    onmessage = (_) => { };
+    destroy = () => {
+        this.isDestroyed = true;
+        this.destroyWebsocket();
+    };
+    destroyWebsocket() {
+        if (this.restartTimeout) {
+            clearTimeout(this.restartTimeout);
+            this.restartTimeout = null;
+        }
+        if (!this.ws) {
+            return;
+        }
+        this.ws.onmessage = null;
+        this.ws.onopen = null;
+        this.ws.onclose = null;
+        if (this.ws.readyState === this.ws.OPEN) {
+            this.ws.close();
+        }
+        this.ws = null;
+    }
+}
+exports.WsClient = WsClient;

package/cjs/web/index.d.ts

@@ -0,0 +1,2 @@
+export { DefaultClient } from './DefaultClient';
+export { WsClient } from './WsClient';

package/cjs/web/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WsClient = exports.DefaultClient = void 0;
+var DefaultClient_1 = require("./DefaultClient");
+Object.defineProperty(exports, "DefaultClient", { enumerable: true, get: function () { return DefaultClient_1.DefaultClient; } });
+var WsClient_1 = require("./WsClient");
+Object.defineProperty(exports, "WsClient", { enumerable: true, get: function () { return WsClient_1.WsClient; } });

package/esm/CamOverlayAPI.d.ts

@@ -0,0 +1,31 @@
+/// <reference types="node" />
+import { IClient } from './internal/common';
+import { CamOverlayOptions, ImageType, TCoordinates, TField, TFile, TFileList, TFileType, TService, TServiceList, TStorage } from './types/CamOverlayAPI';
+import { TNetworkCamera } from './types/common';
+export declare class CamOverlayAPI {
+    private client;
+    constructor(options?: CamOverlayOptions | IClient);
+    checkCameraTime(): Promise<boolean>;
+    getNetworkCameraList(): Promise<TNetworkCamera[]>;
+    wsAutoratization(): Promise<string>;
+    getMjpegStreamImage(mjpegUrl: string): Promise<Blob>;
+    listFiles(fileType: TFileType): Promise<TFileList>;
+    uploadFile(fileType: TFileType, file: Blob, fileName: string): Promise<void>;
+    removeFile(fileType: TFileType, file: TFile): Promise<void>;
+    getFileStorage(fileType: TFileType): Promise<TStorage>;
+    updateInfoticker(serviceID: number, text: string): Promise<void>;
+    setEnabled(serviceID: number, enabled: boolean): Promise<void>;
+    isEnabled(serviceID: number): Promise<boolean>;
+    getSingleService(serviceId: number): Promise<TService>;
+    getServices(): Promise<TService[]>;
+    updateSingleService(serviceId: number, serviceJson: TService): Promise<void>;
+    updateServices(servicesJson: TServiceList): Promise<void>;
+    updateCGText(serviceID: number, fields: TField[]): Promise<void>;
+    updateCGImagePos(serviceID: number, coordinates?: TCoordinates, x?: number, y?: number): Promise<void>;
+    updateCGImage(serviceID: number, path: string, coordinates?: TCoordinates, x?: number, y?: number): Promise<void>;
+    updateCGImageFromData(serviceID: number, imageType: ImageType, imageData: Buffer, coordinates?: TCoordinates, x?: number, y?: number): Promise<void>;
+    private promiseCGUpdate;
+    private get;
+    private post;
+    private parseBlobResponse;
+}

package/esm/CamOverlayDrawingAPI.d.ts

@@ -0,0 +1,86 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import * as EventEmitter from 'events';
+import { WsOptions } from './internal/common';
+export type CamOverlayDrawingOptions = WsOptions & {
+    camera?: number | number[];
+    zIndex?: number;
+};
+export type TCairoResponse = {
+    message: string;
+    call_id: number;
+};
+export type TCairoCreateResponse = {
+    var: string;
+    call_id: number;
+};
+export type TUploadImageResponse = {
+    var: string;
+    width: number;
+    height: number;
+    call_id: number;
+};
+export type TErrorResponse = {
+    error: string;
+    call_id?: number;
+};
+export type TService = {
+    id: number;
+    enabled: number;
+    schedule: string;
+    name: string;
+    identifier: string;
+    cameraList: number[];
+};
+export type TServiceList = {
+    services: TService[];
+};
+export type TAlign = 'A_RIGHT' | 'A_LEFT' | 'A_CENTER';
+export type TextFit = 'TFM_SCALE' | 'TFM_TRUNCATE' | 'TFM_OVERFLOW';
+export type TWriteTextParams = [string, string, number, number, number, number, TAlign, TextFit?];
+export interface CamOverlayDrawingAPI {
+    on(event: 'open', listener: () => void): this;
+    on(event: 'close', listener: () => void): this;
+    on(event: 'error', listener: (err: Error) => void): this;
+    on(event: 'message', listener: (msg: string) => void): this;
+    emit(event: 'open'): boolean;
+    emit(event: 'close'): boolean;
+    emit(event: 'error', err: Error): boolean;
+    emit(event: 'message', msg: string): boolean;
+}
+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/{CamOverlayDrawingAPI.js → esm/CamOverlayDrawingAPI.js}

@@ -121,10 +121,10 @@ export class CamOverlayDrawingAPI extends EventEmitter {
         }
         if (dataJSON.call_id !== undefined) {
             if (errorResponse !== undefined) {
-                this.sendMessages[dataJSON.call_id].reject(new Error(errorResponse.error));
+                this.sendMessages[dataJSON.call_id]?.reject(new Error(errorResponse.error));
             }
             else {
-                this.sendMessages[dataJSON.call_id].resolve(dataJSON);
+                this.sendMessages[dataJSON.call_id]?.resolve(dataJSON);
             }
             delete this.sendMessages[dataJSON.call_id];
         }
@@ -194,6 +194,9 @@ export class CamOverlayDrawingAPI extends EventEmitter {
             const now = Date.now();
             for (const callId in this.sendMessages) {
                 const msg = this.sendMessages[callId];
+                if (!msg) {
+                    continue;
+                }
                 if (now - msg.sentTimestamp > 10000) {
                     reconnect = true;
                     msg.reject(new Error('Message timeout'));
@@ -220,7 +223,7 @@ export class CamOverlayDrawingAPI extends EventEmitter {
     }
     reportClose() {
         for (const callId in this.sendMessages) {
-            this.sendMessages[callId].reject(new Error('Connection lost'));
+            this.sendMessages[callId]?.reject(new Error('Connection lost'));
         }
         this.sendMessages = {};
         this.emit('close');