camstreamerlib 4.0.0-beta.7 → 4.0.0-beta.9

package/esm/CamOverlayAPI.js

@@ -1,61 +1,113 @@
-import { isClient, responseStringify } from './internal/common';
-import { DefaultClient } from './node/DefaultClient';
-import { fileListSchema, ImageType, serviceSchema, storageSchema, } from './types/CamOverlayAPI';
+import { responseStringify } from './internal/common';
+import { ImageType, } from './types/CamOverlayAPI';
 import { ParsingBlobError, ServiceNotFoundError } from './errors/errors';
 import { networkCameraListSchema } from './types/common';
+import { z } from 'zod';
+import { widgetsSchema } from './models/CamOverlayAPI/widgetsSchema';
+import { fileListSchema, storageSchema } from './models/CamOverlayAPI/fileSchema';
+import { paramToUrl } from './internal/utils';
+export const BASE_URL = '/local/camoverlay/api';
 export class CamOverlayAPI {
     client;
-    constructor(options = {}) {
-        if (isClient(options)) {
-            this.client = options;
-        }
-        else {
-            this.client = new DefaultClient(options);
-        }
+    constructor(client) {
+        this.client = client;
     }
+    static getProxyUrlPath = () => `${BASE_URL}/proxy.cgi`;
+    static getFilePreviewPath = (path) => `${BASE_URL}/file_preview.cgi?path=${encodeURIComponent(path)}`;
     async checkCameraTime() {
-        const cameraTime = await this.get('/local/camoverlay/api/camera_time.cgi');
+        const responseSchema = z.discriminatedUnion('state', [
+            z.object({
+                state: z.literal(true),
+                code: z.number(),
+            }),
+            z.object({
+                state: z.literal(false),
+                code: z.number(),
+                reason: z.union([
+                    z.literal('INVALID_TIME'),
+                    z.literal('COULDNT_RESOLVE_HOST'),
+                    z.literal('CONNECTION_ERROR'),
+                ]),
+                message: z.string(),
+            }),
+        ]);
+        const response = await this._get(`${BASE_URL}/camera_time.cgi`);
+        const cameraTime = responseSchema.parse(response);
+        if (!cameraTime.state) {
+            console.error(`Camera time check failed: ${cameraTime.reason} - ${cameraTime.message}`);
+        }
         return cameraTime.state;
     }
     async getNetworkCameraList() {
-        const response = await this.get('/local/camoverlay/api/network_camera_list.cgi');
+        const response = await this._get(`${BASE_URL}/network_camera_list.cgi`);
         return networkCameraListSchema.parse(response.camera_list);
     }
-    async wsAutoratization() {
-        const response = await this.get(`/local/camoverlay/api/ws_authorization.cgi`);
-        return response.data;
+    async wsAuthorization() {
+        const responseSchema = z.object({
+            status: z.number(),
+            message: z.string(),
+            data: z.string(),
+        });
+        const response = await this._get(`${BASE_URL}/ws_authorization.cgi`);
+        return responseSchema.parse(response).data;
     }
     async getMjpegStreamImage(mjpegUrl) {
-        const res = await this.get(`/local/camoverlay/api/fetch_mjpeg_image.cgi?mjpeg_url=${encodeURIComponent(decodeURIComponent(mjpegUrl))}`);
+        const res = await this._get(`${BASE_URL}/fetch_mjpeg_image.cgi?mjpeg_url=${encodeURIComponent(decodeURIComponent(mjpegUrl))}`);
         return await this.parseBlobResponse(res);
     }
     async listFiles(fileType) {
-        const files = await this.get(`/local/camoverlay/api/upload_${fileType}.cgi?action=list`);
+        const fileDataSchema = z.object({
+            code: z.number(),
+            list: fileListSchema,
+        });
+        const files = await this._get(`${BASE_URL}/upload_${fileType}.cgi`, {
+            action: 'list',
+        });
         return fileListSchema.parse(files.list);
     }
-    async uploadFile(fileType, file, fileName) {
-        const formData = new FormData();
-        formData.append('target', 'SD0');
-        formData.append('uploadedFile[]', file, fileName);
-        const path = `/local/camoverlay/api/upload_${fileType}.cgi?action=upload`;
-        await this.post(path, formData);
+    async uploadFile(fileType, formData, storage) {
+        const path = `${BASE_URL}/upload_${fileType}.cgi`;
+        await this._post(path, formData, {
+            action: 'upload',
+            storage: storage,
+        });
     }
-    async removeFile(fileType, file) {
-        const path = `/local/camoverlay/api/upload_${fileType}.cgi?action=remove`;
-        await this.post(path, JSON.stringify(file));
+    async removeFile(fileType, fileParams) {
+        const path = `${BASE_URL}/upload_${fileType}.cgi`;
+        await this._postUrlEncoded(path, {
+            action: 'remove',
+            ...fileParams,
+        });
     }
     async getFileStorage(fileType) {
-        const data = await this.get(`/local/camoverlay/api/upload_${fileType}.cgi?action=get_storage`);
-        return storageSchema.parse(data);
+        const storageDataListSchema = z.array(z.object({
+            type: storageSchema,
+            state: z.string(),
+        }));
+        const responseSchema = z.object({
+            code: z.number(),
+            list: storageDataListSchema,
+        });
+        const data = await this._get(`${BASE_URL}/upload_${fileType}.cgi`, {
+            action: 'get_storage',
+        });
+        if (data.code !== 200) {
+            throw new Error('Error occured while fetching file storage data');
+        }
+        return storageDataListSchema.parse(data.list);
+    }
+    async getFilePreviewFromCamera(path) {
+        const response = await this._get(CamOverlayAPI.getFilePreviewPath(path));
+        return await this.parseBlobResponse(response);
     }
     async updateInfoticker(serviceID, text) {
-        await this.get(`/local/camoverlay/api/infoticker.cgi?service_id=${serviceID}&text=${text}`);
+        await this._get(`${BASE_URL}/infoticker.cgi?service_id=${serviceID}&text=${text}`);
     }
     async setEnabled(serviceID, enabled) {
-        await this.post(`/local/camoverlay/api/enabled.cgi?id_${serviceID}=${enabled ? 1 : 0}`, '');
+        await this._post(`${BASE_URL}/enabled.cgi?id_${serviceID}=${enabled ? 1 : 0}`, '');
     }
     async isEnabled(serviceID) {
-        const res = await this.client.get('/local/camoverlay/api/services.cgi?action=get');
+        const res = await this.client.get(`${BASE_URL}/services.cgi?action=get`);
         if (res.ok) {
             const data = JSON.parse(await res.text());
             for (const service of data.services) {
@@ -69,27 +121,38 @@ export class CamOverlayAPI {
             throw new Error(await responseStringify(res));
         }
     }
-    async getSingleService(serviceId) {
-        const data = await this.get('/local/camoverlay/api/services.cgi', {
+    async getSingleWidget(serviceId) {
+        const data = await this._get(`${BASE_URL}/services.cgi`, {
             action: 'get',
             service_id: serviceId.toString(),
         });
-        return serviceSchema.parse(data);
+        return widgetsSchema.parse(data);
     }
-    async getServices() {
-        const serviceList = await this.get('/local/camoverlay/api/services.cgi?action=get');
-        return serviceSchema.parse(serviceList).services;
+    async getWidgets() {
+        const widgetList = await this._get(`${BASE_URL}/services.cgi`, {
+            action: 'get',
+        });
+        const widgets = widgetList.services;
+        widgets.forEach((widget) => {
+            const parsedWidget = widgetsSchema.safeParse(widget);
+            if (!parsedWidget.success) {
+                console.warn(`[SERVICE SCHEMA MISMATCH]: Service ${widget.name} (${widget.id}) does not match the current schema, or is a hidden service.`);
+            }
+        });
+        return widgets;
     }
-    async updateSingleService(serviceId, serviceJson) {
-        const path = '/local/camoverlay/api/services.cgi';
-        await this.post(path, JSON.stringify(serviceJson), {
+    async updateSingleWidget(widget) {
+        const path = `${BASE_URL}/services.cgi`;
+        await this._postJsonEncoded(path, JSON.stringify(widget), {
             action: 'set',
-            service_id: serviceId.toString(),
+            service_id: widget.id.toString(),
         });
     }
-    async updateServices(servicesJson) {
-        const path = '/local/camoverlay/api/services.cgi?action=set';
-        await this.post(path, JSON.stringify(servicesJson));
+    async updateWidgets(widgets) {
+        const path = `${BASE_URL}/services.cgi`;
+        await this._postJsonEncoded(path, JSON.stringify({ services: widgets }), {
+            action: 'set',
+        });
     }
     updateCGText(serviceID, fields) {
         const params = {};
@@ -129,7 +192,7 @@ export class CamOverlayAPI {
         return this.promiseCGUpdate(serviceID, 'update_image', params, contentType, imageData);
     }
     async promiseCGUpdate(serviceID, action, params = {}, contentType, data) {
-        const path = `/local/camoverlay/api/customGraphics.cgi`;
+        const path = `${BASE_URL}/customGraphics.cgi`;
         let headers = {};
         if (contentType !== undefined && data) {
             headers = { 'Content-Type': contentType };
@@ -143,24 +206,34 @@ export class CamOverlayAPI {
             throw new Error(await responseStringify(res));
         }
     }
-    async get(path, params) {
-        const res = await this.client.get(path, params);
+    async _get(...args) {
+        const res = await this.client.get(...args);
         if (res.ok) {
-            return await res.json();
+            return (await res.json());
         }
         else {
             throw new Error(await responseStringify(res));
         }
     }
-    async post(path, data, params) {
-        const res = await this.client.post(path, data, params);
+    async _post(...args) {
+        const res = await this.client.post(...args);
         if (res.ok) {
-            return await res.json();
+            return (await res.json());
         }
         else {
             throw new Error(await responseStringify(res));
         }
     }
+    async _postUrlEncoded(path, params, headers) {
+        const data = paramToUrl(params);
+        const baseHeaders = { 'Content-Type': 'application/x-www-form-urlencoded' };
+        return this._post(path, data, {}, { ...baseHeaders, ...headers });
+    }
+    async _postJsonEncoded(...args) {
+        const [path, data, params, headers] = args;
+        const baseHeaders = { 'Accept': 'application/json', 'Content-Type': 'application/json' };
+        return this._post(path, data, params, { ...baseHeaders, ...headers });
+    }
     async parseBlobResponse(response) {
         try {
             return await response.blob();

package/esm/CamScripterAPI.d.ts

@@ -1,9 +1,9 @@
 import { IClient } from './internal/common';
-import { CamScripterOptions, TNodeState, TPackageInfoList, TStorage, TStorageType } from './types/CamScripterAPI';
+import { TNodeState, TPackageInfoList, TStorage, TStorageType } from './types/CamScripterAPI';
 import { TNetworkCamera } from './types/common';
-export declare class CamOverlayAPI {
-    private client;
-    constructor(options?: CamScripterOptions | IClient);
+export declare class CamOverlayAPI<Client extends IClient = IClient> {
+    client: Client;
+    constructor(client: Client);
     checkCameraTime(): Promise<boolean>;
     getStorageInfo(): Promise<TStorage>;
     getNetworkCameraList(): Promise<TNetworkCamera[]>;

package/esm/CamScripterAPI.js

@@ -1,16 +1,10 @@
-import { isClient, responseStringify } from './internal/common';
-import { DefaultClient } from './node/DefaultClient';
+import { responseStringify } from './internal/common';
 import { packageInfoListSchema, storageSchema, } from './types/CamScripterAPI';
 import { networkCameraListSchema } from './types/common';
 export class CamOverlayAPI {
     client;
-    constructor(options = {}) {
-        if (isClient(options)) {
-            this.client = options;
-        }
-        else {
-            this.client = new DefaultClient(options);
-        }
+    constructor(client) {
+        this.client = client;
     }
     async checkCameraTime() {
         return (await this.get('/local/camscripter/camera_time.cgi')).state;

package/esm/VapixAPI.d.ts

@@ -36,8 +36,8 @@ export declare class VapixAPI<Client extends IClient = IClient> {
     getParameter(paramNames: string | string[], proxy?: TProxyParam): Promise<Record<string, string>>;
     setParameter(params: Record<string, string | number | boolean>, proxy?: TProxyParam): Promise<boolean>;
     getGuardTourList(proxy?: TProxyParam): Promise<{
-        name: string;
         id: string;
+        name: string;
         running: string;
         tour: {
             moveSpeed?: unknown;

package/esm/VapixAPI.js

@@ -2,7 +2,7 @@ import * as prettifyXml from 'prettify-xml';
 import { parseStringPromise } from 'xml2js';
 import { isNullish, responseStringify } from './internal/common';
 import { sdCardWatchedStatuses, APP_IDS, maxFpsResponseSchema, dateTimeinfoSchema, audioDeviceRequestSchema, audioSampleRatesResponseSchema, } from './types/VapixAPI';
-import { ApplicationAPIError, MaxFPSError, NoDeviceInfoError, SDCardActionError, SDCardJobError, } from './errors/errors';
+import { ApplicationAPIError, MaxFPSError, NoDeviceInfoError, PtzNotSupportedError, SDCardActionError, SDCardJobError, } from './errors/errors';
 import { ProxyClient } from './internal/ProxyClient';
 import { arrayToUrl, paramToUrl } from './internal/utils';
 import { z } from 'zod';
@@ -48,8 +48,8 @@ export class VapixAPI {
     }
     async getSupportedAudioSampleRate(proxy = null) {
         const url = '/axis-cgi/audio/streamingcapabilities.cgi';
-        const formData = { apiVersion: '1.0', method: 'list' };
-        const res = await this.postJson(proxy, url, formData);
+        const jsonData = { apiVersion: '1.0', method: 'list' };
+        const res = await this.postJson(proxy, url, jsonData);
         const encoders = audioSampleRatesResponseSchema.parse(await res.json()).data.encoders;
         const data = encoders.aac ?? encoders.AAC ?? [];
         return data.map((item) => {
@@ -75,7 +75,7 @@ export class VapixAPI {
             await this.postJson(proxy, '/axis-cgi/opticscontrol.cgi', data);
         }
         catch (err) {
-            await this.postJson(proxy, '/axis-cgi/opticssetup.cgi', {
+            await this.getUrlEncoded(proxy, '/axis-cgi/opticssetup.cgi', {
                 autofocus: 'perform',
                 source: '1',
             });
@@ -289,14 +289,22 @@ export class VapixAPI {
             query: 'presetposcamdata',
             format: 'json',
         });
-        return parseCameraPtzResponse(await response.text())[camera] ?? [];
+        const text = await response.text();
+        if (text === '') {
+            throw new PtzNotSupportedError();
+        }
+        return parseCameraPtzResponse(text)[camera] ?? [];
     }
     async listPtzVideoSourceOverview(proxy = null) {
         const response = await this.getUrlEncoded(proxy, '/axis-cgi/com/ptz.cgi', {
             query: 'presetposall',
             format: 'json',
         });
-        const data = parseCameraPtzResponse(await response.text());
+        const text = await response.text();
+        if (text === '') {
+            throw new PtzNotSupportedError();
+        }
+        const data = parseCameraPtzResponse(text);
         const res = {};
         Object.keys(data)
             .map(Number)

package/esm/errors/errors.d.ts

@@ -31,4 +31,7 @@ export declare class FetchDeviceInfoError extends Error {
 export declare class AddNewClipError extends Error {
     constructor(message: string);
 }
+export declare class PtzNotSupportedError extends Error {
+    constructor();
+}
 export {};

package/esm/errors/errors.js

@@ -64,3 +64,9 @@ export class AddNewClipError extends Error {
         this.name = 'AddNewClipError';
     }
 }
+export class PtzNotSupportedError extends Error {
+    constructor() {
+        super('Ptz not supported.');
+        this.name = 'PtzNotSupportedError';
+    }
+}

package/esm/index.d.ts

@@ -6,6 +6,9 @@ export * from './types/common';
 export { CamSwitcherAPI } from './CamSwitcherAPI';
 export { CamSwitcherEvents } from './CamSwitcherEvents';
 export { VapixAPI } from './VapixAPI';
+export { CamOverlayAPI } from './CamOverlayAPI';
 export * from './types/CamSwitcherEvents';
 export * from './types/CamSwitcherAPI';
 export * from './types/VapixAPI';
+export * from './types/CamOverlayAPI';
+export * from './models/CamOverlayAPI';

package/esm/index.js

@@ -6,6 +6,9 @@ export * from './types/common';
 export { CamSwitcherAPI } from './CamSwitcherAPI';
 export { CamSwitcherEvents } from './CamSwitcherEvents';
 export { VapixAPI } from './VapixAPI';
+export { CamOverlayAPI } from './CamOverlayAPI';
 export * from './types/CamSwitcherEvents';
 export * from './types/CamSwitcherAPI';
 export * from './types/VapixAPI';
+export * from './types/CamOverlayAPI';
+export * from './models/CamOverlayAPI';

package/esm/internal/ProxyClient.d.ts

@@ -1,11 +1,11 @@
 /// <reference types="node" />
-import { IClient, TParameters } from './common';
+import { IClient } from './common';
 import { TProxyParam } from '../types/common';
 export declare class ProxyClient<Client extends IClient = IClient> {
     client: Client;
     getProxyUrl: () => string;
     constructor(client: Client, getProxyUrl: () => string);
-    get: (proxy: TProxyParam, path: string, parameters?: TParameters, headers?: Record<string, string>) => Promise<import("./common").TResponse>;
-    post: (proxy: TProxyParam, path: string, data: string | Buffer | FormData, parameters?: TParameters, headers?: Record<string, string>) => Promise<import("./common").TResponse>;
+    get: (proxy: TProxyParam, url: string, parameters?: import("./common").TParameters | undefined, headers?: Record<string, string> | undefined) => Promise<import("./common").TResponse>;
+    post: (proxy: TProxyParam, url: string, data: string | Buffer | FormData, parameters?: import("./common").TParameters | undefined, headers?: Record<string, string> | undefined) => Promise<import("./common").TResponse>;
     private getReal;
 }

package/esm/internal/ProxyClient.js

@@ -6,12 +6,14 @@ export class ProxyClient {
         this.client = client;
         this.getProxyUrl = getProxyUrl;
     }
-    get = (proxy, path, parameters, headers = {}) => {
+    get = (proxy, ...args) => {
+        const [path, parameters, headers] = args;
         const url = addParametersToPath(path, parameters);
         const { realUrl, realHeaders } = this.getReal(proxy, url, headers);
         return this.client.get(realUrl, {}, realHeaders);
     };
-    post = (proxy, path, data, parameters, headers) => {
+    post = (proxy, ...args) => {
+        const [path, data, parameters, headers] = args;
         const url = addParametersToPath(path, parameters);
         const { realUrl, realHeaders } = this.getReal(proxy, url, headers);
         return this.client.post(realUrl, data, {}, realHeaders);

package/esm/internal/common.d.ts

@@ -19,8 +19,8 @@ export type TResponse = {
     body: any | null;
 };
 export type TParameters = Record<string, string | number | boolean | null | undefined>;
-export type TGetFunction = (url: string, parameters?: TParameters, headers?: Record<string, string>) => Promise<TResponse>;
-export type TPostFunction = (url: string, data: string | Buffer | FormData, parameters?: TParameters, headers?: Record<string, string>) => Promise<TResponse>;
+export type TGetFunction<TRes = TResponse> = (url: string, parameters?: TParameters, headers?: Record<string, string>) => Promise<TRes>;
+export type TPostFunction<TRes = TResponse> = (url: string, data: string | Buffer | FormData, parameters?: TParameters, headers?: Record<string, string>) => Promise<TRes>;
 export interface IClient {
     get: TGetFunction;
     post: TPostFunction;

package/esm/models/CamOverlayAPI/accuweatherSchema.d.ts

@@ -0,0 +1,84 @@
+import { z } from 'zod';
+export declare const accuweatherSchema: z.ZodObject<{
+    id: z.ZodNumber;
+    enabled: z.ZodUnion<[z.ZodLiteral<0>, z.ZodLiteral<1>]>;
+    automationType: z.ZodUnion<[z.ZodLiteral<"time">, z.ZodLiteral<"manual">, z.ZodLiteral<"schedule">, z.ZodType<`input${number}`, z.ZodTypeDef, `input${number}`>]>;
+    invertInput: z.ZodOptional<z.ZodBoolean>;
+    cameraList: z.ZodArray<z.ZodNumber, "many">;
+    camera: z.ZodOptional<z.ZodNumber>;
+    schedule: z.ZodOptional<z.ZodString>;
+    customName: z.ZodString;
+    zIndex: z.ZodOptional<z.ZodNumber>;
+    width: z.ZodNumber;
+    height: z.ZodNumber;
+} & {
+    name: z.ZodLiteral<"accuweather">;
+    location: z.ZodString;
+    locationName: z.ZodString;
+    title: z.ZodString;
+    bgStartColor: z.ZodUnion<[z.ZodLiteral<"237,143,73,0.93">, z.ZodLiteral<"0,0,0,0.75">, z.ZodLiteral<"31,32,73,0.9">, z.ZodLiteral<"76,94,127,0.95">]>;
+    bgEndColor: z.ZodUnion<[z.ZodLiteral<"234,181,89,0.93">, z.ZodLiteral<"0,0,0,0.75">, z.ZodLiteral<"73,96,213,0.9">, z.ZodLiteral<"140,150,168,0.95">]>;
+    clockType: z.ZodUnion<[z.ZodLiteral<"12h">, z.ZodLiteral<"24h">]>;
+    lang: z.ZodUnion<[z.ZodLiteral<"en-us">, z.ZodLiteral<"fr-fr">, z.ZodLiteral<"ja-jp">, z.ZodLiteral<"pt-pt">, z.ZodLiteral<"es-es">, z.ZodLiteral<"de-de">, z.ZodLiteral<"ko-kr">, z.ZodLiteral<"zh-hk">, z.ZodLiteral<"zh-cn">, z.ZodLiteral<"nl-nl">, z.ZodLiteral<"cs-cz">, z.ZodLiteral<"ru-ru">, z.ZodLiteral<"sv-se">]>;
+    font: z.ZodUnion<[z.ZodLiteral<"classic">, z.ZodLiteral<"digital">, z.ZodType<string, z.ZodTypeDef, string>]>;
+    units: z.ZodUnion<[z.ZodLiteral<"Metric">, z.ZodLiteral<"Imperial">]>;
+    pos_x: z.ZodNumber;
+    pos_y: z.ZodNumber;
+    coordSystem: z.ZodUnion<[z.ZodLiteral<"top_left">, z.ZodLiteral<"top">, z.ZodLiteral<"top_right">, z.ZodLiteral<"left">, z.ZodLiteral<"center">, z.ZodLiteral<"right">, z.ZodLiteral<"bottom_left">, z.ZodLiteral<"bottom">, z.ZodLiteral<"bottom_right">]>;
+    layout: z.ZodUnion<[z.ZodLiteral<"0">, z.ZodLiteral<"1">, z.ZodLiteral<"2">, z.ZodLiteral<"3">, z.ZodLiteral<"4">, z.ZodLiteral<"5">, z.ZodLiteral<"6">, z.ZodLiteral<"7">, z.ZodLiteral<"8">, z.ZodLiteral<"9">, z.ZodLiteral<"10">, z.ZodLiteral<"11">, z.ZodLiteral<"12">, z.ZodLiteral<"13">]>;
+    scale: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    id: number;
+    enabled: 0 | 1;
+    automationType: "time" | "manual" | "schedule" | `input${number}`;
+    cameraList: number[];
+    customName: string;
+    width: number;
+    height: number;
+    coordSystem: "top_left" | "top" | "top_right" | "left" | "center" | "right" | "bottom_left" | "bottom" | "bottom_right";
+    pos_x: number;
+    pos_y: number;
+    scale: number;
+    name: "accuweather";
+    font: string;
+    location: string;
+    locationName: string;
+    title: string;
+    bgStartColor: "237,143,73,0.93" | "0,0,0,0.75" | "31,32,73,0.9" | "76,94,127,0.95";
+    bgEndColor: "0,0,0,0.75" | "234,181,89,0.93" | "73,96,213,0.9" | "140,150,168,0.95";
+    clockType: "12h" | "24h";
+    lang: "en-us" | "fr-fr" | "ja-jp" | "pt-pt" | "es-es" | "de-de" | "ko-kr" | "zh-hk" | "zh-cn" | "nl-nl" | "cs-cz" | "ru-ru" | "sv-se";
+    units: "Metric" | "Imperial";
+    layout: "0" | "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9" | "10" | "11" | "12" | "13";
+    schedule?: string | undefined;
+    invertInput?: boolean | undefined;
+    camera?: number | undefined;
+    zIndex?: number | undefined;
+}, {
+    id: number;
+    enabled: 0 | 1;
+    automationType: "time" | "manual" | "schedule" | `input${number}`;
+    cameraList: number[];
+    customName: string;
+    width: number;
+    height: number;
+    coordSystem: "top_left" | "top" | "top_right" | "left" | "center" | "right" | "bottom_left" | "bottom" | "bottom_right";
+    pos_x: number;
+    pos_y: number;
+    scale: number;
+    name: "accuweather";
+    font: string;
+    location: string;
+    locationName: string;
+    title: string;
+    bgStartColor: "237,143,73,0.93" | "0,0,0,0.75" | "31,32,73,0.9" | "76,94,127,0.95";
+    bgEndColor: "0,0,0,0.75" | "234,181,89,0.93" | "73,96,213,0.9" | "140,150,168,0.95";
+    clockType: "12h" | "24h";
+    lang: "en-us" | "fr-fr" | "ja-jp" | "pt-pt" | "es-es" | "de-de" | "ko-kr" | "zh-hk" | "zh-cn" | "nl-nl" | "cs-cz" | "ru-ru" | "sv-se";
+    units: "Metric" | "Imperial";
+    layout: "0" | "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9" | "10" | "11" | "12" | "13";
+    schedule?: string | undefined;
+    invertInput?: boolean | undefined;
+    camera?: number | undefined;
+    zIndex?: number | undefined;
+}>;

package/esm/models/CamOverlayAPI/accuweatherSchema.js

@@ -0,0 +1,45 @@
+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),
+    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/models/CamOverlayAPI/constants.d.ts

@@ -0,0 +1,11 @@
+export declare const allowedWidgetNames: {
+    readonly accuweather: "accuweather";
+    readonly infoticker: "infoticker";
+    readonly customGraphics: "customGraphics";
+    readonly ptzCompass: "ptzCompass";
+    readonly images: "images";
+    readonly ptz: "ptz";
+    readonly pip: "pip";
+    readonly screenSharing: "screenSharing";
+    readonly web_camera: "web_camera";
+};

package/esm/models/CamOverlayAPI/constants.js

@@ -0,0 +1,11 @@
+export const allowedWidgetNames = {
+    accuweather: 'accuweather',
+    infoticker: 'infoticker',
+    customGraphics: 'customGraphics',
+    ptzCompass: 'ptzCompass',
+    images: 'images',
+    ptz: 'ptz',
+    pip: 'pip',
+    screenSharing: 'screenSharing',
+    web_camera: 'web_camera',
+};