camstreamerlib 4.0.0-beta.12 → 4.0.0-beta.120

package/esm/types/CamStreamerAPI/CamStreamerAPI.js

@@ -0,0 +1,121 @@
+import { z } from 'zod';
+import { facebookSchema } from './facebookSchema';
+import { windySchema } from './windySchema';
+import { youtubeSchema } from './youtubeSchema';
+import { churchSchema, daCastSchema, dailymotionSchema, gameChangerSchema, hlsPullSchema, hlsPushSchema, ibmSchema, microsoftAzureSchema, microsoftStreamSchema, mpegDvbSchema, rtmpSchema, sdCardSchema, srtSchema, twitchSchema, vimeoSchema, wowzaSchema, youtubeRtmpSchema, } from './streamsSchema';
+import { fileSchema } from '../common';
+export const streamSchema = z.discriminatedUnion('platform', [
+    facebookSchema,
+    mpegDvbSchema,
+    rtmpSchema,
+    sdCardSchema,
+    windySchema,
+    youtubeSchema,
+    vimeoSchema,
+    twitchSchema,
+    churchSchema,
+    srtSchema,
+    daCastSchema,
+    hlsPullSchema,
+    hlsPushSchema,
+    wowzaSchema,
+    dailymotionSchema,
+    ibmSchema,
+    microsoftAzureSchema,
+    microsoftStreamSchema,
+    gameChangerSchema,
+    youtubeRtmpSchema,
+]);
+export const streamListSchema = z.object({ streamList: z.array(streamSchema) });
+export const isFacebookStream = (stream) => {
+    return stream.platform === 'facebook';
+};
+export const isMpegDvbStream = (stream) => {
+    return stream.platform === 'mpeg_dvb';
+};
+export const isRtmpStream = (stream) => {
+    return stream.platform === 'rtmp';
+};
+export const isSdCardStream = (stream) => {
+    return stream.platform === 'sd_card';
+};
+export const isWindyStream = (stream) => {
+    return stream.platform === 'windy';
+};
+export const isYouTubeStream = (stream) => {
+    return stream.platform === 'youtube';
+};
+export const isVimeoStream = (stream) => {
+    return stream.platform === 'vimeo';
+};
+export const isTwitchStream = (stream) => {
+    return stream.platform === 'twitch';
+};
+export const isChurchStream = (stream) => {
+    return stream.platform === 'church';
+};
+export const isSrtStream = (stream) => {
+    return stream.platform === 'srt';
+};
+export const isDaCastStream = (stream) => {
+    return stream.platform === 'da_cast';
+};
+export const isHlsPullStream = (stream) => {
+    return stream.platform === 'hls_pull';
+};
+export const isHlsPushStream = (stream) => {
+    return stream.platform === 'hls_push';
+};
+export const isWowzaStream = (stream) => {
+    return stream.platform === 'wowza';
+};
+export const isDailymotionStream = (stream) => {
+    return stream.platform === 'dailymotion';
+};
+export const isIbmStream = (stream) => {
+    return stream.platform === 'ibm';
+};
+export const isMicrosoftAzureStream = (stream) => {
+    return stream.platform === 'microsoft_azure';
+};
+export const isMicrosoftStream = (stream) => {
+    return stream.platform === 'microsoft_stream';
+};
+export const isGameChangerStream = (stream) => {
+    return stream.platform === 'game_changer';
+};
+export const isYoutubeRtmpStream = (stream) => {
+    return stream.platform === 'youtube_rtmp';
+};
+export var AudioType;
+(function (AudioType) {
+    AudioType[AudioType["MP3"] = 0] = "MP3";
+    AudioType[AudioType["AAC"] = 1] = "AAC";
+})(AudioType || (AudioType = {}));
+export const audioFileStorageTypeSchema = z.union([z.literal('flash'), z.literal('SD0'), z.literal('url')]);
+export const storageListSchema = z.array(z.discriminatedUnion('type', [
+    z.object({
+        type: z.literal('flash'),
+        flash: z.string(),
+    }),
+    z.object({
+        type: z.literal('SD0'),
+        SD0: z.string(),
+    }),
+]));
+export const audioFileSchema = z.object({
+    name: z.string(),
+    path: z.string(),
+    storage: audioFileStorageTypeSchema,
+});
+export const audioFileListSchema = z.array(audioFileSchema);
+export const audioUrlSchema = z.object({
+    fileUrl: z.string(),
+    name: z.string(),
+    storage: z.literal('url'),
+});
+export const audioLocalSchema = z.object({
+    file: fileSchema,
+    name: z.string(),
+    storage: z.enum(['flash', 'SD0']),
+});

package/esm/types/CamStreamerAPI/facebookSchema.js

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

package/esm/types/CamStreamerAPI/index.js

@@ -0,0 +1,6 @@
+export * from './CamStreamerAPI';
+export * from './streamCommonTypes';
+export * from './facebookSchema';
+export * from './windySchema';
+export * from './youtubeSchema';
+export * from './streamsSchema';

package/esm/types/CamStreamerAPI/oldStreamSchema.js

@@ -0,0 +1,50 @@
+import { z } from 'zod';
+export const oldStringStreamSchema = z.object({
+    enabled: z.string(),
+    active: z.string(),
+    audioSource: z.string(),
+    avSyncMsec: z.string(),
+    internalVapixParameters: z.string(),
+    userVapixParameters: z.string(),
+    outputParameters: z.string(),
+    outputType: z.string(),
+    mediaServerUrl: z.string(),
+    inputType: z.string(),
+    inputUrl: z.string(),
+    forceStereo: z.string(),
+    streamDelay: z.string(),
+    statusLed: z.string(),
+    statusPort: z.string(),
+    callApi: z.string(),
+    trigger: z.string(),
+    schedule: z.string(),
+    prepareAhead: z.string(),
+    startTime: z.string(),
+    stopTime: z.string(),
+});
+export const oldStringStreamSchemaWithId = oldStringStreamSchema.extend({
+    streamId: z.string(),
+});
+export const oldStreamSchema = z.object({
+    enabled: z.union([z.literal(0), z.literal(1)]),
+    active: z.union([z.literal(0), z.literal(1)]),
+    audioSource: z.string(),
+    avSyncMsec: z.number().int(),
+    internalVapixParameters: z.string(),
+    userVapixParameters: z.string(),
+    outputParameters: z.string(),
+    outputType: z.union([z.literal('video'), z.literal('images'), z.literal('none')]),
+    mediaServerUrl: z.string(),
+    inputType: z.union([z.literal('CSw'), z.literal('CRS'), z.literal('RTSP_URL')]),
+    inputUrl: z.string(),
+    forceStereo: z.union([z.literal(0), z.literal(1)]),
+    streamDelay: z.number().nullable(),
+    statusLed: z.number(),
+    statusPort: z.string(),
+    callApi: z.number().int(),
+    trigger: z.string(),
+    schedule: z.string(),
+    prepareAhead: z.number().int(),
+    startTime: z.number().nullable(),
+    stopTime: z.number().nullable(),
+});

package/esm/types/CamStreamerAPI/streamCommonTypes.js

@@ -0,0 +1,106 @@
+import { z } from 'zod';
+import { bitrateVapixParamsSchema, booleanSchema, h264ProfileSchema } from '../common';
+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'),
+            port: z.number().optional(),
+        }),
+        z.object({
+            type: z.literal('onetime'),
+            startTime: z.number(),
+            stopTime: z.number(),
+            prepareAheadS: z.number().int().optional(),
+        }),
+        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(),
+            })),
+            prepareAheadS: z.number().int().optional(),
+        }),
+    ]),
+    video: z.object({
+        output: z.object({
+            type: z.union([z.literal('video'), z.literal('images')]),
+            url: z.string().nullable(),
+            parameters: z.string(),
+        }),
+        input: z.discriminatedUnion('type', [
+            z.object({
+                type: z.literal('RTSP_URL'),
+                url: z.string(),
+            }),
+            z.object({
+                type: z.literal('CSw'),
+            }),
+            z.object({
+                type: z.literal('CRS'),
+                streamingProtocol: z.union([z.literal('RTMP'), z.literal('RTMPS'), z.literal('HLS_PUSH')]),
+                internalVapixParameters: z.string(),
+                userVapixParameters: z.string(),
+            }),
+        ]),
+        delayS: z.number().int().nonnegative().optional(),
+    }),
+    audio: z.discriminatedUnion('source', [
+        z.object({
+            source: z.literal('none'),
+        }),
+        z.object({
+            source: z.literal('microphone'),
+            audioChannelNbr: z.union([z.literal(1), z.literal(2)]),
+            forceStereo: z.boolean(),
+        }),
+        z.object({
+            source: z.literal('file'),
+            name: z.string(),
+            path: z.string(),
+            forceStereo: z.boolean(),
+        }),
+        z.object({
+            source: z.literal('url'),
+            name: z.string(),
+            url: z.string(),
+            avSyncMsec: z.number().int().nonnegative(),
+            forceStereo: z.boolean(),
+        }),
+    ]),
+    status: z.object({
+        led: z.boolean(),
+        port: z.number().optional(),
+    }),
+});
+export const internalVapixParametersSchema = bitrateVapixParamsSchema.extend({
+    camera: z.string(),
+    resolution: z.string(),
+    fps: z.number().int(),
+    compression: z.number().int(),
+    govLength: z.number().int(),
+    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(),
+    overlays: z
+        .union([
+        z.literal('all'),
+        z.literal('text'),
+        z.literal('image'),
+        z.literal('application'),
+        z.literal(''),
+        z.literal('off'),
+    ])
+        .optional(),
+});

package/esm/types/CamStreamerAPI/streamsSchema.js

@@ -0,0 +1,57 @@
+import z from 'zod';
+import { streamCommonSchema } from './streamCommonTypes';
+export const commonRtmpSchema = streamCommonSchema.extend({
+    streamKey: z.string(),
+    streamIdentifier: z.string().optional(),
+});
+export const churchSchema = streamCommonSchema.extend({
+    platform: z.literal('church'),
+});
+export const daCastSchema = streamCommonSchema.extend({
+    platform: z.literal('da_cast'),
+});
+export const dailymotionSchema = streamCommonSchema.extend({
+    platform: z.literal('dailymotion'),
+});
+export const gameChangerSchema = commonRtmpSchema.extend({
+    platform: z.literal('game_changer'),
+});
+export const hlsPullSchema = streamCommonSchema.extend({
+    platform: z.literal('hls_pull'),
+});
+export const hlsPushSchema = streamCommonSchema.extend({
+    platform: z.literal('hls_push'),
+});
+export const ibmSchema = streamCommonSchema.extend({
+    platform: z.literal('ibm'),
+});
+export const mpegDvbSchema = streamCommonSchema.extend({
+    platform: z.literal('mpeg_dvb'),
+});
+export const microsoftAzureSchema = streamCommonSchema.extend({
+    platform: z.literal('microsoft_azure'),
+});
+export const microsoftStreamSchema = streamCommonSchema.extend({
+    platform: z.literal('microsoft_stream'),
+});
+export const rtmpSchema = commonRtmpSchema.extend({
+    platform: z.literal('rtmp'),
+});
+export const sdCardSchema = streamCommonSchema.extend({
+    platform: z.literal('sd_card'),
+});
+export const srtSchema = streamCommonSchema.extend({
+    platform: z.literal('srt'),
+});
+export const twitchSchema = streamCommonSchema.extend({
+    platform: z.literal('twitch'),
+});
+export const vimeoSchema = streamCommonSchema.extend({
+    platform: z.literal('vimeo'),
+});
+export const wowzaSchema = streamCommonSchema.extend({
+    platform: z.literal('wowza'),
+});
+export const youtubeRtmpSchema = commonRtmpSchema.extend({
+    platform: z.literal('youtube_rtmp'),
+});

package/esm/types/CamStreamerAPI/windySchema.js

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

package/esm/types/CamStreamerAPI/youtubeSchema.js

@@ -0,0 +1,16 @@
+import z from 'zod';
+import { streamCommonSchema } from './streamCommonTypes';
+export const youtubeSchema = streamCommonSchema.extend({
+    platform: 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')]),
+    dvr: z.boolean(),
+    hasWatchdogs: z.boolean(),
+    countdown: z.boolean(),
+    enableManualControl: z.boolean(),
+});

package/esm/types/CamSwitcherAPI.js

@@ -1,6 +1,6 @@
 import { z } from 'zod';
 import { toCamelCase, toCamelCaseDeep } from '../internal/transformers';
-import { storageTypeSchema, keyboardShortcutsSchema, h264ProfileSchema, audioChannelCountSchema, } from './common';
+import { storageTypeSchema, keyboardShortcutsSchema, h264ProfileSchema, audioChannelCountSchema, keyboardShortcutSchema, bitrateVapixParamsSchema, } from './common';
 const channelTypeSchema = z.union([z.literal('audio'), z.literal('video'), z.literal('av')]);
 const playlistPlayTypeSchema = z.union([
     z.literal('PLAY_ALL'),
@@ -132,3 +132,33 @@ export const clipListSchema = z.object({
         ])),
     })),
 });
+export const cameraOptionsSchema = bitrateVapixParamsSchema
+    .extend({
+    resolution: z.string(),
+    h264Profile: h264ProfileSchema,
+    fps: z.number(),
+    compression: z.number().min(0).max(100),
+    govLength: z.number(),
+    bitrateVapixParams: z.string().nullable(),
+    audioSampleRate: z.number(),
+    audioChannelCount: audioChannelCountSchema,
+    keyboard: z.object({
+        fromSource: keyboardShortcutSchema,
+        none: keyboardShortcutSchema,
+    }),
+})
+    .partial();
+export const globalAudioSettingsTypeSchema = z.union([z.literal('fromSource'), z.literal('source')]);
+export const globalAudioSettingsSchema = z.object({
+    type: globalAudioSettingsTypeSchema,
+    source: z.string(),
+    storage: z.string().optional(),
+});
+export const secondaryAudioSettingsSchema = z.object({
+    type: z.union([z.literal('CLIP'), z.literal('STREAM'), z.literal('NONE')]),
+    streamName: z.string().optional(),
+    clipName: z.string().optional(),
+    storage: storageTypeSchema,
+    secondaryAudioLevel: z.number(),
+    masterAudioLevel: z.number(),
+});

package/esm/types/GenetecAgent.js

@@ -0,0 +1,28 @@
+import { z } from 'zod';
+export const successResponseSchema = z.object({
+    Rsp: z.object({
+        Status: z.literal('Ok'),
+    }),
+});
+export const cameraGuidsResponseSchema = z.object({
+    Rsp: z.object({
+        Status: z.literal('Ok'),
+        Result: z.array(z.object({ Guid: z.string() })),
+    }),
+});
+export const cameraDetailSchema = z.object({
+    Guid: z.string().optional(),
+    Name: z.string().optional(),
+    EntityType: z.string().optional(),
+});
+export const cameraDetailsResponseSchema = z.object({
+    Rsp: z.object({
+        Status: z.literal('Ok'),
+        Result: z.union([z.array(cameraDetailSchema), cameraDetailSchema]),
+    }),
+});
+export const cameraListSchema = z.array(z.object({
+    index: z.number(),
+    value: z.string(),
+    label: z.string(),
+}));