@scrypted/server 0.7.22 → 0.7.24

package/dist/asynciterable-utils.d.ts

@@ -0,0 +1,2 @@
+export declare function asyncFilter<T>(asyncIterable: AsyncIterable<T>, predicate: (t: T) => Promise<boolean>): AsyncIterable<T>;
+export declare function asyncFind<T>(asyncIterable: AsyncIterable<T>, predicate: (t: T) => Promise<boolean>): Promise<T>;

package/dist/cert.d.ts

@@ -0,0 +1,6 @@
+export declare const CURRENT_SELF_SIGNED_CERTIFICATE_VERSION = "v2";
+export declare function createSelfSignedCertificate(): {
+    serviceKey: string;
+    certificate: string;
+    version: string;
+};

package/dist/collection.d.ts

@@ -0,0 +1 @@
+export declare function hasSameElements<T>(a: T[], b: T[]): boolean;

package/dist/db-types.d.ts

@@ -0,0 +1,38 @@
+import { LevelDocument } from "./level";
+import { ScryptedNativeId, SystemDeviceState } from "@scrypted/types";
+export declare class ScryptedDocument implements LevelDocument {
+    _id?: string;
+    _documentType?: string;
+}
+export declare class Settings extends ScryptedDocument {
+    value?: any;
+}
+export declare class Plugin extends ScryptedDocument {
+    packageJson?: any;
+    zip?: string;
+}
+export declare class ScryptedUser extends ScryptedDocument {
+    passwordDate: number;
+    passwordHash: string;
+    token: string;
+    salt: string;
+    aclId: string;
+}
+export declare class ScryptedAlert extends ScryptedDocument {
+    timestamp: number;
+    title: string;
+    path: string;
+    message: string;
+}
+export declare class PluginDevice extends ScryptedDocument {
+    constructor(id?: string);
+    nativeId: ScryptedNativeId;
+    pluginId: string;
+    state: {
+        [property: string]: SystemDeviceState;
+    };
+    stateVersion: number;
+    storage: {
+        [key: string]: string;
+    };
+}

package/dist/event-registry.d.ts

@@ -0,0 +1,19 @@
+import { EventDetails, EventListenerOptions, EventListenerRegister } from "@scrypted/types";
+export declare class EventListenerRegisterImpl implements EventListenerRegister {
+    removeListener: () => void;
+    constructor(removeListener: () => void);
+}
+export declare function getMixinEventName(options: string | EventListenerOptions): string;
+export declare class EventRegistry {
+    systemListeners: Set<(id: string, eventDetails: EventDetails, eventData: any) => void>;
+    listeners: {
+        [token: string]: Set<(eventDetails: EventDetails, eventData: any) => void>;
+    };
+    listen(callback: (id: string, eventDetails: EventDetails, eventData: any) => void): EventListenerRegister;
+    listenDevice(id: string, options: string | EventListenerOptions, callback: (eventDetails: EventDetails, eventData: any) => void): EventListenerRegister;
+    notify(id: string | undefined, eventTime: number, eventInterface: string, property: string | undefined, value: any, options?: {
+        changed?: boolean;
+        mixinId?: string;
+    }): boolean;
+    notifyEventDetails(id: string | undefined, eventDetails: EventDetails, value: any, eventInterface?: string): boolean;
+}

package/dist/http-interfaces.d.ts

@@ -0,0 +1,3 @@
+import { HttpResponse } from "@scrypted/types";
+import { Response } from "express";
+export declare function createResponseInterface(res: Response, unzippedDir: string, filesPath: string): HttpResponse;

package/dist/infer-defaults.d.ts

@@ -0,0 +1,11 @@
+import { ScryptedDeviceType, ScryptedInterface } from "@scrypted/types";
+import { PluginDevice } from "./db-types";
+export declare function inferTypeFromInterfaces(interfaces: ScryptedInterface[]): ScryptedDeviceType;
+export declare function inferTypesFromInterfaces(interfaces: ScryptedInterface[]): ScryptedDeviceType[];
+export declare function getProvidedNameOrDefault(pluginDevice: PluginDevice): string;
+export declare function getDisplayName(pluginDevice: PluginDevice): string;
+export declare function getProvidedTypeOrDefault(pluginDevice: PluginDevice): ScryptedDeviceType;
+export declare function getDisplayType(pluginDevice: PluginDevice): ScryptedDeviceType;
+export declare function inferRoomFromName(name: string): string;
+export declare function getProvidedRoomOrDefault(pluginDevice: PluginDevice): string;
+export declare function getDisplayRoom(pluginDevice: PluginDevice): string;

package/dist/io.d.ts

@@ -0,0 +1,22 @@
+/// <reference types="node" />
+import type { Server, Socket as ServerSocket } from "engine.io";
+export declare type IOServer = {
+    on(ev: 'connection' | 'drain', fn: (socket: IOServerSocket & IOServerSocket) => void): IOServer;
+} & Server;
+export declare type IOServerSocket = ServerSocket & IOSocket;
+export interface IOSocket {
+    send(data: any, options?: any, callback?: any): this;
+    on(ev: "close", fn: (reason: string, description?: Error) => void): this;
+    /**
+     * Fired when the client sends a message.
+     */
+    on(ev: "message", fn: (data: string | Buffer) => void): this;
+    /**
+     * Fired when an error occurs.
+     */
+    on(ev: "error", fn: (err: Error) => void): this;
+    /**
+     * Called when the write buffer is drained
+     */
+    on(ev: "drain", fn: () => void): this;
+}

package/dist/level.d.ts

@@ -0,0 +1,110 @@
+export interface AbstractOptions {
+    readonly [k: string]: any;
+}
+export declare type ErrorCallback = (err: Error | undefined) => void;
+export declare type ErrorValueCallback<V> = (err: Error | undefined, value: V) => void;
+export declare type ErrorKeyValueCallback<K, V> = (err: Error | undefined, key: K, value: V) => void;
+export interface AbstractOpenOptions extends AbstractOptions {
+    createIfMissing?: boolean;
+    errorIfExists?: boolean;
+}
+export interface AbstractGetOptions extends AbstractOptions {
+    asBuffer?: boolean;
+}
+export interface LevelDocument {
+    _id?: any;
+    _documentType?: string;
+}
+export interface LevelDocumentConstructor<T extends LevelDocument> {
+    new (): T;
+}
+export interface AbstractLevelDOWN<K = any, V = any> {
+    open(cb?: ErrorCallback): Promise<void>;
+    open(options: AbstractOpenOptions, cb?: ErrorCallback): Promise<void>;
+    close(cb?: ErrorCallback): void;
+    get(key: K, cb?: ErrorValueCallback<V>): Promise<V>;
+    get(key: K, options: AbstractGetOptions, cb?: ErrorValueCallback<V>): Promise<V>;
+    put(key: K, value: V, cb?: ErrorCallback): Promise<void>;
+    put(key: K, value: V, options: AbstractOptions, cb?: ErrorCallback): Promise<void>;
+    del(key: K, cb?: ErrorCallback): Promise<void>;
+    del(key: K, options: AbstractOptions, cb?: ErrorCallback): Promise<void>;
+    batch(): AbstractChainedBatch<K, V>;
+    batch(array: ReadonlyArray<AbstractBatch<K, V>>, cb?: ErrorCallback): AbstractChainedBatch<K, V>;
+    batch(array: ReadonlyArray<AbstractBatch<K, V>>, options: AbstractOptions, cb?: ErrorCallback): AbstractChainedBatch<K, V>;
+    iterator(options?: AbstractIteratorOptions<K>): AbstractIterator<K, V>;
+    [Symbol.asyncIterator](): AsyncIterator<{
+        key: K;
+        value: V;
+    }>;
+    nextId(): number;
+    tryGet<T extends LevelDocument>(documentConstructor: LevelDocumentConstructor<T>, _id: any, options?: AbstractGetOptions): Promise<T | undefined>;
+    getAll<T extends LevelDocument>(documentConstructor: LevelDocumentConstructor<T>, options?: AbstractGetOptions): AsyncIterable<T>;
+    upsert<T extends LevelDocument>(value: T, options?: AbstractOptions): Promise<T>;
+    remove<T extends LevelDocument>(value: T): Promise<void>;
+    removeId<T extends LevelDocument>(documentConstructor: LevelDocumentConstructor<T>, _id: any): Promise<void>;
+    removeAll<T extends LevelDocument>(documentConstructor: LevelDocumentConstructor<T>): Promise<void>;
+    getCount<T extends LevelDocument>(documentConstructor: LevelDocumentConstructor<T>, options?: AbstractGetOptions): Promise<number>;
+}
+export interface AbstractLevelDOWNConstructor {
+    new <K = any, V = any>(location: string): AbstractLevelDOWN<K, V>;
+    <K = any, V = any>(location: string): AbstractLevelDOWN<K, V>;
+}
+export interface AbstractIteratorOptions<K = any> extends AbstractOptions {
+    gt?: K;
+    gte?: K;
+    lt?: K;
+    lte?: K;
+    reverse?: boolean;
+    limit?: number;
+    keys?: boolean;
+    values?: boolean;
+    keyAsBuffer?: boolean;
+    valueAsBuffer?: boolean;
+}
+export declare type AbstractBatch<K = any, V = any> = PutBatch<K, V> | DelBatch<K, V>;
+export interface PutBatch<K = any, V = any> {
+    readonly type: 'put';
+    readonly key: K;
+    readonly value: V;
+}
+export interface DelBatch<K = any, V = any> {
+    readonly type: 'del';
+    readonly key: K;
+}
+export interface AbstractChainedBatch<K = any, V = any> extends AbstractOptions {
+    put: (key: K, value: V) => this;
+    del: (key: K) => this;
+    clear: () => this;
+    write(cb?: ErrorCallback): any;
+    write(options: any, cb?: ErrorCallback): any;
+}
+export interface AbstractChainedBatchConstructor {
+    new <K = any, V = any>(db: any): AbstractChainedBatch<K, V>;
+    <K = any, V = any>(db: any): AbstractChainedBatch<K, V>;
+}
+export interface AbstractIterator<K, V> extends AbstractOptions {
+    db: AbstractLevelDOWN<K, V>;
+    next(cb?: ErrorKeyValueCallback<K, V>): this;
+    end(cb?: ErrorCallback): void;
+}
+export interface AbstractIteratorConstructor {
+    new <K = any, V = any>(db: any): AbstractIterator<K, V>;
+    <K = any, V = any>(db: any): AbstractIterator<K, V>;
+}
+export interface Level extends AbstractLevelDOWN {
+    readonly location: string;
+    readonly prefix: string;
+    readonly version: string | number;
+    destroy(location: string, cb?: (err: Error | undefined) => void): void;
+    destroy(location: string, prefix: string, cb?: (err: Error | undefined) => void): void;
+}
+interface LevelOptions {
+    readonly prefix?: string;
+    readonly version?: string | number;
+}
+interface LevelConstructor {
+    new (location: string, options?: LevelOptions): Level;
+    (location: string, options?: LevelOptions): Level;
+}
+declare const _default: LevelConstructor;
+export default _default;

package/dist/listen-zero.d.ts

@@ -0,0 +1,10 @@
+/// <reference types="node" />
+import net from 'net';
+export declare function listenZero(server: net.Server, hostname?: string): Promise<number>;
+export declare function listenZeroSingleClient(hostname?: string): Promise<{
+    server: net.Server;
+    url: string;
+    host: string;
+    port: number;
+    clientPromise: Promise<net.Socket>;
+}>;

package/dist/logger.d.ts

@@ -0,0 +1,29 @@
+/// <reference types="node" />
+import { EventEmitter } from 'events';
+import { ScryptedRuntime } from './runtime';
+import { PluginLogger } from './plugin/plugin-api';
+export declare function makeAlertId(path: string, msg: string): string;
+export interface LogEntry {
+    title: string;
+    timestamp: number;
+    level: string;
+    message: string;
+    path: string;
+}
+export declare class Logger extends EventEmitter implements PluginLogger {
+    logs: LogEntry[];
+    children: {
+        [id: string]: Logger;
+    };
+    path: string;
+    title: string;
+    scrypted: ScryptedRuntime;
+    constructor(scrypted: ScryptedRuntime, path: string, title: string);
+    log(level: string, message: string): Promise<void>;
+    purge(before: number): void;
+    clear(): Promise<void>;
+    clearAlert(message: string): Promise<void>;
+    clearAlerts(): Promise<void>;
+    getLogger(id: string, title: string): Logger;
+    getLogs(): LogEntry[];
+}

package/dist/media-helpers.d.ts

@@ -0,0 +1,5 @@
+/// <reference types="node" />
+import { ChildProcess } from "child_process";
+export declare function safeKillFFmpeg(cp: ChildProcess): void;
+export declare function ffmpegLogInitialOutput(console: Console, cp: ChildProcess, forever?: boolean, storage?: Storage): void;
+export declare function safePrintFFmpegArguments(console: Console, args: string[]): void;

package/dist/mixin/mixin-cycle.d.ts

@@ -0,0 +1,3 @@
+import { ScryptedRuntime } from "../runtime";
+export declare function getMixins(scrypted: ScryptedRuntime, id: string): any;
+export declare function hasMixinCycle(scrypted: ScryptedRuntime, id: string, mixins?: string[]): boolean;

package/dist/plugin/acl.d.ts

@@ -0,0 +1,16 @@
+import { EventDetails, ScryptedInterface, ScryptedUserAccessControl } from "@scrypted/types";
+/**
+ * Scrypted Access Controls allow selective reading of state, subscription to evemts,
+ * and invocation of methods.
+ * Everything else should be rejected.
+ */
+export declare class AccessControls {
+    acl: ScryptedUserAccessControl;
+    constructor(acl: ScryptedUserAccessControl);
+    deny(reason?: string): void;
+    shouldRejectDevice(id: string): boolean;
+    shouldRejectProperty(id: string, property: string): boolean;
+    shouldRejectEvent(id: string, eventDetails: EventDetails): boolean;
+    shouldRejectInterface(id: string, scryptedInterface: ScryptedInterface): boolean;
+    shouldRejectMethod(id: string, method: string): boolean;
+}

package/dist/plugin/descriptor.d.ts

@@ -0,0 +1,22 @@
+import { ScryptedInterface, ScryptedInterfaceDescriptor } from "@scrypted/types";
+export declare const allInterfaceProperties: string[];
+export declare function getPropertyInterfaces(descriptors: {
+    [scryptedInterface: string]: ScryptedInterfaceDescriptor;
+}): {
+    [property: string]: ScryptedInterface;
+};
+export declare const propertyInterfaces: {
+    [property: string]: ScryptedInterface;
+};
+export declare function getInterfaceMethods(descriptors: {
+    [scryptedInterface: string]: ScryptedInterfaceDescriptor;
+}, interfaces: Set<string>): string[];
+export declare function getInterfaceProperties(descriptors: {
+    [scryptedInterface: string]: ScryptedInterfaceDescriptor;
+}, interfaces: Set<string>): string[];
+export declare function isValidInterfaceMethod(descriptors: {
+    [scryptedInterface: string]: ScryptedInterfaceDescriptor;
+}, interfaces: Set<string>, method: string): boolean;
+export declare function isValidInterfaceProperty(descriptors: {
+    [scryptedInterface: string]: ScryptedInterfaceDescriptor;
+}, interfaces: string[], property: string): boolean;

package/dist/plugin/media.d.ts

@@ -0,0 +1,71 @@
+/// <reference types="node" />
+import { BufferConverter, DeviceManager, FFmpegInput, MediaManager, MediaObject as MediaObjectInterface, MediaObjectOptions, ScryptedDevice, ScryptedNativeId, SystemDeviceState, SystemManager } from "@scrypted/types";
+import { MediaObjectRemote } from "./plugin-api";
+declare type IdBufferConverter = BufferConverter & {
+    id: string;
+    name: string;
+};
+export declare abstract class MediaManagerBase implements MediaManager {
+    builtinConverters: IdBufferConverter[];
+    extraConverters: IdBufferConverter[];
+    constructor();
+    addConverter(converter: IdBufferConverter): Promise<void>;
+    clearConverters(): Promise<void>;
+    convertMediaObjectToJSON<T>(mediaObject: MediaObjectInterface, toMimeType: string): Promise<T>;
+    abstract getSystemState(): {
+        [id: string]: {
+            [property: string]: SystemDeviceState;
+        };
+    };
+    abstract getDeviceById<T>(id: string): T & ScryptedDevice;
+    abstract getPluginDeviceId(): string;
+    abstract getMixinConsole(mixinId: string, nativeId: ScryptedNativeId): Console;
+    getFFmpegPath(): Promise<string>;
+    getFilesPath(): Promise<string>;
+    getConverters(): IdBufferConverter[];
+    ensureMediaObjectRemote(mediaObject: string | MediaObjectInterface): MediaObjectRemote;
+    convertMediaObject<T>(mediaObject: MediaObjectInterface, toMimeType: string): Promise<T>;
+    convertMediaObjectToInsecureLocalUrl(mediaObject: string | MediaObjectInterface, toMimeType: string): Promise<string>;
+    convertMediaObjectToBuffer(mediaObject: MediaObjectInterface, toMimeType: string): Promise<Buffer>;
+    convertMediaObjectToLocalUrl(mediaObject: string | MediaObjectInterface, toMimeType: string): Promise<string>;
+    convertMediaObjectToUrl(mediaObject: string | MediaObjectInterface, toMimeType: string): Promise<string>;
+    createMediaObjectRemote<T extends MediaObjectOptions>(data: any | Buffer | Promise<string | Buffer>, mimeType: string, options?: T): MediaObjectRemote & T;
+    createFFmpegMediaObject(ffMpegInput: FFmpegInput, options?: MediaObjectOptions): Promise<MediaObjectInterface>;
+    createMediaObjectFromUrl(data: string, options?: MediaObjectOptions): Promise<MediaObjectInterface>;
+    createMediaObject<T extends MediaObjectOptions>(data: any, mimeType: string, options?: T): Promise<MediaObjectInterface & T>;
+    convert(converters: IdBufferConverter[], mediaObject: MediaObjectRemote, toMimeType: string): Promise<{
+        data: Buffer | string | any;
+        mimeType: string;
+    }>;
+}
+export declare class MediaManagerImpl extends MediaManagerBase {
+    systemManager: SystemManager;
+    deviceManager: DeviceManager;
+    constructor(systemManager: SystemManager, deviceManager: DeviceManager);
+    getSystemState(): {
+        [id: string]: {
+            [property: string]: SystemDeviceState;
+        };
+    };
+    getDeviceById<T>(id: string): T;
+    getPluginDeviceId(): string;
+    getMixinConsole(mixinId: string, nativeId: string): Console;
+}
+export declare class MediaManagerHostImpl extends MediaManagerBase {
+    pluginDeviceId: string;
+    getSystemState: () => {
+        [id: string]: {
+            [property: string]: SystemDeviceState;
+        };
+    };
+    console: Console;
+    getDeviceById: (id: string) => any;
+    constructor(pluginDeviceId: string, getSystemState: () => {
+        [id: string]: {
+            [property: string]: SystemDeviceState;
+        };
+    }, console: Console, getDeviceById: (id: string) => any);
+    getPluginDeviceId(): string;
+    getMixinConsole(mixinId: string, nativeId: string): Console;
+}
+export {};

package/dist/plugin/plugin-api.d.ts

@@ -0,0 +1,106 @@
+/// <reference types="node" />
+import type { Device, DeviceManifest, EventDetails, EventListenerOptions, EventListenerRegister, MediaManager, MediaObject, ScryptedDevice, ScryptedInterfaceDescriptor, ScryptedInterfaceProperty, ScryptedNativeId, SystemDeviceState } from '@scrypted/types';
+import { AccessControls } from './acl';
+export interface PluginLogger {
+    log(level: string, message: string): Promise<void>;
+    clear(): Promise<void>;
+    clearAlert(message: string): Promise<void>;
+    clearAlerts(): Promise<void>;
+}
+export interface PluginHostInfo {
+    serverVersion: string;
+}
+export interface PluginAPI {
+    setState(nativeId: ScryptedNativeId, key: string, value: any): Promise<void>;
+    onDevicesChanged(deviceManifest: DeviceManifest): Promise<void>;
+    onDeviceDiscovered(device: Device): Promise<string>;
+    onDeviceEvent(nativeId: ScryptedNativeId, eventInterface: string, eventData?: any): Promise<void>;
+    onMixinEvent(id: string, nativeId: ScryptedNativeId, eventInterface: string, eventData?: any): Promise<void>;
+    onDeviceRemoved(nativeId: string): Promise<void>;
+    setStorage(nativeId: string, storage: {
+        [key: string]: any;
+    }): Promise<void>;
+    getDeviceById(id: string): Promise<ScryptedDevice>;
+    setDeviceProperty(id: string, property: ScryptedInterfaceProperty, value: any): Promise<void>;
+    removeDevice(id: string): Promise<void>;
+    listen(EventListener: (id: string, eventDetails: EventDetails, eventData: any) => void): Promise<EventListenerRegister>;
+    listenDevice(id: string, event: string | EventListenerOptions, callback: (eventDetails: EventDetails, eventData: any) => void): Promise<EventListenerRegister>;
+    getLogger(nativeId: ScryptedNativeId): Promise<PluginLogger>;
+    getComponent(id: string): Promise<any>;
+    getMediaManager(): Promise<MediaManager>;
+    requestRestart(): Promise<void>;
+    setScryptedInterfaceDescriptors(typesVersion: string, descriptors: {
+        [scryptedInterface: string]: ScryptedInterfaceDescriptor;
+    }): Promise<void>;
+}
+export declare class PluginAPIManagedListeners {
+    listeners: Set<EventListenerRegister>;
+    manageListener(listener: EventListenerRegister): EventListenerRegister;
+    removeListeners(): void;
+}
+export declare class PluginAPIProxy extends PluginAPIManagedListeners implements PluginAPI {
+    api: PluginAPI;
+    mediaManager?: MediaManager;
+    acl: AccessControls;
+    constructor(api: PluginAPI, mediaManager?: MediaManager);
+    setScryptedInterfaceDescriptors(typesVersion: string, descriptors: {
+        [scryptedInterface: string]: ScryptedInterfaceDescriptor;
+    }): Promise<void>;
+    setState(nativeId: ScryptedNativeId, key: string, value: any): Promise<void>;
+    onDevicesChanged(deviceManifest: DeviceManifest): Promise<void>;
+    onDeviceDiscovered(device: Device): Promise<string>;
+    onDeviceEvent(nativeId: ScryptedNativeId, eventInterface: any, eventData?: any): Promise<void>;
+    onMixinEvent(id: string, nativeId: ScryptedNativeId, eventInterface: string, eventData?: any): Promise<void>;
+    onDeviceRemoved(nativeId: string): Promise<void>;
+    setStorage(nativeId: ScryptedNativeId, storage: {
+        [key: string]: any;
+    }): Promise<void>;
+    getDeviceById(id: string): Promise<ScryptedDevice>;
+    setDeviceProperty(id: string, property: ScryptedInterfaceProperty, value: any): Promise<void>;
+    removeDevice(id: string): Promise<void>;
+    listen(callback: (id: string, eventDetails: EventDetails, eventData: any) => void): Promise<EventListenerRegister>;
+    listenDevice(id: string, event: string | EventListenerOptions, callback: (eventDetails: EventDetails, eventData: any) => void): Promise<EventListenerRegister>;
+    getLogger(nativeId: ScryptedNativeId): Promise<PluginLogger>;
+    getComponent(id: string): Promise<any>;
+    getMediaManager(): Promise<MediaManager>;
+    requestRestart(): Promise<void>;
+}
+export interface PluginRemoteLoadZipOptions {
+    /**
+     * The filename to load the script as. Use for debugger source mapping.
+     */
+    filename?: string;
+    /**
+     * The path that the zip is currently unzipped at on the server. May not
+     * exist on the "remote", if it is not the same machine.
+     */
+    unzippedPath?: string;
+    fork?: boolean;
+    clusterId: string;
+    clusterSecret: string;
+}
+export interface PluginRemote {
+    loadZip(packageJson: any, zipData: Buffer | string, options: PluginRemoteLoadZipOptions): Promise<any>;
+    setSystemState(state: {
+        [id: string]: {
+            [property: string]: SystemDeviceState;
+        };
+    }): Promise<void>;
+    setNativeId(nativeId: ScryptedNativeId, id: string, storage: {
+        [key: string]: any;
+    }): Promise<void>;
+    updateDeviceState(id: string, state: {
+        [property: string]: SystemDeviceState;
+    }): Promise<void>;
+    /**
+     * @deprecated
+     */
+    notify(id: string, eventTime: number, eventInterface: string, property: string | undefined, value: SystemDeviceState | any, changed?: boolean): Promise<void>;
+    notify(id: string, eventDetails: EventDetails, eventData: SystemDeviceState | any): Promise<void>;
+    ioEvent(id: string, event: string, message?: any): Promise<void>;
+    createDeviceState(id: string, setState: (property: string, value: any) => Promise<any>): Promise<any>;
+    getServicePort(name: string, ...args: any[]): Promise<number>;
+}
+export interface MediaObjectRemote extends MediaObject {
+    getData(): Promise<Buffer | string>;
+}

package/dist/plugin/plugin-console.d.ts

@@ -0,0 +1,28 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import { DeviceManager, ScryptedNativeId, SystemManager } from '@scrypted/types';
+import { PassThrough, Readable } from 'stream';
+export interface ConsoleServer {
+    pluginConsole: Console;
+    readPort: number;
+    writePort: number;
+    destroy(): void;
+    clear(nativeId: ScryptedNativeId): void;
+}
+export interface StdPassThroughs {
+    stdout: PassThrough;
+    stderr: PassThrough;
+    buffers: Buffer[];
+}
+export declare function getConsole(hook: (stdout: PassThrough, stderr: PassThrough) => Promise<void>, also?: Console, alsoPrefix?: string): Console;
+export declare function prepareConsoles(getConsoleName: () => string, systemManager: () => SystemManager, deviceManager: () => DeviceManager, getPlugins: () => Promise<any>): {
+    getDeviceConsole: (nativeId?: ScryptedNativeId) => Console;
+    getMixinConsole: (mixinId: string, nativeId: ScryptedNativeId) => Console;
+};
+export declare function createConsoleServer(remoteStdout: Readable, remoteStderr: Readable, header: string): Promise<{
+    clear(nativeId: ScryptedNativeId): void;
+    destroy(): void;
+    pluginConsole: Console;
+    readPort: number;
+    writePort: number;
+}>;

package/dist/plugin/plugin-debug.d.ts

@@ -0,0 +1,4 @@
+export interface PluginDebug {
+    waitDebug: Promise<void>;
+    inspectPort: number;
+}

package/dist/plugin/plugin-device.d.ts

@@ -0,0 +1,54 @@
+import { EventListener, EventListenerOptions, EventListenerRegister, ScryptedDevice, ScryptedDeviceType } from "@scrypted/types";
+import { PluginDevice } from "../db-types";
+import { PrimitiveProxyHandler } from "../rpc";
+import { ScryptedRuntime } from "../runtime";
+interface MixinTable {
+    mixinProviderId: string;
+    entry: Promise<MixinTableEntry>;
+}
+interface MixinTableEntry {
+    interfaces: Set<string>;
+    methods?: Set<string>;
+    allInterfaces: string[];
+    proxy: any;
+    error?: Error;
+    passthrough: boolean;
+}
+export declare const RefreshSymbol: unique symbol;
+export declare const QueryInterfaceSymbol: unique symbol;
+export declare class PluginDeviceProxyHandler implements PrimitiveProxyHandler<any>, ScryptedDevice {
+    scrypted: ScryptedRuntime;
+    id: string;
+    mixinTable: MixinTable[];
+    releasing: Set<any>;
+    static sortInterfaces(interfaces: string[]): string[];
+    constructor(scrypted: ScryptedRuntime, id: string);
+    toPrimitive(): string;
+    invalidateEntry(mixinEntry: MixinTable): void;
+    getMixinProviderId(id: string, mixinDevice: any): Promise<string | true>;
+    invalidate(): void;
+    /**
+     * Rebuild the mixin table with any currently missing mixins.
+     */
+    rebuildMixinTable(): void;
+    ensureProxy(lastValidMixinId?: string): Promise<PluginDevice>;
+    rebuildEntry(pluginDevice: PluginDevice, mixinId: string, wrappedMixinTablePromise: Promise<MixinTable[]>): Promise<MixinTableEntry>;
+    get(target: any, p: PropertyKey, receiver: any): any;
+    listen(event: string | EventListenerOptions, callback: EventListener): EventListenerRegister;
+    setName(name: string): Promise<void>;
+    setRoom(room: string): Promise<void>;
+    setType(type: ScryptedDeviceType): Promise<void>;
+    setMixins(mixins: string[]): Promise<void>;
+    probe(): Promise<boolean>;
+    applyMixin(method: string, argArray?: any): Promise<any>;
+    findMethod(method: string): Promise<{
+        mixin: MixinTable;
+        entry: MixinTableEntry;
+    }>;
+    findMixin(iface: string): Promise<{
+        mixin: MixinTable;
+        entry: MixinTableEntry;
+    }>;
+    apply(target: any, thisArg: any, argArray?: any): Promise<any>;
+}
+export {};

package/dist/plugin/plugin-error.d.ts

@@ -0,0 +1,2 @@
+export declare class PluginError extends Error {
+}

package/dist/plugin/plugin-host-api.d.ts

@@ -0,0 +1,43 @@
+/// <reference types="lodash" />
+import { Device, DeviceManifest, EventDetails, EventListenerOptions, EventListenerRegister, MediaManager, ScryptedDevice, ScryptedInterfaceDescriptor, ScryptedInterfaceProperty, ScryptedNativeId } from '@scrypted/types';
+import { Logger } from '../logger';
+import { RpcPeer } from '../rpc';
+import { ScryptedRuntime } from '../runtime';
+import { getPropertyInterfaces } from './descriptor';
+import { PluginAPI, PluginAPIManagedListeners } from './plugin-api';
+import { PluginHost } from './plugin-host';
+export declare class PluginHostAPI extends PluginAPIManagedListeners implements PluginAPI {
+    scrypted: ScryptedRuntime;
+    pluginHost: PluginHost;
+    mediaManager: MediaManager;
+    pluginId: string;
+    typesVersion: string;
+    descriptors: {
+        [scryptedInterface: string]: ScryptedInterfaceDescriptor;
+    };
+    propertyInterfaces: ReturnType<typeof getPropertyInterfaces>;
+    [RpcPeer.PROPERTY_PROXY_ONEWAY_METHODS]: string[];
+    restartDebounced: import("lodash").DebouncedFunc<() => Promise<void>>;
+    constructor(scrypted: ScryptedRuntime, pluginId: string, pluginHost: PluginHost, mediaManager: MediaManager);
+    onMixinEvent(id: string, nativeIdOrMixinDevice: ScryptedNativeId | any, eventInterface: string, eventData?: any): Promise<void>;
+    getMediaManager(): Promise<MediaManager>;
+    getLogger(nativeId: ScryptedNativeId): Promise<Logger>;
+    getComponent(id: string): Promise<any>;
+    setDeviceProperty(id: string, property: ScryptedInterfaceProperty, value: any): Promise<void>;
+    setState(nativeId: ScryptedNativeId, key: string, value: any): Promise<void>;
+    setStorage(nativeId: ScryptedNativeId, storage: {
+        [key: string]: string;
+    }): Promise<void>;
+    onDevicesChanged(deviceManifest: DeviceManifest): Promise<void>;
+    onDeviceDiscovered(device: Device): Promise<string>;
+    onDeviceRemoved(nativeId: string): Promise<void>;
+    onDeviceEvent(nativeId: any, eventInterface: any, eventData?: any): Promise<void>;
+    getDeviceById<T>(id: string): Promise<T & ScryptedDevice>;
+    listen(callback: (id: string, eventDetails: EventDetails, eventData: any) => void): Promise<EventListenerRegister>;
+    listenDevice(id: string, event: string | EventListenerOptions, callback: (eventDetails: EventDetails, eventData: any) => void): Promise<EventListenerRegister>;
+    removeDevice(id: string): Promise<void>;
+    requestRestart(): Promise<void>;
+    setScryptedInterfaceDescriptors(typesVersion: string, descriptors: {
+        [scryptedInterface: string]: ScryptedInterfaceDescriptor;
+    }): Promise<void>;
+}