camstreamerlib 4.0.0-beta.114 → 4.0.0-beta.116

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

@@ -10,54 +10,54 @@ declare const csEventsDataSchema: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
     state: string;
 }>, z.ZodObject<{
     type: z.ZodLiteral<"StreamState">;
-    streamID: z.ZodNumber;
+    streamId: z.ZodString;
     isStreaming: z.ZodBoolean;
     active: z.ZodBoolean;
     enabled: z.ZodBoolean;
 }, "strip", z.ZodTypeAny, {
     type: "StreamState";
     enabled: boolean;
+    streamId: string;
     active: boolean;
-    streamID: number;
     isStreaming: boolean;
 }, {
     type: "StreamState";
     enabled: boolean;
+    streamId: string;
     active: boolean;
-    streamID: number;
     isStreaming: boolean;
 }>, z.ZodObject<{
     type: z.ZodLiteral<"CS_API_SUCCESS">;
     apiCall: z.ZodString;
     message: z.ZodString;
-    streamID: z.ZodNumber;
+    streamId: z.ZodString;
 }, "strip", z.ZodTypeAny, {
     message: string;
     type: "CS_API_SUCCESS";
-    streamID: number;
+    streamId: string;
     apiCall: string;
 }, {
     message: string;
     type: "CS_API_SUCCESS";
-    streamID: number;
+    streamId: string;
     apiCall: string;
 }>, z.ZodObject<{
     type: z.ZodLiteral<"CS_API_ERROR">;
     apiCall: z.ZodString;
     message: z.ZodString;
-    streamID: z.ZodNumber;
+    streamId: z.ZodString;
     code: z.ZodString;
 }, "strip", z.ZodTypeAny, {
     code: string;
     message: string;
     type: "CS_API_ERROR";
-    streamID: number;
+    streamId: string;
     apiCall: string;
 }, {
     code: string;
     message: string;
     type: "CS_API_ERROR";
-    streamID: number;
+    streamId: string;
     apiCall: string;
 }>, z.ZodObject<{
     type: z.ZodLiteral<"PortChanged">;
@@ -85,54 +85,54 @@ export declare const csEventsSchema: z.ZodDiscriminatedUnion<"type", [z.ZodObjec
         state: string;
     }>, z.ZodObject<{
         type: z.ZodLiteral<"StreamState">;
-        streamID: z.ZodNumber;
+        streamId: z.ZodString;
         isStreaming: z.ZodBoolean;
         active: z.ZodBoolean;
         enabled: z.ZodBoolean;
     }, "strip", z.ZodTypeAny, {
         type: "StreamState";
         enabled: boolean;
+        streamId: string;
         active: boolean;
-        streamID: number;
         isStreaming: boolean;
     }, {
         type: "StreamState";
         enabled: boolean;
+        streamId: string;
         active: boolean;
-        streamID: number;
         isStreaming: boolean;
     }>, z.ZodObject<{
         type: z.ZodLiteral<"CS_API_SUCCESS">;
         apiCall: z.ZodString;
         message: z.ZodString;
-        streamID: z.ZodNumber;
+        streamId: z.ZodString;
     }, "strip", z.ZodTypeAny, {
         message: string;
         type: "CS_API_SUCCESS";
-        streamID: number;
+        streamId: string;
         apiCall: string;
     }, {
         message: string;
         type: "CS_API_SUCCESS";
-        streamID: number;
+        streamId: string;
         apiCall: string;
     }>, z.ZodObject<{
         type: z.ZodLiteral<"CS_API_ERROR">;
         apiCall: z.ZodString;
         message: z.ZodString;
-        streamID: z.ZodNumber;
+        streamId: z.ZodString;
         code: z.ZodString;
     }, "strip", z.ZodTypeAny, {
         code: string;
         message: string;
         type: "CS_API_ERROR";
-        streamID: number;
+        streamId: string;
         apiCall: string;
     }, {
         code: string;
         message: string;
         type: "CS_API_ERROR";
-        streamID: number;
+        streamId: string;
         apiCall: string;
     }>, z.ZodObject<{
         type: z.ZodLiteral<"PortChanged">;
@@ -155,19 +155,19 @@ export declare const csEventsSchema: z.ZodDiscriminatedUnion<"type", [z.ZodObjec
     } | {
         type: "StreamState";
         enabled: boolean;
+        streamId: string;
         active: boolean;
-        streamID: number;
         isStreaming: boolean;
     } | {
         message: string;
         type: "CS_API_SUCCESS";
-        streamID: number;
+        streamId: string;
         apiCall: string;
     } | {
         code: string;
         message: string;
         type: "CS_API_ERROR";
-        streamID: number;
+        streamId: string;
         apiCall: string;
     } | {
         value: boolean;
@@ -182,19 +182,19 @@ export declare const csEventsSchema: z.ZodDiscriminatedUnion<"type", [z.ZodObjec
     } | {
         type: "StreamState";
         enabled: boolean;
+        streamId: string;
         active: boolean;
-        streamID: number;
         isStreaming: boolean;
     } | {
         message: string;
         type: "CS_API_SUCCESS";
-        streamID: number;
+        streamId: string;
         apiCall: string;
     } | {
         code: string;
         message: string;
         type: "CS_API_ERROR";
-        streamID: number;
+        streamId: string;
         apiCall: string;
     } | {
         value: boolean;
@@ -212,54 +212,54 @@ export declare const csEventsSchema: z.ZodDiscriminatedUnion<"type", [z.ZodObjec
     state: string;
 }>, z.ZodObject<{
     type: z.ZodLiteral<"StreamState">;
-    streamID: z.ZodNumber;
+    streamId: z.ZodString;
     isStreaming: z.ZodBoolean;
     active: z.ZodBoolean;
     enabled: z.ZodBoolean;
 }, "strip", z.ZodTypeAny, {
     type: "StreamState";
     enabled: boolean;
+    streamId: string;
     active: boolean;
-    streamID: number;
     isStreaming: boolean;
 }, {
     type: "StreamState";
     enabled: boolean;
+    streamId: string;
     active: boolean;
-    streamID: number;
     isStreaming: boolean;
 }>, z.ZodObject<{
     type: z.ZodLiteral<"CS_API_SUCCESS">;
     apiCall: z.ZodString;
     message: z.ZodString;
-    streamID: z.ZodNumber;
+    streamId: z.ZodString;
 }, "strip", z.ZodTypeAny, {
     message: string;
     type: "CS_API_SUCCESS";
-    streamID: number;
+    streamId: string;
     apiCall: string;
 }, {
     message: string;
     type: "CS_API_SUCCESS";
-    streamID: number;
+    streamId: string;
     apiCall: string;
 }>, z.ZodObject<{
     type: z.ZodLiteral<"CS_API_ERROR">;
     apiCall: z.ZodString;
     message: z.ZodString;
-    streamID: z.ZodNumber;
+    streamId: z.ZodString;
     code: z.ZodString;
 }, "strip", z.ZodTypeAny, {
     code: string;
     message: string;
     type: "CS_API_ERROR";
-    streamID: number;
+    streamId: string;
     apiCall: string;
 }, {
     code: string;
     message: string;
     type: "CS_API_ERROR";
-    streamID: number;
+    streamId: string;
     apiCall: string;
 }>, z.ZodObject<{
     type: z.ZodLiteral<"PortChanged">;

package/cjs/types/ws/CamStreamerEvents.js

@@ -6,7 +6,7 @@ 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(),
+        streamId: zod_1.z.string(),
         isStreaming: zod_1.z.boolean(),
         active: zod_1.z.boolean(),
         enabled: zod_1.z.boolean(),
@@ -15,13 +15,13 @@ const csEventsDataSchema = zod_1.z.discriminatedUnion('type', [
         type: zod_1.z.literal('CS_API_SUCCESS'),
         apiCall: zod_1.z.string(),
         message: zod_1.z.string(),
-        streamID: zod_1.z.number(),
+        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.number(),
+        streamId: zod_1.z.string(),
         code: zod_1.z.string(),
     }),
     zod_1.z.object({

package/esm/CamStreamerAPI.js

@@ -46,8 +46,8 @@ export class CamStreamerAPI {
         const res = await this._getJson(`${BASE_PATH}/stream_list.cgi`, { action: 'get' }, options);
         const oldStreamListRecord = z.record(z.string(), oldStringStreamSchema).safeParse(res.data);
         if (oldStreamListRecord.success) {
-            const data = Object.entries(oldStreamListRecord.data).map(([id, streamData]) => ({
-                id: parseInt(id),
+            const data = Object.entries(oldStreamListRecord.data).map(([streamId, streamData]) => ({
+                streamId,
                 ...parseCameraStreamResponse(streamData),
             }));
             throw new MigrationError([], data);
@@ -64,7 +64,7 @@ export class CamStreamerAPI {
             const oldStreamParse = oldStringStreamSchemaWithId.safeParse(streamData);
             if (oldStreamParse.success) {
                 oldStreamData.push({
-                    id: parseInt(oldStreamParse.data.id),
+                    streamId: oldStreamParse.data.streamId,
                     ...parseCameraStreamResponse(oldStreamParse.data),
                 });
                 continue;
@@ -88,7 +88,7 @@ export class CamStreamerAPI {
             return newStream.data;
         }
         const oldStream = oldStringStreamSchema.passthrough().parse(res.data);
-        throw new MigrationError([], [{ id: streamId, ...parseCameraStreamResponse(oldStream) }]);
+        throw new MigrationError([], [{ streamId, ...parseCameraStreamResponse(oldStream) }]);
     }
     async setStream(streamId, streamData, options) {
         await this._postJsonEncoded(`${BASE_PATH}/stream_list.cgi`, JSON.stringify(streamData), {

package/esm/types/CamStreamerAPI/CamStreamerAPI.js

@@ -1,26 +1,10 @@
 import { z } from 'zod';
 import { facebookSchema } from './facebookSchema';
-import { mpegDvbSchema } from './mpegDvbSchema';
-import { rtmpSchema } from './rtmpSchema';
-import { sdCardSchema } from './sdCardSchema';
 import { windySchema } from './windySchema';
 import { youtubeSchema } from './youtubeSchema';
-import { vimeoSchema } from './vimeoSchema';
-import { twitchSchema } from './twitchSchema';
-import { churchSchema } from './churchSchema';
-import { srtSchema } from './srtSchema';
-import { daCastSchema } from './daCastSchema';
-import { hlsPullSchema } from './hlsPullSchema';
-import { hlsPushSchema } from './hlsPushSchema';
-import { wowzaSchema } from './wowzaSchema';
-import { dailymotionSchema } from './dailymotionSchema';
-import { ibmSchema } from './ibmSchema';
-import { microsoftAzureSchema } from './microsoftAzureSchema';
-import { microsoftStreamSchema } from './microsoftStreamSchema';
-import { gameChangerSchema } from './gameChangerSchema';
+import { churchSchema, daCastSchema, dailymotionSchema, gameChangerSchema, hlsPullSchema, hlsPushSchema, ibmSchema, microsoftAzureSchema, microsoftStreamSchema, mpegDvbSchema, rtmpSchema, sdCardSchema, srtSchema, twitchSchema, vimeoSchema, wowzaSchema, youtubeRtmpSchema, } from './streamsSchema';
 import { fileSchema } from '../common';
-import { youtubeRtmpSchema } from './youtubeRtmpSchema';
-export const streamSchema = z.discriminatedUnion('type', [
+export const streamSchema = z.discriminatedUnion('platform', [
     facebookSchema,
     mpegDvbSchema,
     rtmpSchema,
@@ -44,64 +28,64 @@ export const streamSchema = z.discriminatedUnion('type', [
 ]);
 export const streamListSchema = z.object({ streamList: z.array(streamSchema) });
 export const isFacebookStream = (stream) => {
-    return stream.type === 'facebook';
+    return stream.platform === 'facebook';
 };
 export const isMpegDvbStream = (stream) => {
-    return stream.type === 'mpeg_dvb';
+    return stream.platform === 'mpeg_dvb';
 };
 export const isRtmpStream = (stream) => {
-    return stream.type === 'rtmp';
+    return stream.platform === 'rtmp';
 };
 export const isSdCardStream = (stream) => {
-    return stream.type === 'sd_card';
+    return stream.platform === 'sd_card';
 };
 export const isWindyStream = (stream) => {
-    return stream.type === 'windy';
+    return stream.platform === 'windy';
 };
 export const isYouTubeStream = (stream) => {
-    return stream.type === 'youtube';
+    return stream.platform === 'youtube';
 };
 export const isVimeoStream = (stream) => {
-    return stream.type === 'vimeo';
+    return stream.platform === 'vimeo';
 };
 export const isTwitchStream = (stream) => {
-    return stream.type === 'twitch';
+    return stream.platform === 'twitch';
 };
 export const isChurchStream = (stream) => {
-    return stream.type === 'church';
+    return stream.platform === 'church';
 };
 export const isSrtStream = (stream) => {
-    return stream.type === 'srt';
+    return stream.platform === 'srt';
 };
 export const isDaCastStream = (stream) => {
-    return stream.type === 'da_cast';
+    return stream.platform === 'da_cast';
 };
 export const isHlsPullStream = (stream) => {
-    return stream.type === 'hls_pull';
+    return stream.platform === 'hls_pull';
 };
 export const isHlsPushStream = (stream) => {
-    return stream.type === 'hls_push';
+    return stream.platform === 'hls_push';
 };
 export const isWowzaStream = (stream) => {
-    return stream.type === 'wowza';
+    return stream.platform === 'wowza';
 };
 export const isDailymotionStream = (stream) => {
-    return stream.type === 'dailymotion';
+    return stream.platform === 'dailymotion';
 };
 export const isIbmStream = (stream) => {
-    return stream.type === 'ibm';
+    return stream.platform === 'ibm';
 };
 export const isMicrosoftAzureStream = (stream) => {
-    return stream.type === 'microsoft_azure';
+    return stream.platform === 'microsoft_azure';
 };
 export const isMicrosoftStream = (stream) => {
-    return stream.type === 'microsoft_stream';
+    return stream.platform === 'microsoft_stream';
 };
 export const isGameChangerStream = (stream) => {
-    return stream.type === 'game_changer';
+    return stream.platform === 'game_changer';
 };
 export const isYoutubeRtmpStream = (stream) => {
-    return stream.type === 'youtube_rtmp';
+    return stream.platform === 'youtube_rtmp';
 };
 export var AudioType;
 (function (AudioType) {

package/esm/types/CamStreamerAPI/facebookSchema.js

@@ -1,21 +1,17 @@
 import z from 'zod';
 import { streamCommonSchema } from './streamCommonTypes';
-export const facebookStreamPrivacySchema = z.union([z.literal('public'), z.literal('friends'), z.literal('only_me')]);
-const timelinePost = z.object({
+const timelinePostSchema = z.object({
     postLocation: z.literal('timeline'),
-    streamPrivacy: facebookStreamPrivacySchema,
+    streamPrivacy: z.union([z.literal('public'), z.literal('friends'), z.literal('only_me')]),
 });
-const pagePost = z.object({
+const pagePostSchema = z.object({
     postLocation: z.literal('page'),
     page: z.string(),
 });
 export const facebookSchema = streamCommonSchema.extend({
-    type: z.literal('facebook'),
+    platform: z.literal('facebook'),
     description: z.string().optional(),
     deleteAfterEnd: z.boolean(),
-    saveToSdCard: z.boolean(),
-    statusCameraLed: z.boolean(),
-    statusCameraOutput: z.string().nullable(),
     countdown: z.boolean(),
-    post: z.discriminatedUnion('postLocation', [timelinePost, pagePost]),
+    post: z.discriminatedUnion('postLocation', [timelinePostSchema, pagePostSchema]),
 });

package/esm/types/CamStreamerAPI/index.js

@@ -1,10 +1,6 @@
 export * from './CamStreamerAPI';
 export * from './streamCommonTypes';
 export * from './facebookSchema';
-export * from './mpegDvbSchema';
-export * from './rtmpSchema';
-export * from './gameChangerSchema';
-export * from './sdCardSchema';
 export * from './windySchema';
 export * from './youtubeSchema';
-export * from './youtubeRtmpSchema';
+export * from './streamsSchema';

package/esm/types/CamStreamerAPI/oldStreamSchema.js

@@ -23,7 +23,7 @@ export const oldStringStreamSchema = z.object({
     stopTime: z.string(),
 });
 export const oldStringStreamSchemaWithId = oldStringStreamSchema.extend({
-    id: z.string(),
+    streamId: z.string(),
 });
 export const oldStreamSchema = z.object({
     enabled: z.union([z.literal(0), z.literal(1)]),

package/esm/types/CamStreamerAPI/streamCommonTypes.js

@@ -1,46 +1,94 @@
 import { z } from 'zod';
 import { bitrateVapixParamsSchema, booleanSchema, h264ProfileSchema } from '../common';
-const scheduleSchema = z.object({
-    start: z.object({
-        day: z.number().int().min(0).max(6),
-        timeS: z.number().int().min(0).max(86400),
-    }),
-    stop: z.object({
-        day: z.number().int().min(0).max(6),
-        timeS: z.number().int().min(0).max(86400),
-    }),
-    isActive: z.boolean(),
-});
-export const streamTriggerSchema = z.discriminatedUnion('type', [
-    z.object({
-        type: z.literal('manual'),
-        ioPort: z.string().nullable(),
-    }),
-    z.object({
-        type: z.literal('onetime'),
-        startTime: z.number(),
-        stopTime: z.number(),
-        ioPort: z.string().nullable(),
+export const streamCommonSchema = z.object({
+    streamId: z.string(),
+    enabled: z.boolean(),
+    active: z.boolean(),
+    title: z.string(),
+    trigger: z.discriminatedUnion('type', [
+        z.object({
+            type: z.literal('manual'),
+            ioPort: z.number().nullable(),
+        }),
+        z.object({
+            type: z.literal('onetime'),
+            startTime: z.number(),
+            stopTime: z.number(),
+        }),
+        z.object({
+            type: z.literal('recurrent'),
+            schedule: z.array(z.object({
+                start: z.object({
+                    day: z.number().int().min(0).max(6),
+                    timeS: z.number().int().min(0).max(86400),
+                }),
+                stop: z.object({
+                    day: z.number().int().min(0).max(6),
+                    timeS: z.number().int().min(0).max(86400),
+                }),
+                isActive: z.boolean(),
+            })),
+        }),
+    ]),
+    video: z.object({
+        output: z.discriminatedUnion('callApi', [
+            z.object({
+                type: z.union([z.literal('video'), z.literal('images')]),
+                callApi: z.literal(false),
+                url: z.string(),
+            }),
+            z.object({
+                type: z.literal('video'),
+                callApi: z.literal(true),
+                prepareAheadS: z.number(),
+            }),
+        ]),
+        outputParameters: z.string(),
+        input: z.discriminatedUnion('type', [
+            z.object({
+                type: z.literal('RTSP_URL'),
+                url: z.string(),
+            }),
+            z.object({
+                type: z.union([z.literal('CSw'), z.literal('CRS')]),
+            }),
+        ]),
+        streamingProtocol: z.union([z.literal('RTMP'), z.literal('RTMPS'), z.literal('HLS_PUSH')]),
+        internalVapixParameters: z.string(),
+        userVapixParameters: z.string(),
+        streamDelay: z
+            .object({
+            value: z.number().int(),
+            unit: z.union([z.literal('seconds'), z.literal('minutes'), z.literal('hours')]),
+        })
+            .optional(),
     }),
-    z.object({
-        type: z.literal('recurrent'),
-        schedule: z.array(scheduleSchema),
+    audio: z
+        .discriminatedUnion('source', [
+        z.object({
+            source: z.literal('microphone'),
+            audioChannelNbr: z.union([z.literal(1), z.literal(2)]),
+            forceStereo: booleanSchema,
+        }),
+        z.object({
+            source: z.literal('file'),
+            fileName: z.string(),
+            filePath: z.string(),
+            forceStereo: booleanSchema,
+        }),
+        z.object({
+            source: z.literal('url'),
+            fileName: z.string(),
+            fileUrl: z.string(),
+            avSyncMsec: z.number().int().nonnegative(),
+            forceStereo: booleanSchema,
+        }),
+    ])
+        .nullable(),
+    status: z.object({
+        led: z.boolean(),
+        port: z.number().nullable(),
     }),
-]);
-export const streamInputTypeSchema = z.union([z.literal('CSw'), z.literal('CRS'), z.literal('RTSP_URL')]);
-export const streamingProtocolTypeSchema = z.union([z.literal('RTMP'), z.literal('RTMPS'), z.literal('HLS_PUSH')]);
-export const videoCodecSchema = z.union([z.literal('h264'), z.literal('h265'), z.literal('av1')]);
-export const overlaysSchema = z.union([
-    z.literal('all'),
-    z.literal('text'),
-    z.literal('image'),
-    z.literal('application'),
-    z.literal(''),
-    z.literal('off'),
-]);
-export const streamDelaySchema = z.object({
-    value: z.number().int(),
-    unit: z.union([z.literal('seconds'), z.literal('minutes'), z.literal('hours')]),
 });
 export const internalVapixParametersSchema = bitrateVapixParamsSchema.extend({
     camera: z.string(),
@@ -48,7 +96,7 @@ export const internalVapixParametersSchema = bitrateVapixParamsSchema.extend({
     fps: z.number().int(),
     compression: z.number().int(),
     govLength: z.number().int(),
-    videoCodec: videoCodecSchema,
+    videoCodec: z.union([z.literal('h264'), z.literal('h265'), z.literal('av1')]),
     h264Profile: h264ProfileSchema.optional(),
     audio: booleanSchema,
     nbrOfChannels: z.union([z.literal(1), z.literal(2)]).optional(),
@@ -63,37 +111,3 @@ export const internalVapixParametersSchema = bitrateVapixParamsSchema.extend({
     ])
         .optional(),
 });
-export const streamVideoSchema = z.object({
-    inputType: streamInputTypeSchema,
-    sourceUrl: z.string().optional(),
-    internalVapixParameters: z.string(),
-    userVapixParameters: z.string(),
-    streamingProtocol: streamingProtocolTypeSchema,
-    streamDelay: streamDelaySchema.optional(),
-});
-export const streamAudioSchema = z.discriminatedUnion('source', [
-    z.object({
-        source: z.literal('none'),
-    }),
-    z.object({ source: z.literal('microphone'), audioChannelNbr: z.union([z.literal(1), z.literal(2)]) }),
-    z.object({
-        source: z.literal('file'),
-        fileName: z.string(),
-        filePath: z.string(),
-    }),
-    z.object({
-        source: z.literal('url'),
-        fileName: z.string(),
-        fileUrl: z.string(),
-        avSyncMsec: z.number().int().nonnegative(),
-    }),
-]);
-export const streamCommonSchema = z.object({
-    id: z.number(),
-    enabled: z.boolean(),
-    active: z.boolean(),
-    title: z.string(),
-    trigger: streamTriggerSchema,
-    video: streamVideoSchema,
-    audio: streamAudioSchema,
-});