camstreamerlib 4.0.0-beta.2 → 4.0.0-beta.21

package/esm/models/CamOverlayAPI/widgetsSchema.js

@@ -0,0 +1,24 @@
+import { customGraphicsSchema } from './customGraphicsSchema';
+import { imagesSchema } from './imagesSchema';
+import { accuweatherSchema } from './accuweatherSchema';
+import { infoTickerSchema } from './infotickerSchema';
+import { pipSchema } from './pipSchema';
+import { ptzCompassSchema } from './ptzCompassSchema';
+import { ptzSchema } from './ptzSchema';
+import { screenSharingSchema } from './screenSharingSchema';
+import { webCameraSharingSchema } from './webCameraSharingSchema';
+import { z } from 'zod';
+export const widgetsSchema = z.discriminatedUnion('name', [
+    infoTickerSchema,
+    accuweatherSchema,
+    ptzCompassSchema,
+    imagesSchema,
+    ptzSchema,
+    pipSchema,
+    customGraphicsSchema,
+    screenSharingSchema,
+    webCameraSharingSchema,
+]);
+export const widgetListSchema = z.object({
+    services: z.array(widgetsSchema),
+});

package/esm/node/DefaultClient.d.ts

@@ -0,0 +1,16 @@
+/// <reference types="node" />
+import { IClient, HttpOptions, TParameters } from '../internal/types';
+import { Response as UndiciResponse } from 'undici';
+export declare class DefaultClient implements IClient<UndiciResponse> {
+    private tls;
+    private ip;
+    private port;
+    private user;
+    private pass;
+    private httpRequestSender;
+    constructor(opt?: HttpOptions);
+    get url(): string;
+    get: (url: string, parameters?: TParameters | undefined, headers?: Record<string, string> | undefined) => Promise<UndiciResponse>;
+    post: (url: string, data: string | Buffer | FormData, parameters?: TParameters | undefined, headers?: Record<string, string> | undefined) => Promise<UndiciResponse>;
+    private getBaseConnectionParams;
+}

package/{node → esm/node}/DefaultClient.js

@@ -25,18 +25,20 @@ export class DefaultClient {
     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);
+    get = (...params) => {
+        const [path, parameters, headers] = params;
+        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);
+    };
+    post = (...params) => {
+        const [path, data, parameters, headers] = params;
+        const options = this.getBaseConnectionParams('POST', path, parameters ?? {});
         options.headers = headers;
         return this.httpRequestSender.sendRequest(options, data);
-    }
+    };
     getBaseConnectionParams(method, path, params) {
-        let pathName = addParametersToPath(path, params);
+        const pathName = addParametersToPath(path, params);
         return {
             method: method,
             protocol: this.tls ? 'https:' : 'http:',

package/esm/node/HttpRequestSender.d.ts

@@ -0,0 +1,28 @@
+/// <reference types="node" />
+import { FormData as UndiciFormData, Response as UndiciResponse } from 'undici';
+export type HttpRequestOptions = {
+    method?: string;
+    protocol: string;
+    host: string;
+    port: number;
+    path: string;
+    user?: string;
+    pass?: string;
+    timeout?: number;
+    headers?: Record<string, string>;
+};
+export type AgentOptions = {
+    rejectUnaurhorized?: boolean;
+    keepAlive?: boolean;
+};
+export declare class HttpRequestSender {
+    private agent?;
+    private authData?;
+    constructor(agentOptions?: AgentOptions);
+    sendRequest(options: HttpRequestOptions, postData?: Buffer | string | UndiciFormData): Promise<UndiciResponse>;
+    private sendRequestWithAuth;
+    private static getURL;
+    private getAuthorization;
+    private invalidateAuthorization;
+    private static getAuthHeader;
+}

package/esm/node/HttpServer.d.ts

@@ -0,0 +1,21 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import * as http from 'http';
+import * as EventEmitter from 'events';
+export type HttpServerOptions = {
+    host?: string;
+    port?: number;
+};
+type TOnRequestCallback = (req: http.IncomingMessage, res: http.ServerResponse) => void;
+export declare class HttpServer extends EventEmitter {
+    private host;
+    private port;
+    private registeredPaths;
+    private server;
+    private sockets;
+    constructor(options?: HttpServerOptions);
+    getServer(): http.Server<typeof http.IncomingMessage, typeof http.ServerResponse>;
+    onRequest(pathName: string, callback: TOnRequestCallback): void;
+    close(): void;
+}
+export {};

package/{node → esm/node}/HttpServer.js

@@ -86,7 +86,7 @@ export class HttpServer extends EventEmitter {
     close() {
         this.server.close();
         for (const key in this.sockets) {
-            this.sockets[key].destroy();
+            this.sockets[key]?.destroy();
         }
     }
 }

package/esm/node/WsClient.d.ts

@@ -0,0 +1,39 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import * as EventEmitter from 'events';
+import { WsOptions } from '../internal/types';
+export type WsClientOptions = WsOptions & {
+    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 {
+    private user;
+    private pass;
+    private address;
+    private protocol?;
+    private pingInterval;
+    private wsOptions;
+    private digestAddress;
+    private isAlive;
+    private pingTimer?;
+    private ws?;
+    private isClosed;
+    constructor(options: WsClientOptions);
+    open(wwwAuthenticateHeader?: string): void;
+    send(data: Buffer | string): void;
+    close(): void;
+    reconnect(): void;
+    private closeWsConnection;
+}

package/esm/node/WsEventClient.d.ts

@@ -0,0 +1,13 @@
+import { IWebsocket } from '../internal/types';
+import { WsClientOptions } from './WsClient';
+type TEvent = {
+    data: string;
+};
+export declare class WsEventClient implements IWebsocket<TEvent> {
+    private wsClient;
+    constructor(options: WsClientOptions);
+    send: (data: string) => void;
+    destroy: () => void;
+    onmessage: ((event: TEvent) => void) | null;
+}
+export {};

package/esm/node/index.d.ts

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

package/esm/node/index.js

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

package/esm/types/CamOverlayAPI.d.ts

@@ -0,0 +1,328 @@
+import { HttpOptions } from '../internal/types';
+import { z } from 'zod';
+import { widgetListSchema, widgetsSchema } from '../models/CamOverlayAPI/widgetsSchema';
+import { fileListSchema, fileSchema, storageSchema } from '../models/CamOverlayAPI/fileSchema';
+import { customGraphicsSchema, fieldSchema } from '../models/CamOverlayAPI/customGraphicsSchema';
+import { infoTickerSchema, accuweatherSchema, ptzCompassSchema, imagesSchema, ptzSchema, pipSchema, screenSharingSchema, webCameraSharingSchema } from '../models/CamOverlayAPI';
+export type CamOverlayOptions = HttpOptions;
+export type TFileType = 'image' | 'font';
+export type TCoordinates = 'top_left' | 'top_right' | 'top' | 'bottom_left' | 'bottom_right' | 'bottom' | 'left' | 'right' | 'center' | '';
+export type TWidget = z.infer<typeof widgetsSchema>;
+export type TWidgetList = z.infer<typeof widgetListSchema>;
+export type TField = z.infer<typeof fieldSchema>;
+export type TFile = z.infer<typeof fileSchema>;
+export type TFileList = z.infer<typeof fileListSchema>;
+export declare enum ImageType {
+    PNG = 0,
+    JPEG = 1
+}
+export type TStorage = z.infer<typeof storageSchema>;
+export type TInfoticker = z.infer<typeof infoTickerSchema>;
+export type TAccuweather = z.infer<typeof accuweatherSchema>;
+export type TPtzCompass = z.infer<typeof ptzCompassSchema>;
+export type TImages = z.infer<typeof imagesSchema>;
+export type TPtz = z.infer<typeof ptzSchema>;
+export type TPip = z.infer<typeof pipSchema>;
+export type TCustomGraphics = z.infer<typeof customGraphicsSchema>;
+export type TScreenSharing = z.infer<typeof screenSharingSchema>;
+export type TWebCameraSharing = z.infer<typeof webCameraSharingSchema>;
+export declare const isInfoticker: (widget: TWidget) => widget is {
+    name: "infoticker";
+    enabled: 0 | 1;
+    id: number;
+    width: number;
+    height: number;
+    source: string;
+    automationType: "time" | "manual" | "schedule" | `input${number}`;
+    cameraList: number[];
+    customName: string;
+    coordSystem: "top" | "bottom";
+    pos_y: number;
+    textColor: string;
+    font: string;
+    fontSize: number;
+    switchingTime: number;
+    clockType: "12h" | "24h";
+    showClock: 0 | 1;
+    bgColor: string;
+    weatherLocation: string;
+    weatherLocationName: string;
+    weatherLang: "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";
+    weatherUnits: "Metric" | "Imperial";
+    numberOfLines: number;
+    crawlLeft: boolean;
+    crawlSpeed: number;
+    sourceType: "url" | "text";
+    schedule?: string | undefined;
+    invertInput?: boolean | undefined;
+    camera?: number | undefined;
+    zIndex?: number | undefined;
+};
+export declare const isAccuweather: (widget: TWidget) => widget is {
+    name: "accuweather";
+    enabled: 0 | 1;
+    id: number;
+    width: number;
+    height: number;
+    automationType: "time" | "manual" | "schedule" | `input${number}`;
+    cameraList: number[];
+    customName: string;
+    coordSystem: "top_left" | "top" | "top_right" | "left" | "center" | "right" | "bottom_left" | "bottom" | "bottom_right";
+    pos_x: number;
+    pos_y: number;
+    scale: number;
+    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;
+};
+export declare const isPtzCompass: (widget: TWidget) => widget is {
+    type: "map" | "image" | "compass";
+    name: "ptzCompass";
+    enabled: 0 | 1;
+    id: number;
+    width: number;
+    height: number;
+    automationType: "time" | "manual" | "schedule" | `input${number}`;
+    cameraList: number[];
+    customName: string;
+    coordSystem: "top_left" | "top" | "top_right" | "left" | "center" | "right" | "bottom_left" | "bottom" | "bottom_right";
+    pos_x: number;
+    pos_y: number;
+    scale: number;
+    image: string;
+    northPan: number;
+    cameraPosX: number;
+    cameraPosY: number;
+    colorScheme: "black" | "white" | "orange";
+    schedule?: string | undefined;
+    invertInput?: boolean | undefined;
+    camera?: number | undefined;
+    zIndex?: number | undefined;
+    generalLng?: number | undefined;
+    generalLat?: number | undefined;
+    generalZoom?: number | undefined;
+    generalMapType?: string | undefined;
+    generalIframeWidth?: number | undefined;
+    generalIframeHeight?: number | undefined;
+    generalAddress?: string | undefined;
+};
+export declare const isImages: (widget: TWidget) => widget is {
+    name: "images";
+    enabled: 0 | 1;
+    id: number;
+    width: number;
+    height: number;
+    automationType: "time" | "manual" | "schedule" | `input${number}`;
+    cameraList: number[];
+    customName: string;
+    overlayList: {
+        duration: number;
+        active: boolean;
+        coordSystem: "top_left" | "top" | "top_right" | "left" | "center" | "right" | "bottom_left" | "bottom" | "bottom_right";
+        pos_x: number;
+        pos_y: number;
+        imgPath: string;
+        imgName: string;
+        scale: number;
+        fps?: number | undefined;
+    }[];
+    schedule?: string | undefined;
+    invertInput?: boolean | undefined;
+    camera?: number | undefined;
+    zIndex?: number | undefined;
+};
+export declare const isPtz: (widget: TWidget) => widget is {
+    name: "ptz";
+    enabled: 0 | 1;
+    id: number;
+    width: number;
+    height: number;
+    automationType: "time" | "manual" | "schedule" | `input${number}`;
+    cameraList: number[];
+    customName: string;
+    ptz_positions: Record<string, {
+        loop: boolean;
+        overlayList: {
+            duration: number;
+            coordSystem: "top_left" | "top" | "top_right" | "left" | "center" | "right" | "bottom_left" | "bottom" | "bottom_right";
+            pos_x: number;
+            pos_y: number;
+            imgPath: string;
+            imgName: string;
+            scale: number;
+        }[];
+    }>;
+    schedule?: string | undefined;
+    invertInput?: boolean | undefined;
+    camera?: number | undefined;
+    zIndex?: number | undefined;
+};
+export declare const isPip: (widget: TWidget) => widget is {
+    name: "pip";
+    enabled: 0 | 1;
+    id: number;
+    width: number;
+    height: number;
+    fps: number;
+    automationType: "time" | "manual" | "schedule" | `input${number}`;
+    cameraList: number[];
+    customName: string;
+    coordSystem: "top_left" | "top" | "top_right" | "left" | "center" | "right" | "bottom_left" | "bottom" | "bottom_right";
+    pos_x: number;
+    pos_y: number;
+    scale: number;
+    screenSize: number;
+    compression: number;
+    source_type: "axis_camera" | "mjpeg_url";
+    mjpeg_url: string;
+    camera_ip: string;
+    camera_port: number;
+    camera_user: string;
+    camera_pass: string;
+    camera_width: number;
+    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][];
+        aspectRatioCorrection: number;
+    };
+    borderColor: string;
+    borderWidth: number;
+    schedule?: string | undefined;
+    invertInput?: boolean | undefined;
+    camera?: number | undefined;
+    zIndex?: number | undefined;
+};
+export declare const isCustomGraphics: (widget: TWidget) => widget is {
+    name: "customGraphics";
+    enabled: 0 | 1;
+    id: number;
+    width: number;
+    height: number;
+    automationType: "time" | "manual" | "schedule" | `input${number}`;
+    cameraList: number[];
+    customName: string;
+    coordSystem: "top_left" | "top" | "top_right" | "left" | "center" | "right" | "bottom_left" | "bottom" | "bottom_right";
+    pos_x: number;
+    pos_y: number;
+    clockFormat: "12h" | "24h";
+    background: "custom" | "image";
+    image: string;
+    customAreaColor: string;
+    customAreaWidth: number;
+    customAreaHeight: number;
+    customAreaCorners: "sharp" | "rounded";
+    mappingZones: ({
+        type: "plain";
+        name: string;
+        pos_x: number;
+        pos_y: number;
+        wrapText: boolean;
+        textLines: number;
+        textWidth: number;
+        textAlign: "A_LEFT" | "A_CENTER" | "A_RIGHT";
+        textVerticalAlign: "VA_TOP" | "VA_CENTER" | "VA_BOTTOM";
+        textColor: string;
+        font: string;
+        fontSize: number;
+        switchingTime: number;
+        text?: {
+            source: string;
+            active: boolean;
+        }[] | undefined;
+    } | {
+        type: "countdown";
+        name: string;
+        pos_x: number;
+        pos_y: number;
+        wrapText: boolean;
+        textLines: number;
+        textWidth: number;
+        textAlign: "A_LEFT" | "A_CENTER" | "A_RIGHT";
+        textVerticalAlign: "VA_TOP" | "VA_CENTER" | "VA_BOTTOM";
+        textColor: string;
+        font: string;
+        fontSize: number;
+        switchingTime: number;
+        settings: {
+            startDate: number;
+            targetDate: number;
+            countdown: boolean;
+            countup: boolean;
+            displayDay: boolean;
+            displayHour: boolean;
+            displayMinute: boolean;
+            displaySeconds: boolean;
+            idleText: string;
+            hideZeros: boolean;
+            delimiter: "colon" | "letters";
+            suffixSeconds: string;
+            suffixMinute: string;
+            suffixHour: string;
+            suffixDay: string;
+            loop: boolean;
+            loopPeriod: number;
+            waitingPeriod: number;
+        };
+        text?: {
+            source: string;
+            active: boolean;
+        }[] | undefined;
+    })[];
+    schedule?: string | undefined;
+    invertInput?: boolean | undefined;
+    camera?: number | undefined;
+    zIndex?: number | undefined;
+};
+export declare const isScreenSharing: (widget: TWidget) => widget is {
+    name: "screenSharing";
+    enabled: 0 | 1;
+    id: number;
+    width: number;
+    height: number;
+    fps: number;
+    automationType: "time" | "manual" | "schedule" | `input${number}`;
+    cameraList: number[];
+    customName: string;
+    coordSystem: "top_left" | "top" | "top_right" | "left" | "center" | "right" | "bottom_left" | "bottom" | "bottom_right";
+    pos_x: number;
+    pos_y: number;
+    screenSize: number;
+    schedule?: string | undefined;
+    invertInput?: boolean | undefined;
+    camera?: number | undefined;
+    zIndex?: number | undefined;
+};
+export declare const isWebCameraSharing: (widget: TWidget) => widget is {
+    name: "web_camera";
+    enabled: 0 | 1;
+    id: number;
+    width: number;
+    height: number;
+    fps: number;
+    automationType: "time" | "manual" | "schedule" | `input${number}`;
+    cameraList: number[];
+    customName: string;
+    coordSystem: "top_left" | "top" | "top_right" | "left" | "center" | "right" | "bottom_left" | "bottom" | "bottom_right";
+    pos_x: number;
+    pos_y: number;
+    screenSize: number;
+    schedule?: string | undefined;
+    invertInput?: boolean | undefined;
+    camera?: number | undefined;
+    zIndex?: number | undefined;
+};

package/esm/types/CamOverlayAPI.js

@@ -0,0 +1,14 @@
+export var ImageType;
+(function (ImageType) {
+    ImageType[ImageType["PNG"] = 0] = "PNG";
+    ImageType[ImageType["JPEG"] = 1] = "JPEG";
+})(ImageType || (ImageType = {}));
+export const isInfoticker = (widget) => widget.name === 'infoticker';
+export const isAccuweather = (widget) => widget.name === 'accuweather';
+export const isPtzCompass = (widget) => widget.name === 'ptzCompass';
+export const isImages = (widget) => widget.name === 'images';
+export const isPtz = (widget) => widget.name === 'ptz';
+export const isPip = (widget) => widget.name === 'pip';
+export const isCustomGraphics = (widget) => widget.name === 'customGraphics';
+export const isScreenSharing = (widget) => widget.name === 'screenSharing';
+export const isWebCameraSharing = (widget) => widget.name === 'web_camera';

package/esm/types/CamScripterAPI.d.ts

@@ -0,0 +1,126 @@
+import { HttpOptions } from '../internal/types';
+import { z } from 'zod';
+export type CamScripterOptions = HttpOptions;
+export type TStorageType = 'INTERNAL' | 'SD_CARD';
+export declare const nodeStateSchema: z.ZodObject<{
+    node_state: z.ZodUnion<[z.ZodLiteral<"OK">, z.ZodLiteral<"NOT_INSTALLED">, z.ZodLiteral<"NOT_FOUND">]>;
+}, "strip", z.ZodTypeAny, {
+    node_state: "OK" | "NOT_INSTALLED" | "NOT_FOUND";
+}, {
+    node_state: "OK" | "NOT_INSTALLED" | "NOT_FOUND";
+}>;
+export type TNodeState = z.infer<typeof nodeStateSchema>;
+export declare const packageInfoListSchema: z.ZodArray<z.ZodObject<{
+    storage: z.ZodUnion<[z.ZodLiteral<"SD_CARD">, z.ZodLiteral<"INTERNAL">]>;
+    manifest: z.ZodObject<{
+        package_name: z.ZodString;
+        package_menu_name: z.ZodString;
+        package_version: z.ZodString;
+        vendor: z.ZodString;
+        required_camscripter_version: z.ZodString;
+        required_camscripter_rbi_version: z.ZodString;
+        ui_link: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        package_name: string;
+        package_menu_name: string;
+        package_version: string;
+        vendor: string;
+        required_camscripter_version: string;
+        required_camscripter_rbi_version: string;
+        ui_link: string;
+    }, {
+        package_name: string;
+        package_menu_name: string;
+        package_version: string;
+        vendor: string;
+        required_camscripter_version: string;
+        required_camscripter_rbi_version: string;
+        ui_link: string;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    storage: "INTERNAL" | "SD_CARD";
+    manifest: {
+        package_name: string;
+        package_menu_name: string;
+        package_version: string;
+        vendor: string;
+        required_camscripter_version: string;
+        required_camscripter_rbi_version: string;
+        ui_link: string;
+    };
+}, {
+    storage: "INTERNAL" | "SD_CARD";
+    manifest: {
+        package_name: string;
+        package_menu_name: string;
+        package_version: string;
+        vendor: string;
+        required_camscripter_version: string;
+        required_camscripter_rbi_version: string;
+        ui_link: string;
+    };
+}>, "many">;
+export type TPackageInfoList = z.infer<typeof packageInfoListSchema>;
+export declare const packageConfigSchema: z.ZodRecord<z.ZodString, z.ZodObject<{
+    enabled: z.ZodBoolean;
+}, "strip", z.ZodTypeAny, {
+    enabled: boolean;
+}, {
+    enabled: boolean;
+}>>;
+export type TPackageConfig = z.infer<typeof packageConfigSchema>;
+export declare const storageSchema: z.ZodUnion<[z.ZodTuple<[z.ZodObject<{
+    type: z.ZodLiteral<"INTERNAL">;
+    capacity_mb: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    type: "INTERNAL";
+    capacity_mb: number;
+}, {
+    type: "INTERNAL";
+    capacity_mb: number;
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"SD_CARD">;
+    capacity_mb: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    type: "SD_CARD";
+    capacity_mb: number;
+}, {
+    type: "SD_CARD";
+    capacity_mb: number;
+}>], null>, z.ZodTuple<[z.ZodObject<{
+    type: z.ZodLiteral<"INTERNAL">;
+    capacity_mb: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    type: "INTERNAL";
+    capacity_mb: number;
+}, {
+    type: "INTERNAL";
+    capacity_mb: number;
+}>], null>]>;
+export type TStorage = z.infer<typeof storageSchema>;
+export type TStorageParsedData = {
+    size: number;
+    storageType: TStorageType;
+}[];
+export declare const camscripterApiResponseSchema: z.ZodObject<{
+    status: z.ZodNumber;
+    message: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    status: number;
+    message: string;
+}, {
+    status: number;
+    message: string;
+}>;
+export type TCamscripterApiResponse = z.infer<typeof camscripterApiResponseSchema>;
+export declare const cameraTimeResponseSchema: z.ZodObject<{
+    state: z.ZodBoolean;
+    code: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    code: number;
+    state: boolean;
+}, {
+    code: number;
+    state: boolean;
+}>;
+export type TCameraTimeResponse = z.infer<typeof cameraTimeResponseSchema>;