camstreamerlib 4.0.0-beta.95 → 4.0.0-beta.97

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

@@ -0,0 +1,202 @@
+import z from 'zod';
+export declare const wowzaSchema: 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;
+        }[];
+    }>]>;
+    inputType: z.ZodUnion<[z.ZodLiteral<"CSw">, z.ZodLiteral<"CRS">, z.ZodLiteral<"RTSP_URL">]>;
+    internalVapixParameters: z.ZodObject<{
+        camera: z.ZodString;
+        resolution: z.ZodOptional<z.ZodString>;
+        compression: z.ZodOptional<z.ZodNumber>;
+        fps: z.ZodOptional<z.ZodNumber>;
+        videobitrate: z.ZodOptional<z.ZodNumber>;
+        videomaxbitrate: z.ZodOptional<z.ZodNumber>;
+        audio: z.ZodOptional<z.ZodUnion<[z.ZodLiteral<0>, z.ZodLiteral<1>]>>;
+    }, "strip", z.ZodTypeAny, {
+        camera: string;
+        resolution?: string | undefined;
+        compression?: number | undefined;
+        audio?: 0 | 1 | undefined;
+        fps?: number | undefined;
+        videobitrate?: number | undefined;
+        videomaxbitrate?: number | undefined;
+    }, {
+        camera: string;
+        resolution?: string | undefined;
+        compression?: number | undefined;
+        audio?: 0 | 1 | undefined;
+        fps?: number | undefined;
+        videobitrate?: number | undefined;
+        videomaxbitrate?: number | undefined;
+    }>;
+} & {
+    type: z.ZodLiteral<"wowza">;
+}, "strip", z.ZodTypeAny, {
+    type: "wowza";
+    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;
+        }[];
+    };
+    inputType: "RTSP_URL" | "CSw" | "CRS";
+    internalVapixParameters: {
+        camera: string;
+        resolution?: string | undefined;
+        compression?: number | undefined;
+        audio?: 0 | 1 | undefined;
+        fps?: number | undefined;
+        videobitrate?: number | undefined;
+        videomaxbitrate?: number | undefined;
+    };
+}, {
+    type: "wowza";
+    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;
+        }[];
+    };
+    inputType: "RTSP_URL" | "CSw" | "CRS";
+    internalVapixParameters: {
+        camera: string;
+        resolution?: string | undefined;
+        compression?: number | undefined;
+        audio?: 0 | 1 | undefined;
+        fps?: number | undefined;
+        videobitrate?: number | undefined;
+        videomaxbitrate?: number | undefined;
+    };
+}>;

package/cjs/types/CamStreamerAPI/wowzaSchema.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.wowzaSchema = void 0;
+const zod_1 = __importDefault(require("zod"));
+const streamCommonTypes_1 = require("./streamCommonTypes");
+exports.wowzaSchema = streamCommonTypes_1.streamCommonSchema.extend({
+    type: zod_1.default.literal('wowza'),
+});

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

@@ -97,23 +97,34 @@ export declare const youtubeSchema: z.ZodObject<{
             isActive: boolean;
         }[];
     }>]>;
+    inputType: z.ZodUnion<[z.ZodLiteral<"CSw">, z.ZodLiteral<"CRS">, z.ZodLiteral<"RTSP_URL">]>;
+    internalVapixParameters: z.ZodObject<{
+        camera: z.ZodString;
+        resolution: z.ZodOptional<z.ZodString>;
+        compression: z.ZodOptional<z.ZodNumber>;
+        fps: z.ZodOptional<z.ZodNumber>;
+        videobitrate: z.ZodOptional<z.ZodNumber>;
+        videomaxbitrate: z.ZodOptional<z.ZodNumber>;
+        audio: z.ZodOptional<z.ZodUnion<[z.ZodLiteral<0>, z.ZodLiteral<1>]>>;
+    }, "strip", z.ZodTypeAny, {
+        camera: string;
+        resolution?: string | undefined;
+        compression?: number | undefined;
+        audio?: 0 | 1 | undefined;
+        fps?: number | undefined;
+        videobitrate?: number | undefined;
+        videomaxbitrate?: number | undefined;
+    }, {
+        camera: string;
+        resolution?: string | undefined;
+        compression?: number | undefined;
+        audio?: 0 | 1 | undefined;
+        fps?: number | undefined;
+        videobitrate?: number | undefined;
+        videomaxbitrate?: number | undefined;
+    }>;
 } & {
     type: z.ZodLiteral<"youtube">;
-    description: z.ZodOptional<z.ZodString>;
-    playlist: z.ZodOptional<z.ZodString>;
-    tags: z.ZodArray<z.ZodString, "many">;
-    notificationEmail: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-    streamPrivacy: z.ZodUnion<[z.ZodLiteral<"public">, z.ZodLiteral<"unlisted">, z.ZodLiteral<"private">]>;
-    latency: z.ZodUnion<[z.ZodLiteral<"normal">, z.ZodLiteral<"low">, z.ZodLiteral<"ultra_low">]>;
-    afterEndStatus: z.ZodUnion<[z.ZodLiteral<"no_change">, z.ZodLiteral<"public">, z.ZodLiteral<"unlisted">, z.ZodLiteral<"private">]>;
-    cameraLedStatus: z.ZodBoolean;
-    dvr: z.ZodBoolean;
-    saveToSdCard: z.ZodBoolean;
-    statusCameraLed: z.ZodBoolean;
-    statusCameraOutput: z.ZodString;
-    hasWatchdogs: z.ZodBoolean;
-    countdown: z.ZodBoolean;
-    enableManualControl: z.ZodBoolean;
 }, "strip", z.ZodTypeAny, {
     type: "youtube";
     enabled: boolean;
@@ -141,21 +152,16 @@ export declare const youtubeSchema: z.ZodObject<{
             isActive: boolean;
         }[];
     };
-    statusCameraLed: boolean;
-    statusCameraOutput: string;
-    saveToSdCard: boolean;
-    tags: string[];
-    streamPrivacy: "public" | "unlisted" | "private";
-    latency: "normal" | "low" | "ultra_low";
-    afterEndStatus: "public" | "unlisted" | "private" | "no_change";
-    cameraLedStatus: boolean;
-    dvr: boolean;
-    hasWatchdogs: boolean;
-    countdown: boolean;
-    enableManualControl: boolean;
-    playlist?: string | undefined;
-    description?: string | undefined;
-    notificationEmail?: string[] | undefined;
+    inputType: "RTSP_URL" | "CSw" | "CRS";
+    internalVapixParameters: {
+        camera: string;
+        resolution?: string | undefined;
+        compression?: number | undefined;
+        audio?: 0 | 1 | undefined;
+        fps?: number | undefined;
+        videobitrate?: number | undefined;
+        videomaxbitrate?: number | undefined;
+    };
 }, {
     type: "youtube";
     enabled: boolean;
@@ -183,19 +189,14 @@ export declare const youtubeSchema: z.ZodObject<{
             isActive: boolean;
         }[];
     };
-    statusCameraLed: boolean;
-    statusCameraOutput: string;
-    saveToSdCard: boolean;
-    tags: string[];
-    streamPrivacy: "public" | "unlisted" | "private";
-    latency: "normal" | "low" | "ultra_low";
-    afterEndStatus: "public" | "unlisted" | "private" | "no_change";
-    cameraLedStatus: boolean;
-    dvr: boolean;
-    hasWatchdogs: boolean;
-    countdown: boolean;
-    enableManualControl: boolean;
-    playlist?: string | undefined;
-    description?: string | undefined;
-    notificationEmail?: string[] | undefined;
+    inputType: "RTSP_URL" | "CSw" | "CRS";
+    internalVapixParameters: {
+        camera: string;
+        resolution?: string | undefined;
+        compression?: number | undefined;
+        audio?: 0 | 1 | undefined;
+        fps?: number | undefined;
+        videobitrate?: number | undefined;
+        videomaxbitrate?: number | undefined;
+    };
 }>;

package/cjs/types/CamStreamerAPI/youtubeSchema.js

@@ -8,19 +8,4 @@ const zod_1 = __importDefault(require("zod"));
 const streamCommonTypes_1 = require("./streamCommonTypes");
 exports.youtubeSchema = streamCommonTypes_1.streamCommonSchema.extend({
     type: zod_1.default.literal('youtube'),
-    description: zod_1.default.string().optional(),
-    playlist: zod_1.default.string().optional(),
-    tags: zod_1.default.array(zod_1.default.string()),
-    notificationEmail: zod_1.default.array(zod_1.default.string().email()).optional(),
-    streamPrivacy: zod_1.default.union([zod_1.default.literal('public'), zod_1.default.literal('unlisted'), zod_1.default.literal('private')]),
-    latency: zod_1.default.union([zod_1.default.literal('normal'), zod_1.default.literal('low'), zod_1.default.literal('ultra_low')]),
-    afterEndStatus: zod_1.default.union([zod_1.default.literal('no_change'), zod_1.default.literal('public'), zod_1.default.literal('unlisted'), zod_1.default.literal('private')]),
-    cameraLedStatus: zod_1.default.boolean(),
-    dvr: zod_1.default.boolean(),
-    saveToSdCard: zod_1.default.boolean(),
-    statusCameraLed: zod_1.default.boolean(),
-    statusCameraOutput: zod_1.default.string(),
-    hasWatchdogs: zod_1.default.boolean(),
-    countdown: zod_1.default.boolean(),
-    enableManualControl: zod_1.default.boolean(),
 });

package/esm/types/CamStreamerAPI/CamStreamerAPI.js

@@ -1,27 +1,48 @@
 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';
+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';
 export const streamSchema = z.discriminatedUnion('type', [
     facebookSchema,
-    hlsSchema,
     mpegDvbSchema,
     rtmpSchema,
     sdCardSchema,
     windySchema,
     youtubeSchema,
+    vimeoSchema,
+    twitchSchema,
+    churchSchema,
+    srtSchema,
+    daCastSchema,
+    hlsPullSchema,
+    hlsPushSchema,
+    wowzaSchema,
+    dailymotionSchema,
+    ibmSchema,
+    microsoftAzureSchema,
+    microsoftStreamSchema,
+    gameChangerSchema,
 ]);
 export const streamListSchema = z.object({ streamList: z.array(streamSchema) });
 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';
 };
@@ -37,6 +58,45 @@ export const isWindyStream = (stream) => {
 export const isYouTubeStream = (stream) => {
     return stream.type === 'youtube';
 };
+export const isVimeoStream = (stream) => {
+    return stream.type === 'vimeo';
+};
+export const isTwitchStream = (stream) => {
+    return stream.type === 'twitch';
+};
+export const isChurchStream = (stream) => {
+    return stream.type === 'church';
+};
+export const isSrtStream = (stream) => {
+    return stream.type === 'srt';
+};
+export const isDaCastStream = (stream) => {
+    return stream.type === 'da_cast';
+};
+export const isHlsPullStream = (stream) => {
+    return stream.type === 'hls_pull';
+};
+export const isHlsPushStream = (stream) => {
+    return stream.type === 'hls_push';
+};
+export const isWowzaStream = (stream) => {
+    return stream.type === 'wowza';
+};
+export const isDailymotionStream = (stream) => {
+    return stream.type === 'dailymotion';
+};
+export const isIbmStream = (stream) => {
+    return stream.type === 'ibm';
+};
+export const isMicrosoftAzureStream = (stream) => {
+    return stream.type === 'microsoft_azure';
+};
+export const isMicrosoftStream = (stream) => {
+    return stream.type === 'microsoft_stream';
+};
+export const isGameChangerStream = (stream) => {
+    return stream.type === 'game_changer';
+};
 export var AudioType;
 (function (AudioType) {
     AudioType[AudioType["MP3"] = 0] = "MP3";

package/esm/types/CamStreamerAPI/churchSchema.js

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

package/esm/types/CamStreamerAPI/daCastSchema.js

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

package/esm/types/CamStreamerAPI/dailymotionSchema.js

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

package/esm/types/CamStreamerAPI/gameChangerSchema.js

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

package/esm/types/CamStreamerAPI/hlsPullSchema.js

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

package/esm/types/CamStreamerAPI/hlsPushSchema.js

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

package/esm/types/CamStreamerAPI/{hlsSchema.js → ibmSchema.js}

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

package/esm/types/CamStreamerAPI/index.js

@@ -1,7 +1,6 @@
 export * from './CamStreamerAPI';
 export * from './streamCommonTypes';
 export * from './facebookSchema';
-export * from './hlsSchema';
 export * from './mpegDvbSchema';
 export * from './rtmpSchema';
 export * from './sdCardSchema';

package/esm/types/CamStreamerAPI/microsoftAzureSchema.js

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

package/esm/types/CamStreamerAPI/microsoftStreamSchema.js

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

package/esm/types/CamStreamerAPI/srtSchema.js

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

package/esm/types/CamStreamerAPI/streamCommonTypes.js

@@ -1,12 +1,25 @@
 import { z } from 'zod';
+import { booleanSchema } from '../common';
 export const streamTypeSchema = z.union([
     z.literal('youtube'),
     z.literal('facebook'),
     z.literal('sd_card'),
     z.literal('windy'),
     z.literal('mpeg_dvb'),
-    z.literal('hls'),
     z.literal('rtmp'),
+    z.literal('dailymotion'),
+    z.literal('ibm'),
+    z.literal('hls_pull'),
+    z.literal('hls_push'),
+    z.literal('wowza'),
+    z.literal('microsoft_stream'),
+    z.literal('microsoft_azure'),
+    z.literal('vimeo'),
+    z.literal('twitch'),
+    z.literal('church'),
+    z.literal('srt'),
+    z.literal('da_cast'),
+    z.literal('game_changer'),
 ]);
 const scheduleSchema = z.object({
     start: z.object({
@@ -30,10 +43,22 @@ export const streamTriggerSchema = z.discriminatedUnion('type', [
         schedule: z.array(scheduleSchema),
     }),
 ]);
+export const streamInputTypeSchema = z.union([z.literal('CSw'), z.literal('CRS'), z.literal('RTSP_URL')]);
+export const internalVapixParametersSchema = z.object({
+    camera: z.string(),
+    resolution: z.string().optional(),
+    compression: z.number().optional(),
+    fps: z.number().int().optional(),
+    videobitrate: z.number().int().optional(),
+    videomaxbitrate: z.number().int().optional(),
+    audio: booleanSchema.optional(),
+});
 export const streamCommonSchema = z.object({
     id: z.number(),
     enabled: z.boolean(),
     active: z.boolean(),
     title: z.string(),
     trigger: streamTriggerSchema,
+    inputType: streamInputTypeSchema,
+    internalVapixParameters: internalVapixParametersSchema,
 });

package/esm/types/CamStreamerAPI/twitchSchema.js

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

package/esm/types/CamStreamerAPI/vimeoSchema.js

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

package/esm/types/CamStreamerAPI/wowzaSchema.js

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

package/esm/types/CamStreamerAPI/youtubeSchema.js

@@ -2,19 +2,4 @@ import z from 'zod';
 import { streamCommonSchema } from './streamCommonTypes';
 export const youtubeSchema = streamCommonSchema.extend({
     type: z.literal('youtube'),
-    description: z.string().optional(),
-    playlist: z.string().optional(),
-    tags: z.array(z.string()),
-    notificationEmail: z.array(z.string().email()).optional(),
-    streamPrivacy: z.union([z.literal('public'), z.literal('unlisted'), z.literal('private')]),
-    latency: z.union([z.literal('normal'), z.literal('low'), z.literal('ultra_low')]),
-    afterEndStatus: z.union([z.literal('no_change'), z.literal('public'), z.literal('unlisted'), z.literal('private')]),
-    cameraLedStatus: z.boolean(),
-    dvr: z.boolean(),
-    saveToSdCard: z.boolean(),
-    statusCameraLed: z.boolean(),
-    statusCameraOutput: z.string(),
-    hasWatchdogs: z.boolean(),
-    countdown: z.boolean(),
-    enableManualControl: z.boolean(),
 });

package/package.json

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