@camera.ui/browser 0.0.68 → 0.0.70

package/dist/types/packages/client/browser/src/client.d.ts

@@ -1,5 +1,5 @@
-import { DeviceManager, PluginsManager, SystemManager } from './proxy';
-import type { CameraUiClientConfig } from './types';
+import { DeviceManager, PluginsManager, SystemManager } from './proxy/index.js';
+import type { CameraUiClientConfig } from './types.js';
 export interface API {
     deviceManager: DeviceManager;
     pluginsManager: PluginsManager;

package/dist/types/packages/client/browser/src/index.d.ts

@@ -1,2 +1,2 @@
-export * from './client';
-export * from './types';
+export * from './client.js';
+export * from './types.js';

package/dist/types/packages/client/browser/src/proxy/cameraDevice.d.ts

@@ -1,6 +1,6 @@
-import { BrowserCameraDevice } from '../../../../../server/src/camera/base/cameraDeviceBrowser';
-import type { BaseLogger, Camera, CameraSource, IceServer, OnSetEvent, StateValues } from '../../../../../shared/types';
-import type { SocketService } from '../socket';
+import { BrowserCameraDevice } from '../../../../../server/src/camera/base/cameraDeviceBrowser.js';
+import type { BaseLogger, Camera, CameraSource, IceServer, OnSetEvent, StateValues } from '../../../../../shared/types/index.js';
+import type { SocketService } from '../socket.js';
 export declare class CameraDeviceProxy extends BrowserCameraDevice {
     private socketService;
     get sources(): CameraSource[];
@@ -9,9 +9,8 @@ export declare class CameraDeviceProxy extends BrowserCameraDevice {
     disconnect(): Promise<void>;
     reboot(): Promise<void>;
     getIceServers(): Promise<IceServer[]>;
-    snapshot(forceNew?: boolean): Promise<ArrayBuffer>;
     updateState<T extends keyof StateValues>(stateName: T, eventData: OnSetEvent<T>): Promise<void>;
     refreshStates(): Promise<void>;
     cleanup(): Promise<void>;
-    private listenToChanges;
+    private listenToMessages;
 }

package/dist/types/packages/client/browser/src/proxy/deviceManager.d.ts

@@ -1,6 +1,6 @@
-import { BrowserCameraDevice } from '../../../../../server/src/camera/base/cameraDeviceBrowser';
-import type { BaseLogger, DeviceManagerBrowserProxyMethods } from '../../../../../shared/types';
-import type { SocketService } from '../socket';
+import { BrowserCameraDevice } from '../../../../../server/src/camera/base/cameraDeviceBrowser.js';
+import type { BaseLogger, DeviceManagerBrowserProxyMethods } from '../../../../../shared/types/index.js';
+import type { SocketService } from '../socket.js';
 export declare class DeviceManager implements DeviceManagerBrowserProxyMethods {
     private socketService;
     private devices;

package/dist/types/packages/client/browser/src/proxy/index.d.ts

@@ -1,4 +1,4 @@
-export * from './cameraDevice';
-export * from './deviceManager';
-export * from './pluginsManager';
-export * from './systemManager';
+export * from './cameraDevice.js';
+export * from './deviceManager.js';
+export * from './pluginsManager.js';
+export * from './systemManager.js';

package/dist/types/packages/client/browser/src/proxy/pluginsManager.d.ts

@@ -1,5 +1,5 @@
-import type { BaseLogger, PluginsManagerBrowserProxyMethods } from '../../../../../shared/types';
-import type { SocketService } from '../socket';
+import type { BaseLogger, PluginsManagerBrowserProxyMethods } from '../../../../../shared/types/index.js';
+import type { SocketService } from '../socket.js';
 export declare class PluginsManager implements PluginsManagerBrowserProxyMethods {
     private socketService;
     private logger;

package/dist/types/packages/client/browser/src/proxy/systemManager.d.ts

@@ -1,5 +1,5 @@
-import type { BaseLogger, SystemManagerBrowserProxyMethods } from '../../../../../shared/types';
-import type { SocketService } from '../socket';
+import type { BaseLogger, SystemManagerBrowserProxyMethods } from '../../../../../shared/types/index.js';
+import type { SocketService } from '../socket.js';
 export declare class SystemManager implements SystemManagerBrowserProxyMethods {
     private socketService;
     private logger;

package/dist/types/packages/client/browser/src/socket.d.ts

@@ -1,5 +1,5 @@
 import { Manager, type Socket } from 'socket.io-client';
-import type { ManagerNames, WebsocketClientRequest } from '../../../../shared/types';
+import type { ManagerNames, WebsocketClientRequest } from '../../../../shared/types/index.js';
 export declare class SocketService {
     manager: Manager;
     private token;

package/dist/types/packages/client/browser/src/types.d.ts

@@ -1,6 +1,6 @@
-import type { BaseLogger } from '../../../../shared/types';
-export type { AudioState, BaseLogger, BasicBrowserPeerConnection, BrowserCameraDevice, Camera, CameraConfig, CameraInput, DoorbellState, FfmpegOptions, Go2RtcAnswerMessage, Go2RtcIceCandidateMessage, Go2RtcIncomingMessage, Go2RtcOfferMessage, Go2RtcOutgoingMessage, LightState, MotionState, ObjectState, SirenState, } from '../../../../shared/types';
-export { BrowserStreamingSession } from '../../../../shared/types';
+import type { BaseLogger } from '../../../../shared/types/index.js';
+export type { AudioState, BaseLogger, BasicBrowserPeerConnection, BrowserCameraDevice, Camera, CameraConfig, CameraInput, DoorbellState, FfmpegOptions, Go2RtcAnswerMessage, Go2RtcIceCandidateMessage, Go2RtcIncomingMessage, Go2RtcOfferMessage, Go2RtcOutgoingMessage, LightState, MotionState, ObjectState, SirenState, } from '../../../../shared/types/index.js';
+export { BrowserStreamingSession } from '../../../../shared/types/index.js';
 export type CameraUiClientConfig = WithCredentials | WithToken;
 interface BaseConfig {
     endpoint: string;

package/dist/types/server/bin/python.d.ts

@@ -0,0 +1,43 @@
+import { PortablePython } from '@bjia56/portable-python';
+export declare const SERVER_PY_VERSION = "3.11";
+export declare class PythonInstaller {
+    static readonly versions: string[];
+    readonly python: PortablePython;
+    readonly venvPath?: string;
+    readonly installPath: string;
+    private _version;
+    private identifier;
+    private logger;
+    private configService;
+    get isInstalled(): boolean;
+    get pluginPythonPath(): string;
+    get serverPythonPath(): string;
+    get pluginPackagesPath(): string;
+    get serverPackagesPath(): string;
+    get version(): string;
+    private get logPrefix();
+    constructor(identifier: string, venvDir?: string, version?: string);
+    install(): Promise<void>;
+    installPluginPython(): Promise<void>;
+    uninstall(): Promise<void>;
+    updatePluginDependencies(requirementsPath: string): Promise<void>;
+    updateServerDependencies(): Promise<void>;
+    installPluginPackages(pkgs: string[]): Promise<string>;
+    installServerPackages(pkgs: string[]): Promise<string>;
+    uninstallPluginPackages(pkgs: string[]): Promise<string>;
+    uninstallServerPackages(pkgs: string[]): Promise<string>;
+    private installPluginRequirements;
+    private installServerRequirements;
+    private updateRequirements;
+    private analyzeDependencies;
+    private updateDependencies;
+    private installRequirements;
+    private installPackages;
+    private uninstallPackages;
+    private getInstalledPackages;
+    private ensureVenv;
+    private createVenv;
+    private removeVenv;
+    private cleanPackageName;
+    private difference;
+}

package/dist/types/server/src/api/database/index.d.ts

@@ -0,0 +1,24 @@
+import { Database as DB, RootDatabase as RootDB } from 'lmdb';
+import type { FastifyInstance } from 'fastify';
+import type { Plugin } from '../../plugins/plugin.js';
+import type { DBAuth, DBCamera, DBPlugin, DBSettings, DBUser } from './types.js';
+export declare class Database {
+    private db;
+    authDB: RootDB<DBAuth, 'auth'>;
+    camerasDB: DB<DBCamera[], 'cameras'>;
+    pluginsDB: DB<DBPlugin[], 'plugins'>;
+    settingsDB: DB<DBSettings, 'settings'>;
+    usersDB: DB<DBUser[], 'users'>;
+    private initialized;
+    private app;
+    private configService;
+    private logger;
+    constructor(app: FastifyInstance);
+    close(): Promise<void>;
+    initialize(): Promise<Database>;
+    updateCameras(): Promise<void>;
+    createPluginDatabase(plugin: Plugin): Promise<void>;
+    private ensureDatabases;
+    private updateConfig;
+    private generateAdmin;
+}

package/dist/types/server/src/api/database/types.d.ts

@@ -1,21 +1,20 @@
-import type { ClientData, JwtTokenEncoded } from '../types';
-export interface DBSettings {
-    readonly _id: string;
-    _rev?: string;
-    settings: DBSetting;
-}
-export interface DBSetting {
-}
-export interface DBTokens {
-    readonly _id: string;
-    _rev?: string;
+import type { ClientData, JwtTokenEncoded } from '../types/index.js';
+export interface DBAuth {
     tokens: JwtTokenEncoded[];
     clients: ClientData[];
 }
-export interface DBUsers {
+export interface DBCamera extends BaseCamera {
+    sources: CameraInputSettings[];
+    extensions: CameraExtensions;
+    interface: CameraUiSettings;
+    recording: CameraRecordingSettings;
+}
+export interface DBPlugin {
     readonly _id: string;
-    _rev?: string;
-    users: DBUser[];
+    pluginName: string;
+    storage: DBPluginStorage;
+}
+export interface DBSettings {
 }
 export interface DBUser {
     readonly _id: string;
@@ -44,16 +43,6 @@ export interface DBCamviewLayoutCamera {
     readonly _id: string;
     name: string;
 }
-export interface DBPlugins {
-    readonly _id: string;
-    _rev?: string;
-    plugins: DBPlugin[];
-}
-export interface DBPlugin {
-    readonly _id: string;
-    pluginName: string;
-    storage: DBPluginStorage;
-}
 export interface DBPluginStorage {
     [key: string]: {
         config: DBPluginStorageValue;
@@ -62,11 +51,6 @@ export interface DBPluginStorage {
 export interface DBPluginStorageValue {
     [key: string]: any;
 }
-export interface DBCameras {
-    readonly _id: string;
-    _rev?: string;
-    cameras: DBCamera[];
-}
 export interface BaseCamera {
     readonly _id: string;
     nativeId?: string;
@@ -84,12 +68,6 @@ export interface BaseCamera {
     objectZones: CameraZone[];
     motionTimeout: number;
 }
-export interface DBCamera extends BaseCamera {
-    sources: CameraInputSettings[];
-    extensions: CameraExtensions;
-    interface: CameraUiSettings;
-    recording: CameraRecordingSettings;
-}
 export interface Camera extends BaseCamera {
     hasAudioDetector: boolean;
     hasMotionDetector: boolean;

package/dist/types/server/src/api/go2rtc/api/application.d.ts

@@ -0,0 +1,9 @@
+import { RequestQueue } from '../queue.js';
+import type { ApplicationResponse, ExitData } from '../types.js';
+export declare class ApplicationApi {
+    private requestQueue;
+    constructor(requestQueue: RequestQueue);
+    close(data: ExitData): Promise<void>;
+    info(): Promise<ApplicationResponse>;
+    restart(): Promise<void>;
+}

package/dist/types/server/src/api/go2rtc/api/config.d.ts

@@ -0,0 +1,9 @@
+import { RequestQueue } from '../queue.js';
+import type { AxiosResponse } from 'axios';
+export declare class ConfigApi {
+    private requestQueue;
+    constructor(requestQueue: RequestQueue);
+    getConfig(): Promise<AxiosResponse>;
+    rewriteConfig(data: Record<string, any>): Promise<AxiosResponse>;
+    mergeConfig(data: Record<string, any>): Promise<AxiosResponse>;
+}

package/dist/types/server/src/api/go2rtc/api/index.d.ts

@@ -0,0 +1,2 @@
+import { type AxiosInstance } from 'axios';
+export declare const axiosInstance: () => AxiosInstance;

package/dist/types/server/src/api/go2rtc/api/snapshot.d.ts

@@ -0,0 +1,8 @@
+import { RequestQueue } from '../queue.js';
+import type { SourceData } from '../types.js';
+export declare class SnapshotApi {
+    private requestQueue;
+    constructor(requestQueue: RequestQueue);
+    jpeg(data: SourceData): Promise<ArrayBuffer>;
+    mp4(data: SourceData): Promise<ArrayBuffer>;
+}

package/dist/types/server/src/api/go2rtc/api/streams.d.ts

@@ -0,0 +1,11 @@
+import { RequestQueue } from '../queue.js';
+import type { AxiosResponse } from 'axios';
+import type { SourceData, StreamData } from '../types.js';
+export declare class StreamsApi {
+    private requestQueue;
+    constructor(requestQueue: RequestQueue);
+    createStream(data: StreamData): Promise<AxiosResponse>;
+    deleteStream(data: SourceData): Promise<AxiosResponse>;
+    getStreamInfo(data: SourceData): Promise<AxiosResponse>;
+    updateStreamSource(data: StreamData): Promise<AxiosResponse>;
+}

package/dist/types/server/src/api/go2rtc/index.d.ts

@@ -0,0 +1,13 @@
+import { ApplicationApi } from './api/application.js';
+import { ConfigApi } from './api/config.js';
+import { SnapshotApi } from './api/snapshot.js';
+import { StreamsApi } from './api/streams.js';
+export declare class Go2RtcApi {
+    private requestQueue;
+    applicationApi: ApplicationApi;
+    configApi: ConfigApi;
+    snapshotApi: SnapshotApi;
+    streamsApi: StreamsApi;
+    constructor();
+    clear(): void;
+}

package/dist/types/server/src/api/go2rtc/queue.d.ts

@@ -0,0 +1,10 @@
+type RequestFunction = () => Promise<any>;
+export declare class RequestQueue {
+    private queue;
+    private isProcessing;
+    constructor();
+    enqueue(requestFunc: RequestFunction): Promise<any>;
+    clear(): void;
+    private processQueue;
+}
+export {};

package/dist/types/server/src/api/middlewares/socketAuth.middleware.d.ts

@@ -0,0 +1,41 @@
+import type { Algorithm } from 'jsonwebtoken';
+import type { Socket } from 'socket.io';
+export declare class UnauthorizedError extends Error {
+    inner: {
+        message: string;
+    };
+    data: {
+        message: string;
+        code: string;
+        type: 'UnauthorizedError';
+    };
+    constructor(code: string, error: {
+        message: string;
+    });
+}
+export declare const isUnauthorizedError: (error: unknown) => error is UnauthorizedError;
+declare module 'socket.io' {
+    interface Socket extends ExtendedSocket {
+    }
+}
+interface ExtendedSocket {
+    encodedToken?: string;
+    decodedToken?: any;
+    user?: any;
+}
+type SocketIOMiddleware = (socket: Socket, next: (error?: UnauthorizedError) => void) => void;
+interface CompleteDecodedToken {
+    header: {
+        alg: Algorithm;
+        [key: string]: any;
+    };
+    payload: any;
+}
+type SecretCallback = (decodedToken: CompleteDecodedToken) => Promise<string> | string;
+export interface AuthorizeOptions {
+    secret: string | SecretCallback;
+    algorithms?: Algorithm[];
+    onAuthentication?: (decodedToken: any) => Promise<any> | any;
+}
+export declare const authorize: (options: AuthorizeOptions) => SocketIOMiddleware;
+export {};

package/dist/types/server/src/api/schemas/backup.schema.d.ts

@@ -1,5 +1,5 @@
-import * as zod from 'zod';
-import type { MultipartFile } from '../types';
+import zod from 'zod';
+import type { MultipartFile } from '../types/index.js';
 export declare const ACCEPTED_BACKUP_TYPES: string[];
 export declare const MAX_BACKUP_FILE_SIZE = 50000000;
 export declare const downloadBackupSchema: zod.ZodObject<{

package/dist/types/server/src/api/schemas/cameras.schema.d.ts

@@ -1,4 +1,4 @@
-import * as zod from 'zod';
+import zod from 'zod';
 export declare const recordingsSettingsSchema: zod.ZodObject<{
     enabled: zod.ZodDefault<zod.ZodBoolean>;
 }, "strict", zod.ZodTypeAny, {

package/dist/types/server/src/api/schemas/config.schema.d.ts

@@ -1,4 +1,4 @@
-import * as zod from 'zod';
+import zod from 'zod';
 export declare const logLevelSchema: zod.ZodUnion<[zod.ZodLiteral<"info">, zod.ZodLiteral<"debug">, zod.ZodLiteral<"warn">, zod.ZodLiteral<"error">, zod.ZodLiteral<"trace">]>;
 export declare const loggerSchema: zod.ZodObject<{
     level: zod.ZodDefault<zod.ZodOptional<zod.ZodUnion<[zod.ZodLiteral<"info">, zod.ZodLiteral<"debug">, zod.ZodLiteral<"warn">, zod.ZodLiteral<"error">, zod.ZodLiteral<"trace">]>>>;

package/dist/types/server/src/api/schemas/go2rtc.schema.d.ts

@@ -1,4 +1,4 @@
-import * as zod from 'zod';
+import zod from 'zod';
 export declare const logLevelGo2rtcSchema: zod.ZodUnion<[zod.ZodLiteral<"info">, zod.ZodLiteral<"debug">, zod.ZodLiteral<"trace">, zod.ZodLiteral<"warn">, zod.ZodLiteral<"error">, zod.ZodLiteral<"fatal">]>;
 export declare const logSchema: zod.ZodObject<{
     format: zod.ZodDefault<zod.ZodString>;

package/dist/types/server/src/api/schemas/users.schema.d.ts

@@ -1,5 +1,5 @@
-import * as zod from 'zod';
-import type { MultipartFile } from '../types';
+import zod from 'zod';
+import type { MultipartFile } from '../types/index.js';
 export declare const ACCEPTED_IMAGE_TYPES: string[];
 export declare const MAX_IMAGE_FILE_SIZE = 5000000;
 export declare const userPreferencesCamviewGridsLayoutCameras: zod.ZodObject<{

package/dist/types/server/src/api/services/auth.service.d.ts

@@ -0,0 +1,20 @@
+import type { ClientData, JwtTokenClientData, JwtTokenEncoded } from '../types/index.js';
+export declare class AuthService {
+    private configService;
+    private dbs;
+    constructor();
+    findById(id: string): JwtTokenEncoded | undefined;
+    findByRefreshToken(refresh_token: string): JwtTokenEncoded | undefined;
+    findByToken(access_token: string): JwtTokenEncoded | undefined;
+    clientDataById(id: string): ClientData | undefined;
+    clientDataByToken(acces_token: string): ClientData | undefined;
+    insert(jwtToken: JwtTokenEncoded, clientData?: ClientData): Promise<void>;
+    invalidateAll(): Promise<void>;
+    invalidateById(id: string): Promise<void>;
+    invalidateByRefreshToken(refresh_token: string): Promise<void>;
+    invalidateByToken(access_token: string): Promise<void>;
+    listTokens(): JwtTokenEncoded[];
+    listClientData(): Promise<ClientData[]>;
+    listTokensAndClientData(): JwtTokenClientData[];
+    patchTokenByRefreshToken(refresh_token: string, newJwtToken: JwtTokenEncoded): Promise<void>;
+}

package/dist/types/server/src/api/services/cameras.service.d.ts

@@ -0,0 +1,54 @@
+import { type CameraExtension } from '../../plugins/types.js';
+import type { Camera, CameraZone, DBCamera } from '../database/types.js';
+type DeepPartial<T> = T extends object ? {
+    [P in keyof T]?: DeepPartial<T[P]>;
+} : T;
+export declare class CamerasService {
+    private configService;
+    private api;
+    private dbs;
+    private go2rtcApi;
+    private usersService;
+    private pluginsService;
+    constructor();
+    createCamera(cameraData: DBCamera): Promise<DBCamera>;
+    createTransformedCamera(cameraData: DBCamera): Promise<Camera>;
+    createZone(cameraname: string, zoneData: CameraZone, zoneType: 'motion' | 'object'): Promise<DBCamera | undefined>;
+    patchZoneByName(cameraname: string, zonename: string, zoneData: CameraZone, zoneType: 'motion' | 'object'): Promise<DBCamera | undefined>;
+    removeZoneByName(cameraname: string, zonename: string, zoneType: 'motion' | 'object'): Promise<void>;
+    createCameraSource(cameraname: string, sourceName: string, address: string): Promise<void>;
+    resetCameraSource(cameraname: string, sourceName: string): Promise<void>;
+    list(): DBCamera[];
+    listTransformed(): Camera[];
+    listByPluginId(pluginId: string): DBCamera[];
+    listTransformedByPluginId(pluginId: string): Camera[];
+    listByExtension(pluginName: string): DBCamera[];
+    listTransformedByExtension(pluginName: string, extensions: CameraExtension[]): Camera[];
+    findById(id: string): DBCamera | undefined;
+    findTransformedById(id: string): Camera | undefined;
+    findByName(cameraname: string): DBCamera | undefined;
+    findTransformedByName(cameraname: string): Camera | undefined;
+    findByPluginAndName(cameraname: string, pluginId: string): DBCamera | undefined;
+    findTransformedByPluginAndName(cameraname: string, pluginId: string): Camera | undefined;
+    patchCameraByName(cameraname: string, cameraData: DeepPartial<DBCamera>): Promise<DBCamera | undefined>;
+    enableExtensionByName(cameraname: string, pluginName: string, extensionType: CameraExtension): Promise<DBCamera | undefined>;
+    disableExtensionByName(cameraname: string, pluginName: string, extensionType: CameraExtension): Promise<DBCamera | undefined>;
+    addExtensionByName(cameraname: string, pluginName: string): Promise<DBCamera | undefined>;
+    removeExtensionByName(cameraname: string, pluginName: string): Promise<DBCamera | undefined>;
+    removeExtension(pluginName: string): Promise<void>;
+    removeByName(cameraname: string): Promise<void>;
+    removeById(id: string): Promise<void>;
+    removeByPluginId(pluginId: string): Promise<void>;
+    removeByPluginIdAndName(cameraname: string, pluginId: string): Promise<void>;
+    removeAll(): Promise<void>;
+    transformCamera(camera: DBCamera): Camera;
+    cameraSourcesChanged(oldCamera: DBCamera, newCamera: DBCamera): boolean;
+    private addCameraSources;
+    private removeCameraSources;
+    private generateWsUrls;
+    private generateRTSPUrls;
+    private generateFFmpegUrls;
+    private generateWWWUrls;
+    private extensionIsEnabled;
+}
+export {};

package/dist/types/server/src/api/services/plugins.service.d.ts

@@ -0,0 +1,25 @@
+import type { Plugin } from '../../plugins/plugin.js';
+import type { PluginWorker } from '../../plugins/worker.js';
+import type { DBPlugin } from '../database/types.js';
+export declare class PluginsService {
+    private configService;
+    private dbs;
+    private pluginManager;
+    constructor();
+    listPlugins(): Plugin[];
+    listPluginProcesses(): PluginWorker[];
+    getPluginByName(pluginName: string): Plugin | undefined;
+    getPluginById(id: string): Plugin | undefined;
+    getPluginProcessByName(pluginName: string): PluginWorker | undefined;
+    getPluginProcessById(id: string): PluginWorker | undefined;
+    installedPlugins(): Plugin[];
+    installedPluginProcesses(): PluginWorker[];
+    listPluginDb(): DBPlugin[];
+    getPluginDbByName(pluginName: string): DBPlugin | undefined;
+    getPluginDbById(id: string): DBPlugin | undefined;
+    insertPluginDb(pluginName: string): Promise<DBPlugin>;
+    removePluginDbByName(pluginName: string): Promise<void>;
+    removePluginDbById(id: string): Promise<void>;
+    removeAllPluginsDb(): Promise<void>;
+    removeOrphanPluginsDb(): Promise<void>;
+}

package/dist/types/server/src/api/services/users.service.d.ts

@@ -0,0 +1,13 @@
+import type { DBUser } from '../database/types.js';
+export declare class UsersService {
+    private configService;
+    private dbs;
+    constructor();
+    createUser(userData: DBUser): Promise<DBUser>;
+    findById(id: string): DBUser | undefined;
+    findByName(username: string): DBUser | undefined;
+    list(): DBUser[];
+    patchUser(username: string, userData: Partial<DBUser>): Promise<DBUser | undefined>;
+    removeByName(username: string): Promise<void>;
+    removeAll(): Promise<void>;
+}

package/dist/types/server/src/api/types/index.d.ts

@@ -1,15 +1,15 @@
-/// <reference types="node" />
-/// <reference types="node" />
-import type { Readable } from 'stream';
-import type { CameraExtension, PluginContract, PluginRootSchema } from '../../plugins/types';
-import type { LoggingLevel } from '../../services/config/types';
-import type { CameraExtensions, CameraZone, DBCamera, DBCamviewLayout, DBRoles, DBUser } from '../database/types';
-import type { ApplicationResponse } from '../go2rtc/types';
-import type { RestoreBackupInput } from '../schemas/backup.schema';
-import type { CreateCameraInput, PatchCameraInput, PreviewCameraInput } from '../schemas/cameras.schema';
-import type { PatchConfigInput } from '../schemas/config.schema';
-import type { PatchGo2RtcConfigInput } from '../schemas/go2rtc.schema';
-import type { CreateUserInput, LoginUserInput, PatchUserInput } from '../schemas/users.schema';
+/// <reference types="node" resolution-mode="require"/>
+/// <reference types="node" resolution-mode="require"/>
+import type { Readable } from 'node:stream';
+import type { CameraExtension, PluginContract, PluginRootSchema } from '../../plugins/types.js';
+import type { LoggingLevel } from '../../services/config/types.js';
+import type { CameraExtensions, CameraZone, DBCamera, DBCamviewLayout, DBRoles, DBUser } from '../database/types.js';
+import type { ApplicationResponse } from '../go2rtc/types.js';
+import type { RestoreBackupInput } from '../schemas/backup.schema.js';
+import type { CreateCameraInput, PatchCameraInput, PreviewCameraInput } from '../schemas/cameras.schema.js';
+import type { PatchConfigInput } from '../schemas/config.schema.js';
+import type { PatchGo2RtcConfigInput } from '../schemas/go2rtc.schema.js';
+import type { CreateUserInput, LoginUserInput, PatchUserInput } from '../schemas/users.schema.js';
 export interface BusboyFileStream extends Readable {
     truncated: boolean;
     bytesRead: number;

package/dist/types/server/src/api/utils/constants.d.ts

@@ -0,0 +1,15 @@
+export declare const HOST_CERT_FILENAME = "camera.ui.cert.pem";
+export declare const HOST_KEY_FILENAME = "camera.ui.key.pem";
+export declare const ROOT_CERT_FILENAME = "camera.ui.root.cert.pem";
+export declare const ROOT_KEY_FILENAME = "camera.ui.root.key.pem";
+export declare const P12_FILENAME = "camera.ui.p12";
+export declare const P12_PASSWORD = "camera.ui";
+export declare const DEFAULTS: {
+    C: string;
+    ST: string;
+    L: string;
+    O: string;
+    OU: string;
+    CN: string;
+    ROOT_CN: string;
+};

package/dist/types/server/src/api/websocket/index.d.ts

@@ -0,0 +1,15 @@
+import { Server } from 'socket.io';
+import type { FastifyInstance } from 'fastify';
+import type { ServerOptions } from 'socket.io';
+import type { SocketNsp, SocketNspMap } from './types.js';
+export declare class SocketService {
+    io: Server;
+    namespaces: Map<SocketNsp, SocketNspMap>;
+    adminNsp: SocketNsp[];
+    private logger;
+    private authService;
+    private configService;
+    constructor(app: FastifyInstance, opts: Partial<ServerOptions>);
+    private registerNamespaces;
+    private setupConnection;
+}

package/dist/types/server/src/api/websocket/nsp/frame.d.ts

@@ -0,0 +1,10 @@
+import type { Namespace, Server, Socket } from 'socket.io';
+import type { SocketNsp } from '../types.js';
+export declare class FrameNamespace {
+    nsp: Namespace;
+    nspName: SocketNsp;
+    readonly connectedClients: Map<string, Set<Socket>>;
+    private decoder;
+    constructor(io: Server);
+    private handleConnection;
+}

package/dist/types/server/src/api/websocket/nsp/logs.d.ts

@@ -0,0 +1,11 @@
+import type { Namespace, Server, Socket } from 'socket.io';
+import type { SocketNsp } from '../types.js';
+export declare class LogsNamespace {
+    nsp: Namespace;
+    nspName: SocketNsp;
+    private nativeTail?;
+    private configService;
+    constructor(io: Server);
+    connect(socket: Socket, filter?: string[]): void;
+    private tailLogFromFileNative;
+}

package/dist/types/server/src/api/websocket/nsp/metrics.d.ts

@@ -0,0 +1,33 @@
+import type { Namespace, Server } from 'socket.io';
+import type { CpuInfo, CpuTempInfo, MemoryInfo, NetworkInfo, PluginProcessesInfo, ProcessesInfo, SocketNsp } from '../types.js';
+export declare class MetricsNamespace {
+    nsp: Namespace;
+    nspName: SocketNsp;
+    private logger;
+    private configService;
+    private pluginManager;
+    private go2rtc;
+    private cpuHistory;
+    private cpuTempHistory;
+    private memHistory;
+    private networkHistory;
+    private processServerHistory;
+    private processGo2RtcHistory;
+    private processPluginsHistory;
+    private memoryInfo?;
+    constructor(io: Server);
+    getProcessesInfo(payload: any, callback?: Function): Promise<ProcessesInfo>;
+    getPluginsProcessesInfo(payload: any, callback?: Function): Promise<PluginProcessesInfo>;
+    getServerCpuInfo(payload?: any, callback?: Function): Promise<CpuInfo>;
+    getServerMemoryInfo(payload?: any, callback?: Function): Promise<MemoryInfo>;
+    getCpuTempInfo(payload?: any, callback?: Function): Promise<CpuTempInfo>;
+    getNetworkUsageInfo(payload?: any, callback?: Function): Promise<NetworkInfo>;
+    private getCpuTemp;
+    private getProcesses;
+    private getCpuLoad;
+    private getCpuLoadAlt;
+    private getCpuTempLegacy;
+    private getCpuTempAlt;
+    private getMemoryUsage;
+    private getCurrentNetworkUsage;
+}