camstreamerlib 4.0.0-beta.4 → 4.0.0-beta.41

package/esm/node/events/GenetecAgent.js

@@ -0,0 +1,119 @@
+import { responseStringify, pad } from '../../internal/utils';
+import { cameraDetailsResponseSchema, cameraGuidsResponseSchema, successResponseSchema, } from '../../types/GenetecAgent';
+export class GenetecAgent {
+    settings;
+    baseUrl;
+    credentials;
+    constructor(options = {}) {
+        this.settings = {
+            protocol: options.protocol ?? 'http',
+            ip: options.ip ?? '127.0.0.1',
+            port: options.port ?? 80,
+            baseUri: options.baseUri ?? 'WebSdk',
+            user: options.user ?? 'root',
+            pass: options.pass ?? '',
+            appId: options.appId ?? '',
+            timeout: options.timeout ?? 10000,
+        };
+        this.baseUrl = `${this.settings.protocol}://${this.settings.ip}:${this.settings.port}/${this.settings.baseUri}`;
+        this.credentials = btoa(`${this.settings.user};${this.settings.appId}:${this.settings.pass}`);
+    }
+    async checkConnection() {
+        const requestOptions = this.getRequestOptions('GET');
+        const res = await this.fetchWithTimeout(new URL(this.baseUrl), requestOptions);
+        if (!res.ok) {
+            throw new Error(await responseStringify(res));
+        }
+        const responseBody = await res.text();
+        const result = await successResponseSchema.safeParseAsync(JSON.parse(responseBody));
+        if (!result.success) {
+            throw new Error('Genetec connection test failed: ' + JSON.stringify(result.error.issues) + '\n' + responseBody);
+        }
+    }
+    async getAllCameraGuids() {
+        const requestOptions = this.getRequestOptions('GET');
+        const url = new URL(`${this.baseUrl}/report/EntityConfiguration`);
+        url.searchParams.set('q', 'EntityTypes@Camera');
+        const res = await this.fetchWithTimeout(url, requestOptions);
+        if (!res.ok) {
+            throw new Error(await responseStringify(res));
+        }
+        const responseBody = await res.text();
+        const result = await cameraGuidsResponseSchema.safeParseAsync(JSON.parse(responseBody));
+        if (!result.success) {
+            throw new Error('Genetec get camera guids failed: ' + JSON.stringify(result.error.issues) + '\n' + responseBody);
+        }
+        return result.data;
+    }
+    async getCameraDetails(guids, parameters) {
+        const params = parameters.join(',');
+        const requestOptions = this.getRequestOptions('GET');
+        const allCameras = [];
+        const chunkSize = 10;
+        while (guids.length > 0) {
+            const chunk = guids.slice(0, chunkSize);
+            guids.splice(0, chunkSize);
+            const url = new URL(`${this.baseUrl}/entity`);
+            url.searchParams.set('q', chunk.map((item) => `entity=${item.Guid},${params}`).join(','));
+            const res = await this.fetchWithTimeout(url, requestOptions);
+            if (!res.ok) {
+                throw new Error(await responseStringify(res));
+            }
+            const responseBody = await res.text();
+            const result = await cameraDetailsResponseSchema.safeParseAsync(JSON.parse(responseBody));
+            if (!result.success) {
+                throw new Error('Genetec get camera details failed: ' + JSON.stringify(result.error.issues) + '\n' + responseBody);
+            }
+            const data = result.data;
+            const resultArray = Array.isArray(data.Rsp.Result) ? data.Rsp.Result : [data.Rsp.Result];
+            allCameras.push(...resultArray);
+        }
+        return allCameras;
+    }
+    async sendBookmark(guids, bookmarkText) {
+        const timeStamp = this.getTimeStamp();
+        const requestOptions = this.getRequestOptions('POST');
+        const url = new URL(`${this.baseUrl}/action`);
+        url.searchParams.set('q', guids.map((guid) => `AddCameraBookmark(${guid},${timeStamp},${bookmarkText})`).join(','));
+        const res = await this.fetchWithTimeout(url, requestOptions);
+        if (!res.ok) {
+            throw new Error(await responseStringify(res));
+        }
+        const responseBody = await res.text();
+        const result = await successResponseSchema.safeParseAsync(JSON.parse(responseBody));
+        if (!result.success) {
+            throw new Error('Genetec send bookmark failed: ' + JSON.stringify(result.error.issues) + '\n' + responseBody);
+        }
+    }
+    getRequestOptions(method) {
+        return {
+            method,
+            headers: new Headers({
+                Authorization: `Basic ${this.credentials}`,
+                Accept: 'text/json',
+            }),
+            redirect: 'follow',
+        };
+    }
+    getTimeStamp() {
+        const date = new Date();
+        const year = date.getUTCFullYear();
+        const month = pad(date.getUTCMonth() + 1, 2);
+        const day = pad(date.getUTCDate(), 2);
+        const hours = pad(date.getUTCHours(), 2);
+        const minutes = pad(date.getUTCMinutes(), 2);
+        const seconds = pad(date.getUTCSeconds(), 2);
+        const miliSeconds = pad(date.getUTCMilliseconds(), 2);
+        return `${year}-${month}-${day}T${hours}:${minutes}:${seconds}.${miliSeconds}Z`;
+    }
+    async fetchWithTimeout(url, options) {
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), this.settings.timeout);
+        try {
+            return await fetch(url, { ...options, signal: controller.signal });
+        }
+        finally {
+            clearTimeout(timeoutId);
+        }
+    }
+}

package/esm/node/index.js

@@ -1,2 +1,17 @@
-export { DefaultClient } from './DefaultClient';
-export { WsClient } from './WsClient';
+export * from './DefaultClient';
+export * from './WsClient';
+export * from './HttpServer';
+export * from './HttpRequestSender';
+export * from './events/AxisCameraStationEvents';
+export * from './events/GenetecAgent';
+export * from '../types/GenetecAgent';
+export { ResourceManager } from './CamOverlayPainter/ResourceManager';
+export { Painter } from './CamOverlayPainter/Painter';
+export { Frame } from './CamOverlayPainter/Frame';
+export * from '../types/CamOverlayPainter';
+export { CamOverlayDrawingAPI } from './CamOverlayDrawingAPI';
+export * from '../types/CamOverlayDrawingAPI';
+export { CamScripterAPICameraEventsGenerator } from './CamScripterAPICameraEventsGenerator';
+export * from '../types/CamScripterAPICameraEventsGenerator';
+export { VapixEvents } from './VapixEvents';
+export * from '../types/VapixEvents';

package/esm/types/CamOverlayAPI/CamOverlayAPI.js

@@ -0,0 +1,76 @@
+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 fileStorageTypeSchema = z.union([
+    z.literal('flash'),
+    z.literal('SD0'),
+    z.literal('ftp'),
+    z.literal('samba'),
+    z.literal('url'),
+]);
+export const storageDataListSchema = z.array(z.object({
+    type: fileStorageTypeSchema,
+    state: z.string(),
+}));
+export const storageResponseSchema = z.object({
+    code: z.number(),
+    list: storageDataListSchema,
+});
+export const fileSchema = z.object({
+    name: z.string(),
+    path: z.string().url(),
+    storage: fileStorageTypeSchema,
+});
+export const fileListSchema = z.array(fileSchema);
+export const fileDataSchema = z.object({
+    code: z.number(),
+    list: fileListSchema,
+});

package/esm/types/CamOverlayAPI/accuweatherSchema.js

@@ -0,0 +1,44 @@
+import { z } from 'zod';
+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(),
+    bgStartColor: z.union([
+        z.literal('237,143,73,0.93'),
+        z.literal('0,0,0,0.75'),
+        z.literal('31,32,73,0.9'),
+        z.literal('76,94,127,0.95'),
+    ]),
+    bgEndColor: z.union([
+        z.literal('234,181,89,0.93'),
+        z.literal('0,0,0,0.75'),
+        z.literal('73,96,213,0.9'),
+        z.literal('140,150,168,0.95'),
+    ]),
+    clockType: z.union([z.literal('12h'), z.literal('24h')]),
+    lang: languageSchema,
+    font: fontSchema,
+    units: weatherUnitSchema,
+    pos_x: z.number(),
+    pos_y: z.number(),
+    coordSystem: coordinateSystemSchema,
+    layout: z.union([
+        z.literal('0'),
+        z.literal('1'),
+        z.literal('2'),
+        z.literal('3'),
+        z.literal('4'),
+        z.literal('5'),
+        z.literal('6'),
+        z.literal('7'),
+        z.literal('8'),
+        z.literal('9'),
+        z.literal('10'),
+        z.literal('11'),
+        z.literal('12'),
+        z.literal('13'),
+    ]),
+    scale: z.number().nonnegative(),
+});

package/esm/types/CamOverlayAPI/customGraphicsSchema.js

@@ -0,0 +1,69 @@
+import { z } from 'zod';
+import { serviceNames, coordinateSystemSchema, fontSchema, serviceCommonSchema } from './serviceCommonTypes';
+const mappingZonesCommonSchema = z.object({
+    name: z.string(),
+    pos_x: z.number(),
+    pos_y: z.number(),
+    text: z
+        .array(z.object({
+        source: z.string(),
+        active: z.boolean(),
+    }))
+        .optional(),
+    wrapText: z.boolean(),
+    textLines: z.number().positive(),
+    textWidth: z.number().nonnegative(),
+    textAlign: z.union([z.literal('A_LEFT'), z.literal('A_CENTER'), z.literal('A_RIGHT')]),
+    textVerticalAlign: z.union([z.literal('VA_TOP'), z.literal('VA_CENTER'), z.literal('VA_BOTTOM')]),
+    textColor: z.string(),
+    font: fontSchema,
+    fontSize: z.number().nonnegative(),
+    switchingTime: z.number().nonnegative(),
+});
+export const mappingZonesCountdownSettingsSchema = z.object({
+    startDate: z.number().nonnegative(),
+    targetDate: z.number().nonnegative(),
+    countdown: z.boolean(),
+    countup: z.boolean(),
+    displayDay: z.boolean(),
+    displayHour: z.boolean(),
+    displayMinute: z.boolean(),
+    displaySeconds: z.boolean(),
+    idleText: z.string(),
+    hideZeros: z.boolean(),
+    delimiter: z.union([z.literal('colon'), z.literal('letters')]),
+    suffixSeconds: z.string(),
+    suffixMinute: z.string(),
+    suffixHour: z.string(),
+    suffixDay: z.string(),
+    loop: z.boolean(),
+    loopPeriod: z.number().nonnegative(),
+    waitingPeriod: z.number().nonnegative(),
+});
+const mappingZonePlainSchema = mappingZonesCommonSchema.extend({
+    type: z.literal('plain'),
+});
+const mappingZoneCountdownSchema = mappingZonesCommonSchema.extend({
+    type: z.literal('countdown'),
+    settings: mappingZonesCountdownSettingsSchema,
+});
+export const mappingZoneSchema = z.discriminatedUnion('type', [mappingZonePlainSchema, mappingZoneCountdownSchema]);
+export const customGraphicsSchema = serviceCommonSchema.extend({
+    name: z.literal(serviceNames.customGraphics),
+    pos_x: z.number(),
+    pos_y: z.number(),
+    coordSystem: coordinateSystemSchema,
+    clockFormat: z.union([z.literal('12h'), z.literal('24h')]),
+    background: z.enum(['custom', 'image']),
+    image: z.string(),
+    customAreaColor: z.string(),
+    customAreaWidth: z.number().nonnegative(),
+    customAreaHeight: z.number().nonnegative(),
+    customAreaCorners: z.union([z.literal('sharp'), z.literal('rounded')]),
+    mappingZones: z.array(mappingZoneSchema),
+});
+export const fieldSchema = z.object({
+    field_name: z.string(),
+    text: z.string(),
+    color: z.string().optional(),
+});

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/types/CamOverlayAPI/index.js

@@ -0,0 +1,11 @@
+export * from './CamOverlayAPI';
+export * from './serviceCommonTypes';
+export * from './accuweatherSchema';
+export * from './customGraphicsSchema';
+export * from './imagesSchema';
+export * from './infotickerSchema';
+export * from './pipSchema';
+export * from './ptzCompassSchema';
+export * from './ptzSchema';
+export * from './screenSharingSchema';
+export * from './webCameraSharingSchema';

package/esm/types/CamOverlayAPI/infotickerSchema.js

@@ -0,0 +1,23 @@
+import { z } from 'zod';
+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(),
+    bgColor: z.string(),
+    weatherLocation: z.string(),
+    weatherLocationName: z.string(),
+    weatherLang: languageSchema,
+    weatherUnits: weatherUnitSchema,
+    numberOfLines: z.number().positive(),
+    switchingTime: z.number().nonnegative(),
+    crawlLeft: z.boolean(),
+    crawlSpeed: z.number(),
+    coordSystem: z.union([z.literal('top'), z.literal('bottom')]),
+    pos_y: z.number(),
+    font: fontSchema,
+    fontSize: z.number().nonnegative(),
+    sourceType: z.union([z.literal('text'), z.literal('url')]),
+    source: z.string(),
+});

package/esm/types/CamOverlayAPI/pipSchema.js

@@ -0,0 +1,36 @@
+import { z } from 'zod';
+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(),
+    fps: z.number(),
+    compression: z.number().nonnegative(),
+    screenSize: z.number().nonnegative(),
+    source_type: z.union([z.literal('axis_camera'), z.literal('mjpeg_url')]),
+    mjpeg_url: z.union([z.string().url(), z.literal('')]),
+    camera_ip: z.union([z.string().ip(), z.literal('')]),
+    camera_port: z.number().nonnegative(),
+    camera_user: z.string(),
+    camera_pass: z.string(),
+    camera_width: z.number().nonnegative(),
+    camera_height: z.number().nonnegative(),
+    camera_view_area: z.string(),
+    camera_overlay_params: z.union([
+        z.literal('overlays=off'),
+        z.literal('overlays=all'),
+        z.literal('overlays=text'),
+        z.literal('overlays=image'),
+        z.literal('overlays=application'),
+    ]),
+    rotate: z.union([z.literal(0), z.literal(90), z.literal(180), z.literal(270)]),
+    dewarping: z.object({
+        enabled: z.boolean(),
+        rectangle: z.array(z.tuple([z.number(), z.number()])),
+        aspectRatioCorrection: z.number(),
+    }),
+    borderColor: z.string(),
+    borderWidth: z.number(),
+    scale: z.number(),
+});

package/esm/types/CamOverlayAPI/ptzCompassSchema.js

@@ -0,0 +1,22 @@
+import { z } from 'zod';
+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,
+    scale: z.number().nonnegative(),
+    type: z.union([z.literal('compass'), z.literal('map'), z.literal('image')]),
+    image: z.union([z.string().url(), z.literal('')]),
+    northPan: z.number(),
+    cameraPosX: z.number(),
+    cameraPosY: z.number(),
+    colorScheme: z.enum(['black', 'white', 'orange']),
+    generalLng: z.number().optional(),
+    generalLat: z.number().optional(),
+    generalZoom: z.number().nonnegative().optional(),
+    generalMapType: z.string().optional(),
+    generalIframeWidth: z.number().optional(),
+    generalIframeHeight: z.number().optional(),
+    generalAddress: z.string().optional(),
+});

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/types/CamOverlayAPI/serviceCommonTypes.js

@@ -0,0 +1,88 @@
+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'),
+    z.literal('top_right'),
+    z.literal('left'),
+    z.literal('center'),
+    z.literal('right'),
+    z.literal('bottom_left'),
+    z.literal('bottom'),
+    z.literal('bottom_right'),
+]);
+export const languageSchema = z.union([
+    z.literal('en-us'),
+    z.literal('fr-fr'),
+    z.literal('ja-jp'),
+    z.literal('pt-pt'),
+    z.literal('es-es'),
+    z.literal('de-de'),
+    z.literal('ko-kr'),
+    z.literal('zh-hk'),
+    z.literal('zh-cn'),
+    z.literal('nl-nl'),
+    z.literal('cs-cz'),
+    z.literal('ru-ru'),
+    z.literal('sv-se'),
+]);
+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([
+        z.literal('time'),
+        z.literal('manual'),
+        z.literal('schedule'),
+        z.custom((val) => {
+            return typeof val === 'string' ? /^input\d+$/.test(val) : false;
+        }),
+    ]),
+    invertInput: z.boolean().optional(),
+    cameraList: z.array(z.number()),
+    camera: z.number().nonnegative().optional(),
+    schedule: z.string().optional(),
+    customName: z.string(),
+    zIndex: z.number().optional(),
+    width: z.number().nonnegative(),
+    height: z.number().nonnegative(),
+});
+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,
+    pos_x: z.number(),
+    pos_y: z.number(),
+    imgPath: z.string(),
+    imgName: z.string(),
+    duration: z.number(),
+    scale: z.number(),
+    fps: z.number().optional(),
+});

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