camstreamerlib 4.0.0-beta.75 → 4.0.0-beta.77

package/cjs/types/CamStreamerAPI/index.js

@@ -0,0 +1,25 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./CamStreamerAPI"), exports);
+__exportStar(require("./streamCommonTypes"), exports);
+__exportStar(require("./facebookSchema"), exports);
+__exportStar(require("./hlsSchema"), exports);
+__exportStar(require("./mpegDvbSchema"), exports);
+__exportStar(require("./rtmpSchema"), exports);
+__exportStar(require("./sdCardSchema"), exports);
+__exportStar(require("./windySchema"), exports);
+__exportStar(require("./youtubeSchema"), exports);

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

@@ -0,0 +1,72 @@
+import z from 'zod';
+export declare const mpegDvbSchema: z.ZodObject<{
+    enabled: z.ZodBoolean;
+    active: z.ZodBoolean;
+    title: z.ZodString;
+    order: z.ZodNumber;
+} & {
+    type: z.ZodLiteral<"mpeg_dvb">;
+    ipAddress: z.ZodString;
+    port: z.ZodNumber;
+    standard: z.ZodEnum<["DVB", "ATSC"]>;
+    nullPacketsPaddingEnabled: z.ZodBoolean;
+    nullPacketsPaddingKbps: z.ZodNumber;
+    videoPid: z.ZodNumber;
+    audioPid: z.ZodNumber;
+    mpegtsStreamId: z.ZodNumber;
+    pmtPid: z.ZodNumber;
+    pcrPid: z.ZodNumber;
+    pcrPeriodMs: z.ZodNumber;
+    providerName: z.ZodString;
+    serviceName: z.ZodString;
+    triggerType: z.ZodEnum<["manual", "onetime", "recurrent", "io", "nonstop"]>;
+    statusCameraLed: z.ZodBoolean;
+    statusCameraOutput: z.ZodNumber;
+    saveToSdCard: z.ZodBoolean;
+}, "strip", z.ZodTypeAny, {
+    type: "mpeg_dvb";
+    port: number;
+    enabled: boolean;
+    active: boolean;
+    title: string;
+    order: number;
+    ipAddress: string;
+    standard: "DVB" | "ATSC";
+    nullPacketsPaddingEnabled: boolean;
+    nullPacketsPaddingKbps: number;
+    videoPid: number;
+    audioPid: number;
+    mpegtsStreamId: number;
+    pmtPid: number;
+    pcrPid: number;
+    pcrPeriodMs: number;
+    providerName: string;
+    serviceName: string;
+    triggerType: "manual" | "onetime" | "recurrent" | "io" | "nonstop";
+    statusCameraLed: boolean;
+    statusCameraOutput: number;
+    saveToSdCard: boolean;
+}, {
+    type: "mpeg_dvb";
+    port: number;
+    enabled: boolean;
+    active: boolean;
+    title: string;
+    order: number;
+    ipAddress: string;
+    standard: "DVB" | "ATSC";
+    nullPacketsPaddingEnabled: boolean;
+    nullPacketsPaddingKbps: number;
+    videoPid: number;
+    audioPid: number;
+    mpegtsStreamId: number;
+    pmtPid: number;
+    pcrPid: number;
+    pcrPeriodMs: number;
+    providerName: string;
+    serviceName: string;
+    triggerType: "manual" | "onetime" | "recurrent" | "io" | "nonstop";
+    statusCameraLed: boolean;
+    statusCameraOutput: number;
+    saveToSdCard: boolean;
+}>;

package/cjs/types/CamStreamerAPI/mpegDvbSchema.js

@@ -0,0 +1,28 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mpegDvbSchema = void 0;
+const zod_1 = __importDefault(require("zod"));
+const streamCommonTypes_1 = require("./streamCommonTypes");
+exports.mpegDvbSchema = streamCommonTypes_1.streamCommonSchema.extend({
+    type: zod_1.default.literal('mpeg_dvb'),
+    ipAddress: zod_1.default.string(),
+    port: zod_1.default.number(),
+    standard: zod_1.default.enum(['DVB', 'ATSC']),
+    nullPacketsPaddingEnabled: zod_1.default.boolean(),
+    nullPacketsPaddingKbps: zod_1.default.number(),
+    videoPid: zod_1.default.number(),
+    audioPid: zod_1.default.number(),
+    mpegtsStreamId: zod_1.default.number(),
+    pmtPid: zod_1.default.number(),
+    pcrPid: zod_1.default.number(),
+    pcrPeriodMs: zod_1.default.number(),
+    providerName: zod_1.default.string(),
+    serviceName: zod_1.default.string(),
+    triggerType: zod_1.default.enum(['manual', 'onetime', 'recurrent', 'io', 'nonstop']),
+    statusCameraLed: zod_1.default.boolean(),
+    statusCameraOutput: zod_1.default.number(),
+    saveToSdCard: zod_1.default.boolean(),
+});

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

@@ -0,0 +1,137 @@
+import { z } from 'zod';
+export declare const oldStringStreamSchema: z.ZodObject<{
+    enabled: z.ZodString;
+    active: z.ZodString;
+    audioSource: z.ZodString;
+    avSyncMsec: z.ZodString;
+    internalVapixParameters: z.ZodString;
+    userVapixParameters: z.ZodString;
+    outputParameters: z.ZodString;
+    outputType: z.ZodString;
+    mediaServerUrl: z.ZodString;
+    inputType: z.ZodString;
+    inputUrl: z.ZodString;
+    forceStereo: z.ZodString;
+    streamDelay: z.ZodString;
+    statusLed: z.ZodString;
+    statusPort: z.ZodString;
+    callApi: z.ZodString;
+    trigger: z.ZodString;
+    schedule: z.ZodString;
+    prepareAhead: z.ZodString;
+    startTime: z.ZodString;
+    stopTime: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    enabled: string;
+    active: string;
+    audioSource: string;
+    avSyncMsec: string;
+    internalVapixParameters: string;
+    userVapixParameters: string;
+    outputParameters: string;
+    outputType: string;
+    mediaServerUrl: string;
+    inputType: string;
+    inputUrl: string;
+    forceStereo: string;
+    streamDelay: string;
+    statusLed: string;
+    statusPort: string;
+    callApi: string;
+    trigger: string;
+    schedule: string;
+    prepareAhead: string;
+    startTime: string;
+    stopTime: string;
+}, {
+    enabled: string;
+    active: string;
+    audioSource: string;
+    avSyncMsec: string;
+    internalVapixParameters: string;
+    userVapixParameters: string;
+    outputParameters: string;
+    outputType: string;
+    mediaServerUrl: string;
+    inputType: string;
+    inputUrl: string;
+    forceStereo: string;
+    streamDelay: string;
+    statusLed: string;
+    statusPort: string;
+    callApi: string;
+    trigger: string;
+    schedule: string;
+    prepareAhead: string;
+    startTime: string;
+    stopTime: string;
+}>;
+export type TOldStringStream = z.infer<typeof oldStringStreamSchema>;
+export declare const oldStreamSchema: z.ZodObject<{
+    enabled: z.ZodUnion<[z.ZodLiteral<0>, z.ZodLiteral<1>]>;
+    active: z.ZodUnion<[z.ZodLiteral<0>, z.ZodLiteral<1>]>;
+    audioSource: z.ZodString;
+    avSyncMsec: z.ZodNumber;
+    internalVapixParameters: z.ZodString;
+    userVapixParameters: z.ZodString;
+    outputParameters: z.ZodString;
+    outputType: z.ZodUnion<[z.ZodLiteral<"video">, z.ZodLiteral<"images">, z.ZodLiteral<"none">]>;
+    mediaServerUrl: z.ZodString;
+    inputType: z.ZodUnion<[z.ZodLiteral<"CSw">, z.ZodLiteral<"CRS">, z.ZodLiteral<"RTSP_URL">]>;
+    inputUrl: z.ZodString;
+    forceStereo: z.ZodUnion<[z.ZodLiteral<0>, z.ZodLiteral<1>]>;
+    streamDelay: z.ZodNullable<z.ZodNumber>;
+    statusLed: z.ZodNumber;
+    statusPort: z.ZodString;
+    callApi: z.ZodNumber;
+    trigger: z.ZodString;
+    schedule: z.ZodString;
+    prepareAhead: z.ZodNumber;
+    startTime: z.ZodNullable<z.ZodNumber>;
+    stopTime: z.ZodNullable<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    enabled: 0 | 1;
+    active: 0 | 1;
+    audioSource: string;
+    avSyncMsec: number;
+    internalVapixParameters: string;
+    userVapixParameters: string;
+    outputParameters: string;
+    outputType: "video" | "none" | "images";
+    mediaServerUrl: string;
+    inputType: "RTSP_URL" | "CSw" | "CRS";
+    inputUrl: string;
+    forceStereo: 0 | 1;
+    streamDelay: number | null;
+    statusLed: number;
+    statusPort: string;
+    callApi: number;
+    trigger: string;
+    schedule: string;
+    prepareAhead: number;
+    startTime: number | null;
+    stopTime: number | null;
+}, {
+    enabled: 0 | 1;
+    active: 0 | 1;
+    audioSource: string;
+    avSyncMsec: number;
+    internalVapixParameters: string;
+    userVapixParameters: string;
+    outputParameters: string;
+    outputType: "video" | "none" | "images";
+    mediaServerUrl: string;
+    inputType: "RTSP_URL" | "CSw" | "CRS";
+    inputUrl: string;
+    forceStereo: 0 | 1;
+    streamDelay: number | null;
+    statusLed: number;
+    statusPort: string;
+    callApi: number;
+    trigger: string;
+    schedule: string;
+    prepareAhead: number;
+    startTime: number | null;
+    stopTime: number | null;
+}>;
+export type TOldStream = z.infer<typeof oldStreamSchema>;

package/cjs/types/{CamStreamerAPI.js → CamStreamerAPI/oldStreamSchema.js}

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.camstreamerServerResponseSchema = exports.cameraStreamResponseSchema = exports.streamSchema = exports.cameraStreamSchema = void 0;
+exports.oldStreamSchema = exports.oldStringStreamSchema = void 0;
 const zod_1 = require("zod");
-exports.cameraStreamSchema = zod_1.z.object({
+exports.oldStringStreamSchema = zod_1.z.object({
     enabled: zod_1.z.string(),
     active: zod_1.z.string(),
     audioSource: zod_1.z.string(),
@@ -25,7 +25,7 @@ exports.cameraStreamSchema = zod_1.z.object({
     startTime: zod_1.z.string(),
     stopTime: zod_1.z.string(),
 });
-exports.streamSchema = zod_1.z.object({
+exports.oldStreamSchema = zod_1.z.object({
     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)]),
     audioSource: zod_1.z.string(),
@@ -48,12 +48,3 @@ exports.streamSchema = zod_1.z.object({
     startTime: zod_1.z.number().nullable(),
     stopTime: zod_1.z.number().nullable(),
 });
-exports.cameraStreamResponseSchema = zod_1.z.object({
-    data: exports.cameraStreamSchema,
-    code: zod_1.z.number(),
-    message: zod_1.z.string(),
-});
-exports.camstreamerServerResponseSchema = zod_1.z.object({
-    code: zod_1.z.number(),
-    message: zod_1.z.string(),
-});

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

@@ -0,0 +1,21 @@
+import z from 'zod';
+export declare const rtmpSchema: z.ZodObject<{
+    enabled: z.ZodBoolean;
+    active: z.ZodBoolean;
+    title: z.ZodString;
+    order: z.ZodNumber;
+} & {
+    type: z.ZodLiteral<"rtmp">;
+}, "strip", z.ZodTypeAny, {
+    type: "rtmp";
+    enabled: boolean;
+    active: boolean;
+    title: string;
+    order: number;
+}, {
+    type: "rtmp";
+    enabled: boolean;
+    active: boolean;
+    title: string;
+    order: number;
+}>;

package/cjs/types/CamStreamerAPI/rtmpSchema.js

@@ -0,0 +1,11 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rtmpSchema = 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'),
+});

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

@@ -0,0 +1,21 @@
+import z from 'zod';
+export declare const sdCardSchema: z.ZodObject<{
+    enabled: z.ZodBoolean;
+    active: z.ZodBoolean;
+    title: z.ZodString;
+    order: z.ZodNumber;
+} & {
+    type: z.ZodLiteral<"sd_card">;
+}, "strip", z.ZodTypeAny, {
+    type: "sd_card";
+    enabled: boolean;
+    active: boolean;
+    title: string;
+    order: number;
+}, {
+    type: "sd_card";
+    enabled: boolean;
+    active: boolean;
+    title: string;
+    order: number;
+}>;

package/cjs/types/CamStreamerAPI/sdCardSchema.js

@@ -0,0 +1,11 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sdCardSchema = void 0;
+const zod_1 = __importDefault(require("zod"));
+const streamCommonTypes_1 = require("./streamCommonTypes");
+exports.sdCardSchema = streamCommonTypes_1.streamCommonSchema.extend({
+    type: zod_1.default.literal('sd_card'),
+});

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

@@ -0,0 +1,20 @@
+import { z } from 'zod';
+export declare const streamTypeSchema: z.ZodUnion<[z.ZodLiteral<"youtube">, z.ZodLiteral<"facebook">, z.ZodLiteral<"sd_card">, z.ZodLiteral<"windy">, z.ZodLiteral<"mpeg_dvb">, z.ZodLiteral<"hls">, z.ZodLiteral<"rtmp">]>;
+export type TStreamType = z.infer<typeof streamTypeSchema>;
+export declare const streamCommonSchema: z.ZodObject<{
+    enabled: z.ZodBoolean;
+    active: z.ZodBoolean;
+    title: z.ZodString;
+    order: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    enabled: boolean;
+    active: boolean;
+    title: string;
+    order: number;
+}, {
+    enabled: boolean;
+    active: boolean;
+    title: string;
+    order: number;
+}>;
+export type TCommonStream = z.infer<typeof streamCommonSchema>;

package/cjs/types/CamStreamerAPI/streamCommonTypes.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.streamCommonSchema = exports.streamTypeSchema = void 0;
+const zod_1 = require("zod");
+exports.streamTypeSchema = zod_1.z.union([
+    zod_1.z.literal('youtube'),
+    zod_1.z.literal('facebook'),
+    zod_1.z.literal('sd_card'),
+    zod_1.z.literal('windy'),
+    zod_1.z.literal('mpeg_dvb'),
+    zod_1.z.literal('hls'),
+    zod_1.z.literal('rtmp'),
+]);
+exports.streamCommonSchema = zod_1.z.object({
+    enabled: zod_1.z.boolean(),
+    active: zod_1.z.boolean(),
+    title: zod_1.z.string(),
+    order: zod_1.z.number(),
+});

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

@@ -0,0 +1,21 @@
+import z from 'zod';
+export declare const windySchema: z.ZodObject<{
+    enabled: z.ZodBoolean;
+    active: z.ZodBoolean;
+    title: z.ZodString;
+    order: z.ZodNumber;
+} & {
+    type: z.ZodLiteral<"windy">;
+}, "strip", z.ZodTypeAny, {
+    type: "windy";
+    enabled: boolean;
+    active: boolean;
+    title: string;
+    order: number;
+}, {
+    type: "windy";
+    enabled: boolean;
+    active: boolean;
+    title: string;
+    order: number;
+}>;

package/cjs/types/CamStreamerAPI/windySchema.js

@@ -0,0 +1,11 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.windySchema = void 0;
+const zod_1 = __importDefault(require("zod"));
+const streamCommonTypes_1 = require("./streamCommonTypes");
+exports.windySchema = streamCommonTypes_1.streamCommonSchema.extend({
+    type: zod_1.default.literal('windy'),
+});

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

@@ -0,0 +1,21 @@
+import z from 'zod';
+export declare const youtubeSchema: z.ZodObject<{
+    enabled: z.ZodBoolean;
+    active: z.ZodBoolean;
+    title: z.ZodString;
+    order: z.ZodNumber;
+} & {
+    type: z.ZodLiteral<"youtube">;
+}, "strip", z.ZodTypeAny, {
+    type: "youtube";
+    enabled: boolean;
+    active: boolean;
+    title: string;
+    order: number;
+}, {
+    type: "youtube";
+    enabled: boolean;
+    active: boolean;
+    title: string;
+    order: number;
+}>;

package/cjs/types/CamStreamerAPI/youtubeSchema.js

@@ -0,0 +1,11 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.youtubeSchema = void 0;
+const zod_1 = __importDefault(require("zod"));
+const streamCommonTypes_1 = require("./streamCommonTypes");
+exports.youtubeSchema = streamCommonTypes_1.streamCommonSchema.extend({
+    type: zod_1.default.literal('youtube'),
+});

package/cjs/types/common.d.ts

@@ -1,4 +1,5 @@
 import { z } from 'zod';
+export declare const booleanSchema: z.ZodUnion<[z.ZodLiteral<0>, z.ZodLiteral<1>]>;
 export declare const audioChannelSchema: z.ZodUnion<[z.ZodLiteral<"mono">, z.ZodLiteral<"stereo">]>;
 export type TAudioChannel = z.infer<typeof audioChannelSchema>;
 export declare const audioChannelCountSchema: z.ZodUnion<[z.ZodLiteral<1>, z.ZodLiteral<2>]>;

package/cjs/types/common.js

@@ -1,7 +1,8 @@
 "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 = void 0;
+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')]);
 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')]);

package/esm/CamStreamerAPI.js

@@ -1,13 +1,15 @@
 import { z } from 'zod';
 import { ProxyClient } from './internal/ProxyClient';
-import { cameraStreamSchema } from './types/CamStreamerAPI';
-import { ErrorWithResponse, UtcTimeFetchError, WsAuthorizationError } from './errors/errors';
+import { streamSchema } from './types/CamStreamerAPI/CamStreamerAPI';
+import { ErrorWithResponse, UtcTimeFetchError, WsAuthorizationError, MigrationError } from './errors/errors';
+import { oldStringStreamSchema } from './types/CamStreamerAPI/oldStreamSchema';
 const BASE_PATH = '/local/camstreamer';
 export class CamStreamerAPI {
     client;
     constructor(client) {
         this.client = client;
     }
+    static getProxyPath = () => `${BASE_PATH}/proxy.cgi`;
     getClient(proxyParams) {
         return proxyParams ? new ProxyClient(this.client, proxyParams) : this.client;
     }
@@ -27,35 +29,46 @@ export class CamStreamerAPI {
     }
     async getStreamList(options) {
         const res = await this._getJson(`${BASE_PATH}/stream/list.cgi`, undefined, options);
-        const list = z.record(z.string(), cameraStreamSchema).parse(res.data);
         const streamList = {};
-        for (const [key, data] of Object.entries(list)) {
-            const streamId = parseInt(key);
-            streamList[streamId] = parseCameraStreamResponse(data);
+        const invalidList = {};
+        for (const [key, value] of Object.entries(res.data)) {
+            const id = parseInt(key);
+            try {
+                const parsed = streamSchema.parse(value);
+                streamList[id] = parsed;
+            }
+            catch (err) {
+                const oldStream = oldStringStreamSchema.parse(value);
+                const parsedOldStream = parseCameraStreamResponse(oldStream);
+                invalidList[id] = parsedOldStream;
+            }
+        }
+        if (Object.keys(invalidList).length > 0) {
+            throw new MigrationError(streamList, invalidList);
         }
         return streamList;
     }
     async getStream(streamId, options) {
         const res = await this._getJson(`${BASE_PATH}/stream/get.cgi`, { stream_id: streamId }, options);
-        const cameraData = cameraStreamSchema.parse(res.data);
-        return parseCameraStreamResponse(cameraData);
-    }
-    async getStreamParameter(streamId, paramName, options) {
-        const res = await this._getJson(`${BASE_PATH}/stream/get.cgi`, { stream_id: streamId }, options);
-        return z.string().parse(res.data[paramName]);
-    }
-    async setStream(streamId, params, options) {
-        const { streamDelay, startTime, stopTime, ...rest } = params;
-        await this._getJson(`${BASE_PATH}/stream/set.cgi`, {
-            stream_id: streamId,
-            streamDelay: streamDelay ?? '',
-            startTime: startTime ?? null,
-            stopTime: stopTime ?? null,
-            ...rest,
-        }, options);
+        try {
+            return streamSchema.parse(res.data);
+        }
+        catch (err) {
+            const oldStream = oldStringStreamSchema.parse(res.data);
+            const parsedOldStream = parseCameraStreamResponse(oldStream);
+            throw new MigrationError({}, { [streamId]: parsedOldStream });
+        }
     }
-    async setStreamParameter(streamId, paramName, value, options) {
-        await this._getJson(`${BASE_PATH}/stream/set.cgi`, { stream_id: streamId, [paramName]: value }, options);
+    async setStream(streamId, streamData, options) {
+        const agent = this.getClient(options?.proxyParams);
+        await agent.post({
+            path: `${BASE_PATH}/stream/set.cgi`,
+            data: streamData,
+            parameters: {
+                stream_id: streamId,
+            },
+            timeout: options?.timeout,
+        });
     }
     async isStreaming(streamId, options) {
         const res = await this._getJson(`${BASE_PATH}/get_streamstat.cgi`, { stream_id: streamId }, options);

package/esm/errors/errors.js

@@ -174,3 +174,13 @@ export class BadRequestError extends ErrorWithResponse {
         this.name = 'BadRequestError';
     }
 }
+export class MigrationError extends Error {
+    valid;
+    invalid;
+    constructor(valid, invalid) {
+        super('Migration to newer version is needed: some stream entries failed to parse.');
+        this.name = 'MigrationError';
+        this.valid = valid;
+        this.invalid = invalid;
+    }
+}

package/esm/types/CamStreamerAPI/CamStreamerAPI.js

@@ -0,0 +1,38 @@
+import { z } from 'zod';
+import { facebookSchema } from './facebookSchema';
+import { hlsSchema } from './hlsSchema';
+import { mpegDvbSchema } from './mpegDvbSchema';
+import { rtmpSchema } from './rtmpSchema';
+import { sdCardSchema } from './sdCardSchema';
+import { windySchema } from './windySchema';
+import { youtubeSchema } from './youtubeSchema';
+export const streamSchema = z.discriminatedUnion('type', [
+    facebookSchema,
+    hlsSchema,
+    mpegDvbSchema,
+    rtmpSchema,
+    sdCardSchema,
+    windySchema,
+    youtubeSchema,
+]);
+export const isFacebookStream = (stream) => {
+    return stream.type === 'facebook';
+};
+export const isHlsStream = (stream) => {
+    return stream.type === 'hls';
+};
+export const isMpegDvbStream = (stream) => {
+    return stream.type === 'mpeg_dvb';
+};
+export const isRtmpStream = (stream) => {
+    return stream.type === 'rtmp';
+};
+export const isSdCardStream = (stream) => {
+    return stream.type === 'sd_card';
+};
+export const isWindyStream = (stream) => {
+    return stream.type === 'windy';
+};
+export const isYouTubeStream = (stream) => {
+    return stream.type === 'youtube';
+};

package/esm/types/CamStreamerAPI/facebookSchema.js

@@ -0,0 +1,5 @@
+import z from 'zod';
+import { streamCommonSchema } from './streamCommonTypes';
+export const facebookSchema = streamCommonSchema.extend({
+    type: z.literal('facebook'),
+});

package/esm/types/CamStreamerAPI/hlsSchema.js

@@ -0,0 +1,5 @@
+import z from 'zod';
+import { streamCommonSchema } from './streamCommonTypes';
+export const hlsSchema = streamCommonSchema.extend({
+    type: z.literal('hls'),
+});

package/esm/types/CamStreamerAPI/index.js

@@ -0,0 +1,9 @@
+export * from './CamStreamerAPI';
+export * from './streamCommonTypes';
+export * from './facebookSchema';
+export * from './hlsSchema';
+export * from './mpegDvbSchema';
+export * from './rtmpSchema';
+export * from './sdCardSchema';
+export * from './windySchema';
+export * from './youtubeSchema';