camstreamerlib 4.0.15 → 4.0.17-dev-milestone.0

package/esm/node/events/MilestoneAgent.js

@@ -0,0 +1,120 @@
+import { ErrorWithResponse } from '../../errors/errors';
+import { HttpRequestSender } from '../HttpRequestSender';
+import { camerasResponseSchema, tokenResponseSchema, } from '../../types/MilestoneAgent';
+const CLIENT_ID = 'GrantValidatorClient';
+const PAGE_SIZE = 100;
+const TOKEN_EXPIRY_MARGIN_SEC = 60;
+export class MilestoneAgent {
+    settings;
+    protocol;
+    sender;
+    token;
+    constructor(options = {}) {
+        this.settings = {
+            protocol: options.protocol ?? 'https_insecure',
+            ip: options.ip ?? '127.0.0.1',
+            port: options.port ?? 443,
+            user: options.user ?? '',
+            pass: options.pass ?? '',
+            timeout: options.timeout ?? 10000,
+        };
+        this.protocol = this.settings.protocol === 'http' ? 'http:' : 'https:';
+        const tlsInsecure = this.settings.protocol === 'https_insecure';
+        this.sender = new HttpRequestSender({ rejectUnaurhorized: !tlsInsecure });
+    }
+    async checkConnection() {
+        await this.getToken(true);
+        await this.getCamerasPage(1, 1);
+    }
+    async getAllCameras() {
+        const cameras = [];
+        let page = 1;
+        for (;;) {
+            const pageCameras = await this.getCamerasPage(page, PAGE_SIZE);
+            cameras.push(...pageCameras);
+            if (pageCameras.length < PAGE_SIZE) {
+                break;
+            }
+            page += 1;
+        }
+        return cameras;
+    }
+    async sendBookmark(cameraId, bookmark) {
+        const token = await this.getToken();
+        const body = JSON.stringify({
+            ...bookmark,
+            devicePath: { type: 'cameras', id: cameraId },
+        });
+        const res = await this.sender.sendRequest(this.getRequestOptions('POST', '/api/rest/v1/bookmarks', token, {
+            'Content-Type': 'application/json',
+        }), body);
+        if (!res.ok) {
+            throw new ErrorWithResponse(res);
+        }
+    }
+    async getCamerasPage(page, itemsPerPage) {
+        const token = await this.getToken();
+        const res = await this.sender.sendRequest(this.getRequestOptions('GET', `/api/rest/v1/cameras?page=${page}&itemsPerPage=${itemsPerPage}`, token));
+        if (!res.ok) {
+            throw new ErrorWithResponse(res);
+        }
+        const responseBody = await res.text();
+        const result = await camerasResponseSchema.safeParseAsync(JSON.parse(responseBody));
+        if (!result.success) {
+            throw new Error('Milestone get cameras failed: ' + JSON.stringify(result.error.issues) + '\n' + responseBody);
+        }
+        return result.data.array;
+    }
+    async getToken(forceRefresh = false) {
+        const nowSec = Date.now() / 1000;
+        if (!forceRefresh && this.token !== undefined && this.token.expiresAt > nowSec) {
+            return this.token.value;
+        }
+        const body = new URLSearchParams({
+            grant_type: 'password',
+            username: this.settings.user,
+            password: this.settings.pass,
+            client_id: CLIENT_ID,
+        }).toString();
+        const res = await this.sender.sendRequest({
+            method: 'POST',
+            protocol: this.protocol,
+            host: this.settings.ip,
+            port: this.settings.port,
+            path: '/idp/connect/token',
+            timeout: this.settings.timeout,
+            headers: {
+                'Content-Type': 'application/x-www-form-urlencoded',
+                'Accept': 'application/json',
+            },
+        }, body);
+        if (!res.ok) {
+            throw new ErrorWithResponse(res);
+        }
+        const responseBody = await res.text();
+        const result = await tokenResponseSchema.safeParseAsync(JSON.parse(responseBody));
+        if (!result.success) {
+            throw new Error('Milestone authorization failed: ' + JSON.stringify(result.error.issues) + '\n' + responseBody);
+        }
+        this.token = {
+            value: result.data.access_token,
+            expiresAt: nowSec + result.data.expires_in - TOKEN_EXPIRY_MARGIN_SEC,
+        };
+        return this.token.value;
+    }
+    getRequestOptions(method, path, token, extraHeaders) {
+        return {
+            method,
+            protocol: this.protocol,
+            host: this.settings.ip,
+            port: this.settings.port,
+            path,
+            timeout: this.settings.timeout,
+            headers: {
+                Authorization: `Bearer ${token}`,
+                Accept: 'application/json',
+                ...extraHeaders,
+            },
+        };
+    }
+}

package/esm/node/events/MilestoneAgent.test.js

@@ -0,0 +1,100 @@
+import { describe, test, expect, beforeEach, jest } from '@jest/globals';
+import { HttpRequestSender } from '../HttpRequestSender';
+import { MilestoneAgent } from './MilestoneAgent';
+jest.mock('../HttpRequestSender');
+function jsonResponse(body, status = 200) {
+    return {
+        ok: status >= 200 && status < 300,
+        status,
+        statusText: 'OK',
+        text: () => Promise.resolve(JSON.stringify(body)),
+    };
+}
+const TOKEN_BODY = { access_token: 'abc123', expires_in: 3600, token_type: 'Bearer', scope: 'managementserver' };
+describe('MilestoneAgent', () => {
+    const MockedSender = jest.mocked(HttpRequestSender);
+    let sendRequest;
+    beforeEach(() => {
+        sendRequest = jest.fn();
+        MockedSender.mockImplementation(() => ({ sendRequest }));
+    });
+    function callsTo(prefix) {
+        return sendRequest.mock.calls.filter((c) => c[0].path.startsWith(prefix));
+    }
+    function routeByPath(handlers) {
+        sendRequest.mockImplementation((...args) => {
+            const options = args[0];
+            if (options.path === '/idp/connect/token') {
+                return Promise.resolve(jsonResponse(TOKEN_BODY));
+            }
+            for (const [prefix, handler] of Object.entries(handlers)) {
+                if (options.path.startsWith(prefix)) {
+                    if (typeof handler === 'function') {
+                        const page = Number(new URLSearchParams(options.path.split('?')[1]).get('page'));
+                        return Promise.resolve(handler(page));
+                    }
+                    return Promise.resolve(handler);
+                }
+            }
+            throw new Error(`Unexpected path ${options.path}`);
+        });
+    }
+    test('fetches a bearer token before listing cameras and sends it in the header', async () => {
+        routeByPath({ '/api/rest/v1/cameras': jsonResponse({ array: [{ id: 'cam-1', displayName: 'Cam 1' }] }) });
+        const agent = new MilestoneAgent({ ip: '1.2.3.4' });
+        const cameras = await agent.getAllCameras();
+        expect(cameras).toEqual([{ id: 'cam-1', displayName: 'Cam 1' }]);
+        const tokenCalls = callsTo('/idp/connect/token');
+        expect(tokenCalls.length).toBe(1);
+        expect(tokenCalls[0][0].method).toBe('POST');
+        const camerasCall = callsTo('/api/rest/v1/cameras')[0];
+        expect(camerasCall[0].headers.Authorization).toBe('Bearer abc123');
+    });
+    test('reuses the cached token across calls', async () => {
+        routeByPath({ '/api/rest/v1/cameras': jsonResponse({ array: [] }) });
+        const agent = new MilestoneAgent({ ip: '1.2.3.4' });
+        await agent.getAllCameras();
+        await agent.getAllCameras();
+        expect(callsTo('/idp/connect/token').length).toBe(1);
+    });
+    test('pages through cameras until a non-full page is returned', async () => {
+        const fullPage = (page) => jsonResponse({ array: Array.from({ length: 100 }, (_, i) => ({ id: `p${page}-${i}` })) });
+        routeByPath({
+            '/api/rest/v1/cameras': (page) => page < 3 ? fullPage(page) : jsonResponse({ array: [{ id: 'last' }] }),
+        });
+        const agent = new MilestoneAgent({ ip: '1.2.3.4' });
+        const cameras = await agent.getAllCameras();
+        expect(cameras.length).toBe(201);
+        expect(cameras[cameras.length - 1]).toEqual({ id: 'last' });
+    });
+    test('sends a bookmark with the camera devicePath', async () => {
+        routeByPath({ '/api/rest/v1/bookmarks': jsonResponse({ result: {} }, 201) });
+        const agent = new MilestoneAgent({ ip: '1.2.3.4' });
+        await agent.sendBookmark('cam-guid', {
+            header: 'Airbus A320',
+            description: 'ICAO BC4AA',
+            timeBegin: '2026-04-16T10:25:00.000Z',
+            timeEnd: '2026-04-16T10:25:00.000Z',
+            timeTriggered: '2026-04-16T10:25:00.000Z',
+            reference: 'BC4AA',
+        });
+        const call = callsTo('/api/rest/v1/bookmarks')[0];
+        expect(call).toBeDefined();
+        const body = JSON.parse(call[1]);
+        expect(body.devicePath).toEqual({ type: 'cameras', id: 'cam-guid' });
+        expect(body.header).toBe('Airbus A320');
+        expect(body.description).toBe('ICAO BC4AA');
+    });
+    test('throws on a non-ok bookmark response', async () => {
+        routeByPath({ '/api/rest/v1/bookmarks': jsonResponse({ error: 'nope' }, 500) });
+        const agent = new MilestoneAgent({ ip: '1.2.3.4' });
+        await expect(agent.sendBookmark('cam-guid', {
+            header: 'h',
+            description: 'd',
+            timeBegin: 't',
+            timeEnd: 't',
+            timeTriggered: 't',
+            reference: 'r',
+        })).rejects.toThrow();
+    });
+});

package/esm/node/index.js

@@ -6,6 +6,8 @@ export * from './events/AxisCameraStationEvents';
 export * from './TimeZoneDaemon';
 export * from './events/GenetecAgent';
 export * from '../types/GenetecAgent';
+export * from './events/MilestoneAgent';
+export * from '../types/MilestoneAgent';
 export { ResourceManager } from './CamOverlayPainter/ResourceManager';
 export { Painter } from './CamOverlayPainter/Painter';
 export { Frame } from './CamOverlayPainter/Frame';

package/esm/types/MilestoneAgent.js

@@ -0,0 +1,15 @@
+import { z } from 'zod';
+export const tokenResponseSchema = z.object({
+    access_token: z.string(),
+    expires_in: z.number(),
+    token_type: z.string(),
+});
+export const milestoneCameraSchema = z.object({
+    id: z.string(),
+    name: z.string().optional(),
+    displayName: z.string().optional(),
+    enabled: z.boolean().optional(),
+});
+export const camerasResponseSchema = z.object({
+    array: z.array(milestoneCameraSchema),
+});

package/esm/types/PlaneTrackerAPI.js

@@ -199,6 +199,20 @@ export const cameraSettingsSchema = z.object({
         pass: '',
         sourceKey: '',
     }),
+    milestone: connectionSchema
+        .extend({
+        enabled: z.boolean(),
+        cameraList: z.string().array().default([]),
+    })
+        .default({
+        enabled: false,
+        protocol: 'https_insecure',
+        ip: '',
+        port: 443,
+        user: '',
+        pass: '',
+        cameraList: [],
+    }),
     camstreamerIntegration: z
         .object({
         adPlacementEnabled: z.boolean(),

package/esm/types/ws/PlaneTrackerEvents.js

@@ -44,6 +44,7 @@ export var EUserActions;
     EUserActions["TRACK_ICAO"] = "trackIcao.cgi";
     EUserActions["TRACK_TARGET"] = "trackTarget.cgi";
     EUserActions["RESET_ICAO"] = "resetIcao.cgi";
+    EUserActions["RESET_TARGET"] = "resetTarget.cgi";
     EUserActions["SET_PRIORITY_LIST"] = "setPriorityList.cgi";
     EUserActions["SET_BLACK_LIST"] = "setBlackList.cgi";
     EUserActions["SET_WHITE_LIST"] = "setWhiteList.cgi";
@@ -86,6 +87,13 @@ const eventsDataSchema = z.union([
         params: userSchema,
         postJsonBody: z.any(),
     }),
+    z.object({
+        type: z.literal('USER_ACTION'),
+        cgi: z.literal(EUserActions.RESET_TARGET),
+        ip: z.string(),
+        params: userSchema,
+        postJsonBody: z.any(),
+    }),
     z.object({
         type: z.literal('USER_ACTION'),
         cgi: z.literal(EUserActions.SET_PRIORITY_LIST),

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "camstreamerlib",
-    "version": "4.0.15",
+    "version": "4.0.17-dev-milestone.0",
     "description": "Helper library for CamStreamer ACAP applications.",
     "prettier": "@camstreamer/prettier-config",
     "engine": {

package/types/PlaneTrackerAPI.d.ts

@@ -107,6 +107,15 @@ export declare class PlaneTrackerAPI<Client extends IClient<TResponse, any>> ext
             protocol: "https" | "http" | "https_insecure";
             sourceKey: string;
         };
+        milestone: {
+            ip: string;
+            enabled: boolean;
+            port: number;
+            cameraList: string[];
+            pass: string;
+            user: string;
+            protocol: "https" | "http" | "https_insecure";
+        };
         camstreamerIntegration: {
             adPlacementEnabled: boolean;
             adMinIntervalSec: number;

package/types/node/events/MilestoneAgent.d.ts

@@ -0,0 +1,14 @@
+import { MilestoneAgentOptions, TBookmark, TMilestoneCamera } from '../../types/MilestoneAgent';
+export declare class MilestoneAgent {
+    private settings;
+    private protocol;
+    private sender;
+    private token?;
+    constructor(options?: MilestoneAgentOptions);
+    checkConnection(): Promise<void>;
+    getAllCameras(): Promise<TMilestoneCamera[]>;
+    sendBookmark(cameraId: string, bookmark: TBookmark): Promise<void>;
+    private getCamerasPage;
+    private getToken;
+    private getRequestOptions;
+}

package/types/node/events/MilestoneAgent.test.d.ts

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

package/types/node/index.d.ts

@@ -6,6 +6,8 @@ export * from './events/AxisCameraStationEvents';
 export * from './TimeZoneDaemon';
 export * from './events/GenetecAgent';
 export * from '../types/GenetecAgent';
+export * from './events/MilestoneAgent';
+export * from '../types/MilestoneAgent';
 export { ResourceManager } from './CamOverlayPainter/ResourceManager';
 export { Painter } from './CamOverlayPainter/Painter';
 export { Frame } from './CamOverlayPainter/Frame';

package/types/types/MilestoneAgent.d.ts

@@ -0,0 +1,81 @@
+import { z } from 'zod';
+export type MilestoneAgentOptions = {
+    protocol?: 'http' | 'https' | 'https_insecure';
+    ip?: string;
+    port?: number;
+    user?: string;
+    pass?: string;
+    timeout?: number;
+};
+export declare const tokenResponseSchema: z.ZodObject<{
+    access_token: z.ZodString;
+    expires_in: z.ZodNumber;
+    token_type: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    access_token: string;
+    expires_in: number;
+    token_type: string;
+}, {
+    access_token: string;
+    expires_in: number;
+    token_type: string;
+}>;
+export type TTokenResponse = z.infer<typeof tokenResponseSchema>;
+export declare const milestoneCameraSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodOptional<z.ZodString>;
+    displayName: z.ZodOptional<z.ZodString>;
+    enabled: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    name?: string | undefined;
+    enabled?: boolean | undefined;
+    displayName?: string | undefined;
+}, {
+    id: string;
+    name?: string | undefined;
+    enabled?: boolean | undefined;
+    displayName?: string | undefined;
+}>;
+export type TMilestoneCamera = z.infer<typeof milestoneCameraSchema>;
+export declare const camerasResponseSchema: z.ZodObject<{
+    array: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodOptional<z.ZodString>;
+        displayName: z.ZodOptional<z.ZodString>;
+        enabled: z.ZodOptional<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        name?: string | undefined;
+        enabled?: boolean | undefined;
+        displayName?: string | undefined;
+    }, {
+        id: string;
+        name?: string | undefined;
+        enabled?: boolean | undefined;
+        displayName?: string | undefined;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    array: {
+        id: string;
+        name?: string | undefined;
+        enabled?: boolean | undefined;
+        displayName?: string | undefined;
+    }[];
+}, {
+    array: {
+        id: string;
+        name?: string | undefined;
+        enabled?: boolean | undefined;
+        displayName?: string | undefined;
+    }[];
+}>;
+export type TCamerasResponse = z.infer<typeof camerasResponseSchema>;
+export type TBookmark = {
+    header: string;
+    description: string;
+    timeBegin: string;
+    timeEnd: string;
+    timeTriggered: string;
+    reference: string;
+};

package/types/types/PlaneTrackerAPI.d.ts

@@ -358,6 +358,32 @@ export declare const cameraSettingsSchema: z.ZodObject<{
         protocol: "https" | "http" | "https_insecure";
         sourceKey: string;
     }>>;
+    milestone: z.ZodDefault<z.ZodObject<{
+        protocol: z.ZodUnion<[z.ZodLiteral<"http">, z.ZodLiteral<"https">, z.ZodLiteral<"https_insecure">]>;
+        ip: z.ZodUnion<[z.ZodString, z.ZodLiteral<"">]>;
+        port: z.ZodNumber;
+        user: z.ZodString;
+        pass: z.ZodString;
+    } & {
+        enabled: z.ZodBoolean;
+        cameraList: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        ip: string;
+        enabled: boolean;
+        port: number;
+        cameraList: string[];
+        pass: string;
+        user: string;
+        protocol: "https" | "http" | "https_insecure";
+    }, {
+        ip: string;
+        enabled: boolean;
+        port: number;
+        pass: string;
+        user: string;
+        protocol: "https" | "http" | "https_insecure";
+        cameraList?: string[] | undefined;
+    }>>;
     camstreamerIntegration: z.ZodDefault<z.ZodObject<{
         adPlacementEnabled: z.ZodBoolean;
         adMinIntervalSec: z.ZodNumber;
@@ -463,6 +489,15 @@ export declare const cameraSettingsSchema: z.ZodObject<{
         protocol: "https" | "http" | "https_insecure";
         sourceKey: string;
     };
+    milestone: {
+        ip: string;
+        enabled: boolean;
+        port: number;
+        cameraList: string[];
+        pass: string;
+        user: string;
+        protocol: "https" | "http" | "https_insecure";
+    };
     camstreamerIntegration: {
         adPlacementEnabled: boolean;
         adMinIntervalSec: number;
@@ -606,6 +641,15 @@ export declare const cameraSettingsSchema: z.ZodObject<{
         protocol: "https" | "http" | "https_insecure";
         sourceKey: string;
     } | undefined;
+    milestone?: {
+        ip: string;
+        enabled: boolean;
+        port: number;
+        pass: string;
+        user: string;
+        protocol: "https" | "http" | "https_insecure";
+        cameraList?: string[] | undefined;
+    } | undefined;
     camstreamerIntegration?: {
         adPlacementEnabled: boolean;
         adMinIntervalSec: number;

package/types/types/ws/PlaneTrackerEvents.d.ts

@@ -107,6 +107,7 @@ export declare enum EUserActions {
     TRACK_ICAO = "trackIcao.cgi",
     TRACK_TARGET = "trackTarget.cgi",
     RESET_ICAO = "resetIcao.cgi",
+    RESET_TARGET = "resetTarget.cgi",
     SET_PRIORITY_LIST = "setPriorityList.cgi",
     SET_BLACK_LIST = "setBlackList.cgi",
     SET_WHITE_LIST = "setWhiteList.cgi",
@@ -408,6 +409,44 @@ declare const eventsDataSchema: z.ZodUnion<readonly [z.ZodObject<{
     ip: string;
     cgi: EUserActions.RESET_ICAO;
     postJsonBody?: any;
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"USER_ACTION">;
+    cgi: z.ZodLiteral<EUserActions.RESET_TARGET>;
+    ip: z.ZodString;
+    params: z.ZodObject<{
+        userId: z.ZodString;
+        userName: z.ZodString;
+        userPriority: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        userId: string;
+        userName: string;
+        userPriority: string;
+    }, {
+        userId: string;
+        userName: string;
+        userPriority: string;
+    }>;
+    postJsonBody: z.ZodAny;
+}, "strip", z.ZodTypeAny, {
+    params: {
+        userId: string;
+        userName: string;
+        userPriority: string;
+    };
+    type: "USER_ACTION";
+    ip: string;
+    cgi: EUserActions.RESET_TARGET;
+    postJsonBody?: any;
+}, {
+    params: {
+        userId: string;
+        userName: string;
+        userPriority: string;
+    };
+    type: "USER_ACTION";
+    ip: string;
+    cgi: EUserActions.RESET_TARGET;
+    postJsonBody?: any;
 }>, z.ZodObject<{
     type: z.ZodLiteral<"USER_ACTION">;
     cgi: z.ZodLiteral<EUserActions.SET_PRIORITY_LIST>;
@@ -1406,6 +1445,44 @@ export declare const ptrEventsSchema: z.ZodUnion<readonly [z.ZodObject<{
         ip: string;
         cgi: EUserActions.RESET_ICAO;
         postJsonBody?: any;
+    }>, z.ZodObject<{
+        type: z.ZodLiteral<"USER_ACTION">;
+        cgi: z.ZodLiteral<EUserActions.RESET_TARGET>;
+        ip: z.ZodString;
+        params: z.ZodObject<{
+            userId: z.ZodString;
+            userName: z.ZodString;
+            userPriority: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            userId: string;
+            userName: string;
+            userPriority: string;
+        }, {
+            userId: string;
+            userName: string;
+            userPriority: string;
+        }>;
+        postJsonBody: z.ZodAny;
+    }, "strip", z.ZodTypeAny, {
+        params: {
+            userId: string;
+            userName: string;
+            userPriority: string;
+        };
+        type: "USER_ACTION";
+        ip: string;
+        cgi: EUserActions.RESET_TARGET;
+        postJsonBody?: any;
+    }, {
+        params: {
+            userId: string;
+            userName: string;
+            userPriority: string;
+        };
+        type: "USER_ACTION";
+        ip: string;
+        cgi: EUserActions.RESET_TARGET;
+        postJsonBody?: any;
     }>, z.ZodObject<{
         type: z.ZodLiteral<"USER_ACTION">;
         cgi: z.ZodLiteral<EUserActions.SET_PRIORITY_LIST>;
@@ -2185,6 +2262,16 @@ export declare const ptrEventsSchema: z.ZodUnion<readonly [z.ZodObject<{
         ip: string;
         cgi: EUserActions.RESET_ICAO;
         postJsonBody?: any;
+    } | {
+        params: {
+            userId: string;
+            userName: string;
+            userPriority: string;
+        };
+        type: "USER_ACTION";
+        ip: string;
+        cgi: EUserActions.RESET_TARGET;
+        postJsonBody?: any;
     } | {
         params: {
             userId: string;
@@ -2414,6 +2501,16 @@ export declare const ptrEventsSchema: z.ZodUnion<readonly [z.ZodObject<{
         ip: string;
         cgi: EUserActions.RESET_ICAO;
         postJsonBody?: any;
+    } | {
+        params: {
+            userId: string;
+            userName: string;
+            userPriority: string;
+        };
+        type: "USER_ACTION";
+        ip: string;
+        cgi: EUserActions.RESET_TARGET;
+        postJsonBody?: any;
     } | {
         params: {
             userId: string;
@@ -2860,6 +2957,44 @@ export declare const ptrEventsSchema: z.ZodUnion<readonly [z.ZodObject<{
     ip: string;
     cgi: EUserActions.RESET_ICAO;
     postJsonBody?: any;
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"USER_ACTION">;
+    cgi: z.ZodLiteral<EUserActions.RESET_TARGET>;
+    ip: z.ZodString;
+    params: z.ZodObject<{
+        userId: z.ZodString;
+        userName: z.ZodString;
+        userPriority: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        userId: string;
+        userName: string;
+        userPriority: string;
+    }, {
+        userId: string;
+        userName: string;
+        userPriority: string;
+    }>;
+    postJsonBody: z.ZodAny;
+}, "strip", z.ZodTypeAny, {
+    params: {
+        userId: string;
+        userName: string;
+        userPriority: string;
+    };
+    type: "USER_ACTION";
+    ip: string;
+    cgi: EUserActions.RESET_TARGET;
+    postJsonBody?: any;
+}, {
+    params: {
+        userId: string;
+        userName: string;
+        userPriority: string;
+    };
+    type: "USER_ACTION";
+    ip: string;
+    cgi: EUserActions.RESET_TARGET;
+    postJsonBody?: any;
 }>, z.ZodObject<{
     type: z.ZodLiteral<"USER_ACTION">;
     cgi: z.ZodLiteral<EUserActions.SET_PRIORITY_LIST>;