camstreamerlib 4.0.0-beta.11 → 4.0.0-beta.111

package/esm/types/CamStreamerAPI/facebookSchema.js

@@ -0,0 +1,21 @@
+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({
+    postLocation: z.literal('timeline'),
+    streamPrivacy: facebookStreamPrivacySchema,
+});
+const pagePost = z.object({
+    postLocation: z.literal('page'),
+    page: z.string(),
+});
+export const facebookSchema = streamCommonSchema.extend({
+    type: 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]),
+});

package/esm/types/CamStreamerAPI/gameChangerSchema.js

@@ -0,0 +1,5 @@
+import z from 'zod';
+import { commonRtmpSchema } from './rtmpSchema';
+export const gameChangerSchema = commonRtmpSchema.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/ibmSchema.js

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

package/esm/types/CamStreamerAPI/index.js

@@ -0,0 +1,10 @@
+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';

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/mpegDvbSchema.js

@@ -0,0 +1,21 @@
+import z from 'zod';
+import { streamCommonSchema } from './streamCommonTypes';
+export const mpegDvbSchema = streamCommonSchema.extend({
+    type: z.literal('mpeg_dvb'),
+    ipAddress: z.string(),
+    port: z.number(),
+    standard: z.enum(['DVB', 'ATSC']),
+    nullPacketsPaddingEnabled: z.boolean(),
+    nullPacketsPaddingKbps: z.number(),
+    videoPid: z.number(),
+    audioPid: z.number(),
+    mpegtsStreamId: z.number(),
+    pmtPid: z.number(),
+    pcrPid: z.number(),
+    pcrPeriodMs: z.number(),
+    providerName: z.string(),
+    serviceName: z.string(),
+    statusCameraLed: z.boolean(),
+    statusCameraOutput: z.string().nullable(),
+    saveToSdCard: z.boolean(),
+});

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({
+    id: 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/rtmpSchema.js

@@ -0,0 +1,13 @@
+import z from 'zod';
+import { streamCommonSchema } from './streamCommonTypes';
+export const commonRtmpSchema = streamCommonSchema.extend({
+    outputUrl: z.string(),
+    streamKey: z.string(),
+    streamIdentifier: z.string().optional(),
+    saveToSdCard: z.boolean(),
+    statusCameraLed: z.boolean(),
+    statusCameraOutput: z.string().nullable(),
+});
+export const rtmpSchema = commonRtmpSchema.extend({
+    type: z.literal('rtmp'),
+});

package/esm/types/CamStreamerAPI/sdCardSchema.js

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

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

@@ -0,0 +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() }),
+    z.object({
+        type: z.literal('recurrent'),
+        schedule: z.array(scheduleSchema),
+    }),
+]);
+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(),
+    resolution: z.string(),
+    fps: z.number().int(),
+    compression: z.number().int(),
+    govLength: z.number().int(),
+    videoCodec: videoCodecSchema,
+    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(),
+});
+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,
+});

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/windySchema.js

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

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/youtubeRtmpSchema.js

@@ -0,0 +1,5 @@
+import z from 'zod';
+import { commonRtmpSchema } from './rtmpSchema';
+export const youtubeRtmpSchema = commonRtmpSchema.extend({
+    type: z.literal('youtube_rtmp'),
+});

package/esm/types/CamStreamerAPI/youtubeSchema.js

@@ -0,0 +1,19 @@
+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')]),
+    dvr: z.boolean(),
+    saveToSdCard: z.boolean(),
+    statusCameraLed: z.boolean(),
+    statusCameraOutput: z.string().nullable(),
+    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(),
+}));