server/sdk: update

sdk/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@scrypted/sdk",
-  "version": "0.2.78",
+  "version": "0.2.82",
   "description": "",
   "main": "dist/src/index.js",
   "exports": {

sdk/types/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@scrypted/types",
-  "version": "0.2.71",
+  "version": "0.2.74",
   "description": "",
   "main": "dist/index.js",
   "author": "",

sdk/types/scrypted_python/scrypted_sdk/types.py

@@ -419,7 +419,6 @@ class LauncherApplicationInfo(TypedDict):
     pass
 
 class MediaObjectOptions(TypedDict):
-    metadata: Any
     sourceId: str
     pass
 
@@ -1015,6 +1014,8 @@ def listen(self, event: str | EventListenerOptions, callback: EventListener) ->
         pass
     async def probe(self) -> bool:
         pass
+    async def setMixins(self, mixins: list[str]) -> None:
+        pass
     async def setName(self, name: str) -> None:
         pass
     async def setRoom(self, room: str) -> None:
@@ -1219,9 +1220,9 @@ async def convertMediaObjectToUrl(self, mediaObject: str | MediaObject, toMimeTy
         pass
     async def createFFmpegMediaObject(self, ffmpegInput: FFmpegInput, options: MediaObjectOptions = None) -> MediaObject:
         pass
-    async def createMediaObject(self, data: Any, mimeType: str, options: MediaObjectOptions = None) -> MediaObject:
+    async def createMediaObject(self, data: Any, mimeType: str, options: Any = None) -> Any:
         pass
-    async def createMediaObjectFromUrl(self, data: str, options: MediaObjectOptions = None) -> MediaObject:
+    async def createMediaObjectFromUrl(self, data: str, options: Any = None) -> MediaObject:
         pass
     async def getFFmpegPath(self) -> str:
         pass
@@ -1743,6 +1744,7 @@ def applicationInfo(self, value: LauncherApplicationInfo):
     "methods": [
       "listen",
       "probe",
+      "setMixins",
       "setName",
       "setRoom",
       "setType"

sdk/types/src/types.input.ts

@@ -20,6 +20,8 @@ export interface ScryptedDevice {
 
   setType(type: ScryptedDeviceType): Promise<void>;
 
+  setMixins(mixins: string[]): Promise<void>;
+
   /**
    * Probes the device, ensuring creation of it and any mixins.
    */
@@ -1269,6 +1271,25 @@ export interface ObjectDetection {
   detectObjects(mediaObject: MediaObject, session?: ObjectDetectionSession, callbacks?: ObjectDetectionCallbacks): Promise<ObjectsDetected>;
   getDetectionModel(settings?: { [key: string]: any }): Promise<ObjectDetectionModel>;
 }
+export interface VideoFrameOptions {
+  resize?: {
+    width: number,
+    height: number,
+  };
+  format?: string;
+}
+export interface VideoFrame extends MediaObject {
+  timestamp: number;
+  width: number;
+  height: number;
+  format: string;
+  read(options?: VideoFrameOptions): Promise<Buffer>;
+}
+export interface VideoFrameGeneratorOptions extends VideoFrameOptions {
+}
+export interface VideoFrameGenerator {
+  generateVideoFrames(mediaObject: MediaObject, options?: VideoFrameGeneratorOptions, filter?: (videoFrame: VideoFrame) => Promise<boolean>): Promise<AsyncGenerator<VideoFrame>>;
+}
 /**
  * Logger is exposed via log.* to allow writing to the Scrypted log.
  */
@@ -1337,13 +1358,15 @@ export interface OauthClient {
   onOauthCallback(callbackUrl: string): Promise<void>;
 
 }
+export type SerializableType = null | undefined | number | string | { [key: string]: SerializableType } | SerializableType[];
+export type TopLevelSerializableType = Function | Buffer | SerializableType;
 
 export interface MediaObjectOptions {
   /**
    * The device id of the source of the MediaObject.
    */
   sourceId?: string;
-  metadata?: any;
+  [key: string]: TopLevelSerializableType;
 }
 
 /**
@@ -1394,14 +1417,14 @@ export interface MediaManager {
   /**
    * Create a MediaObject from an URL. The mime type will be determined dynamically while resolving the url.
    */
-  createMediaObjectFromUrl(data: string, options?: MediaObjectOptions): Promise<MediaObject>;
+  createMediaObjectFromUrl<T extends MediaObjectOptions>(data: string, options?: T): Promise<MediaObject>;
 
   /**
    * Create a MediaObject.
    * If the data is a buffer, JSON object, or primitive type, it will be serialized.
    * All other objects will be objects will become RPC objects.
    */
-  createMediaObject(data: any | Buffer, mimeType: string, options?: MediaObjectOptions): Promise<MediaObject>;
+  createMediaObject<T extends MediaObjectOptions>(data: any | Buffer, mimeType: string, options?: T): Promise<MediaObject & T>;
 
   /**
    * Get the path to ffmpeg on the host system.

server/package.json

@@ -4,7 +4,7 @@
   "description": "",
   "dependencies": {
     "@mapbox/node-pre-gyp": "^1.0.10",
-    "@scrypted/types": "^0.2.72",
+    "@scrypted/types": "^0.2.74",
     "adm-zip": "^0.5.9",
     "axios": "^0.21.4",
     "body-parser": "^1.19.0",

server/src/plugin/system.ts

@@ -1,6 +1,7 @@
 import { EventListener, EventListenerOptions, EventListenerRegister, Logger, ScryptedDevice, ScryptedDeviceType, ScryptedInterface, ScryptedInterfaceDescriptor, ScryptedInterfaceDescriptors, ScryptedInterfaceProperty, SystemDeviceState, SystemManager } from "@scrypted/types";
 import { EventRegistry } from "../event-registry";
 import { PrimitiveProxyHandler, RpcPeer } from '../rpc';
+import type { PluginComponent } from "../services/plugin";
 import { getInterfaceMethods, getInterfaceProperties, getPropertyInterfaces, isValidInterfaceMethod, propertyInterfaces } from "./descriptor";
 import { PluginAPI } from "./plugin-api";
 
@@ -120,6 +121,11 @@ class DeviceProxyHandler implements PrimitiveProxyHandler<any>, ScryptedDevice {
         return this.systemManager.api.setDeviceProperty(this.id, ScryptedInterfaceProperty.type, type);
     }
 
+    async setMixins(mixins: string[]) {
+        const plugins = await this.systemManager.getComponent('plugins') as PluginComponent;
+        await plugins.setMixins(this.id, mixins);
+    }
+
     async probe(): Promise<boolean> {
         return this.apply(() => 'probe', undefined, []);
     }