camstreamerlib 4.0.0-beta.2 → 4.0.0-beta.4

package/cjs/node/DefaultClient.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DefaultClient = void 0;
+const utils_1 = require("../internal/utils");
+const HttpRequestSender_1 = require("./HttpRequestSender");
+class DefaultClient {
+    tls;
+    ip;
+    port;
+    user;
+    pass;
+    httpRequestSender;
+    constructor(opt = {}) {
+        this.tls = opt.tls ?? false;
+        this.ip = opt.ip ?? '127.0.0.1';
+        this.port = opt.port ?? (this.tls ? 443 : 80);
+        this.user = opt.user ?? '';
+        this.pass = opt.pass ?? '';
+        let agentOptions;
+        if (opt.tlsInsecure !== undefined || opt.keepAlive !== undefined) {
+            agentOptions = {
+                rejectUnaurhorized: !opt.tlsInsecure,
+                keepAlive: opt.keepAlive,
+            };
+        }
+        this.httpRequestSender = new HttpRequestSender_1.HttpRequestSender(agentOptions);
+    }
+    get url() {
+        return `${this.tls ? 'https' : 'http'}://${this.user}:${this.pass}@${this.ip}:${this.port}`;
+    }
+    async get(path, parameters = {}, headers) {
+        const options = this.getBaseConnectionParams('GET', path, parameters);
+        options.headers = headers;
+        return this.httpRequestSender.sendRequest(options);
+    }
+    async post(path, data, parameters = {}, headers) {
+        const options = this.getBaseConnectionParams('POST', path, parameters);
+        options.headers = headers;
+        return this.httpRequestSender.sendRequest(options, data);
+    }
+    getBaseConnectionParams(method, path, params) {
+        const pathName = (0, utils_1.addParametersToPath)(path, params);
+        return {
+            method: method,
+            protocol: this.tls ? 'https:' : 'http:',
+            host: this.ip,
+            port: this.port,
+            path: pathName,
+            user: this.user,
+            pass: this.pass,
+        };
+    }
+}
+exports.DefaultClient = DefaultClient;

package/cjs/node/HttpRequestSender.js

@@ -0,0 +1,89 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpRequestSender = void 0;
+const Digest_1 = require("../internal/Digest");
+const undici_1 = require("undici");
+class HttpRequestSender {
+    agent;
+    authData;
+    constructor(agentOptions) {
+        this.agent = new undici_1.Agent({
+            connect: { rejectUnauthorized: agentOptions?.rejectUnaurhorized, keepAlive: agentOptions?.keepAlive },
+        });
+    }
+    sendRequest(options, postData) {
+        return this.sendRequestWithAuth(options, postData);
+    }
+    async sendRequestWithAuth(options, postData, wwwAuthenticateHeader) {
+        options.timeout ??= 10000;
+        const url = HttpRequestSender.getURL(options);
+        const authorization = this.getAuthorization(options, wwwAuthenticateHeader);
+        if (authorization !== undefined) {
+            options.headers ??= {};
+            options.headers['Authorization'] = authorization;
+        }
+        const req = new undici_1.Request(url, { body: postData, method: options.method, headers: options.headers });
+        const res = await (0, undici_1.fetch)(req, { signal: AbortSignal.timeout(options.timeout), dispatcher: this.agent });
+        if (!res.ok) {
+            this.invalidateAuthorization();
+        }
+        if (res.status === 401) {
+            const authenticateHeader = res.headers.get('www-authenticate');
+            if (authenticateHeader !== null &&
+                authenticateHeader.indexOf('Digest') !== -1 &&
+                wwwAuthenticateHeader === undefined) {
+                return this.sendRequestWithAuth(options, postData, authenticateHeader);
+            }
+            else {
+                return res;
+            }
+        }
+        else {
+            return res;
+        }
+    }
+    static getURL(options) {
+        const url = new URL(`${options.protocol}//${options.host}:${options.port}${options.path}`);
+        return url.toString();
+    }
+    getAuthorization(options, wwwAuthenticateHeader) {
+        if (options.user === undefined || options.pass === undefined) {
+            this.authData = undefined;
+            return;
+        }
+        if (this.authData &&
+            (this.authData.host !== options.host ||
+                this.authData.port !== options.port ||
+                this.authData.user !== options.user ||
+                this.authData.pass !== options.pass ||
+                (wwwAuthenticateHeader !== undefined && this.authData.wwwAuthenticateHeader !== wwwAuthenticateHeader))) {
+            this.authData = undefined;
+        }
+        if (this.authData === undefined) {
+            this.authData = {
+                host: options.host,
+                port: options.port,
+                user: options.user,
+                pass: options.pass,
+                wwwAuthenticateHeader,
+                digest: new Digest_1.Digest(),
+            };
+        }
+        return HttpRequestSender.getAuthHeader(options, this.authData);
+    }
+    invalidateAuthorization() {
+        this.authData = undefined;
+    }
+    static getAuthHeader(options, authData) {
+        if (options.user === undefined || options.pass === undefined) {
+            throw new Error('No credentials found');
+        }
+        if (authData.wwwAuthenticateHeader !== undefined && authData.wwwAuthenticateHeader.indexOf('Digest') !== -1) {
+            return authData.digest.getAuthHeader(options.user, options.pass, options.method ?? 'GET', options.path, authData.wwwAuthenticateHeader);
+        }
+        else {
+            return `Basic ${btoa(options.user + ':' + options.pass)}`;
+        }
+    }
+}
+exports.HttpRequestSender = HttpRequestSender;

package/cjs/node/HttpServer.js

@@ -0,0 +1,96 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpServer = void 0;
+const http = require("http");
+const url = require("url");
+const fs = require("fs");
+const path = require("path");
+const EventEmitter = require("events");
+class HttpServer extends EventEmitter {
+    host;
+    port;
+    registeredPaths;
+    server;
+    sockets;
+    constructor(options) {
+        super();
+        this.host = options?.host ?? process.env.HTTP_HOST ?? '0.0.0.0';
+        this.port = options?.port ?? parseInt(process.env.HTTP_PORT ?? '80');
+        this.registeredPaths = new Map();
+        this.server = http.createServer((req, res) => {
+            this.emit('access', req.method + ' ' + req.url);
+            const parsedUrl = url.parse(req.url ?? '');
+            parsedUrl.pathname ??= '';
+            const requestCallback = this.registeredPaths.get(parsedUrl.pathname);
+            if (requestCallback) {
+                requestCallback(req, res);
+                return;
+            }
+            let pathname = `./html${parsedUrl.pathname}`;
+            const ext = path.parse(pathname).ext;
+            const map = {
+                '.ico': 'image/x-icon',
+                '.html': 'text/html',
+                '.js': 'text/javascript',
+                '.json': 'application/json',
+                '.css': 'text/css',
+                '.png': 'image/png',
+                '.jpg': 'image/jpeg',
+                '.wav': 'audio/wav',
+                '.mp3': 'audio/mpeg',
+                '.svg': 'image/svg+xml',
+                '.pdf': 'application/pdf',
+                '.doc': 'application/msword',
+            };
+            fs.access(pathname, fs.constants.R_OK, (err) => {
+                if (err) {
+                    res.statusCode = 404;
+                    res.end(`File ${pathname} not found!`);
+                    this.emit('error', `File ${pathname} not found!`);
+                    return;
+                }
+                if (fs.statSync(pathname).isDirectory()) {
+                    pathname += `/index${ext}`;
+                }
+                fs.readFile(pathname, (error, data) => {
+                    if (error) {
+                        res.statusCode = 500;
+                        res.end(`Error getting the file: ${error}`);
+                        this.emit('error', `Error getting the file: ${error}`);
+                    }
+                    else {
+                        res.setHeader('Content-type', map[ext] ?? 'text/plain');
+                        res.setHeader('Access-Control-Allow-Origin', '*');
+                        res.end(data);
+                    }
+                });
+            });
+        });
+        this.server.on('error', (err) => {
+            this.emit('error', err);
+        });
+        this.server.listen(this.port, this.host);
+        this.sockets = {};
+        let idTracker = 0;
+        this.server.on('connection', (socket) => {
+            const socketID = idTracker++;
+            this.sockets[socketID] = socket;
+            socket.on('close', () => {
+                delete this.sockets[socketID];
+            });
+        });
+    }
+    getServer() {
+        return this.server;
+    }
+    onRequest(pathName, callback) {
+        this.registeredPaths.set(pathName, callback);
+    }
+    close() {
+        this.server.close();
+        for (const key in this.sockets) {
+            this.sockets[key]?.destroy();
+        }
+    }
+}
+exports.HttpServer = HttpServer;

package/cjs/node/WsClient.js

@@ -0,0 +1,149 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WsClient = void 0;
+const EventEmitter = require("events");
+const WebSocket = require("ws");
+const Digest_1 = require("../internal/Digest");
+class WsClient extends EventEmitter {
+    user;
+    pass;
+    address;
+    protocol;
+    pingInterval;
+    wsOptions;
+    digestAddress;
+    isAlive = true;
+    pingTimer;
+    ws;
+    isClosed = false;
+    constructor(options) {
+        super();
+        const tls = options.tls ?? false;
+        const tlsInsecure = options.tlsInsecure ?? false;
+        const ip = options.ip ?? '127.0.0.1';
+        const port = options.port ?? (tls ? 443 : 80);
+        this.user = options.user ?? '';
+        this.pass = options.pass ?? '';
+        const protocol = tls ? 'wss' : 'ws';
+        this.address = `${protocol}://${ip}:${port}${options.address}`;
+        this.digestAddress = options.address;
+        this.pingInterval = options.pingInterval ?? 30000;
+        this.protocol = options.protocol;
+        this.wsOptions = {
+            auth: `${this.user}:${this.pass}`,
+            rejectUnauthorized: !tlsInsecure,
+            headers: options.headers ?? {},
+        };
+    }
+    open(wwwAuthenticateHeader) {
+        try {
+            if (this.ws !== undefined) {
+                return;
+            }
+            this.isClosed = false;
+            if (this.protocol === undefined) {
+                this.ws = new WebSocket(this.address, this.wsOptions);
+            }
+            else {
+                this.ws = new WebSocket(this.address, this.protocol, this.wsOptions);
+            }
+            this.ws.binaryType = 'arraybuffer';
+            this.isAlive = true;
+            this.pingTimer = setInterval(async () => {
+                if ((this.ws && this.ws.readyState !== WebSocket.OPEN) || this.isAlive === false) {
+                    this.emit('error', new Error('Connection timeout'));
+                    await this.closeWsConnection();
+                }
+                else {
+                    this.isAlive = false;
+                    this.ws?.ping();
+                }
+            }, this.pingInterval);
+            this.ws.on('pong', () => {
+                this.isAlive = true;
+            });
+            if (wwwAuthenticateHeader !== undefined) {
+                this.wsOptions.headers['Authorization'] = new Digest_1.Digest().getAuthHeader(this.user, this.pass, 'GET', this.digestAddress, wwwAuthenticateHeader);
+            }
+            this.ws.on('unexpected-response', (req, res) => {
+                if (res.statusCode === 401 && res.headers['www-authenticate'] !== undefined) {
+                    if (this.pingTimer) {
+                        clearInterval(this.pingTimer);
+                    }
+                    this.ws?.removeAllListeners();
+                    this.ws = undefined;
+                    this.open(res.headers['www-authenticate']);
+                }
+                else {
+                    this.emit('error', new Error('Status code: ' + res.statusCode));
+                    this.closeWsConnection();
+                }
+            });
+            this.ws.on('open', () => this.emit('open'));
+            this.ws.on('message', (data) => this.emit('message', data));
+            this.ws.on('error', (error) => {
+                this.emit('error', error);
+                this.closeWsConnection();
+            });
+            this.ws.on('close', () => this.closeWsConnection());
+        }
+        catch (error) {
+            this.emit('error', error instanceof Error ? error : new Error('Unknown error'));
+            this.closeWsConnection();
+        }
+    }
+    send(data) {
+        if (this.ws === undefined) {
+            throw new Error("This websocket hasn't been opened yet.");
+        }
+        if (this.ws.readyState === this.ws.OPEN) {
+            this.ws.send(data);
+        }
+    }
+    close() {
+        if (this.isClosed) {
+            return;
+        }
+        this.isClosed = true;
+        this.closeWsConnection();
+    }
+    reconnect() {
+        this.closeWsConnection();
+    }
+    closeWsConnection() {
+        if (this.ws === undefined) {
+            return;
+        }
+        const wsCopy = this.ws;
+        this.ws = undefined;
+        try {
+            if (this.pingTimer) {
+                clearInterval(this.pingTimer);
+            }
+            wsCopy.removeAllListeners();
+            wsCopy.on('error', () => { });
+            if (wsCopy.readyState !== WebSocket.CLOSING && wsCopy.readyState !== WebSocket.CLOSED) {
+                wsCopy.close();
+            }
+            setTimeout(() => {
+                if (wsCopy.readyState !== WebSocket.CLOSED) {
+                    wsCopy.terminate();
+                }
+            }, 5000);
+            this.emit('close');
+        }
+        catch (err) {
+            console.error(err);
+        }
+        finally {
+            const shouldRestart = !this.isClosed;
+            setTimeout(() => {
+                wsCopy.removeAllListeners();
+                if (shouldRestart && !this.isClosed) {
+                    this.open();
+                }
+            }, 10000);
+        }
+    }
+}
+exports.WsClient = WsClient;

package/cjs/node/WsEventClient.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WsEventClient = void 0;
+const WsClient_1 = require("./WsClient");
+class WsEventClient {
+    wsClient;
+    constructor(options) {
+        this.wsClient = new WsClient_1.WsClient(options);
+        this.wsClient.on('message', (data) => {
+            this.onmessage?.({ data: data.toString() });
+        });
+    }
+    send = (data) => {
+        this.wsClient.send(data);
+    };
+    destroy = () => {
+        this.wsClient.close();
+        this.onmessage = null;
+    };
+    onmessage = null;
+}
+exports.WsEventClient = WsEventClient;

package/cjs/node/index.d.ts

@@ -0,0 +1,2 @@
+export { DefaultClient } from './DefaultClient';
+export { WsClient } from './WsClient';

package/cjs/node/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WsClient = exports.DefaultClient = void 0;
+var DefaultClient_1 = require("./DefaultClient");
+Object.defineProperty(exports, "DefaultClient", { enumerable: true, get: function () { return DefaultClient_1.DefaultClient; } });
+var WsClient_1 = require("./WsClient");
+Object.defineProperty(exports, "WsClient", { enumerable: true, get: function () { return WsClient_1.WsClient; } });

package/cjs/types/CamOverlayAPI.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.storageSchema = exports.imageStorageSchema = exports.fontStorageSchema = exports.ImageType = exports.fileListSchema = exports.fileSchema = exports.fieldSchema = exports.serviceSchema = void 0;
+const zod_1 = require("zod");
+exports.serviceSchema = zod_1.z.record(zod_1.z.string(), zod_1.z.any());
+exports.fieldSchema = zod_1.z.object({
+    field_name: zod_1.z.string(),
+    text: zod_1.z.string(),
+    color: zod_1.z.string().optional(),
+});
+exports.fileSchema = zod_1.z.object({
+    name: zod_1.z.string(),
+    path: zod_1.z.string(),
+    storage: zod_1.z.string(),
+});
+exports.fileListSchema = zod_1.z.array(exports.fileSchema);
+var ImageType;
+(function (ImageType) {
+    ImageType[ImageType["PNG"] = 0] = "PNG";
+    ImageType[ImageType["JPEG"] = 1] = "JPEG";
+})(ImageType || (exports.ImageType = ImageType = {}));
+exports.fontStorageSchema = zod_1.z.tuple([
+    zod_1.z.object({
+        type: zod_1.z.literal('SD0'),
+        state: zod_1.z.literal('SD Card'),
+    }),
+    zod_1.z.object({
+        type: zod_1.z.literal('flash'),
+        state: zod_1.z.string(),
+    }),
+]);
+exports.imageStorageSchema = zod_1.z.tuple([
+    ...exports.fontStorageSchema.items,
+    zod_1.z.object({
+        type: zod_1.z.literal('samba'),
+        state: zod_1.z.literal('Microsoft Network Share'),
+    }),
+    zod_1.z.object({
+        type: zod_1.z.literal('url'),
+        state: zod_1.z.literal('URL'),
+    }),
+    zod_1.z.object({
+        type: zod_1.z.literal('ftp'),
+        state: zod_1.z.literal('FTP'),
+    }),
+]);
+exports.storageSchema = zod_1.z.union([exports.fontStorageSchema, exports.imageStorageSchema]);

package/cjs/types/CamScripterAPI.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.storageSchema = exports.packageInfoListSchema = void 0;
+const zod_1 = require("zod");
+exports.packageInfoListSchema = zod_1.z.array(zod_1.z.object({
+    storage: zod_1.z.union([zod_1.z.literal('SD_CARD'), zod_1.z.literal('INTERNAL')]),
+    manifest: zod_1.z.object({
+        package_name: zod_1.z.string(),
+        package_menu_name: zod_1.z.string(),
+        package_version: zod_1.z.string(),
+        vendor: zod_1.z.string(),
+        required_camscripter_version: zod_1.z.string(),
+        required_camscripter_rbi_version: zod_1.z.string(),
+        ui_link: zod_1.z.string(),
+    }),
+}));
+exports.storageSchema = zod_1.z.array(zod_1.z.object({
+    type: zod_1.z.union([zod_1.z.literal('INTERNAL'), zod_1.z.literal('SD_CARD')]),
+    capacity_mb: zod_1.z.number(),
+}));

package/cjs/types/CamStreamerAPI.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.streamListSchema = exports.streamAttributesSchema = void 0;
+const zod_1 = require("zod");
+exports.streamAttributesSchema = zod_1.z.object({
+    enabled: zod_1.z.string(),
+    active: zod_1.z.string(),
+    audioSource: zod_1.z.string(),
+    avSyncMsec: zod_1.z.string(),
+    internalVapixParameters: zod_1.z.string(),
+    userVapixParameters: zod_1.z.string(),
+    outputParameters: zod_1.z.string(),
+    outputType: zod_1.z.string(),
+    mediaServerUrl: zod_1.z.string(),
+    inputType: zod_1.z.string(),
+    inputUrl: zod_1.z.string(),
+    forceStereo: zod_1.z.string(),
+    streamDelay: zod_1.z.string(),
+    statusLed: zod_1.z.string(),
+    statusPort: zod_1.z.string(),
+    callApi: zod_1.z.string(),
+    trigger: zod_1.z.string(),
+    schedule: zod_1.z.string(),
+    prepareAhead: zod_1.z.string(),
+    startTime: zod_1.z.string(),
+    stopTime: zod_1.z.string(),
+});
+exports.streamListSchema = zod_1.z.record(zod_1.z.string(), exports.streamAttributesSchema);

package/cjs/types/CamSwitcherAPI.js

@@ -0,0 +1,137 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.clipListSchema = exports.playlistQueueSchema = exports.trackerSaveLoadSchema = exports.trackerSaveSchema = exports.playlistSaveLoadSchema = exports.clipSaveLoadSchema = exports.clipSaveSchema = exports.streamSaveLoadSchema = exports.audioPushInfoSchema = exports.outputInfoSchema = exports.storageInfoListSchema = void 0;
+const zod_1 = require("zod");
+const transformers_1 = require("../internal/transformers");
+const common_1 = require("./common");
+const channelTypeSchema = zod_1.z.union([zod_1.z.literal('audio'), zod_1.z.literal('video'), zod_1.z.literal('av')]);
+const playlistPlayTypeSchema = zod_1.z.union([
+    zod_1.z.literal('PLAY_ALL'),
+    zod_1.z.literal('PLAY_ALL_LOOP'),
+    zod_1.z.literal('PLAY_ALL_SHUFFLED'),
+    zod_1.z.literal('PLAY_ALL_LOOP_SHUFFLED'),
+    zod_1.z.literal('PLAY_ONE_RANDOM'),
+]);
+exports.storageInfoListSchema = zod_1.z.array(zod_1.z.object({
+    storage: common_1.storageTypeSchema,
+    writable: zod_1.z.boolean(),
+    size: zod_1.z.number(),
+    available: zod_1.z.number(),
+}));
+exports.outputInfoSchema = zod_1.z
+    .object({
+    rtsp_url: zod_1.z.string(),
+    ws: zod_1.z.string(),
+    ws_initial_message: zod_1.z.string(),
+})
+    .transform(transformers_1.toCamelCase);
+exports.audioPushInfoSchema = zod_1.z
+    .object({
+    ws: zod_1.z.string(),
+    ws_initial_message: zod_1.z.string(),
+})
+    .transform(transformers_1.toCamelCase);
+const streamSaveSchema = zod_1.z.object({
+    niceName: zod_1.z.string(),
+    ip: zod_1.z.string(),
+    mdnsName: zod_1.z.string(),
+    port: zod_1.z.number(),
+    enabled: zod_1.z.boolean(),
+    auth: zod_1.z.string(),
+    query: zod_1.z.string(),
+    channel: channelTypeSchema,
+    keyboard: common_1.keyboardShortcutsSchema,
+    sortIndexOverview: zod_1.z.number().optional(),
+    viewNumber: zod_1.z.number(),
+});
+exports.streamSaveLoadSchema = zod_1.z.record(zod_1.z.string(), streamSaveSchema.partial());
+exports.clipSaveSchema = zod_1.z.object({
+    niceName: zod_1.z.string(),
+    channel: channelTypeSchema,
+    keyboard: common_1.keyboardShortcutsSchema,
+    sortIndexOverview: zod_1.z.number(),
+});
+exports.clipSaveLoadSchema = zod_1.z.record(zod_1.z.string(), exports.clipSaveSchema.partial());
+const playlistStreamSaveSchema = zod_1.z
+    .object({
+    stream_name: zod_1.z.string(),
+    clip_name: zod_1.z.string(),
+    tracker_name: zod_1.z.string(),
+    storage: common_1.storageTypeSchema,
+})
+    .partial();
+const playlistSaveSchema = zod_1.z.object({
+    channel: channelTypeSchema,
+    isFavourite: zod_1.z.boolean(),
+    keyboard: common_1.keyboardShortcutsSchema,
+    niceName: zod_1.z.string(),
+    sortIndexFavourite: zod_1.z.number().optional(),
+    sortIndexOverview: zod_1.z.number().optional(),
+    play_type: playlistPlayTypeSchema,
+    default: zod_1.z.boolean().optional(),
+    stream_list: zod_1.z.array(zod_1.z.object({
+        id: zod_1.z.string(),
+        isTimeoutCustom: zod_1.z.boolean(),
+        ptz_preset_pos_name: zod_1.z.string(),
+        repeat: zod_1.z.number(),
+        timeout: zod_1.z.number(),
+        video: playlistStreamSaveSchema,
+        audio: playlistStreamSaveSchema.optional(),
+    })),
+});
+exports.playlistSaveLoadSchema = zod_1.z.record(zod_1.z.string(), playlistSaveSchema.partial());
+exports.trackerSaveSchema = zod_1.z.object({
+    id: zod_1.z.string(),
+    name: zod_1.z.string(),
+    previewId: zod_1.z.string(),
+    duration: zod_1.z.number(),
+    keyboard: common_1.keyboardShortcutsSchema,
+    channel: channelTypeSchema,
+    sortIndexOverview: zod_1.z.number(),
+    width: zod_1.z.number(),
+    height: zod_1.z.number(),
+    fps: zod_1.z.number(),
+    motion_history_frames: zod_1.z.number(),
+    include_zone: zod_1.z.array(zod_1.z.array(zod_1.z.number()).length(2)),
+    include_node_ids: zod_1.z.array(zod_1.z.string()),
+    camera_list: zod_1.z.array(zod_1.z.object({
+        id: zod_1.z.string(),
+        name: zod_1.z.string(),
+        overview: zod_1.z.boolean(),
+        zone: zod_1.z.array(zod_1.z.number()).length(4),
+        playlist_name: zod_1.z.string(),
+        ptz_preset_pos_no: zod_1.z.number(),
+    })),
+    viewNumber: zod_1.z.number(),
+    camera_view_number: zod_1.z.number(),
+});
+exports.trackerSaveLoadSchema = zod_1.z.record(zod_1.z.string(), exports.trackerSaveSchema.partial());
+exports.playlistQueueSchema = zod_1.z
+    .object({
+    playlist_queue_list: zod_1.z.array(zod_1.z.string()),
+})
+    .transform(transformers_1.toCamelCaseDeep);
+exports.clipListSchema = zod_1.z.object({
+    clip_list: zod_1.z.record(zod_1.z.string(), zod_1.z.object({
+        storage: common_1.storageTypeSchema,
+        duration: zod_1.z.number(),
+        stream_list: zod_1.z.array(zod_1.z.union([
+            zod_1.z.object({
+                type: zod_1.z.literal('video'),
+                width: zod_1.z.number(),
+                height: zod_1.z.number(),
+                sample_rate: zod_1.z.number(),
+                h264_profile: common_1.h264ProfileSchema,
+                h264_level: zod_1.z.literal('4.1'),
+                gop: zod_1.z.number(),
+                fps: zod_1.z.number(),
+                bitrate: zod_1.z.number(),
+            }),
+            zod_1.z.object({
+                type: zod_1.z.literal('audio'),
+                sample_rate: zod_1.z.number(),
+                channel_count: common_1.audioChannelCountSchema,
+            }),
+        ])),
+    })),
+});