@camera.ui/browser 0.0.69 → 0.0.70

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

@@ -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/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/index.js';
-export interface DBSettings {
-    readonly _id: string;
-    _rev?: string;
-    settings: DBSetting;
-}
-export interface DBSetting {
-}
-export interface DBTokens {
-    readonly _id: string;
-    _rev?: string;
+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/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/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;
+}

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

@@ -0,0 +1,11 @@
+import type { Namespace, Server, Socket } from 'socket.io';
+import type { SocketNsp } from '../types.js';
+export declare class NotificationsNamespace {
+    nsp: Namespace;
+    nspName: SocketNsp;
+    private logger;
+    constructor(io: Server);
+    clearNotifications(): Promise<void>;
+    getNotifications(socket: Socket): Promise<void>;
+    removeNotification(id?: string): Promise<void>;
+}

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

@@ -0,0 +1,13 @@
+import type { Namespace, Server } from 'socket.io';
+import type { PLUGIN_STATUS } from '../../../plugins/types.js';
+import type { SocketNsp } from '../types.js';
+export declare class PluginsNamespace {
+    nsp: Namespace;
+    nspName: SocketNsp;
+    private pluginManager;
+    constructor(io: Server);
+    pluginStatus(pluginName: string, callback?: Function): Promise<void | {
+        pluginName: string;
+        status: PLUGIN_STATUS;
+    }>;
+}

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

@@ -0,0 +1,9 @@
+import type { Namespace, Server, Socket } from 'socket.io';
+import type { SocketNsp } from '../types.js';
+export declare class ServerNamespace {
+    nsp: Namespace;
+    nspName: SocketNsp;
+    private logger;
+    constructor(io: Server);
+    checkUpdate(socket?: Socket): Promise<void>;
+}

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

@@ -0,0 +1,20 @@
+import type { Namespace, Server, Socket } from 'socket.io';
+import { PLUGIN_STATUS } from '../../../plugins/types.js';
+import { RUNTIME_STATUS } from '../../../services/config/types.js';
+import type { SocketNsp } from '../types.js';
+export declare class StatusNamespace {
+    nsp: Namespace;
+    nspName: SocketNsp;
+    private configService;
+    private pluginManager;
+    private go2rtc;
+    constructor(io: Server);
+    watchStats(socket: Socket, payload: any, callback?: Function): {
+        name: string;
+        status: RUNTIME_STATUS;
+    }[];
+    watchPluginStats(socket: Socket, payload: any, callback?: Function): {
+        name: string;
+        status: PLUGIN_STATUS;
+    }[];
+}

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

@@ -0,0 +1,15 @@
+import type { Namespace, Server } from 'socket.io';
+import type { SocketNsp } from '../types.js';
+export declare class StreamsNamespace {
+    nsp: Namespace;
+    nspName: SocketNsp;
+    private bridges;
+    private logger;
+    private configService;
+    constructor(io: Server);
+    private connectBridge;
+    private sendMessage;
+    private closeBridge;
+    private onEnd;
+    private onDestroy;
+}

package/dist/types/server/src/api/{ws → websocket}/types.d.ts

@@ -2,7 +2,7 @@ import { PLUGIN_STATUS } from '../../plugins/types.js';
 import type { Namespace } from 'socket.io';
 import type { WebSocket } from 'ws';
 import type { VideoStreamingMode } from '../database/types.js';
-export type SocketNsp = '/camera.ui' | '/metrics' | '/logs' | '/status' | '/notifications' | '/streams' | '/plugins' | '/proxy';
+export type SocketNsp = '/camera.ui' | '/metrics' | '/logs' | '/status' | '/notifications' | '/streams' | '/plugins' | '/proxy' | '/frame';
 export interface SocketNspMap {
     nsp: Namespace;
     [key: string]: any;

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

@@ -0,0 +1,44 @@
+/// <reference types="node" resolution-mode="require"/>
+import 'reflect-metadata';
+import { EventEmitter } from 'node:events';
+import { CameraController } from './camera/controller.js';
+import type { Camera, CameraExtensions } from './api/database/types.js';
+import type { StreamManager } from './decoder/worker/index.js';
+import type { BasePlugin } from './plugins/base.js';
+import type { API } from './plugins/node/api.js';
+import type { PluginLogger } from './plugins/node/logger.js';
+import type { CameraExtension } from './plugins/types.js';
+export interface PluginConstructor {
+    new (logger: PluginLogger, api: API): BasePlugin;
+}
+export declare const enum API_EVENT {
+    FINISH_LAUNCHING = "finishLaunching",
+    SHUTDOWN = "shutdown"
+}
+export declare interface CameraUiAPI {
+    on(event: 'finishLaunching', listener: () => void): this;
+    on(event: 'shutdown', listener: () => void): this;
+    emit(event: 'finishLaunching'): boolean;
+    emit(event: 'shutdown'): boolean;
+}
+export declare class CameraUiAPI extends EventEmitter {
+    private camerasMap;
+    constructor();
+    configureCameras(): Promise<void>;
+    addCamera(camera: Camera): Promise<{
+        controller: CameraController;
+        manager: StreamManager;
+    }>;
+    getCamera(cameraId: string): {
+        controller: CameraController;
+        manager: StreamManager;
+    } | undefined;
+    getCameras(pluginId?: string): {
+        controller: CameraController;
+        manager: StreamManager;
+    }[];
+    updateCamera(camera: Camera, extensions: CameraExtensions): void;
+    removeCamera(camera: Camera, extensions: CameraExtensions): Promise<void>;
+    selectCamera(pluginId: string, camera: Camera, extension: CameraExtension): void;
+    deselectCamera(pluginId: string, camera: Camera, extension: CameraExtension): void;
+}

package/dist/types/server/src/camera/base/cameraDevice.d.ts

@@ -12,6 +12,7 @@ export declare abstract class CameraDevice extends BaseCameraDevice {
     set prebufferDelegate(delegate: CameraPrebufferDelegate);
     abstract generateFrames(): AsyncIterableIterator<Frame>;
     abstract getFfmpegPath(): Promise<string>;
+    snapshot(forceNew?: boolean): Promise<ArrayBuffer>;
     createSession(sourceName: string, options?: StreamingConnectionOptions): Promise<StreamingSession>;
     streamVideo(sourceName: string, options: FfmpegOptions): Promise<StreamingSession>;
     recordToFile(sourceName: string, outputPath: string, duration?: number): Promise<void>;

package/dist/types/server/src/camera/base/cameraDeviceBrowser.d.ts

@@ -1,5 +1,6 @@
 import { BrowserStreamingSession } from '../streaming/browser/browser-streaming-session.js';
 import { BaseCameraDevice } from './index.js';
 export declare abstract class BrowserCameraDevice extends BaseCameraDevice {
+    snapshot(forceNew?: boolean): Promise<ArrayBuffer>;
     createSession(sourceName: string, videoElement: HTMLVideoElement): Promise<BrowserStreamingSession>;
 }