camstreamerlib 4.0.0-beta.47 → 4.0.0-beta.48

package/esm/types/ws/PlaneTrackerEvents.js

@@ -0,0 +1,74 @@
+import { z } from 'zod';
+const apiFlightDataSchema = z.object({
+    icao: z.string(),
+    lat: z.number(),
+    lon: z.number(),
+    heading: z.number(),
+    groundSpeed: z.number(),
+    altitudeAMSL: z.number(),
+    cameraDistance: z.number(),
+    autoTrackingOrder: z.number(),
+    whiteListed: z.boolean(),
+    blackListed: z.boolean(),
+    priorityListed: z.boolean(),
+    autoSelectionIgnored: z.boolean(),
+    signalQuality: z.number(),
+    emergencyState: z.boolean(),
+    emergencyStatusMessage: z.string(),
+});
+const apiUserSchema = z.object({
+    userId: z.string(),
+    userName: z.string(),
+    userPriority: z.number(),
+    ip: z.string(),
+});
+const ptrEventsDataSchema = z.discriminatedUnion('type', [
+    z.object({
+        type: z.literal('CAMERA_POSITION'),
+        lat: z.number(),
+        lon: z.number(),
+        azimuth: z.number().min(0).max(360),
+        elevation: z.number().min(-90).max(90),
+        fov: z.number(),
+    }),
+    z.object({
+        type: z.literal('TRACKING_START'),
+        icao: z.string(),
+    }),
+    z.object({
+        type: z.literal('TRACKING_STOP'),
+    }),
+    z.object({
+        type: z.literal('FLIGHT_LIST'),
+        list: z.array(apiFlightDataSchema),
+    }),
+    z.object({
+        type: z.literal('USER_ACTION'),
+        ip: z.string(),
+        params: z.object({
+            userId: z.string(),
+            userName: z.string(),
+            userPriority: z.number(),
+        }),
+        cgi: z.string(),
+        postJsonBody: z.any(),
+    }),
+    z.object({
+        type: z.literal('CONNECTED_USERS'),
+        users: z.array(apiUserSchema),
+    }),
+    z.object({
+        type: z.literal('FORCE_TRACKING_STATUS'),
+        enabled: z.boolean(),
+        icao: z.string().optional(),
+    }),
+    z.object({
+        type: z.literal('API_LOCK_STATUS'),
+        isLocked: z.boolean(),
+        user: apiUserSchema.optional(),
+    }),
+]);
+export const ptrEventsSchema = z.discriminatedUnion('type', [
+    z.object({ type: z.literal('init'), data: ptrEventsDataSchema }),
+    ...ptrEventsDataSchema.options,
+]);

package/esm/web/DefaultClient.js

@@ -1,5 +1,9 @@
 import { addParametersToPath } from '../internal/utils';
 export class DefaultClient {
+    domain;
+    constructor(domain = '') {
+        this.domain = domain;
+    }
     get = (params) => {
         return this.fetchWithTimeout(addParametersToPath(params.path, params.parameters), {
             method: 'GET',
@@ -13,11 +17,11 @@ export class DefaultClient {
             headers: params.headers,
         }, params.timeout);
     };
-    async fetchWithTimeout(url, options, timeout) {
+    async fetchWithTimeout(path, options, timeout) {
         const controller = new AbortController();
         const timeoutId = timeout !== undefined ? setTimeout(() => controller.abort(), timeout) : null;
         try {
-            return await fetch(url, { ...options, signal: controller.signal });
+            return await fetch(`${this.domain}${path}`, { ...options, signal: controller.signal });
         }
         finally {
             if (timeoutId) {

package/esm/web/WsClient.js

@@ -1,13 +1,11 @@
 const REFRESH_TIMEOUT = 5000;
 export class WsClient {
     getUrl;
-    getAuthToken;
     isDestroyed = false;
     ws = null;
     restartTimeout = null;
-    constructor(getUrl, getAuthToken) {
+    constructor(getUrl) {
         this.getUrl = getUrl;
-        this.getAuthToken = getAuthToken;
     }
     init() {
         if (this.isDestroyed) {
@@ -15,17 +13,9 @@ export class WsClient {
         }
         this.destroyWebsocket();
         const ws = new WebSocket(this.getUrl(), 'events');
-        ws.onopen = async () => {
-            try {
-                const token = await this.getAuthToken();
-                ws.send(JSON.stringify({ authorization: token }));
-            }
-            catch (error) {
-                console.error('Error sending auth token:', error);
-                ws.close();
-            }
-        };
-        ws.onmessage = (e) => this.onmessage(e);
+        ws.binaryType = 'arraybuffer';
+        ws.onopen = () => this.onOpen();
+        ws.onmessage = (e) => this.onMessage(e.data);
         ws.onclose = () => {
             this.restartTimeout = window.setTimeout(() => this.init(), REFRESH_TIMEOUT);
         };
@@ -34,7 +24,15 @@ export class WsClient {
     send = (msg) => {
         this.ws?.send(msg);
     };
-    onmessage = (_) => { };
+    onMessage = (_) => { };
+    onOpen = () => { };
+    onClose = () => { };
+    onError = (error) => {
+        console.error(error);
+    };
+    reconnect = () => {
+        this.ws?.close();
+    };
     destroy = () => {
         this.isDestroyed = true;
         this.destroyWebsocket();

package/esm/ws/CamOverlayEvents.js

@@ -0,0 +1,20 @@
+import { WsEvents } from '../internal/WsEvents';
+import { coEventsSchema } from '../types/ws/CamOverlayEvents';
+export class CamOverlayEvents extends WsEvents {
+    getAuthToken;
+    constructor(ws, getAuthToken) {
+        super(coEventsSchema, ws);
+        this.getAuthToken = getAuthToken;
+        this.ws.onOpen = this.sendInitMsg;
+    }
+    sendInitMsg = async () => {
+        try {
+            const token = await this.getAuthToken();
+            this.ws.send(JSON.stringify({ authorization: token }));
+        }
+        catch (error) {
+            console.error('Error on open:', error);
+            this.ws.reconnect();
+        }
+    };
+}

package/esm/ws/CamStreamerEvents.js

@@ -0,0 +1,20 @@
+import { WsEvents } from '../internal/WsEvents';
+import { csEventsSchema } from '../types/ws/CamStreamerEvents';
+export class CamStreamerEvents extends WsEvents {
+    getAuthToken;
+    constructor(ws, getAuthToken) {
+        super(csEventsSchema, ws);
+        this.getAuthToken = getAuthToken;
+        this.ws.onOpen = this.sendInitMsg;
+    }
+    sendInitMsg = async () => {
+        try {
+            const token = await this.getAuthToken();
+            this.ws.send(JSON.stringify({ authorization: token }));
+        }
+        catch (error) {
+            console.error('Error on open:', error);
+            this.ws.reconnect();
+        }
+    };
+}

package/esm/ws/CamSwitcherEvents.js

@@ -0,0 +1,20 @@
+import { WsEvents } from '../internal/WsEvents';
+import { cswEventsSchema } from '../types/ws/CamSwitcherEvents';
+export class CamSwitcherEvents extends WsEvents {
+    getAuthToken;
+    constructor(ws, getAuthToken) {
+        super(cswEventsSchema, ws);
+        this.getAuthToken = getAuthToken;
+        this.ws.onOpen = this.sendInitMsg;
+    }
+    sendInitMsg = async () => {
+        try {
+            const token = await this.getAuthToken();
+            this.ws.send(JSON.stringify({ authorization: token }));
+        }
+        catch (error) {
+            console.error('Error on open:', error);
+            this.ws.reconnect();
+        }
+    };
+}

package/esm/ws/PlaneTrackerEvents.js

@@ -0,0 +1,18 @@
+import { WsEvents } from '../internal/WsEvents';
+import { ptrEventsSchema } from '../types/ws/PlaneTrackerEvents';
+export class PlaneTrackerEvents extends WsEvents {
+    _apiUser;
+    constructor(ws, _apiUser) {
+        super(ptrEventsSchema, ws);
+        this._apiUser = _apiUser;
+        this.ws.onOpen = this.sendInitMsg;
+    }
+    sendInitMsg = () => {
+        this.ws.send(JSON.stringify({
+            type: 'USER_INFO',
+            userId: this._apiUser.userId,
+            userName: this._apiUser.userName,
+            userPriority: this._apiUser.userPriority,
+        }));
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "camstreamerlib",
-    "version": "4.0.0-beta.47",
+    "version": "4.0.0-beta.48",
     "description": "Helper library for CamStreamer ACAP applications.",
     "prettier": "@camstreamer/prettier-config",
     "engine": {

package/types/CamSwitcherAPI.d.ts

@@ -12,7 +12,7 @@ export declare class CamSwitcherAPI<Client extends IClient<TResponse, any>> {
     });
     static getProxyPath: () => string;
     static getWsEventsPath: () => string;
-    static getClipPreviewPath: (id: string, storage: TStorageType) => string;
+    static getClipPreviewPath: (clipId: string, storage: TStorageType) => string;
     getClient(proxyParams?: TProxyParams): Client | ProxyClient<Client>;
     checkCameraTime(options?: THttpRequestOptions): Promise<boolean>;
     getNetworkCameraList(options?: THttpRequestOptions): Promise<{

package/types/PlaneTrackerAPI.d.ts

@@ -1,5 +1,5 @@
 import { IClient, TBlobResponse, TParameters, TResponse } from './internal/types';
-import { ICAO, TApiUser, TBlackList, TCameraSettings, TExportDataType, TImportDataType, TPriorityList, TTrackingMode, TWhiteList, TZones } from './types/PlaneTrackerAPI';
+import { ICAO, TApiUser, TBlackList, TCameraSettings, TExportDataType, TGetIcaoByOption, TImportDataType, TPriorityList, TTrackingMode, TWhiteList, TZones } from './types/PlaneTrackerAPI';
 import { THttpRequestOptions, TProxyParams } from './types/common';
 import { ProxyClient } from './internal/ProxyClient';
 export declare class PlaneTrackerAPI<Client extends IClient<TResponse, any>> {
@@ -177,6 +177,7 @@ export declare class PlaneTrackerAPI<Client extends IClient<TResponse, any>> {
     setTrackingMode(mode: TTrackingMode['mode'], options?: THttpRequestOptions): Promise<void>;
     startTrackingPlane(icao: ICAO, options?: THttpRequestOptions): Promise<void>;
     stopTrackingPlane(options?: THttpRequestOptions): Promise<void>;
+    getIcao(by: TGetIcaoByOption, value: string, options?: THttpRequestOptions): Promise<string>;
     getPriorityList(options?: THttpRequestOptions): Promise<{
         priorityList: string[];
     }>;

package/types/index.d.ts

@@ -4,17 +4,23 @@ export * from './internal/utils';
 export * from './internal/versionCompare';
 export * from './internal/ProxyClient';
 export * from './types/common';
-export { CamOverlayAPI } from './CamOverlayAPI';
-export * from './types/CamOverlayAPI';
-export { CamScripterAPI } from './CamScripterAPI';
-export * from './types/CamScripterAPI';
 export { CamStreamerAPI } from './CamStreamerAPI';
 export * from './types/CamStreamerAPI';
+export { CamStreamerEvents } from './ws/CamStreamerEvents';
+export * from './types/ws/CamStreamerEvents';
+export { CamOverlayAPI } from './CamOverlayAPI';
+export * from './types/CamOverlayAPI';
+export { CamOverlayEvents } from './ws/CamOverlayEvents';
+export * from './types/ws/CamOverlayEvents';
 export { CamSwitcherAPI } from './CamSwitcherAPI';
 export * from './types/CamSwitcherAPI';
-export { CamSwitcherEvents } from './CamSwitcherEvents';
-export * from './types/CamSwitcherEvents';
+export { CamSwitcherEvents } from './ws/CamSwitcherEvents';
+export * from './types/ws/CamSwitcherEvents';
 export { PlaneTrackerAPI } from './PlaneTrackerAPI';
 export * from './types/PlaneTrackerAPI';
+export { PlaneTrackerEvents } from './ws/PlaneTrackerEvents';
+export * from './types/ws/PlaneTrackerEvents';
+export { CamScripterAPI } from './CamScripterAPI';
+export * from './types/CamScripterAPI';
 export { VapixAPI } from './VapixAPI';
 export * from './types/VapixAPI';

package/types/internal/WsEvents.d.ts

@@ -1,4 +1,4 @@
-import { IWebsocket } from './types';
+import { IWsClient } from './types';
 type TEventType<T extends {
     type: string;
 }> = T extends {
@@ -22,14 +22,12 @@ type TListenerFunction<T extends {
 }, Type extends TEventType<T>> = (data: TEvent<T, Type>, isInit: boolean) => void;
 export declare class WsEvents<T extends {
     type: string;
-}, Event extends {
-    data: string;
 }> {
     private zodSchema;
-    ws: IWebsocket<Event>;
+    ws: IWsClient;
     private _isDestroyed;
     private listeners;
-    constructor(zodSchema: TZodSchema<T>, ws: IWebsocket<Event>);
+    constructor(zodSchema: TZodSchema<T>, ws: IWsClient);
     get isDestroyed(): boolean;
     resendInitData(): void;
     addListener<Type extends TEventType<T>>(type: Type, listener: TListenerFunction<T, Type>, id: string): void;

package/types/internal/types.d.ts

@@ -9,7 +9,6 @@ export type Options = {
 export type HttpOptions = Options & {
     keepAlive?: boolean;
 };
-export type WsOptions = Options;
 export type TParameters = Record<string, string | number | boolean | null | undefined>;
 export type TResponse = {
     json: () => Promise<any>;
@@ -36,10 +35,12 @@ export interface IClient<TRes extends TResponse, Data> {
     post: (params: TPostParams<Data>) => Promise<TRes>;
 }
 export type TBlobResponse<Client extends IClient<TResponse, any>> = Awaited<ReturnType<Awaited<ReturnType<Client['get']>>['blob']>>;
-export interface IWebsocket<Event extends {
-    readonly data: string;
-}> {
+export interface IWsClient {
+    onMessage: null | ((data: ArrayBuffer | string) => void);
+    onOpen: () => void;
+    onClose: () => void;
+    onError: (error: Error) => void;
+    send: (data: ArrayBuffer | string) => void;
+    reconnect: () => void;
     destroy: () => void;
-    onmessage: null | ((event: Event) => void);
-    send: (data: string) => void;
 }

package/types/node/CamScripterAPICameraEventsGenerator.d.ts

@@ -1,6 +1,6 @@
 /// <reference types="node" />
 import EventEmitter from 'events';
-import { WsOptions } from '../internal/types';
+import { Options } from '../internal/types';
 import { TCamScripterEvent, TEventDeclaration, TEventUndeclaration, TCamScripterResponse } from '../types/CamScripterAPICameraEventsGenerator';
 export declare class CamScripterAPICameraEventsGenerator extends EventEmitter {
     private tls;
@@ -14,7 +14,7 @@ export declare class CamScripterAPICameraEventsGenerator extends EventEmitter {
     private timeoutCheckTimer;
     private wsConnected;
     private ws;
-    constructor(options?: WsOptions);
+    constructor(options?: Options);
     connect(): void;
     disconnect(): void;
     declareEvent(eventDeclaration: TEventDeclaration): Promise<TCamScripterResponse>;

package/types/node/Digest.test.d.ts

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

package/types/node/VapixEvents.d.ts

@@ -1,5 +1,5 @@
 import { EventEmitter2 as EventEmitter } from 'eventemitter2';
-import { WsOptions } from '../internal/types';
+import { Options } from '../internal/types';
 export declare class VapixEvents extends EventEmitter {
     private tls;
     private tlsInsecure;
@@ -8,7 +8,7 @@ export declare class VapixEvents extends EventEmitter {
     private user;
     private pass;
     private ws;
-    constructor(options?: WsOptions);
+    constructor(options?: Options);
     connect(): void;
     disconnect(): void;
     private createWsClient;

package/types/node/WsClient.d.ts

@@ -1,25 +1,11 @@
-/// <reference types="node" />
-/// <reference types="node" />
-/// <reference types="node" />
-import EventEmitter from 'events';
-import { WsOptions } from '../internal/types';
-export type WsClientOptions = WsOptions & {
+import { IWsClient, Options } from '../internal/types';
+export type WsClientOptions = Options & {
     address: string;
     headers?: Record<string, string>;
     pingInterval?: number;
     protocol?: string;
 };
-export interface WsClient {
-    on(event: 'open', listener: () => void): this;
-    on(event: 'close', listener: () => void): this;
-    on(event: 'message', listener: (data: Buffer) => void): this;
-    on(event: 'error', listener: (err: Error) => void): this;
-    emit(event: 'open'): boolean;
-    emit(event: 'close'): boolean;
-    emit(event: 'message', data: Buffer): boolean;
-    emit(event: 'error', err: Error): boolean;
-}
-export declare class WsClient extends EventEmitter {
+export declare class WsClient implements IWsClient {
     private user;
     private pass;
     private address;
@@ -33,8 +19,12 @@ export declare class WsClient extends EventEmitter {
     private isClosed;
     constructor(options: WsClientOptions);
     open(wwwAuthenticateHeader?: string): void;
-    send(data: Buffer | string): void;
-    close(): void;
+    onMessage: (_: ArrayBuffer | string) => void;
+    onOpen: () => void;
+    onClose: () => void;
+    onError: (error: Error) => void;
+    send(data: ArrayBuffer | string): void;
+    destroy(): void;
     reconnect(): void;
     private closeWsConnection;
 }

package/types/types/CamOverlayAPI/CamOverlayAPI.d.ts

@@ -527,7 +527,7 @@ export declare const servicesSchema: z.ZodDiscriminatedUnion<"name", [z.ZodObjec
     camera_height: z.ZodNumber;
     camera_view_area: z.ZodString;
     camera_overlay_params: z.ZodUnion<[z.ZodLiteral<"overlays=off">, z.ZodLiteral<"overlays=all">, z.ZodLiteral<"overlays=text">, z.ZodLiteral<"overlays=image">, z.ZodLiteral<"overlays=application">]>;
-    rotate: z.ZodUnion<[z.ZodLiteral<0>, z.ZodLiteral<90>, z.ZodLiteral<180>, z.ZodLiteral<270>]>;
+    rotate: z.ZodDefault<z.ZodUnion<[z.ZodLiteral<0>, z.ZodLiteral<90>, z.ZodLiteral<180>, z.ZodLiteral<270>]>>;
     dewarping: z.ZodObject<{
         enabled: z.ZodBoolean;
         rectangle: z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, "many">;
@@ -608,7 +608,6 @@ export declare const servicesSchema: z.ZodDiscriminatedUnion<"name", [z.ZodObjec
     camera_height: number;
     camera_view_area: string;
     camera_overlay_params: "overlays=off" | "overlays=all" | "overlays=text" | "overlays=image" | "overlays=application";
-    rotate: 0 | 90 | 180 | 270;
     dewarping: {
         enabled: boolean;
         rectangle: [number, number][];
@@ -620,6 +619,7 @@ export declare const servicesSchema: z.ZodDiscriminatedUnion<"name", [z.ZodObjec
     schedule?: string | undefined;
     invertInput?: boolean | undefined;
     zIndex?: number | undefined;
+    rotate?: 0 | 90 | 180 | 270 | undefined;
 }>, z.ZodObject<{
     id: z.ZodNumber;
     enabled: z.ZodUnion<[z.ZodLiteral<0>, z.ZodLiteral<1>]>;
@@ -1997,7 +1997,7 @@ export declare const serviceListSchema: z.ZodObject<{
         camera_height: z.ZodNumber;
         camera_view_area: z.ZodString;
         camera_overlay_params: z.ZodUnion<[z.ZodLiteral<"overlays=off">, z.ZodLiteral<"overlays=all">, z.ZodLiteral<"overlays=text">, z.ZodLiteral<"overlays=image">, z.ZodLiteral<"overlays=application">]>;
-        rotate: z.ZodUnion<[z.ZodLiteral<0>, z.ZodLiteral<90>, z.ZodLiteral<180>, z.ZodLiteral<270>]>;
+        rotate: z.ZodDefault<z.ZodUnion<[z.ZodLiteral<0>, z.ZodLiteral<90>, z.ZodLiteral<180>, z.ZodLiteral<270>]>>;
         dewarping: z.ZodObject<{
             enabled: z.ZodBoolean;
             rectangle: z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, "many">;
@@ -2078,7 +2078,6 @@ export declare const serviceListSchema: z.ZodObject<{
         camera_height: number;
         camera_view_area: string;
         camera_overlay_params: "overlays=off" | "overlays=all" | "overlays=text" | "overlays=image" | "overlays=application";
-        rotate: 0 | 90 | 180 | 270;
         dewarping: {
             enabled: boolean;
             rectangle: [number, number][];
@@ -2090,6 +2089,7 @@ export declare const serviceListSchema: z.ZodObject<{
         schedule?: string | undefined;
         invertInput?: boolean | undefined;
         zIndex?: number | undefined;
+        rotate?: 0 | 90 | 180 | 270 | undefined;
     }>, z.ZodObject<{
         id: z.ZodNumber;
         enabled: z.ZodUnion<[z.ZodLiteral<0>, z.ZodLiteral<1>]>;
@@ -3533,7 +3533,6 @@ export declare const serviceListSchema: z.ZodObject<{
         camera_height: number;
         camera_view_area: string;
         camera_overlay_params: "overlays=off" | "overlays=all" | "overlays=text" | "overlays=image" | "overlays=application";
-        rotate: 0 | 90 | 180 | 270;
         dewarping: {
             enabled: boolean;
             rectangle: [number, number][];
@@ -3545,6 +3544,7 @@ export declare const serviceListSchema: z.ZodObject<{
         schedule?: string | undefined;
         invertInput?: boolean | undefined;
         zIndex?: number | undefined;
+        rotate?: 0 | 90 | 180 | 270 | undefined;
     } | {
         name: "customGraphics";
         enabled: 0 | 1;

package/types/types/CamOverlayAPI/pipSchema.d.ts

@@ -29,7 +29,7 @@ export declare const pipSchema: z.ZodObject<{
     camera_height: z.ZodNumber;
     camera_view_area: z.ZodString;
     camera_overlay_params: z.ZodUnion<[z.ZodLiteral<"overlays=off">, z.ZodLiteral<"overlays=all">, z.ZodLiteral<"overlays=text">, z.ZodLiteral<"overlays=image">, z.ZodLiteral<"overlays=application">]>;
-    rotate: z.ZodUnion<[z.ZodLiteral<0>, z.ZodLiteral<90>, z.ZodLiteral<180>, z.ZodLiteral<270>]>;
+    rotate: z.ZodDefault<z.ZodUnion<[z.ZodLiteral<0>, z.ZodLiteral<90>, z.ZodLiteral<180>, z.ZodLiteral<270>]>>;
     dewarping: z.ZodObject<{
         enabled: z.ZodBoolean;
         rectangle: z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, "many">;
@@ -110,7 +110,6 @@ export declare const pipSchema: z.ZodObject<{
     camera_height: number;
     camera_view_area: string;
     camera_overlay_params: "overlays=off" | "overlays=all" | "overlays=text" | "overlays=image" | "overlays=application";
-    rotate: 0 | 90 | 180 | 270;
     dewarping: {
         enabled: boolean;
         rectangle: [number, number][];
@@ -122,4 +121,5 @@ export declare const pipSchema: z.ZodObject<{
     schedule?: string | undefined;
     invertInput?: boolean | undefined;
     zIndex?: number | undefined;
+    rotate?: 0 | 90 | 180 | 270 | undefined;
 }>;

package/types/types/CamOverlayDrawingAPI.d.ts

@@ -1,5 +1,5 @@
-import { WsOptions } from '../internal/types';
-export type CamOverlayDrawingOptions = WsOptions & {
+import { Options } from '../internal/types';
+export type CamOverlayDrawingOptions = Options & {
     camera?: number | number[];
     zIndex?: number;
 };

package/types/types/PlaneTrackerAPI.d.ts

@@ -666,6 +666,14 @@ export declare const serverSettingsSchema: z.ZodObject<{
 }>;
 export type TServerSettings = z.infer<typeof serverSettingsSchema>;
 export type ICAO = string;
+export declare const getIcaoSchema: z.ZodObject<{
+    icao: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    icao: string;
+}, {
+    icao: string;
+}>;
+export type TGetIcaoByOption = 'registration' | 'callsign';
 export declare const trackingModeSchema: z.ZodObject<{
     mode: z.ZodUnion<[z.ZodLiteral<"MANUAL">, z.ZodLiteral<"AUTOMATIC">]>;
 }, "strip", z.ZodTypeAny, {

package/types/types/ws/CamOverlayEvents.d.ts

@@ -0,0 +1,88 @@
+import { z } from 'zod';
+export declare const coEventsSchema: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+    type: z.ZodLiteral<"init">;
+    data: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+        type: z.ZodLiteral<"authorization">;
+        state: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        type: "authorization";
+        state: string;
+    }, {
+        type: "authorization";
+        state: string;
+    }>, z.ZodObject<{
+        type: z.ZodLiteral<"ServiceStart">;
+        serviceId: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        type: "ServiceStart";
+        serviceId: number;
+    }, {
+        type: "ServiceStart";
+        serviceId: number;
+    }>, z.ZodObject<{
+        type: z.ZodLiteral<"ServiceStop">;
+        serviceId: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        type: "ServiceStop";
+        serviceId: number;
+    }, {
+        type: "ServiceStop";
+        serviceId: number;
+    }>]>;
+}, "strip", z.ZodTypeAny, {
+    type: "init";
+    data: {
+        type: "authorization";
+        state: string;
+    } | {
+        type: "ServiceStart";
+        serviceId: number;
+    } | {
+        type: "ServiceStop";
+        serviceId: number;
+    };
+}, {
+    type: "init";
+    data: {
+        type: "authorization";
+        state: string;
+    } | {
+        type: "ServiceStart";
+        serviceId: number;
+    } | {
+        type: "ServiceStop";
+        serviceId: number;
+    };
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"authorization">;
+    state: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    type: "authorization";
+    state: string;
+}, {
+    type: "authorization";
+    state: string;
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"ServiceStart">;
+    serviceId: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    type: "ServiceStart";
+    serviceId: number;
+}, {
+    type: "ServiceStart";
+    serviceId: number;
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"ServiceStop">;
+    serviceId: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    type: "ServiceStop";
+    serviceId: number;
+}, {
+    type: "ServiceStop";
+    serviceId: number;
+}>]>;
+export type TCamOverlayEvent = z.infer<typeof coEventsSchema>;
+export type TCamOverlayEventType = TCamOverlayEvent['type'];
+export type TCamOverlayEventOfType<T extends TCamOverlayEventType> = Extract<TCamOverlayEvent, {
+    type: T;
+}>;