camstreamerlib 4.0.0-beta.9 → 4.0.0-beta.91

package/esm/{models → types}/CamOverlayAPI/pipSchema.js

@@ -1,8 +1,7 @@
-import { allowedWidgetNames } from './constants';
-import { coordinateSystemSchema, widgetCommonSchema } from './widgetCommonSchema';
 import { z } from 'zod';
-export const pipSchema = widgetCommonSchema.extend({
-    name: z.literal(allowedWidgetNames.pip),
+import { serviceNames, coordinateSystemSchema, serviceCommonSchema } from './serviceCommonTypes';
+export const pipSchema = serviceCommonSchema.extend({
+    name: z.literal(serviceNames.pip),
     coordSystem: coordinateSystemSchema,
     pos_x: z.number(),
     pos_y: z.number(),
@@ -25,7 +24,7 @@ export const pipSchema = widgetCommonSchema.extend({
         z.literal('overlays=image'),
         z.literal('overlays=application'),
     ]),
-    rotate: z.union([z.literal(0), z.literal(90), z.literal(180), z.literal(270)]),
+    rotate: z.union([z.literal(0), z.literal(90), z.literal(180), z.literal(270)]).default(0),
     dewarping: z.object({
         enabled: z.boolean(),
         rectangle: z.array(z.tuple([z.number(), z.number()])),

package/esm/{models → types}/CamOverlayAPI/ptzCompassSchema.js

@@ -1,8 +1,7 @@
-import { allowedWidgetNames } from './constants';
-import { coordinateSystemSchema, widgetCommonSchema } from './widgetCommonSchema';
 import { z } from 'zod';
-export const ptzCompassSchema = widgetCommonSchema.extend({
-    name: z.literal(allowedWidgetNames.ptzCompass),
+import { serviceNames, coordinateSystemSchema, serviceCommonSchema } from './serviceCommonTypes';
+export const ptzCompassSchema = serviceCommonSchema.extend({
+    name: z.literal(serviceNames.ptzCompass),
     pos_x: z.number(),
     pos_y: z.number(),
     coordSystem: coordinateSystemSchema,
@@ -20,4 +19,5 @@ export const ptzCompassSchema = widgetCommonSchema.extend({
     generalIframeWidth: z.number().optional(),
     generalIframeHeight: z.number().optional(),
     generalAddress: z.string().optional(),
+    showDegrees: z.boolean().default(false),
 });

package/esm/types/CamOverlayAPI/ptzSchema.js

@@ -0,0 +1,9 @@
+import { z } from 'zod';
+import { serviceNames, overlaySchema, serviceCommonSchema } from './serviceCommonTypes';
+export const ptzSchema = serviceCommonSchema.extend({
+    name: z.literal(serviceNames.ptz),
+    ptz_positions: z.record(z.string(), z.object({
+        overlayList: z.array(overlaySchema.omit({ active: true, fps: true })),
+        loop: z.boolean(),
+    })),
+});

package/esm/types/CamOverlayAPI/scoreBoardSchema.js

@@ -0,0 +1,129 @@
+import { z } from 'zod';
+import { coordinateSystemSchema, serviceNames } from './serviceCommonTypes';
+export const sportFontSchema = z.union([
+    z.literal('classic'),
+    z.custom((val) => {
+        return typeof val === 'string';
+    }),
+]);
+export const scoreBoardSchema = z.object({
+    id: z.number().nonnegative(),
+    enabled: z.union([z.literal(0), z.literal(1)]),
+    schedule: z.string().optional(),
+    cameraList: z.array(z.number()),
+    zIndex: z.number().nonnegative(),
+    name: z.literal(serviceNames.scoreBoard),
+    pos_x: z.number(),
+    pos_y: z.number(),
+    coordSystem: coordinateSystemSchema,
+    width: z.number(),
+    height: z.number(),
+    scale: z.number(),
+    teamHomeShortname: z.string(),
+    teamGuestShortname: z.string(),
+    teamHomeBackgroundColor: z.string(),
+    teamGuestBackgroundColor: z.string(),
+    teamHomeTextColor: z.string(),
+    teamGuestTextColor: z.string(),
+    teamHomeImgPath: z.string(),
+    teamGuestImgPath: z.string(),
+    teamHomeCurrentScore: z.number(),
+    teamGuestCurrentScore: z.number(),
+    baseTimeTimestamp: z.number(),
+    baseTimePlaytime: z.number(),
+    currentPeriodPlaytime: z.number(),
+    timeIsRunning: z.boolean(),
+    currentPeriodLength: z.number(),
+    currentPeriod: z.number(),
+    font: sportFontSchema.default('classic'),
+});
+export const baseballScoreBoardSchema = z.object({
+    id: z.number().nonnegative(),
+    enabled: z.union([z.literal(0), z.literal(1)]),
+    schedule: z.string().optional(),
+    cameraList: z.array(z.number()),
+    zIndex: z.number().nonnegative(),
+    name: z.literal(serviceNames.baseballScoreBoard),
+    pos_x: z.number(),
+    pos_y: z.number(),
+    coordSystem: coordinateSystemSchema,
+    width: z.number(),
+    height: z.number(),
+    scale: z.number(),
+    matchFinished: z.boolean(),
+    bases: z.tuple([z.boolean(), z.boolean(), z.boolean()]),
+    homeInning: z.boolean(),
+    inning: z.number().nonnegative(),
+    outs: z.number().nonnegative(),
+    balls: z.number().nonnegative(),
+    strikes: z.number().nonnegative(),
+    baseTimeTimestamp: z.number(),
+    baseTimePlaytime: z.number(),
+    timeIsRunning: z.boolean(),
+    teamHomeShortname: z.string(),
+    teamGuestShortname: z.string(),
+    teamHomeBackgroundColor: z.string(),
+    teamGuestBackgroundColor: z.string(),
+    teamHomeTextColor: z.string(),
+    teamGuestTextColor: z.string(),
+    teamHomeCurrentScore: z.number(),
+    teamGuestCurrentScore: z.number(),
+    footerImgPath: z.string().optional(),
+    footerText: z.string().optional(),
+    footerBackgroundColor: z.string().optional(),
+    footerTextColor: z.string().optional(),
+    font: sportFontSchema.default('classic'),
+});
+export const baseballScoreBoardAutomaticSchema = z.object({
+    id: z.number().nonnegative(),
+    enabled: z.union([z.literal(0), z.literal(1)]),
+    schedule: z.string().optional(),
+    cameraList: z.array(z.number()),
+    zIndex: z.number().nonnegative(),
+    name: z.literal(serviceNames.myBallBaseballWidgets),
+    width: z.number(),
+    height: z.number(),
+    scale: z.number(),
+    matchDetailLink: z.string(),
+    matchListLink: z.string(),
+    mirrored: z.boolean(),
+    pregameWidgetText: z.string(),
+    teamHomeBackgroundColor: z.string(),
+    teamGuestBackgroundColor: z.string(),
+    teamHomeTextColor: z.string(),
+    teamGuestTextColor: z.string(),
+    homeLogoPath: z.string(),
+    guestLogoPath: z.string(),
+    footerImgPath: z.string().optional(),
+    footerText: z.string().optional(),
+    footerBackgroundColor: z.string().optional(),
+    footerTextColor: z.string().optional(),
+    font: sportFontSchema.default('classic'),
+});
+export const scoreOverviewSchema = z.object({
+    id: z.number().nonnegative(),
+    enabled: z.union([z.literal(0), z.literal(1)]),
+    cameraList: z.array(z.number()),
+    zIndex: z.number().nonnegative(),
+    name: z.literal(serviceNames.scoreOverview),
+    pos_x: z.number(),
+    pos_y: z.number(),
+    coordSystem: coordinateSystemSchema,
+    width: z.number(),
+    height: z.number(),
+    scale: z.number(),
+    teamHomeName: z.string(),
+    teamGuestName: z.string(),
+    teamHomeBackgroundColor: z.string(),
+    teamGuestBackgroundColor: z.string(),
+    teamHomeTextColor: z.string(),
+    teamGuestTextColor: z.string(),
+    teamHomeImgPath: z.string(),
+    teamGuestImgPath: z.string(),
+    teamHomeCurrentScore: z.number(),
+    teamGuestCurrentScore: z.number(),
+    scoreVisible: z.boolean(),
+    description: z.string(),
+    textFont: sportFontSchema.default('classic'),
+    scoreFont: z.literal('classic'),
+});

package/esm/types/CamOverlayAPI/screenSharingSchema.js

@@ -0,0 +1,5 @@
+import { z } from 'zod';
+import { serviceNames, sharingSchema } from './serviceCommonTypes';
+export const screenSharingSchema = sharingSchema.extend({
+    name: z.literal(serviceNames.screenSharing),
+});

package/esm/{models/CamOverlayAPI/widgetCommonSchema.js → types/CamOverlayAPI/serviceCommonTypes.js}

@@ -1,4 +1,19 @@
 import { z } from 'zod';
+export const serviceNames = {
+    accuweather: 'accuweather',
+    infoticker: 'infoticker',
+    customGraphics: 'customGraphics',
+    ptzCompass: 'ptzCompass',
+    images: 'images',
+    ptz: 'ptz',
+    pip: 'pip',
+    screenSharing: 'screenSharing',
+    web_camera: 'web_camera',
+    scoreBoard: 'scoreBoard',
+    baseballScoreBoard: 'baseballScoreBoard',
+    myBallBaseballWidgets: 'myBallBaseballWidgets',
+    scoreOverview: 'scoreOverview',
+};
 export const coordinateSystemSchema = z.union([
     z.literal('top_left'),
     z.literal('top'),
@@ -25,7 +40,15 @@ export const languageSchema = z.union([
     z.literal('ru-ru'),
     z.literal('sv-se'),
 ]);
-export const widgetCommonSchema = z.object({
+export const fontSchema = z.union([
+    z.literal('classic'),
+    z.literal('digital'),
+    z.custom((val) => {
+        return typeof val === 'string';
+    }),
+]);
+export const weatherUnitSchema = z.union([z.literal('Metric'), z.literal('Imperial')]);
+export const serviceCommonSchema = z.object({
     id: z.number().nonnegative(),
     enabled: z.union([z.literal(0), z.literal(1)]),
     automationType: z.union([
@@ -40,19 +63,18 @@ export const widgetCommonSchema = z.object({
     cameraList: z.array(z.number()),
     camera: z.number().nonnegative().optional(),
     schedule: z.string().optional(),
-    customName: z.string(),
+    customName: z.string().default(''),
     zIndex: z.number().optional(),
     width: z.number().nonnegative(),
     height: z.number().nonnegative(),
 });
-export const fontSchema = z.union([
-    z.literal('classic'),
-    z.literal('digital'),
-    z.custom((val) => {
-        return typeof val === 'string';
-    }),
-]);
-export const weatherUnitSchema = z.union([z.literal('Metric'), z.literal('Imperial')]);
+export const sharingSchema = serviceCommonSchema.extend({
+    pos_x: z.number().nonnegative(),
+    pos_y: z.number().nonnegative(),
+    coordSystem: coordinateSystemSchema,
+    screenSize: z.number().positive(),
+    fps: z.number(),
+});
 export const overlaySchema = z.object({
     active: z.boolean(),
     coordSystem: coordinateSystemSchema,
@@ -64,10 +86,3 @@ export const overlaySchema = z.object({
     scale: z.number(),
     fps: z.number().optional(),
 });
-export const sharingSchema = widgetCommonSchema.extend({
-    pos_x: z.number().nonnegative(),
-    pos_y: z.number().nonnegative(),
-    coordSystem: coordinateSystemSchema,
-    screenSize: z.number().positive(),
-    fps: z.number(),
-});

package/esm/types/CamOverlayAPI/webCameraSharingSchema.js

@@ -0,0 +1,5 @@
+import { z } from 'zod';
+import { serviceNames, sharingSchema } from './serviceCommonTypes';
+export const webCameraSharingSchema = sharingSchema.extend({
+    name: z.literal(serviceNames.web_camera),
+});

package/esm/types/CamOverlayDrawingAPI.js

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

package/esm/types/CamOverlayPainter.js

@@ -0,0 +1,11 @@
+export const COORD = {
+    top_left: [-1, -1],
+    center_left: [-1, 0],
+    bottom_left: [-1, 1],
+    top_center: [0, -1],
+    center: [0, 0],
+    bottom_center: [0, 1],
+    top_right: [1, -1],
+    center_right: [1, 0],
+    bottom_right: [1, 1],
+};

package/esm/types/CamScripterAPI.js

@@ -1,17 +1,33 @@
 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(),
+});
+export const cameraTimeResponseSchema = z.object({
+    state: z.boolean(),
+    code: z.number(),
+});

package/esm/types/CamScripterAPICameraEventsGenerator.js

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

package/esm/types/CamStreamerAPI/CamStreamerAPI.js

@@ -0,0 +1,65 @@
+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';
+export const streamSchema = z.discriminatedUnion('type', [
+    facebookSchema,
+    hlsSchema,
+    mpegDvbSchema,
+    rtmpSchema,
+    sdCardSchema,
+    windySchema,
+    youtubeSchema,
+]);
+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';
+};
+export const isRtmpStream = (stream) => {
+    return stream.type === 'rtmp';
+};
+export const isSdCardStream = (stream) => {
+    return stream.type === 'sd_card';
+};
+export const isWindyStream = (stream) => {
+    return stream.type === 'windy';
+};
+export const isYouTubeStream = (stream) => {
+    return stream.type === 'youtube';
+};
+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 audioFileDataSchema = z.object({
+    code: z.number(),
+    list: audioFileListSchema,
+});

package/esm/types/CamStreamerAPI/facebookSchema.js

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

package/esm/types/CamStreamerAPI/hlsSchema.js

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

package/esm/types/CamStreamerAPI/index.js

@@ -0,0 +1,9 @@
+export * from './CamStreamerAPI';
+export * from './streamCommonTypes';
+export * from './facebookSchema';
+export * from './hlsSchema';
+export * from './mpegDvbSchema';
+export * from './rtmpSchema';
+export * from './sdCardSchema';
+export * from './windySchema';
+export * from './youtubeSchema';

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(),
+    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,5 @@
+import z from 'zod';
+import { streamCommonSchema } from './streamCommonTypes';
+export const rtmpSchema = streamCommonSchema.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/streamCommonTypes.js

@@ -0,0 +1,62 @@
+import { z } from 'zod';
+export const streamTypeSchema = z.union([
+    z.literal('youtube'),
+    z.literal('facebook'),
+    z.literal('sd_card'),
+    z.literal('windy'),
+    z.literal('mpeg_dvb'),
+    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'),
+]);
+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 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: z.union([z.literal(0), z.literal(1)]).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/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/youtubeSchema.js

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

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, } 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 bitrateModeSchema = z.union([z.literal('VBR'), z.literal('MBR'), z.literal('ABR')]);
+export const bitrateVapixParamsSchema = z.object({
+    bitrateMode: bitrateModeSchema,
+    maximumBitRate: z.number(),
+    retentionTime: z.number(),
+    bitRateLimit: z.number(),
+});
+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(),
+}));