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

package/esm/types/CamOverlayAPI/CamOverlayAPI.js

@@ -0,0 +1,110 @@
+import { z } from 'zod';
+import { infoTickerSchema } from './infotickerSchema';
+import { accuweatherSchema } from './accuweatherSchema';
+import { ptzCompassSchema } from './ptzCompassSchema';
+import { imagesSchema } from './imagesSchema';
+import { ptzSchema } from './ptzSchema';
+import { pipSchema } from './pipSchema';
+import { customGraphicsSchema } from './customGraphicsSchema';
+import { screenSharingSchema } from './screenSharingSchema';
+import { webCameraSharingSchema } from './webCameraSharingSchema';
+import { baseballScoreBoardAutomaticSchema, baseballScoreBoardSchema, scoreBoardSchema, scoreOverviewSchema, } from './scoreBoardSchema';
+export const wsResponseSchema = z.object({
+    status: z.number(),
+    message: z.string(),
+});
+export const servicesSchema = z.discriminatedUnion('name', [
+    infoTickerSchema,
+    accuweatherSchema,
+    ptzCompassSchema,
+    imagesSchema,
+    ptzSchema,
+    pipSchema,
+    customGraphicsSchema,
+    screenSharingSchema,
+    webCameraSharingSchema,
+    scoreBoardSchema,
+    baseballScoreBoardSchema,
+    baseballScoreBoardAutomaticSchema,
+    scoreOverviewSchema,
+]);
+export const serviceListSchema = z.object({
+    services: z.array(servicesSchema),
+});
+export const isAccuweather = (service) => service.name === 'accuweather';
+export const isCustomGraphics = (service) => service.name === 'customGraphics';
+export const isImages = (service) => service.name === 'images';
+export const isInfoticker = (service) => service.name === 'infoticker';
+export const isPip = (service) => service.name === 'pip';
+export const isPtzCompass = (service) => service.name === 'ptzCompass';
+export const isPtz = (service) => service.name === 'ptz';
+export const isScreenSharing = (service) => service.name === 'screenSharing';
+export const isWebCameraSharing = (service) => service.name === 'web_camera';
+export const isScoreBoard = (service) => service.name === 'scoreBoard';
+export const isBaseballScoreBoard = (service) => service.name === 'baseballScoreBoard';
+export const isBaseballScoreBoardAutomatic = (service) => service.name === 'myBallBaseballWidgets';
+export const isScoreOverview = (service) => service.name === 'scoreOverview';
+export var ImageType;
+(function (ImageType) {
+    ImageType[ImageType["PNG"] = 0] = "PNG";
+    ImageType[ImageType["JPEG"] = 1] = "JPEG";
+})(ImageType || (ImageType = {}));
+export const imageFileStorageTypeSchema = z.union([
+    z.literal('flash'),
+    z.literal('SD0'),
+    z.literal('ftp'),
+    z.literal('samba'),
+    z.literal('url'),
+]);
+export const fontFileStorageTypeSchema = z.union([z.literal('flash'), z.literal('SD0')]);
+export const imageFilestorageDataListSchema = z.array(z.object({
+    type: imageFileStorageTypeSchema,
+    state: z.string(),
+}));
+export const fontStorageDataListSchema = z.array(z.object({
+    type: fontFileStorageTypeSchema,
+    state: z.string(),
+}));
+export const getStorageDataListSchema = (fileType) => {
+    return fileType === 'image' ? imageFilestorageDataListSchema : fontStorageDataListSchema;
+};
+export const imageStorageResponseSchema = z.object({
+    code: z.number(),
+    list: imageFilestorageDataListSchema,
+});
+export const fontStorageResponseSchema = z.object({
+    code: z.number(),
+    list: fontStorageDataListSchema,
+});
+export const getStorageResponseSchema = (fileType) => {
+    return fileType === 'image' ? imageStorageResponseSchema : fontStorageResponseSchema;
+};
+export const imageFileSchema = z.object({
+    name: z.string(),
+    path: z.string().url(),
+    storage: imageFileStorageTypeSchema,
+});
+export const fontFileSchema = z.object({
+    name: z.string(),
+    path: z.string().url(),
+    storage: fontFileStorageTypeSchema,
+});
+export const getFileSchema = (fileType) => {
+    return fileType === 'image' ? imageFileSchema : fontFileSchema;
+};
+export const imageFileListSchema = z.array(imageFileSchema);
+export const fontFileListSchema = z.array(fontFileSchema);
+export const getFileListSchema = (fileType) => {
+    return fileType === 'image' ? imageFileListSchema : fontFileListSchema;
+};
+export const imageFileDataSchema = z.object({
+    code: z.number(),
+    list: imageFileListSchema,
+});
+export const fontFileDataSchema = z.object({
+    code: z.number(),
+    list: fontFileListSchema,
+});
+export const getFileDataSchema = (fileType) => {
+    return fileType === 'image' ? imageFileDataSchema : fontFileDataSchema;
+};

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

@@ -1,8 +1,7 @@
-import { allowedWidgetNames } from './constants';
-import { coordinateSystemSchema, fontSchema, languageSchema, weatherUnitSchema, widgetCommonSchema, } from './widgetCommonSchema';
 import { z } from 'zod';
-export const accuweatherSchema = widgetCommonSchema.extend({
-    name: z.literal(allowedWidgetNames.accuweather),
+import { serviceNames, coordinateSystemSchema, fontSchema, languageSchema, weatherUnitSchema, serviceCommonSchema, } from './serviceCommonTypes';
+export const accuweatherSchema = serviceCommonSchema.extend({
+    name: z.literal(serviceNames.accuweather),
     location: z.string(),
     locationName: z.string(),
     title: z.string(),

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

@@ -1,6 +1,5 @@
-import { allowedWidgetNames } from './constants';
-import { coordinateSystemSchema, fontSchema, widgetCommonSchema } from './widgetCommonSchema';
 import { z } from 'zod';
+import { serviceNames, coordinateSystemSchema, fontSchema, serviceCommonSchema } from './serviceCommonTypes';
 const mappingZonesCommonSchema = z.object({
     name: z.string(),
     pos_x: z.number(),
@@ -49,8 +48,8 @@ const mappingZoneCountdownSchema = mappingZonesCommonSchema.extend({
     settings: mappingZonesCountdownSettingsSchema,
 });
 export const mappingZoneSchema = z.discriminatedUnion('type', [mappingZonePlainSchema, mappingZoneCountdownSchema]);
-export const customGraphicsSchema = widgetCommonSchema.extend({
-    name: z.literal(allowedWidgetNames.customGraphics),
+export const customGraphicsSchema = serviceCommonSchema.extend({
+    name: z.literal(serviceNames.customGraphics),
     pos_x: z.number(),
     pos_y: z.number(),
     coordSystem: coordinateSystemSchema,

package/esm/types/CamOverlayAPI/imagesSchema.js

@@ -0,0 +1,6 @@
+import { z } from 'zod';
+import { serviceNames, overlaySchema, serviceCommonSchema } from './serviceCommonTypes';
+export const imagesSchema = serviceCommonSchema.extend({
+    name: z.literal(serviceNames.images),
+    overlayList: z.array(overlaySchema),
+});

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

@@ -1,3 +1,5 @@
+export * from './CamOverlayAPI';
+export * from './serviceCommonTypes';
 export * from './accuweatherSchema';
 export * from './customGraphicsSchema';
 export * from './imagesSchema';
@@ -7,7 +9,3 @@ export * from './ptzCompassSchema';
 export * from './ptzSchema';
 export * from './screenSharingSchema';
 export * from './webCameraSharingSchema';
-export * from './widgetCommonSchema';
-export * from './widgetsSchema';
-export * from './constants';
-export * from './fileSchema';

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

@@ -1,8 +1,7 @@
-import { allowedWidgetNames } from './constants';
-import { fontSchema, languageSchema, weatherUnitSchema, widgetCommonSchema } from './widgetCommonSchema';
 import { z } from 'zod';
-export const infoTickerSchema = widgetCommonSchema.extend({
-    name: z.literal(allowedWidgetNames.infoticker),
+import { serviceNames, fontSchema, languageSchema, weatherUnitSchema, serviceCommonSchema } from './serviceCommonTypes';
+export const infoTickerSchema = serviceCommonSchema.extend({
+    name: z.literal(serviceNames.infoticker),
     showClock: z.union([z.literal(0), z.literal(1)]),
     clockType: z.union([z.literal('12h'), z.literal('24h')]),
     textColor: z.string(),

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,137 @@
+import { z } from 'zod';
+import { facebookSchema } from './facebookSchema';
+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';
+import { fileSchema } from '../common';
+import { youtubeRtmpSchema } from './youtubeRtmpSchema';
+export const streamSchema = z.discriminatedUnion('type', [
+    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.type === 'facebook';
+};
+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 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 const isYoutubeRtmpStream = (stream) => {
+    return stream.type === '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/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'),
+});