@camera.ui/browser 0.0.109 → 0.0.111

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

@@ -1,15 +1,16 @@
-import type { AuthConfig } from '@camera.ui/common';
-import type { PLUGIN_STATUS, PluginContract } from '@camera.ui/plugineer';
-import type { CameraExtension, CameraZone, RootSchema } from '@camera.ui/types';
+import type { AuthConfig } from '@camera.ui/rpc-common';
+import type { CameraExtension, CameraExtensions, DetectionZone, ProbeConfig, SchemaConfig } from '@camera.ui/types';
 import type { Readable } from 'node:stream';
+import type { PLUGIN_STATUS, PluginContract } from '../../plugins/types.js';
 import type { LoggingLevel } from '../../services/config/types.js';
-import type { CameraExtensions, DBCamera, DBCamviewLayout, DBRoles, DBUser } from '../database/types.js';
-import type { ApplicationResponse } from '../go2rtc/types.js';
+import type { DBCamera, DBCamviewLayout, DBRoles, DBUser } from '../database/types.js';
+import type { ApplicationResponse, DeviceSourceType } from '../go2rtc/types.js';
 import type { RestoreBackupInput } from '../schemas/backup.schema.js';
-import type { CreateCameraInput, PatchCameraInput, PreviewCameraInput } from '../schemas/cameras.schema.js';
+import type { CreateCameraInput, PairCameraInput, 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 { DetectAudioInput, DetectMotionInput, DetectObjectInput } from '../schemas/plugins.schema.js';
+import type { PatchStorateInput, SetStorageInput, SubmitStorageInput } from '../schemas/storage.schema.js';
 import type { PatchSystemInput } from '../schemas/system.schema.js';
 import type { CreateShortcutInput, CreateUserInput, CreateViewInput, LoginUserInput, PatchShortcutInput, PatchUserInput, PatchViewInput } from '../schemas/users.schema.js';
 export interface BusboyFileStream extends Readable {
@@ -25,23 +26,28 @@ export interface UiNotification {
     link?: string;
 }
 export interface JwtTokenEncoded {
-    _id: string;
+    readonly _id: string;
     access_token: string;
     refresh_token: string;
     token_type: string;
     expires_in: number;
     expires_at: Date;
 }
-export interface JwtPayload {
-    _id: string;
-    avatar: string;
+export interface UserData extends JwtTokenEncoded {
     username: string;
+    avatar: string;
     role: DBRoles;
-    oneLogin: boolean;
     rememberMe: boolean;
+    singleSession: boolean;
     firstLogin: boolean;
     sessionTimer: number;
 }
+export interface JwtPayload {
+    _id: string;
+    username: string;
+    rememberMe: boolean;
+    sessionTimer: number;
+}
 export interface JwtRefreshPayload {
     _id: string;
 }
@@ -54,7 +60,6 @@ export interface ClientData {
 export declare const enum REFRESH_TOKEN {
     EXPIRES_IN = "7d"
 }
-export declare const PAGINATION_DEFAULTS: PaginationQuery;
 export interface CameraCamviewSettings {
     enabled: boolean;
     mode: InterfaceStreamMode;
@@ -64,10 +69,6 @@ export type InterfaceStreamMode = 'live' | 'snapshot';
 export interface JwtTokenDecoded {
     _id: string;
     username: string;
-    avatar: string;
-    role: DBRoles;
-    oneLogin: boolean;
-    firstLogin: boolean;
     rememberMe: boolean;
     sessionTimer: number;
     exp: Readonly<number>;
@@ -105,8 +106,8 @@ export interface Pagination {
     startIndex: number;
     endIndex: number;
     totalItems: number;
-    currentPage?: number;
-    totalPages?: number;
+    currentPage: number;
+    totalPages: number;
     nextPageQuery?: string | null;
     prevPageQuery?: string | null;
 }
@@ -130,12 +131,8 @@ export interface PluginExtension {
     pluginName: string;
     displayName: string;
     type: CameraExtension[];
-    builtIn?: boolean;
-    externPlugin?: boolean;
 }
-export interface PluginExtensionConfig extends PluginExtension {
-    rootSchema?: RootSchema;
-    config?: Record<string, any>;
+export interface PluginExtensionConfig extends PluginExtension, SchemaConfig {
 }
 export interface ExtensionsResponse {
     pagination: Pagination;
@@ -169,7 +166,6 @@ export interface Go2RtcInfo {
     auth: Partial<Go2RtcInfoAuth>;
 }
 export interface NatsInfo {
-    servers: string[];
     auth: AuthConfig;
 }
 export interface TokenClientDataResponse {
@@ -205,21 +201,31 @@ export interface AuthRefreshRequest {
         refresh_token: string;
     };
 }
-export interface AuthTokensRequest {
-    Querystring: {
-        clientData?: boolean;
-    };
-}
 export interface CamerasParamsRequest {
     Params: {
         cameraname: string;
     };
 }
+export interface CamerasStreamRequest {
+    Params: {
+        cameraid: string;
+        sourcename: string;
+    };
+}
 export interface CameraSnapshotQueryRequest {
     Querystring: {
         forceNew?: boolean;
     };
 }
+export interface CameraDiscoverQueryRequest {
+    Querystring: {
+        type?: DeviceSourceType;
+        src?: string;
+    };
+}
+export interface CameraProbeSourceQueryRequest {
+    Querystring: ProbeConfig;
+}
 export interface CameraSourceParamsRequest {
     Params: {
         sourcename: string;
@@ -230,11 +236,6 @@ export interface CamerasParamsIdRequest {
         cameraid: string;
     };
 }
-export interface CameraZonesParamsRequest {
-    Params: {
-        zonename: string;
-    };
-}
 export interface CamerasExtensionsParamsRequest {
     Params: {
         cameraname: string;
@@ -248,24 +249,28 @@ export interface CamerasExtensionsRequest {
     };
 }
 export interface CameraZoneInsertPatchRequest {
-    Body: CameraZone;
+    Body: DetectionZone[];
 }
 export interface CamerasInsertRequest {
     Body: CreateCameraInput;
 }
+export interface CameraPairRequest {
+    Body: PairCameraInput;
+}
 export interface CamerasPreviewRequest {
     Body: PreviewCameraInput;
 }
 export interface CamerasPatchRequest {
     Body: PatchCameraInput;
 }
-export interface ExtensionsPatchRequest {
-    Body: Record<string, any>;
+export interface StoragePatchRequest {
+    Body: PatchStorateInput;
 }
-export interface ExtensionsSubmitRequest {
-    Body: {
-        configPath: string;
-    };
+export interface StorageSetRequest {
+    Body: SetStorageInput;
+}
+export interface StorageSubmitRequest {
+    Body: SubmitStorageInput;
 }
 export interface ConfigRequest {
     Querystring: {
@@ -338,11 +343,6 @@ export interface PluginsDetectAudioRequest {
 export interface PluginsInterfaceQueryType {
     type: 'objectDetection' | 'motionDetection' | 'audioDetection';
 }
-export interface PluginsInterfaceQuery {
-    Querystring: {
-        type: PluginsInterfaceQueryType;
-    };
-}
 export interface UsersParamsRequest {
     Params: {
         username: string;
@@ -431,6 +431,7 @@ export interface CamerasSettings {
 export interface InterfaceSettinges {
     showBottomBarOnMobile: boolean;
     selectedSettingsView: SettingsViews;
+    navbarStayCollapsed: boolean;
 }
 export interface UiSettingsLocalStorage {
     cameras: CamerasSettings;
@@ -594,6 +595,7 @@ export interface CameraUiPlugin {
     links?: {
         npm?: string;
         homepage?: string;
+        bugs?: string;
     };
     author?: string;
     engines?: {

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

@@ -1,16 +1,18 @@
-import type { PLUGIN_STATUS } from '@camera.ui/plugineer';
 import type { Namespace } from 'socket.io';
+import type { PLUGIN_STATUS } from '../../plugins/types.js';
 import type { RuntimeInfo } from '../../services/config/types.js';
-export type SocketNsp = '/camera.ui' | '/metrics' | '/logs' | '/status' | '/notifications' | '/plugins' | '/proxy' | '/server';
+export type SocketNsp = '/camera.ui' | '/metrics' | '/logs' | '/status' | '/notifications' | '/plugins' | '/server';
 export interface SocketNspMap {
     nsp: Namespace;
     [key: string]: any;
 }
+export type ProcessType = 'system' | 'core' | 'frameworker' | 'plugin';
 export interface ProcessInfo {
     name: string;
     pid?: number;
     cpuLoad: string;
     memLoad: string;
+    type: ProcessType;
     timestamp: number;
 }
 export interface ServerProcessInfo {

package/dist/types/server/src/camera/classes.d.ts

@@ -0,0 +1,2 @@
+import type { Detection } from '@camera.ui/types';
+export declare function transformLabels(detections: Detection[]): Detection[];

package/dist/types/{packages/plugineer/src/polyglot/node → server/src}/camera/index.d.ts

@@ -1,21 +1,27 @@
 import { Subscribed } from '@camera.ui/common/utils';
+import { CameraDeviceCapability } from '@camera.ui/types';
 import TTLCache from '@isaacs/ttlcache';
 import { BehaviorSubject } from 'rxjs';
-import type { AudioSetEvent, AudioState, BatterySetEvent, BatteryState, Camera, CameraActivitySettings, CameraDelegate, CameraFrameWorkerSettings, CameraInformation, CameraInput, CameraInternalSource, CameraPTZDelegate, CameraSource, CameraType, DetectionZone, DoorbellSetEvent, DoorbellState, LightSetEvent, LightState, LoggerService, MotionSetEvent, MotionState, ObjectSetEvent, ObjectState, SetValues, SirenSetEvent, SirenState, StateValues } from '@camera.ui/types';
+import type { AudioState, BatteryState, Camera, CameraDetectionSettings, CameraFrameWorkerSettings, CameraInformation, CameraSource, CameraType, DetectionZone, DoorbellState, LightState, LoggerService, MotionState, ObjectState, SetValues, SirenState, StateValues } from '@camera.ui/types';
 import type { Observable } from 'rxjs';
+import type { CameraInterfaces, PluginCapabilities } from './types.js';
 export declare abstract class BaseCameraDevice extends Subscribed {
+    #private;
     readonly logger: LoggerService;
     protected snapshotCache: TTLCache<string, ArrayBuffer>;
-    protected cameraSubject: BehaviorSubject<Camera>;
-    protected cameraState: BehaviorSubject<boolean>;
-    protected lightState: BehaviorSubject<LightState>;
-    protected motionState: BehaviorSubject<MotionState>;
-    protected audioState: BehaviorSubject<AudioState>;
-    protected objectState: BehaviorSubject<ObjectState>;
-    protected doorbellState: BehaviorSubject<DoorbellState>;
-    protected sirenState: BehaviorSubject<SirenState>;
-    protected batteryState: BehaviorSubject<BatteryState>;
+    readonly cameraSubject: BehaviorSubject<Camera>;
+    readonly cameraState: BehaviorSubject<boolean>;
+    readonly frameWorkerState: BehaviorSubject<boolean>;
+    readonly lightState: BehaviorSubject<LightState>;
+    readonly motionState: BehaviorSubject<MotionState>;
+    readonly audioState: BehaviorSubject<AudioState>;
+    readonly objectState: BehaviorSubject<ObjectState>;
+    readonly doorbellState: BehaviorSubject<DoorbellState>;
+    readonly sirenState: BehaviorSubject<SirenState>;
+    readonly batteryState: BehaviorSubject<BatteryState>;
+    readonly capabilities: BehaviorSubject<PluginCapabilities[]>;
     readonly onConnected: Observable<boolean>;
+    readonly onFrameWorkerConnected: Observable<boolean>;
     readonly onLightSwitched: Observable<LightState>;
     readonly onMotionDetected: Observable<MotionState>;
     readonly onAudioDetected: Observable<AudioState>;
@@ -23,13 +29,13 @@ export declare abstract class BaseCameraDevice extends Subscribed {
     readonly onDoorbellPressed: Observable<DoorbellState>;
     readonly onSirenDetected: Observable<SirenState>;
     readonly onBatteryChanged: Observable<BatteryState>;
-    protected abstract cameraDelegate: CameraDelegate;
-    protected abstract ptzDelegate: CameraPTZDelegate;
+    protected abstract cameraInterfaces: CameraInterfaces;
     protected get cameraObject(): Camera;
     get id(): string;
     get nativeId(): string | undefined;
     get pluginId(): string;
     get connected(): boolean;
+    get frameWorkerConnected(): boolean;
     get disabled(): boolean;
     get name(): string;
     get type(): CameraType;
@@ -37,29 +43,27 @@ export declare abstract class BaseCameraDevice extends Subscribed {
     get isCloud(): boolean;
     get hasLight(): boolean;
     get hasSiren(): boolean;
-    get hasBinarySensor(): boolean;
+    get hasDoorbell(): boolean;
     get hasBattery(): boolean;
-    get hasMotionDetector(): boolean;
-    get extendedMotionDetector(): boolean;
     get hasAudioDetector(): boolean;
+    get hasMotionDetector(): boolean;
     get hasObjectDetector(): boolean;
     get hasPtz(): boolean;
     get snapshotTTL(): number;
-    get activityZones(): DetectionZone[];
-    get activitySettings(): CameraActivitySettings;
+    get detectionZones(): DetectionZone[];
+    get detectionSettings(): CameraDetectionSettings;
     get frameWorkerSettings(): CameraFrameWorkerSettings;
     get streamSource(): CameraSource;
-    get snapshotSource(): CameraInput | undefined;
+    get snapshotSource(): CameraSource | undefined;
     get highResolutionSource(): CameraSource | undefined;
     get midResolutionSource(): CameraSource | undefined;
     get lowResolutionSource(): CameraSource | undefined;
-    get ptz(): CameraPTZDelegate;
+    get interfaces(): CameraInterfaces;
     abstract get sources(): CameraSource[];
-    abstract get internalSources(): CameraInternalSource[];
     constructor(camera: Camera, logger: LoggerService);
-    protected abstract cleanup(): void;
+    getCapabilities(): CameraDeviceCapability[];
+    hasCapability(capability: CameraDeviceCapability): boolean;
     getValue<T extends keyof StateValues>(stateName: T): StateValues[T];
-    snapshot(forceNew?: boolean): Promise<ArrayBuffer | undefined>;
     onStateChange<T extends keyof StateValues>(stateName: T): Observable<{
         newState: StateValues[T];
         oldState: StateValues[T];
@@ -69,23 +73,20 @@ export declare abstract class BaseCameraDevice extends Subscribed {
         oldData: Camera[T];
         newData: Camera[T];
     }>;
+    onCapabilitiesChange(): Observable<{
+        oldCapabilities: CameraDeviceCapability[];
+        newCapabilities: CameraDeviceCapability[];
+    }>;
+    protected abstract cleanup(): void;
     protected removeAllListeners(): void;
     protected updateCamera(updatedCamera: Camera): void;
     protected updateCameraState(state: boolean): void;
+    protected updateFrameWorkerState(state: boolean): void;
+    protected updateCapabilities(capabilities: PluginCapabilities[]): void;
     protected updateStateInternal<T extends keyof SetValues>(stateName: T, eventData: SetValues[T], skipCheck?: boolean, skipDetectionsCheck?: boolean): void;
     protected checkStateInternal<T extends keyof SetValues>(stateName: T, event: SetValues[T], skipDetectionsCheck?: boolean): {
         changed: boolean;
         event: StateValues[T];
     };
     protected stateChanged<T extends keyof SetValues>(oldState?: SetValues[T], newState?: SetValues[T], type?: keyof StateValues): boolean;
-    protected getAudioState(event: AudioSetEvent, ignoreLastEvet?: boolean): AudioState;
-    protected getMotionState(event: MotionSetEvent, ignoreLastEvet?: boolean): MotionState;
-    protected getObjectState(event: ObjectSetEvent, ignoreLastEvet?: boolean): ObjectState;
-    protected getDoorbellState(event: DoorbellSetEvent, ignoreLastEvet?: boolean): DoorbellState;
-    protected getLightState(event: LightSetEvent, ignoreLastEvet?: boolean): LightState;
-    protected getSirenState(event: SirenSetEvent, ignoreLastEvet?: boolean): SirenState;
-    protected getBatteryState(event: BatterySetEvent, ignoreLastEvet?: boolean): BatteryState;
-    protected cleanState<T extends keyof StateValues>(state: StateValues[T] | SetValues[T]): SetValues[T];
-    private isStateEvent;
-    private createStateObservable;
 }

package/dist/types/server/src/camera/interfaces.d.ts

@@ -0,0 +1,17 @@
+import type { RPCConnection } from '@camera.ui/rpc-common';
+import type { PTZCommand, PTZInterface, SnapshotInterface, StreamingInterface } from '@camera.ui/types';
+import type { BehaviorSubject } from 'rxjs';
+import type { CameraInterfaces, PluginCapabilities } from './types.js';
+interface ProxyInstance {
+    createRPCConnection(namespace: string): Promise<RPCConnection>;
+}
+export declare class CameraInterface implements CameraInterfaces {
+    #private;
+    interfaces?: PTZInterface | SnapshotInterface | StreamingInterface;
+    constructor(proxy: ProxyInstance, capabilities: BehaviorSubject<PluginCapabilities[]>, cameraId: string, pluginId?: string);
+    streamUrl(sourceName: string): Promise<string>;
+    snapshot(sourceId: string, forceNew?: boolean): Promise<ArrayBuffer | undefined>;
+    ptzCommand(command: PTZCommand): Promise<void>;
+    disconnect(): Promise<void>;
+}
+export {};

package/dist/types/{packages/plugineer/src/polyglot/node → server/src}/camera/polygon.d.ts

@@ -1,4 +1,4 @@
-import type { CameraActivitySettings, Detection, DetectionZone } from '@camera.ui/types';
+import type { CameraDetectionSettings, Detection, DetectionZone } from '@camera.ui/types';
 export declare const convertZonePointsToPixels: (zone: DetectionZone, detection: Detection) => DetectionZone;
 export declare const convertBoundingBoxToPixels: (detection: Detection) => Detection;
-export declare const areDetectionsValid: (detections: Detection[], zones: DetectionZone[], activitySettings: CameraActivitySettings) => Detection[];
+export declare const areDetectionsValid: (detections: Detection[], zones: DetectionZone[], activitySettings: CameraDetectionSettings) => Detection[];

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

@@ -1,11 +1,17 @@
-import type { FrameData, FrameMetadata, MotionState, SetValues, StateValues } from '@camera.ui/types';
-export interface FrameState extends MotionState {
-    frameData: FrameData;
-    metadata: FrameMetadata;
+import type { AudioSetEvent, AudioState, BatterySetEvent, BatteryState, CameraDevice, CameraDeviceCapability, DoorbellSetEvent, DoorbellState, LightSetEvent, LightState, MotionSetEvent, MotionState, ObjectSetEvent, ObjectState, ProbeConfig, ProbeStream, PTZInterface, SirenSetEvent, SirenState, SnapshotInterface, StreamingInterface } from '@camera.ui/types';
+import type { RefreshedStates } from '../rpc/types.js';
+import type { FunctionPropertyNames } from '../types.js';
+export type States = LightState | MotionState | AudioState | ObjectState | DoorbellState | SirenState | BatteryState;
+export type Sets = LightSetEvent | MotionSetEvent | AudioSetEvent | ObjectSetEvent | DoorbellSetEvent | SirenSetEvent | BatterySetEvent;
+export interface CameraDeviceInterface extends Omit<Pick<CameraDevice, FunctionPropertyNames<CameraDevice>>, 'extend' | 'addCapabilities' | 'removeCapabilities' | 'getFrames' | 'onStateChange' | 'onPropertyChange' | 'onCapabilitiesChange'> {
+    refreshStates(): Promise<RefreshedStates>;
+    snapshot(sourceId: string, forceNew?: boolean): Promise<ArrayBuffer | undefined>;
+    probeStream(sourceId: string, probeConfig?: ProbeConfig, refresh?: boolean): Promise<ProbeStream | undefined>;
+    addPluginCapabilities(pluginId: string, capabilities: CameraDeviceCapability[]): void;
+    removePluginCapabilities(pluginId: string, capabilities: CameraDeviceCapability[]): void;
+}
+export type CameraInterfaces = PTZInterface & SnapshotInterface & StreamingInterface;
+export interface PluginCapabilities {
+    pluginId: string;
+    capabilities: CameraDeviceCapability[];
 }
-export type CameraStateCallbacks = {
-    [K in keyof StateValues]: (event: StateValues[K]) => void;
-};
-export type StateValue<T extends keyof StateValues> = StateValues[T];
-export type SetValue<T extends keyof SetValues> = SetValues[T];
-export type OnChangeCallback<T extends keyof StateValues> = (newEvent: StateValues[T], oldEvent: StateValues[T]) => void;

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

@@ -1,14 +1,15 @@
-export declare const sourcePrefixes: readonly ["bubble://", "dvrip://", "echo:", "exec:", "expr:", "ffmpeg:", "gopro://", "hass:", "homekit://", "http://", "https://", "httpx://", "isapi://", "ivideon:", "kasa://", "nest:", "onvif://", "roborock://", "rtmp://", "rtsp://", "rtspx://", "tapo://", "tcp://", "webrtc:", "webtorrent:"];
-export declare const rtspPresets: readonly ["#backchannel=0", "#header=", "#media=audio", "#media=video", "#timeout=10", "#timeout=20", "#timeout=30", "#transport="];
+export declare const sourcePrefixes: readonly ["bubble://", "doorbird://", "dvrip://", "echo:", "eseecloud://", "exec:", "expr:", "ffmpeg:", "flussonic://", "gopro://", "hass:", "homekit://", "http://", "https://", "httpx://", "isapi://", "ivideon:", "kasa://", "nest:", "onvif://", "ring:", "roborock://", "rtmp://", "rtsp://", "rtspx://", "tapo://", "tcp://", "webrtc:", "webtorrent:"];
+export declare const rtspPresets: readonly ["#backchannel=", "#header=", "#media=audio", "#media=video", "#timeout=10", "#timeout=20", "#timeout=30", "#transport="];
 export declare const ffmpegPresets: readonly ["#audio=aac", "#audio=aac/16000", "#audio=mp3", "#audio=opus", "#audio=pcm", "#audio=pcm/8000", "#audio=pcm/16000", "#audio=pcm/48000", "#audio=pcma", "#audio=pcma/8000", "#audio=pcma/16000", "#audio=pcma/48000", "#audio=pcml", "#audio=pcml/8000", "#audio=pcml/44100", "#audio=pcmu", "#audio=pcmu/8000", "#audio=pcmu/16000", "#audio=pcmu/48000", "#drawtext", "#hardware", "#hardware=cuda", "#hardware=dxva2", "#hardware=rkmpp", "#hardware=v4l2m2m", "#hardware=vaapi", "#hardware=videotoolbox", "#height=", "#raw=", "#rotate=-90", "#rotate=90", "#rotate=180", "#rotate=270", "#video=copy", "#video=h264", "#video=h265", "#video=mjpeg", "#width="];
 export declare const homekitPresets: readonly ["client_id=", "client_private=", "device_id=", "device_public="];
 export declare const httpPresets: readonly ["#header="];
 export declare const nestPresets: readonly ["client_id=", "client_secret=", "refresh_token=", "project_id=", "device_id="];
-export declare const webrtcPreset: readonly ["#client_id=", "#format=openipc", "#format=wyze", "#format=kinesis", "#ice_servers="];
+export declare const ringPresets: readonly ["device_id=", "refresh_token="];
+export declare const webrtcPresets: readonly ["#client_id=", "#format=openipc", "#format=wyze", "#format=kinesis", "#ice_servers="];
 export type SourcePrefixes = (typeof sourcePrefixes)[number];
 export type RtspPresets = (typeof rtspPresets)[number];
 export type FFmpegPresets = (typeof ffmpegPresets)[number];
 export type HomekitPresets = (typeof homekitPresets)[number];
 export type HttpPresets = (typeof httpPresets)[number];
 export type NestPresets = (typeof nestPresets)[number];
-export type WebrtcPresets = (typeof webrtcPreset)[number];
+export type WebrtcPresets = (typeof webrtcPresets)[number];

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

@@ -0,0 +1,15 @@
+import type { Camera, CameraConfig, CoreManager, DeviceManager, FfmpegArgs, HWAccelOptions, IceServer } from '@camera.ui/types';
+import type { PluginInfo } from '../plugins/types.js';
+export interface CoreManagerInterface extends Omit<CoreManager, keyof CoreManager> {
+    getFFmpegPath(): Promise<string>;
+    getHwaccelInfo(options: HWAccelOptions): Promise<FfmpegArgs[]>;
+    getServerAddresses(): Promise<string[]>;
+    getIceServers(): Promise<IceServer[]>;
+    getPlugin(pluginName: string): Promise<PluginInfo | undefined>;
+}
+export interface DeviceManagerInterface extends Omit<DeviceManager, keyof DeviceManager> {
+    createCamera(cameraConfig: CameraConfig, pluginId: string): Promise<Camera>;
+    updateCamera(cameraNameOrId: string, cameraConfig: Partial<CameraConfig>, pluginId: string): Promise<Camera>;
+    getCamera(cameraNameOrId: string, pluginId: string): Promise<Camera | undefined>;
+    removeCamera(cameraNameOrId: string, pluginId: string): Promise<void>;
+}

package/dist/types/server/src/plugins/schema.d.ts

@@ -1,34 +1,27 @@
-import { z } from 'zod';
-import type { JsonSchema, JsonSchemaArray, JsonSchemaBoolean, JsonSchemaEnum, JsonSchemaForm, JsonSchemaNumber, JsonSchemaObject, JsonSchemaObjectButton, JsonSchemaObjectWithButtons, JsonSchemaString, RootSchema } from '@camera.ui/types';
-import type { ZodTypeAny } from 'zod';
-type RootZodSchema = z.ZodObject<Record<string, ZodTypeAny>, 'strict', ZodTypeAny, Record<string, any>, Record<string, any>>;
-type OptionalZodString = z.ZodOptional<z.ZodString> | z.ZodString | z.ZodOptional<z.ZodEffects<z.ZodString, string, string>> | z.ZodEffects<z.ZodString, string, string>;
-type OptionalZodNumber = z.ZodOptional<z.ZodNumber> | z.ZodNumber | z.ZodOptional<z.ZodEffects<z.ZodNumber, number, number>> | z.ZodEffects<z.ZodNumber, number, number>;
-type OptionalZodBoolean = z.ZodOptional<z.ZodBoolean> | z.ZodBoolean;
-type OptionalZodZobject = z.ZodOptional<z.ZodObject<Record<string, z.ZodTypeAny>, 'strict', z.ZodTypeAny, Record<string, any>, Record<string, any>>> | z.ZodObject<Record<string, z.ZodTypeAny>, 'strict', z.ZodTypeAny, Record<string, any>, Record<string, any>> | z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>> | z.ZodRecord<z.ZodString, z.ZodAny>;
-type OptionalZodArray = z.ZodOptional<z.ZodType<any, any, any>> | z.ZodType<any, any, any>;
-type OptionalZodEnum = z.ZodOptional<z.ZodUnion<[z.ZodTypeAny, z.ZodTypeAny, ...z.ZodTypeAny[]]>> | z.ZodUnion<[z.ZodTypeAny, z.ZodTypeAny, ...z.ZodTypeAny[]]> | z.ZodEffects<z.ZodAny, any, any> | z.ZodUnion<any>;
-type OptionalZodEnumMultiple = z.ZodOptional<z.ZodArray<z.ZodUnion<[ZodTypeAny, ZodTypeAny, ...ZodTypeAny[]]>, 'many'>> | z.ZodArray<z.ZodUnion<[ZodTypeAny, ZodTypeAny, ...ZodTypeAny[]]>, 'many'> | z.ZodEffects<z.ZodAny, any, any> | z.ZodUnion<any>;
-type ZodAny = z.ZodType<any, any, any>;
-export declare const generateSchema: (value: any) => JsonSchema;
-export declare const generateRootSchema: (value: Record<string, any>) => RootSchema;
-export declare const generateJsonFromSchemaWithConfig: (jsonSchema: JsonSchema, config: Record<string, any>, path?: string) => any;
-export declare const generateStorableConfig: (jsonSchema: JsonSchemaForm | JsonSchema, config: Record<string, any>) => Record<string, any>;
-export declare const schemaIsReadonly: (jsonSchema: JsonSchema, group?: string) => boolean;
-export declare const schemaIsStorable: (jsonSchema: JsonSchema, group?: string) => boolean;
-export declare const generateZodSchemaFromRoot: (rootSchema: RootSchema) => RootZodSchema;
-export declare const generateZodSchema: (jsonSchema: JsonSchema) => ZodAny;
-export declare const generateNumberSchema: () => JsonSchemaNumber;
-export declare const genereateBooleanSchema: () => JsonSchemaBoolean;
-export declare const generateStringSchema: (value: string) => JsonSchemaString;
-export declare const generateEnumSchema: (value: (string | number | boolean)[]) => JsonSchemaEnum;
-export declare const generateObjectSchema: (value: Record<string, any>) => JsonSchemaObject;
-export declare const generateObjectSchemaWithButtons: (value: Record<string, any>, buttons: JsonSchemaObjectButton[]) => JsonSchemaObjectWithButtons;
-export declare const generateArraySchema: (array: string[] | number[] | boolean[] | Record<string, any>[]) => JsonSchemaArray;
-export declare const createZodStringSchema: (jsonSchema: JsonSchemaString) => OptionalZodString;
-export declare const createZodNumberSchema: (jsonSchema: JsonSchemaNumber) => OptionalZodNumber;
-export declare const createZodBooleanSchema: (jsonSchema: JsonSchemaBoolean) => OptionalZodBoolean;
-export declare const createEnumSchema: (jsonSchema: JsonSchemaEnum) => OptionalZodEnum | OptionalZodEnumMultiple;
-export declare const createZodObjectSchema: (jsonSchema: JsonSchemaObject) => OptionalZodZobject;
-export declare const createZodArraySchema: (jsonSchema: JsonSchemaArray) => OptionalZodArray;
-export {};
+import * as zod from 'zod';
+import type { JsonSchema, JsonSchemaArray, JsonSchemaBoolean, JsonSchemaButton, JsonSchemaEnum, JsonSchemaNumber, JsonSchemaString, JsonSchemaSubmit, JsonSchemaWithoutCallbacks, JsonSchemaWithoutKey } from '@camera.ui/types';
+export declare const isStringType: (schema: JsonSchemaWithoutKey) => schema is JsonSchemaString;
+export declare const isNumberType: (schema: JsonSchemaWithoutKey) => schema is JsonSchemaNumber;
+export declare const isBooleanType: (schema: JsonSchemaWithoutKey) => schema is JsonSchemaBoolean;
+export declare const isEnumType: (schema: JsonSchemaWithoutKey) => schema is JsonSchemaEnum;
+export declare const isArrayType: (schema: JsonSchemaWithoutKey) => schema is JsonSchemaArray;
+export declare const isButtonType: (schema: JsonSchemaWithoutKey) => schema is JsonSchemaButton;
+export declare const isSubmitType: (schema: JsonSchemaWithoutKey) => schema is JsonSchemaSubmit;
+export declare const isValidableStringType: (schema: JsonSchemaWithoutKey) => schema is JsonSchemaString;
+export declare const isConfigDefault: (config: Record<string, any>, schemas: JsonSchema[]) => boolean;
+export declare const generateDefaultValue: (schema: JsonSchema) => any;
+export declare const generateConfigFromSchemas: (schemas: JsonSchema[]) => Record<string, any>;
+export declare const getValueByKey: (config: Record<string, any> | undefined, key: string) => any;
+export declare const setValueByKey: (config: Record<string, any>, key: string, value: any) => void;
+export declare const findSchemaByKey: (schemas: JsonSchema[], key: string) => JsonSchema | undefined;
+export declare const removeCallbacksFromSchema: (schema: JsonSchemaWithoutKey) => JsonSchemaWithoutCallbacks;
+export declare const removeCallbacksFromSchemas: (schemas: JsonSchema[]) => JsonSchemaWithoutCallbacks[];
+export declare const generateStorableConfig: (schemas: JsonSchema[], config: Record<string, any>) => Record<string, any>;
+export declare const getSchemasByGroup: (schemas: JsonSchema[], group: string) => JsonSchema[];
+export declare const schemaGroupIsReadonly: (schemas: JsonSchema[], group: string) => boolean;
+export declare const schemaGroupIsStorable: (schemas: JsonSchema[], group: string) => boolean;
+export declare const isValidFormat: (value: string, format?: string) => boolean;
+export declare const validateValue: (value: any, schema: JsonSchemaWithoutKey) => boolean;
+export declare const validateConfig: (config: Record<string, any>, schemas: JsonSchema[]) => Record<string, string[]>;
+export declare const generateZodSchemaField: (schema: JsonSchema) => zod.ZodTypeAny;
+export declare const generateZodSchema: (schemas: JsonSchema[]) => zod.ZodObject<any>;

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

@@ -1,7 +1,49 @@
-import type { CameraExtension } from '@camera.ui/types';
+import type { Camera, CameraExtension } from '@camera.ui/types';
 export interface Context {
     engines?: Record<string, string>;
     dependencies?: Record<string, string>;
 }
 export declare const PLUGIN_IDENTIFIER_PATTERN: RegExp;
 export declare const CAMERA_EXTENSIONS: CameraExtension[];
+export interface ProcessLoadMessage {
+    cameras: Camera[];
+    plugin: PluginInfo;
+    storage: PluginStorage;
+}
+export interface ProcessMessage {
+    type: PLUGIN_COMMAND;
+    data?: ProcessLoadMessage;
+}
+export interface ProcessResponse {
+    type: PLUGIN_STATUS;
+    error?: string;
+}
+export declare enum PLUGIN_STATUS {
+    READY = "ready",
+    STARTING = "starting",
+    STARTED = "started",
+    STOPPING = "stopping",
+    STOPPED = "stopped",
+    ERROR = "error",
+    UNKNOWN = "unknown",
+    DISABLED = "disabled"
+}
+export declare enum PLUGIN_COMMAND {
+    START = "start",
+    STOP = "stop"
+}
+export interface PluginStorage {
+    installPath: string;
+    storagePath: string;
+}
+export interface PluginInfo {
+    id: string;
+    name: string;
+    contract: PluginContract;
+}
+export interface PluginContract {
+    extensions: CameraExtension[];
+    dependencies?: string[];
+    pythonVersion?: string;
+    bundled?: boolean;
+}

package/dist/types/server/src/rpc/namespaces.d.ts

@@ -0,0 +1,35 @@
+export interface CoreManagerNamespaces {
+    coreManagerSubject: string;
+    coreManagerRpc: string;
+}
+export interface DeviceManagerNamespaces {
+    deviceManagerSubject: string;
+    deviceManagerRpc: string;
+}
+export interface FrameWorkerNamespaces {
+    frameWorkerChildRpc: string;
+    frameWorkerChild: string;
+}
+export interface PluginNamespaces {
+    pluginDeviceManagerSubject: string;
+    pluginChildRpc: string;
+    pluginChild: string;
+    pluginStorageRpc: string;
+}
+export interface CameraNamespaces {
+    cameraSubject: string;
+    cameraControllerRpc: string;
+    cameraMotionFrameSubject: string;
+}
+export interface PluginCameraNamespaces {
+    cameraInterfacesRpc: string;
+    cameraStorageRpc: string;
+}
+export declare class NamespaceManager {
+    static coreManagerNamespaces(): CoreManagerNamespaces;
+    static deviceManagerNamespaces(): DeviceManagerNamespaces;
+    static frameWorkerNamespaces(cameraId: string): FrameWorkerNamespaces;
+    static pluginNamespaces(pluginId: string): PluginNamespaces;
+    static cameraNamespaces(cameraId: string): CameraNamespaces;
+    static pluginCameraNamespaces(pluginId: string, cameraId: string): PluginCameraNamespaces;
+}