camstreamerlib 4.0.0-beta.105 → 4.0.0-beta.107

package/cjs/types/CamStreamerAPI/rtmpSchema.d.ts

@@ -1,4 +1,306 @@
 import z from 'zod';
+export declare const commonRtmpSchema: z.ZodObject<{
+    id: z.ZodNumber;
+    enabled: z.ZodBoolean;
+    active: z.ZodBoolean;
+    title: z.ZodString;
+    trigger: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+        type: z.ZodLiteral<"manual">;
+        ioPort: z.ZodNullable<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        type: "manual";
+        ioPort: string | null;
+    }, {
+        type: "manual";
+        ioPort: string | null;
+    }>, z.ZodObject<{
+        type: z.ZodLiteral<"onetime">;
+        startTime: z.ZodNumber;
+        stopTime: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        type: "onetime";
+        startTime: number;
+        stopTime: number;
+    }, {
+        type: "onetime";
+        startTime: number;
+        stopTime: number;
+    }>, z.ZodObject<{
+        type: z.ZodLiteral<"recurrent">;
+        schedule: z.ZodArray<z.ZodObject<{
+            start: z.ZodObject<{
+                day: z.ZodNumber;
+                timeS: z.ZodNumber;
+            }, "strip", z.ZodTypeAny, {
+                day: number;
+                timeS: number;
+            }, {
+                day: number;
+                timeS: number;
+            }>;
+            stop: z.ZodObject<{
+                day: z.ZodNumber;
+                timeS: z.ZodNumber;
+            }, "strip", z.ZodTypeAny, {
+                day: number;
+                timeS: number;
+            }, {
+                day: number;
+                timeS: number;
+            }>;
+            isActive: z.ZodBoolean;
+        }, "strip", z.ZodTypeAny, {
+            start: {
+                day: number;
+                timeS: number;
+            };
+            stop: {
+                day: number;
+                timeS: number;
+            };
+            isActive: boolean;
+        }, {
+            start: {
+                day: number;
+                timeS: number;
+            };
+            stop: {
+                day: number;
+                timeS: number;
+            };
+            isActive: boolean;
+        }>, "many">;
+    }, "strip", z.ZodTypeAny, {
+        type: "recurrent";
+        schedule: {
+            start: {
+                day: number;
+                timeS: number;
+            };
+            stop: {
+                day: number;
+                timeS: number;
+            };
+            isActive: boolean;
+        }[];
+    }, {
+        type: "recurrent";
+        schedule: {
+            start: {
+                day: number;
+                timeS: number;
+            };
+            stop: {
+                day: number;
+                timeS: number;
+            };
+            isActive: boolean;
+        }[];
+    }>]>;
+    video: z.ZodObject<{
+        inputType: z.ZodUnion<[z.ZodLiteral<"CSw">, z.ZodLiteral<"CRS">, z.ZodLiteral<"RTSP_URL">]>;
+        sourceUrl: z.ZodOptional<z.ZodString>;
+        internalVapixParameters: z.ZodString;
+        userVapixParameters: z.ZodString;
+        streamingProtocol: z.ZodUnion<[z.ZodLiteral<"RTMP">, z.ZodLiteral<"RTMPS">, z.ZodLiteral<"HLS_PUSH">]>;
+        streamDelay: z.ZodOptional<z.ZodObject<{
+            value: z.ZodNumber;
+            unit: z.ZodUnion<[z.ZodLiteral<"seconds">, z.ZodLiteral<"minutes">, z.ZodLiteral<"hours">]>;
+        }, "strip", z.ZodTypeAny, {
+            value: number;
+            unit: "seconds" | "minutes" | "hours";
+        }, {
+            value: number;
+            unit: "seconds" | "minutes" | "hours";
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        inputType: "RTSP_URL" | "CSw" | "CRS";
+        internalVapixParameters: string;
+        userVapixParameters: string;
+        streamingProtocol: "RTMP" | "RTMPS" | "HLS_PUSH";
+        sourceUrl?: string | undefined;
+        streamDelay?: {
+            value: number;
+            unit: "seconds" | "minutes" | "hours";
+        } | undefined;
+    }, {
+        inputType: "RTSP_URL" | "CSw" | "CRS";
+        internalVapixParameters: string;
+        userVapixParameters: string;
+        streamingProtocol: "RTMP" | "RTMPS" | "HLS_PUSH";
+        sourceUrl?: string | undefined;
+        streamDelay?: {
+            value: number;
+            unit: "seconds" | "minutes" | "hours";
+        } | undefined;
+    }>;
+    audio: z.ZodDiscriminatedUnion<"source", [z.ZodObject<{
+        source: z.ZodLiteral<"none">;
+    }, "strip", z.ZodTypeAny, {
+        source: "none";
+    }, {
+        source: "none";
+    }>, z.ZodObject<{
+        source: z.ZodLiteral<"microphone">;
+        audioChannelNbr: z.ZodUnion<[z.ZodLiteral<1>, z.ZodLiteral<2>]>;
+    }, "strip", z.ZodTypeAny, {
+        source: "microphone";
+        audioChannelNbr: 1 | 2;
+    }, {
+        source: "microphone";
+        audioChannelNbr: 1 | 2;
+    }>, z.ZodObject<{
+        source: z.ZodLiteral<"file">;
+        fileName: z.ZodString;
+        filePath: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        source: "file";
+        fileName: string;
+        filePath: string;
+    }, {
+        source: "file";
+        fileName: string;
+        filePath: string;
+    }>, z.ZodObject<{
+        source: z.ZodLiteral<"url">;
+        fileName: z.ZodString;
+        fileUrl: z.ZodString;
+        avSyncMsec: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        source: "url";
+        fileName: string;
+        fileUrl: string;
+        avSyncMsec: number;
+    }, {
+        source: "url";
+        fileName: string;
+        fileUrl: string;
+        avSyncMsec: number;
+    }>]>;
+} & {
+    outputUrl: z.ZodString;
+    streamKey: z.ZodString;
+    streamIdentifier: z.ZodOptional<z.ZodString>;
+    saveToSdCard: z.ZodBoolean;
+    statusCameraLed: z.ZodBoolean;
+    statusCameraOutput: z.ZodNullable<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    audio: {
+        source: "none";
+    } | {
+        source: "microphone";
+        audioChannelNbr: 1 | 2;
+    } | {
+        source: "file";
+        fileName: string;
+        filePath: string;
+    } | {
+        source: "url";
+        fileName: string;
+        fileUrl: string;
+        avSyncMsec: number;
+    };
+    video: {
+        inputType: "RTSP_URL" | "CSw" | "CRS";
+        internalVapixParameters: string;
+        userVapixParameters: string;
+        streamingProtocol: "RTMP" | "RTMPS" | "HLS_PUSH";
+        sourceUrl?: string | undefined;
+        streamDelay?: {
+            value: number;
+            unit: "seconds" | "minutes" | "hours";
+        } | undefined;
+    };
+    enabled: boolean;
+    id: number;
+    active: boolean;
+    title: string;
+    trigger: {
+        type: "manual";
+        ioPort: string | null;
+    } | {
+        type: "onetime";
+        startTime: number;
+        stopTime: number;
+    } | {
+        type: "recurrent";
+        schedule: {
+            start: {
+                day: number;
+                timeS: number;
+            };
+            stop: {
+                day: number;
+                timeS: number;
+            };
+            isActive: boolean;
+        }[];
+    };
+    statusCameraLed: boolean;
+    statusCameraOutput: string | null;
+    saveToSdCard: boolean;
+    outputUrl: string;
+    streamKey: string;
+    streamIdentifier?: string | undefined;
+}, {
+    audio: {
+        source: "none";
+    } | {
+        source: "microphone";
+        audioChannelNbr: 1 | 2;
+    } | {
+        source: "file";
+        fileName: string;
+        filePath: string;
+    } | {
+        source: "url";
+        fileName: string;
+        fileUrl: string;
+        avSyncMsec: number;
+    };
+    video: {
+        inputType: "RTSP_URL" | "CSw" | "CRS";
+        internalVapixParameters: string;
+        userVapixParameters: string;
+        streamingProtocol: "RTMP" | "RTMPS" | "HLS_PUSH";
+        sourceUrl?: string | undefined;
+        streamDelay?: {
+            value: number;
+            unit: "seconds" | "minutes" | "hours";
+        } | undefined;
+    };
+    enabled: boolean;
+    id: number;
+    active: boolean;
+    title: string;
+    trigger: {
+        type: "manual";
+        ioPort: string | null;
+    } | {
+        type: "onetime";
+        startTime: number;
+        stopTime: number;
+    } | {
+        type: "recurrent";
+        schedule: {
+            start: {
+                day: number;
+                timeS: number;
+            };
+            stop: {
+                day: number;
+                timeS: number;
+            };
+            isActive: boolean;
+        }[];
+    };
+    statusCameraLed: boolean;
+    statusCameraOutput: string | null;
+    saveToSdCard: boolean;
+    outputUrl: string;
+    streamKey: string;
+    streamIdentifier?: string | undefined;
+}>;
 export declare const rtmpSchema: z.ZodObject<{
     id: z.ZodNumber;
     enabled: z.ZodBoolean;
@@ -178,10 +480,14 @@ export declare const rtmpSchema: z.ZodObject<{
         avSyncMsec: number;
     }>]>;
 } & {
-    type: z.ZodLiteral<"rtmp">;
     outputUrl: z.ZodString;
     streamKey: z.ZodString;
     streamIdentifier: z.ZodOptional<z.ZodString>;
+    saveToSdCard: z.ZodBoolean;
+    statusCameraLed: z.ZodBoolean;
+    statusCameraOutput: z.ZodNullable<z.ZodString>;
+} & {
+    type: z.ZodLiteral<"rtmp">;
 }, "strip", z.ZodTypeAny, {
     type: "rtmp";
     audio: {
@@ -235,6 +541,9 @@ export declare const rtmpSchema: z.ZodObject<{
             isActive: boolean;
         }[];
     };
+    statusCameraLed: boolean;
+    statusCameraOutput: string | null;
+    saveToSdCard: boolean;
     outputUrl: string;
     streamKey: string;
     streamIdentifier?: string | undefined;
@@ -291,6 +600,9 @@ export declare const rtmpSchema: z.ZodObject<{
             isActive: boolean;
         }[];
     };
+    statusCameraLed: boolean;
+    statusCameraOutput: string | null;
+    saveToSdCard: boolean;
     outputUrl: string;
     streamKey: string;
     streamIdentifier?: string | undefined;

package/cjs/types/CamStreamerAPI/rtmpSchema.js

@@ -3,12 +3,17 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.rtmpSchema = void 0;
+exports.rtmpSchema = exports.commonRtmpSchema = void 0;
 const zod_1 = __importDefault(require("zod"));
 const streamCommonTypes_1 = require("./streamCommonTypes");
-exports.rtmpSchema = streamCommonTypes_1.streamCommonSchema.extend({
-    type: zod_1.default.literal('rtmp'),
+exports.commonRtmpSchema = streamCommonTypes_1.streamCommonSchema.extend({
     outputUrl: zod_1.default.string(),
     streamKey: zod_1.default.string(),
     streamIdentifier: zod_1.default.string().optional(),
+    saveToSdCard: zod_1.default.boolean(),
+    statusCameraLed: zod_1.default.boolean(),
+    statusCameraOutput: zod_1.default.string().nullable(),
+});
+exports.rtmpSchema = exports.commonRtmpSchema.extend({
+    type: zod_1.default.literal('rtmp'),
 });

package/cjs/types/CamStreamerAPI/youtubeSchema.d.ts

@@ -189,7 +189,7 @@ export declare const youtubeSchema: z.ZodObject<{
     dvr: z.ZodBoolean;
     saveToSdCard: z.ZodBoolean;
     statusCameraLed: z.ZodBoolean;
-    statusCameraOutput: z.ZodString;
+    statusCameraOutput: z.ZodNullable<z.ZodString>;
     hasWatchdogs: z.ZodBoolean;
     countdown: z.ZodBoolean;
     enableManualControl: z.ZodBoolean;
@@ -247,7 +247,7 @@ export declare const youtubeSchema: z.ZodObject<{
         }[];
     };
     statusCameraLed: boolean;
-    statusCameraOutput: string;
+    statusCameraOutput: string | null;
     saveToSdCard: boolean;
     tags: string[];
     streamPrivacy: "public" | "unlisted" | "private";
@@ -314,7 +314,7 @@ export declare const youtubeSchema: z.ZodObject<{
         }[];
     };
     statusCameraLed: boolean;
-    statusCameraOutput: string;
+    statusCameraOutput: string | null;
     saveToSdCard: boolean;
     tags: string[];
     streamPrivacy: "public" | "unlisted" | "private";

package/cjs/types/CamStreamerAPI/youtubeSchema.js

@@ -18,7 +18,7 @@ exports.youtubeSchema = streamCommonTypes_1.streamCommonSchema.extend({
     dvr: zod_1.default.boolean(),
     saveToSdCard: zod_1.default.boolean(),
     statusCameraLed: zod_1.default.boolean(),
-    statusCameraOutput: zod_1.default.string(),
+    statusCameraOutput: zod_1.default.string().nullable(),
     hasWatchdogs: zod_1.default.boolean(),
     countdown: zod_1.default.boolean(),
     enableManualControl: zod_1.default.boolean(),

package/esm/CamOverlayAPI.js

@@ -3,7 +3,7 @@ import { ParsingBlobError, ErrorWithResponse, ServiceNotFoundError, StorageDataF
 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';
 const BASE_PATH = '/local/camoverlay/api';
 export class CamOverlayAPI {
     client;
@@ -33,7 +33,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, {
@@ -52,7 +52,7 @@ export class CamOverlayAPI {
         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);

package/esm/types/CamOverlayAPI/CamOverlayAPI.js

@@ -49,28 +49,62 @@ export var ImageType;
     ImageType[ImageType["PNG"] = 0] = "PNG";
     ImageType[ImageType["JPEG"] = 1] = "JPEG";
 })(ImageType || (ImageType = {}));
-export const fileStorageTypeSchema = z.union([
+export const imageFileStorageTypeSchema = z.union([
     z.literal('flash'),
     z.literal('SD0'),
     z.literal('ftp'),
     z.literal('samba'),
     z.literal('url'),
 ]);
-export const storageDataListSchema = z.array(z.object({
-    type: fileStorageTypeSchema,
+export const fontFileStorageTypeSchema = z.union([z.literal('flash'), z.literal('SD0')]);
+export const imageFilestorageDataListSchema = z.array(z.object({
+    type: imageFileStorageTypeSchema,
     state: z.string(),
 }));
-export const storageResponseSchema = z.object({
+export const fontStorageDataListSchema = z.array(z.object({
+    type: fontFileStorageTypeSchema,
+    state: z.string(),
+}));
+export const getStorageDataListSchema = (fileType) => {
+    return fileType === 'image' ? imageFilestorageDataListSchema : fontStorageDataListSchema;
+};
+export const imageStorageResponseSchema = z.object({
     code: z.number(),
-    list: storageDataListSchema,
+    list: imageFilestorageDataListSchema,
 });
-export const fileSchema = z.object({
+export const fontStorageResponseSchema = z.object({
+    code: z.number(),
+    list: fontStorageDataListSchema,
+});
+export const getStorageResponseSchema = (fileType) => {
+    return fileType === 'image' ? imageStorageResponseSchema : fontStorageResponseSchema;
+};
+export const imageFileSchema = z.object({
     name: z.string(),
     path: z.string().url(),
-    storage: fileStorageTypeSchema,
+    storage: imageFileStorageTypeSchema,
+});
+export const fontFileSchema = z.object({
+    name: z.string(),
+    path: z.string().url(),
+    storage: fontFileStorageTypeSchema,
+});
+export const getFileSchema = (fileType) => {
+    return fileType === 'image' ? imageFileSchema : fontFileSchema;
+};
+export const imageFileListSchema = z.array(imageFileSchema);
+export const fontFileListSchema = z.array(fontFileSchema);
+export const getFileListSchema = (fileType) => {
+    return fileType === 'image' ? imageFileListSchema : fontFileListSchema;
+};
+export const imageFileDataSchema = z.object({
+    code: z.number(),
+    list: imageFileListSchema,
 });
-export const fileListSchema = z.array(fileSchema);
-export const fileDataSchema = z.object({
+export const fontFileDataSchema = z.object({
     code: z.number(),
-    list: fileListSchema,
+    list: fontFileListSchema,
 });
+export const getFileDataSchema = (fileType) => {
+    return fileType === 'image' ? imageFileDataSchema : fontFileDataSchema;
+};

package/esm/types/CamStreamerAPI/gameChangerSchema.js

@@ -1,5 +1,5 @@
 import z from 'zod';
-import { streamCommonSchema } from './streamCommonTypes';
-export const gameChangerSchema = streamCommonSchema.extend({
+import { commonRtmpSchema } from './rtmpSchema';
+export const gameChangerSchema = commonRtmpSchema.extend({
     type: z.literal('game_changer'),
 });

package/esm/types/CamStreamerAPI/index.js

@@ -3,6 +3,7 @@ export * from './streamCommonTypes';
 export * from './facebookSchema';
 export * from './mpegDvbSchema';
 export * from './rtmpSchema';
+export * from './gameChangerSchema';
 export * from './sdCardSchema';
 export * from './windySchema';
 export * from './youtubeSchema';

package/esm/types/CamStreamerAPI/mpegDvbSchema.js

@@ -16,6 +16,6 @@ export const mpegDvbSchema = streamCommonSchema.extend({
     providerName: z.string(),
     serviceName: z.string(),
     statusCameraLed: z.boolean(),
-    statusCameraOutput: z.string(),
+    statusCameraOutput: z.string().nullable(),
     saveToSdCard: z.boolean(),
 });

package/esm/types/CamStreamerAPI/rtmpSchema.js

@@ -1,8 +1,13 @@
 import z from 'zod';
 import { streamCommonSchema } from './streamCommonTypes';
-export const rtmpSchema = streamCommonSchema.extend({
-    type: z.literal('rtmp'),
+export const commonRtmpSchema = streamCommonSchema.extend({
     outputUrl: z.string(),
     streamKey: z.string(),
     streamIdentifier: z.string().optional(),
+    saveToSdCard: z.boolean(),
+    statusCameraLed: z.boolean(),
+    statusCameraOutput: z.string().nullable(),
+});
+export const rtmpSchema = commonRtmpSchema.extend({
+    type: z.literal('rtmp'),
 });

package/esm/types/CamStreamerAPI/youtubeSchema.js

@@ -12,7 +12,7 @@ export const youtubeSchema = streamCommonSchema.extend({
     dvr: z.boolean(),
     saveToSdCard: z.boolean(),
     statusCameraLed: z.boolean(),
-    statusCameraOutput: z.string(),
+    statusCameraOutput: z.string().nullable(),
     hasWatchdogs: z.boolean(),
     countdown: z.boolean(),
     enableManualControl: z.boolean(),

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "camstreamerlib",
-    "version": "4.0.0-beta.105",
+    "version": "4.0.0-beta.107",
     "description": "Helper library for CamStreamer ACAP applications.",
     "prettier": "@camstreamer/prettier-config",
     "engine": {

package/types/CamOverlayAPI.d.ts

@@ -1,7 +1,7 @@
 import { IClient, TBlobResponse, TResponse } from './internal/types';
 import { THttpRequestOptions, TProxyParams } from './types/common';
 import { ProxyClient } from './internal/ProxyClient';
-import { ImageType, TCoordinates, TField, TFile, TFileType, TFileStorageType, TService } from './types/CamOverlayAPI';
+import { ImageType, TCoordinates, TField, TFile, TFileType, TFileStorageType, TService, TFileList, TStorageDataList } from './types/CamOverlayAPI';
 export declare class CamOverlayAPI<Client extends IClient<TResponse, any>> {
     private client;
     constructor(client: Client);
@@ -16,17 +16,10 @@ export declare class CamOverlayAPI<Client extends IClient<TResponse, any>> {
     }[]>;
     wsAuthorization(options?: THttpRequestOptions): Promise<string>;
     getMjpegStreamImage(mjpegUrl: string, options?: THttpRequestOptions): Promise<TBlobResponse<Client>>;
-    listFiles(fileType: TFileType, options?: THttpRequestOptions): Promise<{
-        path: string;
-        name: string;
-        storage: "url" | "flash" | "SD0" | "ftp" | "samba";
-    }[]>;
-    uploadFile(fileType: TFileType, formData: Parameters<Client['post']>[0]['data'], storage: TFileStorageType, options?: THttpRequestOptions): Promise<void>;
-    removeFile(fileType: TFileType, fileParams: TFile, options?: THttpRequestOptions): Promise<void>;
-    getFileStorage(fileType: TFileType, options?: THttpRequestOptions): Promise<{
-        type: "url" | "flash" | "SD0" | "ftp" | "samba";
-        state: string;
-    }[]>;
+    listFiles<T extends TFileType>(fileType: T, options?: THttpRequestOptions): Promise<TFileList<T>>;
+    uploadFile<T extends TFileType>(fileType: T, formData: Parameters<Client['post']>[0]['data'], storage: TFileStorageType<T>, options?: THttpRequestOptions): Promise<void>;
+    removeFile<T extends TFileType>(fileType: T, fileParams: TFile<T>, options?: THttpRequestOptions): Promise<void>;
+    getFileStorage<T extends TFileType>(fileType: T, options?: THttpRequestOptions): Promise<TStorageDataList<T>>;
     getFilePreviewFromCamera(path: string, options?: THttpRequestOptions): Promise<TBlobResponse<Client>>;
     updateInfoticker(serviceId: number, text: string, options?: THttpRequestOptions): Promise<void>;
     setEnabled(serviceId: number, enabled: boolean, options?: THttpRequestOptions): Promise<void>;

package/types/CamStreamerAPI.d.ts

@@ -132,7 +132,7 @@ export declare class CamStreamerAPI<Client extends IClient<TResponse, any>> {
         providerName: string;
         serviceName: string;
         statusCameraLed: boolean;
-        statusCameraOutput: string;
+        statusCameraOutput: string | null;
         saveToSdCard: boolean;
     } | {
         type: "rtmp";
@@ -187,6 +187,9 @@ export declare class CamStreamerAPI<Client extends IClient<TResponse, any>> {
                 isActive: boolean;
             }[];
         };
+        statusCameraLed: boolean;
+        statusCameraOutput: string | null;
+        saveToSdCard: boolean;
         outputUrl: string;
         streamKey: string;
         streamIdentifier?: string | undefined;
@@ -350,7 +353,7 @@ export declare class CamStreamerAPI<Client extends IClient<TResponse, any>> {
             }[];
         };
         statusCameraLed: boolean;
-        statusCameraOutput: string;
+        statusCameraOutput: string | null;
         saveToSdCard: boolean;
         tags: string[];
         streamPrivacy: "public" | "unlisted" | "private";
@@ -1052,6 +1055,12 @@ export declare class CamStreamerAPI<Client extends IClient<TResponse, any>> {
                 isActive: boolean;
             }[];
         };
+        statusCameraLed: boolean;
+        statusCameraOutput: string | null;
+        saveToSdCard: boolean;
+        outputUrl: string;
+        streamKey: string;
+        streamIdentifier?: string | undefined;
     })[]>;
     setStreamList(streamList: TStreamList['streamList'], options?: THttpRequestOptions): Promise<void>;
     getStream(streamId: number, options?: THttpRequestOptions): Promise<{
@@ -1174,7 +1183,7 @@ export declare class CamStreamerAPI<Client extends IClient<TResponse, any>> {
         providerName: string;
         serviceName: string;
         statusCameraLed: boolean;
-        statusCameraOutput: string;
+        statusCameraOutput: string | null;
         saveToSdCard: boolean;
     } | {
         type: "rtmp";
@@ -1229,6 +1238,9 @@ export declare class CamStreamerAPI<Client extends IClient<TResponse, any>> {
                 isActive: boolean;
             }[];
         };
+        statusCameraLed: boolean;
+        statusCameraOutput: string | null;
+        saveToSdCard: boolean;
         outputUrl: string;
         streamKey: string;
         streamIdentifier?: string | undefined;
@@ -1392,7 +1404,7 @@ export declare class CamStreamerAPI<Client extends IClient<TResponse, any>> {
             }[];
         };
         statusCameraLed: boolean;
-        statusCameraOutput: string;
+        statusCameraOutput: string | null;
         saveToSdCard: boolean;
         tags: string[];
         streamPrivacy: "public" | "unlisted" | "private";
@@ -2094,6 +2106,12 @@ export declare class CamStreamerAPI<Client extends IClient<TResponse, any>> {
                 isActive: boolean;
             }[];
         };
+        statusCameraLed: boolean;
+        statusCameraOutput: string | null;
+        saveToSdCard: boolean;
+        outputUrl: string;
+        streamKey: string;
+        streamIdentifier?: string | undefined;
     }>;
     setStream(streamId: number, streamData: TStream, options?: THttpRequestOptions): Promise<void>;
     isStreaming(streamId: number, options?: THttpRequestOptions): Promise<boolean>;