camstreamerlib 4.0.0-beta.16 → 4.0.0-beta.161

package/esm/types/CamScripterAPI.js

@@ -1,17 +1,29 @@
 import { z } from 'zod';
+import { flashStorageTypeSchema, sdCardStorageTypeSchema, storageTypeSchema } from './common';
+export const nodeStateSchema = z.object({
+    node_state: z.union([z.literal('OK'), z.literal('NOT_INSTALLED'), z.literal('NOT_FOUND')]),
+});
 export const packageInfoListSchema = z.array(z.object({
-    storage: z.union([z.literal('SD_CARD'), z.literal('INTERNAL')]),
+    storage: storageTypeSchema,
     manifest: z.object({
         package_name: z.string(),
         package_menu_name: z.string(),
         package_version: z.string(),
         vendor: z.string(),
-        required_camscripter_version: z.string(),
-        required_camscripter_rbi_version: z.string(),
+        required_camscripter_version: z.string().optional(),
+        required_camscripter_rbi_version: z.string().optional(),
         ui_link: z.string(),
     }),
 }));
-export const storageSchema = z.array(z.object({
-    type: z.union([z.literal('INTERNAL'), z.literal('SD_CARD')]),
-    capacity_mb: z.number(),
-}));
+export const packageConfigSchema = z.record(z.string(), z.object({ enabled: z.boolean() }));
+export const cameraStorageSchema = z.union([
+    z.tuple([
+        z.object({ type: flashStorageTypeSchema, capacity_mb: z.number() }),
+        z.object({ type: sdCardStorageTypeSchema, capacity_mb: z.number() }),
+    ]),
+    z.tuple([z.object({ type: flashStorageTypeSchema, capacity_mb: z.number() })]),
+]);
+export const camscripterApiResponseSchema = z.object({
+    status: z.number(),
+    message: z.string(),
+});

package/esm/types/CamScripterAPICameraEventsGenerator.js

@@ -0,0 +1 @@
+export {};

package/esm/types/CamStreamerAPI/CamStreamerAPI.js

@@ -0,0 +1,199 @@
+import { boolean, z } from 'zod';
+import { facebookSchema } from './facebookSchema';
+import { windySchema } from './windySchema';
+import { youtubeSchema } from './youtubeSchema';
+import { daCastSchema, dailymotionSchema, facebookRtmpSchema, gameChangerSchema, hlsPullSchema, hlsPushSchema, ibmSchema, microsoftAzureSchema, microsoftStreamSchema, mpegDvbSchema, rtmpSchema, sdCardSchema, srtSchema, streamPlatforms, twitchSchema, vimeoSchema, wowzaSchema, youtubeRtmpSchema, } from './streamsSchema';
+import { fileSchema } from '../common';
+export const streamSchema = z.discriminatedUnion('platform', [
+    facebookSchema,
+    facebookRtmpSchema,
+    mpegDvbSchema,
+    rtmpSchema,
+    sdCardSchema,
+    windySchema,
+    youtubeSchema,
+    vimeoSchema,
+    twitchSchema,
+    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 === streamPlatforms.facebook;
+};
+export const isFacebookRtmpStream = (stream) => {
+    return stream.platform === streamPlatforms.facebook_rtmp;
+};
+export const isMpegDvbStream = (stream) => {
+    return stream.platform === streamPlatforms.mpeg_dvb;
+};
+export const isRtmpStream = (stream) => {
+    return stream.platform === streamPlatforms.rtmp;
+};
+export const isSdCardStream = (stream) => {
+    return stream.platform === streamPlatforms.sd_card;
+};
+export const isWindyStream = (stream) => {
+    return stream.platform === streamPlatforms.windy;
+};
+export const isYouTubeStream = (stream) => {
+    return stream.platform === streamPlatforms.youtube;
+};
+export const isVimeoStream = (stream) => {
+    return stream.platform === streamPlatforms.vimeo;
+};
+export const isTwitchStream = (stream) => {
+    return stream.platform === streamPlatforms.twitch;
+};
+export const isSrtStream = (stream) => {
+    return stream.platform === streamPlatforms.srt;
+};
+export const isDaCastStream = (stream) => {
+    return stream.platform === streamPlatforms.da_cast;
+};
+export const isHlsPullStream = (stream) => {
+    return stream.platform === streamPlatforms.hls_pull;
+};
+export const isHlsPushStream = (stream) => {
+    return stream.platform === streamPlatforms.hls_push;
+};
+export const isWowzaStream = (stream) => {
+    return stream.platform === streamPlatforms.wowza;
+};
+export const isDailymotionStream = (stream) => {
+    return stream.platform === streamPlatforms.dailymotion;
+};
+export const isIbmStream = (stream) => {
+    return stream.platform === streamPlatforms.ibm;
+};
+export const isMicrosoftAzureStream = (stream) => {
+    return stream.platform === streamPlatforms.microsoft_azure;
+};
+export const isMicrosoftStream = (stream) => {
+    return stream.platform === streamPlatforms.microsoft_stream;
+};
+export const isGameChangerStream = (stream) => {
+    return stream.platform === streamPlatforms.game_changer;
+};
+export const isYoutubeRtmpStream = (stream) => {
+    return stream.platform === streamPlatforms.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']),
+});
+export const streamStatsSchema = z.object({
+    net_stats: z.string(),
+    stream_bytes_time_ms: z.number().nonnegative(),
+    stream_bytes: z.number().nonnegative(),
+    start_count: z.number().nonnegative(),
+    is_streaming: z.literal(0).or(z.literal(1)),
+});
+export const srtStreamStatisticsSchema = z.object({
+    msTimeStamp: z.number().nonnegative(),
+    pktSentTotal: z.number().nonnegative(),
+    byteSentTotal: z.number().nonnegative(),
+    pktRetransTotal: z.number().nonnegative(),
+    byteRetransTotal: z.number().nonnegative(),
+    pktSndDropTotal: z.number().nonnegative(),
+    byteSndDropTotal: z.number().nonnegative(),
+    mbpsSendRate: z.number().nonnegative(),
+    mbpsBandwidth: z.number().nonnegative(),
+    mbpsMaxBW: z.number().nonnegative(),
+    msRTT: z.number().nonnegative(),
+    msSndBuf: z.number().nonnegative(),
+});
+export const diagnosticsParamsSchema = z.object({
+    camerainfo: boolean().optional(),
+    checkserver: boolean().optional(),
+    checkservertime: boolean().optional(),
+    speedtest: boolean().optional(),
+    pingtest: boolean().optional(),
+    videoHostPort: z.string().optional(),
+    audioHostPort: z.string().optional(),
+});
+export const diagnosticsSchema = z.object({
+    status: z.number(),
+    message: z.string(),
+    data: z.object({
+        audioHostPort: z
+            .object({
+            code: z.number(),
+            message: z.string(),
+        })
+            .optional(),
+        cameraInfo: z
+            .object({
+            uptime: z.string(),
+            availableRAM: z.number(),
+            availableInternal: z.number(),
+        })
+            .optional(),
+        checkServer: z
+            .object({
+            state: z.string(),
+            message: z.string(),
+        })
+            .optional(),
+        checkServerTime: z
+            .object({
+            code: z.number(),
+            message: z.string(),
+        })
+            .optional(),
+        videoHostPort: z
+            .object({
+            code: z.number(),
+            message: z.string(),
+        })
+            .optional(),
+        speedTest: z
+            .object({
+            code: z.string(),
+            data: z.array(z.object({ timestamp: z.number(), speed: z.number() })),
+        })
+            .optional(),
+        pingTest: z
+            .object({
+            output: z.string(),
+        })
+            .optional(),
+    }),
+});

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,120 @@
+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(),
+            everActivated: z.boolean(),
+            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.discriminatedUnion('type', [
+            z.object({
+                type: z.literal('video'),
+                url: z.string().nullable(),
+                parameters: z.string(),
+                saveToSdCard: z
+                    .object({
+                    ruleId: z.string(),
+                    configurationId: z.string(),
+                })
+                    .optional(),
+            }),
+            z.object({
+                type: z.literal('images'),
+                url: z.string().nullable(),
+                imageIntervalS: z.number(),
+            }),
+            z.object({
+                type: z.literal('none'),
+                saveToSdCard: z.object({
+                    ruleId: z.string(),
+                    configurationId: z.string(),
+                }),
+            }),
+        ]),
+        input: z.discriminatedUnion('type', [
+            z.object({
+                type: z.literal('RTSP_URL'),
+                url: z.string(),
+                internalVapixParameters: z.string(),
+            }),
+            z.object({
+                type: z.literal('CSw'),
+            }),
+            z.object({
+                type: z.literal('CRS'),
+                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.number().int(),
+            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('off')])
+        .optional(),
+});

package/esm/types/CamStreamerAPI/streamsSchema.js

@@ -0,0 +1,75 @@
+import z from 'zod';
+import { streamCommonSchema } from './streamCommonTypes';
+export const streamPlatforms = {
+    da_cast: 'da_cast',
+    dailymotion: 'dailymotion',
+    facebook_rtmp: 'facebook_rtmp',
+    game_changer: 'game_changer',
+    hls_pull: 'hls_pull',
+    hls_push: 'hls_push',
+    ibm: 'ibm',
+    mpeg_dvb: 'mpeg_dvb',
+    microsoft_azure: 'microsoft_azure',
+    microsoft_stream: 'microsoft_stream',
+    rtmp: 'rtmp',
+    sd_card: 'sd_card',
+    srt: 'srt',
+    twitch: 'twitch',
+    vimeo: 'vimeo',
+    wowza: 'wowza',
+    youtube_rtmp: 'youtube_rtmp',
+    windy: 'windy',
+    youtube: 'youtube',
+    facebook: 'facebook',
+};
+export const daCastSchema = streamCommonSchema.extend({
+    platform: z.literal(streamPlatforms.da_cast),
+});
+export const dailymotionSchema = streamCommonSchema.extend({
+    platform: z.literal(streamPlatforms.dailymotion),
+});
+export const facebookRtmpSchema = streamCommonSchema.extend({
+    platform: z.literal(streamPlatforms.facebook_rtmp),
+});
+export const gameChangerSchema = streamCommonSchema.extend({
+    platform: z.literal(streamPlatforms.game_changer),
+});
+export const hlsPullSchema = streamCommonSchema.extend({
+    platform: z.literal(streamPlatforms.hls_pull),
+});
+export const hlsPushSchema = streamCommonSchema.extend({
+    platform: z.literal(streamPlatforms.hls_push),
+});
+export const ibmSchema = streamCommonSchema.extend({
+    platform: z.literal(streamPlatforms.ibm),
+});
+export const mpegDvbSchema = streamCommonSchema.extend({
+    platform: z.literal(streamPlatforms.mpeg_dvb),
+});
+export const microsoftAzureSchema = streamCommonSchema.extend({
+    platform: z.literal(streamPlatforms.microsoft_azure),
+});
+export const microsoftStreamSchema = streamCommonSchema.extend({
+    platform: z.literal(streamPlatforms.microsoft_stream),
+});
+export const rtmpSchema = streamCommonSchema.extend({
+    platform: z.literal(streamPlatforms.rtmp),
+});
+export const sdCardSchema = streamCommonSchema.extend({
+    platform: z.literal(streamPlatforms.sd_card),
+});
+export const srtSchema = streamCommonSchema.extend({
+    platform: z.literal(streamPlatforms.srt),
+});
+export const twitchSchema = streamCommonSchema.extend({
+    platform: z.literal(streamPlatforms.twitch),
+});
+export const vimeoSchema = streamCommonSchema.extend({
+    platform: z.literal(streamPlatforms.vimeo),
+});
+export const wowzaSchema = streamCommonSchema.extend({
+    platform: z.literal(streamPlatforms.wowza),
+});
+export const youtubeRtmpSchema = streamCommonSchema.extend({
+    platform: z.literal(streamPlatforms.youtube_rtmp),
+});

package/esm/types/CamStreamerAPI/windySchema.js

@@ -0,0 +1,13 @@
+import z from 'zod';
+import { streamCommonSchema } from './streamCommonTypes';
+export const windySchema = streamCommonSchema.extend({
+    platform: z.literal('windy'),
+    locationLat: z.number(),
+    locationLon: z.number(),
+    locationName: z.string(),
+    locationAddress: z.string(),
+    mapZoom: z.number(),
+    direction: z.enum(['N', 'NE', 'E', 'SE', 'S', 'SW', 'W', 'NW']).nullable(),
+    position: z.union([z.literal('fix'), z.literal('rotating'), z.literal('controllable')]),
+    webPageUrl: z.string(),
+});

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(),
+    playlists: z.array(z.string()),
+    tags: z.array(z.string()),
+    notificationEmails: z.array(z.string().email()),
+    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().optional(),
+    streamingProtocol: z.union([z.literal('RTMP'), z.literal('RTMPS'), z.literal('HLS')]),
+});

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,40 @@ 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(),
+});
+export const clipFilesListSchema = z.object({
+    status: z.number(),
+    message: z.string(),
+    data: z.object({
+        files: z.array(z.string()),
+    }),
+});

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(),
+}));