camstreamerlib 4.0.0-beta.99 → 4.0.1

package/cjs/types/common.d.ts

@@ -48,3 +48,30 @@ export type TCameraImageConfig = {
     overlays?: string;
     [key: string]: string | number | undefined;
 };
+export declare const bitrateModeSchema: z.ZodUnion<[z.ZodLiteral<"VBR">, z.ZodLiteral<"MBR">, z.ZodLiteral<"ABR">]>;
+export type TBitrateMode = z.infer<typeof bitrateModeSchema>;
+export declare const bitrateVapixParamsSchema: z.ZodObject<{
+    bitrateMode: z.ZodUnion<[z.ZodLiteral<"VBR">, z.ZodLiteral<"MBR">, z.ZodLiteral<"ABR">]>;
+    maximumBitRate: z.ZodNumber;
+    retentionTime: z.ZodNumber;
+    bitRateLimit: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    bitrateMode: "VBR" | "MBR" | "ABR";
+    maximumBitRate: number;
+    retentionTime: number;
+    bitRateLimit: number;
+}, {
+    bitrateMode: "VBR" | "MBR" | "ABR";
+    maximumBitRate: number;
+    retentionTime: number;
+    bitRateLimit: number;
+}>;
+export type TBitrateVapixParams = z.infer<typeof bitrateVapixParamsSchema>;
+export type FileLike = typeof File extends {
+    prototype: infer T;
+} ? T : {
+    name: string;
+    size: number;
+    type: string;
+};
+export declare const fileSchema: z.ZodType<File, z.ZodTypeDef, File>;

package/cjs/types/common.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.keyboardShortcutsSchema = exports.keyboardShortcutSchema = exports.networkCameraListSchema = exports.storageTypeSchema = exports.sdCardStorageTypeSchema = exports.flashStorageTypeSchema = exports.h264ProfileSchema = exports.audioChannelCountSchema = exports.audioChannelSchema = exports.booleanSchema = void 0;
+exports.fileSchema = exports.bitrateVapixParamsSchema = exports.bitrateModeSchema = exports.keyboardShortcutsSchema = exports.keyboardShortcutSchema = exports.networkCameraListSchema = exports.storageTypeSchema = exports.sdCardStorageTypeSchema = exports.flashStorageTypeSchema = exports.h264ProfileSchema = exports.audioChannelCountSchema = exports.audioChannelSchema = exports.booleanSchema = void 0;
 const zod_1 = require("zod");
 exports.booleanSchema = zod_1.z.union([zod_1.z.literal(0), zod_1.z.literal(1)]);
 exports.audioChannelSchema = zod_1.z.union([zod_1.z.literal('mono'), zod_1.z.literal('stereo')]);
@@ -15,3 +15,15 @@ exports.networkCameraListSchema = zod_1.z.array(zod_1.z.object({
 }));
 exports.keyboardShortcutSchema = zod_1.z.string().nullable();
 exports.keyboardShortcutsSchema = zod_1.z.record(exports.keyboardShortcutSchema);
+exports.bitrateModeSchema = zod_1.z.union([zod_1.z.literal('VBR'), zod_1.z.literal('MBR'), zod_1.z.literal('ABR')]);
+exports.bitrateVapixParamsSchema = zod_1.z.object({
+    bitrateMode: exports.bitrateModeSchema,
+    maximumBitRate: zod_1.z.number(),
+    retentionTime: zod_1.z.number(),
+    bitRateLimit: zod_1.z.number(),
+});
+exports.fileSchema = typeof File !== 'undefined'
+    ? zod_1.z.instanceof(File)
+    : zod_1.z.custom((val) => {
+        return val !== null && typeof val === 'object' && 'name' in val && 'size' in val && 'type' in val;
+    });

package/cjs/types/ws/CamStreamerEvents.d.ts

@@ -10,58 +10,67 @@ declare const csEventsDataSchema: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
     state: string;
 }>, z.ZodObject<{
     type: z.ZodLiteral<"StreamState">;
-    streamID: z.ZodNumber;
-    enabled: z.ZodUnion<[z.ZodLiteral<0>, z.ZodLiteral<1>]>;
-    active: z.ZodUnion<[z.ZodLiteral<0>, z.ZodLiteral<1>]>;
-    automationState: z.ZodUnion<[z.ZodLiteral<0>, z.ZodLiteral<1>]>;
-    isStreaming: z.ZodUnion<[z.ZodLiteral<0>, z.ZodLiteral<1>]>;
+    streamId: z.ZodString;
+    isStreaming: z.ZodBoolean;
+    active: z.ZodBoolean;
+    enabled: z.ZodBoolean;
 }, "strip", z.ZodTypeAny, {
     type: "StreamState";
-    enabled: 0 | 1;
-    active: 0 | 1;
-    streamID: number;
-    automationState: 0 | 1;
-    isStreaming: 0 | 1;
+    streamId: string;
+    enabled: boolean;
+    active: boolean;
+    isStreaming: boolean;
 }, {
     type: "StreamState";
-    enabled: 0 | 1;
-    active: 0 | 1;
-    streamID: number;
-    automationState: 0 | 1;
-    isStreaming: 0 | 1;
+    streamId: string;
+    enabled: boolean;
+    active: boolean;
+    isStreaming: boolean;
 }>, z.ZodObject<{
     type: z.ZodLiteral<"CS_API_SUCCESS">;
     apiCall: z.ZodString;
     message: z.ZodString;
-    streamID: z.ZodString;
+    streamId: z.ZodString;
 }, "strip", z.ZodTypeAny, {
     message: string;
     type: "CS_API_SUCCESS";
-    streamID: string;
+    streamId: string;
     apiCall: string;
 }, {
     message: string;
     type: "CS_API_SUCCESS";
-    streamID: string;
+    streamId: string;
     apiCall: string;
 }>, z.ZodObject<{
     type: z.ZodLiteral<"CS_API_ERROR">;
     apiCall: z.ZodString;
     message: z.ZodString;
-    streamID: z.ZodString;
+    streamId: z.ZodString;
     code: z.ZodString;
 }, "strip", z.ZodTypeAny, {
     code: string;
     message: string;
     type: "CS_API_ERROR";
-    streamID: string;
+    streamId: string;
     apiCall: string;
 }, {
     code: string;
     message: string;
     type: "CS_API_ERROR";
-    streamID: string;
+    streamId: string;
     apiCall: string;
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"PortChanged">;
+    port: z.ZodNumber;
+    value: z.ZodBoolean;
+}, "strip", z.ZodTypeAny, {
+    value: boolean;
+    type: "PortChanged";
+    port: number;
+}, {
+    value: boolean;
+    type: "PortChanged";
+    port: number;
 }>]>;
 export declare const csEventsSchema: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
     type: z.ZodLiteral<"init">;
@@ -76,58 +85,67 @@ export declare const csEventsSchema: z.ZodDiscriminatedUnion<"type", [z.ZodObjec
         state: string;
     }>, z.ZodObject<{
         type: z.ZodLiteral<"StreamState">;
-        streamID: z.ZodNumber;
-        enabled: z.ZodUnion<[z.ZodLiteral<0>, z.ZodLiteral<1>]>;
-        active: z.ZodUnion<[z.ZodLiteral<0>, z.ZodLiteral<1>]>;
-        automationState: z.ZodUnion<[z.ZodLiteral<0>, z.ZodLiteral<1>]>;
-        isStreaming: z.ZodUnion<[z.ZodLiteral<0>, z.ZodLiteral<1>]>;
+        streamId: z.ZodString;
+        isStreaming: z.ZodBoolean;
+        active: z.ZodBoolean;
+        enabled: z.ZodBoolean;
     }, "strip", z.ZodTypeAny, {
         type: "StreamState";
-        enabled: 0 | 1;
-        active: 0 | 1;
-        streamID: number;
-        automationState: 0 | 1;
-        isStreaming: 0 | 1;
+        streamId: string;
+        enabled: boolean;
+        active: boolean;
+        isStreaming: boolean;
     }, {
         type: "StreamState";
-        enabled: 0 | 1;
-        active: 0 | 1;
-        streamID: number;
-        automationState: 0 | 1;
-        isStreaming: 0 | 1;
+        streamId: string;
+        enabled: boolean;
+        active: boolean;
+        isStreaming: boolean;
     }>, z.ZodObject<{
         type: z.ZodLiteral<"CS_API_SUCCESS">;
         apiCall: z.ZodString;
         message: z.ZodString;
-        streamID: z.ZodString;
+        streamId: z.ZodString;
     }, "strip", z.ZodTypeAny, {
         message: string;
         type: "CS_API_SUCCESS";
-        streamID: string;
+        streamId: string;
         apiCall: string;
     }, {
         message: string;
         type: "CS_API_SUCCESS";
-        streamID: string;
+        streamId: string;
         apiCall: string;
     }>, z.ZodObject<{
         type: z.ZodLiteral<"CS_API_ERROR">;
         apiCall: z.ZodString;
         message: z.ZodString;
-        streamID: z.ZodString;
+        streamId: z.ZodString;
         code: z.ZodString;
     }, "strip", z.ZodTypeAny, {
         code: string;
         message: string;
         type: "CS_API_ERROR";
-        streamID: string;
+        streamId: string;
         apiCall: string;
     }, {
         code: string;
         message: string;
         type: "CS_API_ERROR";
-        streamID: string;
+        streamId: string;
         apiCall: string;
+    }>, z.ZodObject<{
+        type: z.ZodLiteral<"PortChanged">;
+        port: z.ZodNumber;
+        value: z.ZodBoolean;
+    }, "strip", z.ZodTypeAny, {
+        value: boolean;
+        type: "PortChanged";
+        port: number;
+    }, {
+        value: boolean;
+        type: "PortChanged";
+        port: number;
     }>]>;
 }, "strip", z.ZodTypeAny, {
     type: "init";
@@ -136,22 +154,25 @@ export declare const csEventsSchema: z.ZodDiscriminatedUnion<"type", [z.ZodObjec
         state: string;
     } | {
         type: "StreamState";
-        enabled: 0 | 1;
-        active: 0 | 1;
-        streamID: number;
-        automationState: 0 | 1;
-        isStreaming: 0 | 1;
+        streamId: string;
+        enabled: boolean;
+        active: boolean;
+        isStreaming: boolean;
     } | {
         message: string;
         type: "CS_API_SUCCESS";
-        streamID: string;
+        streamId: string;
         apiCall: string;
     } | {
         code: string;
         message: string;
         type: "CS_API_ERROR";
-        streamID: string;
+        streamId: string;
         apiCall: string;
+    } | {
+        value: boolean;
+        type: "PortChanged";
+        port: number;
     };
 }, {
     type: "init";
@@ -160,22 +181,25 @@ export declare const csEventsSchema: z.ZodDiscriminatedUnion<"type", [z.ZodObjec
         state: string;
     } | {
         type: "StreamState";
-        enabled: 0 | 1;
-        active: 0 | 1;
-        streamID: number;
-        automationState: 0 | 1;
-        isStreaming: 0 | 1;
+        streamId: string;
+        enabled: boolean;
+        active: boolean;
+        isStreaming: boolean;
     } | {
         message: string;
         type: "CS_API_SUCCESS";
-        streamID: string;
+        streamId: string;
         apiCall: string;
     } | {
         code: string;
         message: string;
         type: "CS_API_ERROR";
-        streamID: string;
+        streamId: string;
         apiCall: string;
+    } | {
+        value: boolean;
+        type: "PortChanged";
+        port: number;
     };
 }>, z.ZodObject<{
     type: z.ZodLiteral<"authorization">;
@@ -188,58 +212,67 @@ export declare const csEventsSchema: z.ZodDiscriminatedUnion<"type", [z.ZodObjec
     state: string;
 }>, z.ZodObject<{
     type: z.ZodLiteral<"StreamState">;
-    streamID: z.ZodNumber;
-    enabled: z.ZodUnion<[z.ZodLiteral<0>, z.ZodLiteral<1>]>;
-    active: z.ZodUnion<[z.ZodLiteral<0>, z.ZodLiteral<1>]>;
-    automationState: z.ZodUnion<[z.ZodLiteral<0>, z.ZodLiteral<1>]>;
-    isStreaming: z.ZodUnion<[z.ZodLiteral<0>, z.ZodLiteral<1>]>;
+    streamId: z.ZodString;
+    isStreaming: z.ZodBoolean;
+    active: z.ZodBoolean;
+    enabled: z.ZodBoolean;
 }, "strip", z.ZodTypeAny, {
     type: "StreamState";
-    enabled: 0 | 1;
-    active: 0 | 1;
-    streamID: number;
-    automationState: 0 | 1;
-    isStreaming: 0 | 1;
+    streamId: string;
+    enabled: boolean;
+    active: boolean;
+    isStreaming: boolean;
 }, {
     type: "StreamState";
-    enabled: 0 | 1;
-    active: 0 | 1;
-    streamID: number;
-    automationState: 0 | 1;
-    isStreaming: 0 | 1;
+    streamId: string;
+    enabled: boolean;
+    active: boolean;
+    isStreaming: boolean;
 }>, z.ZodObject<{
     type: z.ZodLiteral<"CS_API_SUCCESS">;
     apiCall: z.ZodString;
     message: z.ZodString;
-    streamID: z.ZodString;
+    streamId: z.ZodString;
 }, "strip", z.ZodTypeAny, {
     message: string;
     type: "CS_API_SUCCESS";
-    streamID: string;
+    streamId: string;
     apiCall: string;
 }, {
     message: string;
     type: "CS_API_SUCCESS";
-    streamID: string;
+    streamId: string;
     apiCall: string;
 }>, z.ZodObject<{
     type: z.ZodLiteral<"CS_API_ERROR">;
     apiCall: z.ZodString;
     message: z.ZodString;
-    streamID: z.ZodString;
+    streamId: z.ZodString;
     code: z.ZodString;
 }, "strip", z.ZodTypeAny, {
     code: string;
     message: string;
     type: "CS_API_ERROR";
-    streamID: string;
+    streamId: string;
     apiCall: string;
 }, {
     code: string;
     message: string;
     type: "CS_API_ERROR";
-    streamID: string;
+    streamId: string;
     apiCall: string;
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"PortChanged">;
+    port: z.ZodNumber;
+    value: z.ZodBoolean;
+}, "strip", z.ZodTypeAny, {
+    value: boolean;
+    type: "PortChanged";
+    port: number;
+}, {
+    value: boolean;
+    type: "PortChanged";
+    port: number;
 }>]>;
 export type TCamStreamerEvent = z.infer<typeof csEventsDataSchema>;
 export type TCamStreamerEventType = TCamStreamerEvent['type'];

package/cjs/types/ws/CamStreamerEvents.js

@@ -6,25 +6,29 @@ const csEventsDataSchema = 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('StreamState'),
-        streamID: zod_1.z.number(),
-        enabled: zod_1.z.union([zod_1.z.literal(0), zod_1.z.literal(1)]),
-        active: zod_1.z.union([zod_1.z.literal(0), zod_1.z.literal(1)]),
-        automationState: zod_1.z.union([zod_1.z.literal(0), zod_1.z.literal(1)]),
-        isStreaming: zod_1.z.union([zod_1.z.literal(0), zod_1.z.literal(1)]),
+        streamId: zod_1.z.string(),
+        isStreaming: zod_1.z.boolean(),
+        active: zod_1.z.boolean(),
+        enabled: zod_1.z.boolean(),
     }),
     zod_1.z.object({
         type: zod_1.z.literal('CS_API_SUCCESS'),
         apiCall: zod_1.z.string(),
         message: zod_1.z.string(),
-        streamID: zod_1.z.string(),
+        streamId: zod_1.z.string(),
     }),
     zod_1.z.object({
         type: zod_1.z.literal('CS_API_ERROR'),
         apiCall: zod_1.z.string(),
         message: zod_1.z.string(),
-        streamID: zod_1.z.string(),
+        streamId: zod_1.z.string(),
         code: zod_1.z.string(),
     }),
+    zod_1.z.object({
+        type: zod_1.z.literal('PortChanged'),
+        port: zod_1.z.number(),
+        value: zod_1.z.boolean(),
+    }),
 ]);
 exports.csEventsSchema = zod_1.z.discriminatedUnion('type', [
     zod_1.z.object({ type: zod_1.z.literal('init'), data: csEventsDataSchema }),

package/cjs/types/ws/CamSwitcherEvents.d.ts

@@ -23,12 +23,12 @@ declare const cswEventsDataSchema: z.ZodDiscriminatedUnion<"type", [z.ZodObject<
     state: z.ZodBoolean;
 }, "strip", z.ZodTypeAny, {
     type: "StreamAvailable";
-    stream_name: string;
     state: boolean;
+    stream_name: string;
 }, {
     type: "StreamAvailable";
-    stream_name: string;
     state: boolean;
+    stream_name: string;
 }>, z.ZodObject<{
     type: z.ZodLiteral<"StreamSwitchAudio">;
     stream_name: z.ZodOptional<z.ZodString>;
@@ -176,12 +176,12 @@ export declare const cswEventsSchema: z.ZodDiscriminatedUnion<"type", [z.ZodObje
         state: z.ZodBoolean;
     }, "strip", z.ZodTypeAny, {
         type: "StreamAvailable";
-        stream_name: string;
         state: boolean;
+        stream_name: string;
     }, {
         type: "StreamAvailable";
-        stream_name: string;
         state: boolean;
+        stream_name: string;
     }>, z.ZodObject<{
         type: z.ZodLiteral<"StreamSwitchAudio">;
         stream_name: z.ZodOptional<z.ZodString>;
@@ -313,8 +313,8 @@ export declare const cswEventsSchema: z.ZodDiscriminatedUnion<"type", [z.ZodObje
         playlist_name: string;
     } | {
         type: "StreamAvailable";
-        stream_name: string;
         state: boolean;
+        stream_name: string;
     } | {
         type: "StreamSwitchAudio";
         master_audio: boolean;
@@ -366,8 +366,8 @@ export declare const cswEventsSchema: z.ZodDiscriminatedUnion<"type", [z.ZodObje
         playlist_name: string;
     } | {
         type: "StreamAvailable";
-        stream_name: string;
         state: boolean;
+        stream_name: string;
     } | {
         type: "StreamSwitchAudio";
         master_audio: boolean;
@@ -433,12 +433,12 @@ export declare const cswEventsSchema: z.ZodDiscriminatedUnion<"type", [z.ZodObje
     state: z.ZodBoolean;
 }, "strip", z.ZodTypeAny, {
     type: "StreamAvailable";
-    stream_name: string;
     state: boolean;
+    stream_name: string;
 }, {
     type: "StreamAvailable";
-    stream_name: string;
     state: boolean;
+    stream_name: string;
 }>, z.ZodObject<{
     type: z.ZodLiteral<"StreamSwitchAudio">;
     stream_name: z.ZodOptional<z.ZodString>;

package/cjs/types/ws/PlaneTrackerEvents.d.ts

@@ -419,11 +419,11 @@ export declare const planeTrackerUserActionData: z.ZodDiscriminatedUnion<"cgi",
         userPriority: string;
     }>;
     postJsonBody: z.ZodObject<{
-        mode: z.ZodUnion<[z.ZodLiteral<"MANUAL">, z.ZodLiteral<"AUTOMATIC">]>;
+        mode: z.ZodDefault<z.ZodUnion<[z.ZodLiteral<"MANUAL">, z.ZodLiteral<"AUTOMATIC">]>>;
     }, "strip", z.ZodTypeAny, {
         mode: "MANUAL" | "AUTOMATIC";
     }, {
-        mode: "MANUAL" | "AUTOMATIC";
+        mode?: "MANUAL" | "AUTOMATIC" | undefined;
     }>;
 }, "strip", z.ZodTypeAny, {
     params: {
@@ -445,7 +445,7 @@ export declare const planeTrackerUserActionData: z.ZodDiscriminatedUnion<"cgi",
     ip: string;
     cgi: PlaneTrackerUserActions.SET_TRACKING_MODE;
     postJsonBody: {
-        mode: "MANUAL" | "AUTOMATIC";
+        mode?: "MANUAL" | "AUTOMATIC" | undefined;
     };
 }>, z.ZodObject<{
     cgi: z.ZodLiteral<PlaneTrackerUserActions.SET_ZONES>;

package/esm/CamOverlayAPI.js

@@ -1,20 +1,15 @@
-import { paramToUrl } from './internal/utils';
-import { ParsingBlobError, ErrorWithResponse, ServiceNotFoundError, StorageDataFetchError } from './errors/errors';
+import { ErrorWithResponse, ServiceNotFoundError, StorageDataFetchError } from './errors/errors';
 import { networkCameraListSchema } from './types/common';
 import { z } from 'zod';
-import { ProxyClient } from './internal/ProxyClient';
-import { fileListSchema, ImageType, storageDataListSchema, serviceListSchema, servicesSchema, wsResponseSchema, } from './types/CamOverlayAPI';
+import { ImageType, serviceListSchema, servicesSchema, wsResponseSchema, getStorageDataListSchema, getFileListSchema, } from './types/CamOverlayAPI';
+import { BasicAPI } from './internal/BasicAPI';
 const BASE_PATH = '/local/camoverlay/api';
-export class CamOverlayAPI {
-    client;
-    constructor(client) {
-        this.client = client;
-    }
+export class CamOverlayAPI extends BasicAPI {
     static getBasePath = () => BASE_PATH;
     static getProxyPath = () => `${BASE_PATH}/proxy.cgi`;
     static getFilePreviewPath = (path) => `${BASE_PATH}/image.cgi?path=${encodeURIComponent(path)}`;
-    getClient(proxyParams) {
-        return proxyParams ? new ProxyClient(this.client, proxyParams) : this.client;
+    async checkAPIAvailable(options) {
+        await this._getJson(`${BASE_PATH}/api_check.cgi`, undefined, options);
     }
     async checkCameraTime(options) {
         const res = await this._getJson(`${BASE_PATH}/camera_time.cgi`, undefined, options);
@@ -33,7 +28,7 @@ export class CamOverlayAPI {
     }
     async listFiles(fileType, options) {
         const res = await this._getJson(`${BASE_PATH}/upload_${fileType}.cgi`, { action: 'list' }, options);
-        return fileListSchema.parse(res.list);
+        return getFileListSchema(fileType).parse(res.list);
     }
     async uploadFile(fileType, formData, storage, options) {
         await this._post(`${BASE_PATH}/upload_${fileType}.cgi`, formData, {
@@ -45,14 +40,14 @@ export class CamOverlayAPI {
         await this._postUrlEncoded(`${BASE_PATH}/upload_${fileType}.cgi`, {
             action: 'remove',
             ...fileParams,
-        }, options, undefined);
+        }, options);
     }
     async getFileStorage(fileType, options) {
         const res = await this._getJson(`${BASE_PATH}/upload_${fileType}.cgi`, { action: 'get_storage' }, options);
         if (res.code !== 200) {
             throw new StorageDataFetchError(res);
         }
-        return storageDataListSchema.parse(res.list);
+        return getStorageDataListSchema(fileType).parse(res.list);
     }
     async getFilePreviewFromCamera(path, options) {
         return await this._getBlob(CamOverlayAPI.getFilePreviewPath(path), undefined, options);
@@ -96,15 +91,15 @@ export class CamOverlayAPI {
         return services;
     }
     async updateSingleService(service, options) {
-        await this._postJsonEncoded(`${BASE_PATH}/services.cgi`, JSON.stringify(service), {
+        await this._postJsonEncoded(`${BASE_PATH}/services.cgi`, service, {
             action: 'set',
             service_id: service.id,
-        }, options, undefined);
+        }, options);
     }
     async updateServices(services, options) {
-        await this._postJsonEncoded(`${BASE_PATH}/services.cgi`, JSON.stringify({ services: services }), {
+        await this._postJsonEncoded(`${BASE_PATH}/services.cgi`, { services: services }, {
             action: 'set',
-        }, options, undefined);
+        }, options);
     }
     updateCGText(serviceId, fields, options) {
         const params = {};
@@ -143,6 +138,9 @@ export class CamOverlayAPI {
         };
         return this.promiseCGUpdate(serviceId, 'update_image', params, contentType, imageData, options);
     }
+    downloadReport(options) {
+        return this._getText(`${BASE_PATH}/report.cgi`, undefined, options);
+    }
     async promiseCGUpdate(serviceId, action, params = {}, contentType, data, options) {
         const path = `${BASE_PATH}/customGraphics.cgi`;
         let headers = {};
@@ -165,51 +163,4 @@ export class CamOverlayAPI {
             throw new ErrorWithResponse(res);
         }
     }
-    async _getJson(path, parameters, options) {
-        const agent = this.getClient(options?.proxyParams);
-        const res = await agent.get({ path, parameters, timeout: options?.timeout });
-        if (res.ok) {
-            return await res.json();
-        }
-        else {
-            throw new ErrorWithResponse(res);
-        }
-    }
-    async _post(path, data, parameters, options, headers) {
-        const agent = this.getClient(options?.proxyParams);
-        const res = await agent.post({ path, data, parameters, headers, timeout: options?.timeout });
-        if (res.ok) {
-            return await res.json();
-        }
-        else {
-            throw new ErrorWithResponse(res);
-        }
-    }
-    async _getBlob(path, parameters, options) {
-        const agent = this.getClient(options?.proxyParams);
-        const res = await agent.get({ path, parameters, timeout: options?.timeout });
-        if (res.ok) {
-            return await this.parseBlobResponse(res);
-        }
-        else {
-            throw new ErrorWithResponse(res);
-        }
-    }
-    async parseBlobResponse(response) {
-        try {
-            return (await response.blob());
-        }
-        catch (err) {
-            throw new ParsingBlobError(err);
-        }
-    }
-    async _postUrlEncoded(path, parameters, options, headers) {
-        const data = paramToUrl(parameters);
-        const baseHeaders = { 'Content-Type': 'application/x-www-form-urlencoded' };
-        return this._post(path, data, undefined, options, { ...baseHeaders, ...headers });
-    }
-    async _postJsonEncoded(path, data, parameters, options, headers) {
-        const baseHeaders = { 'Accept': 'application/json', 'Content-Type': 'application/json' };
-        return this._post(path, data, parameters, options, { ...baseHeaders, ...headers });
-    }
 }