scrypted-tempest
Version:
Scrypted Tempest Plugin
1,577 lines (1,558 loc) • 498 kB
JavaScript
/******/ (() => { // webpackBootstrap
/******/ var __webpack_modules__ = ({
/***/ "../scrypted-homeassistant/src/unitConverter.ts":
/*!******************************************************!*\
!*** ../scrypted-homeassistant/src/unitConverter.ts ***!
\******************************************************/
/***/ ((__unused_webpack_module, exports) => {
"use strict";
Object.defineProperty(exports, "__esModule", ({ value: true }));
exports.UnitConverter = exports.Unit = exports.UnitGroup = void 0;
var UnitGroup;
(function (UnitGroup) {
UnitGroup["None"] = "None";
UnitGroup["Temperature"] = "Temperature";
UnitGroup["Speed"] = "Speed";
UnitGroup["Length"] = "Length";
UnitGroup["Pressure"] = "Pressure";
})(UnitGroup = exports.UnitGroup || (exports.UnitGroup = {}));
var Unit;
(function (Unit) {
Unit["NONE"] = "";
// Temperature
// Actually Kelving is SI for temperature
Unit["C"] = "\u00B0C";
Unit["F"] = "\u00B0F";
// Speed
Unit["M_S"] = "m/s";
Unit["KM_H"] = "km/h";
Unit["MI_H"] = "mph";
// Length
Unit["M"] = "m";
Unit["MM"] = "mm";
Unit["KM"] = "km";
Unit["IN"] = "in";
Unit["MI"] = "mi";
// Pressure
Unit["PA"] = "Pa";
Unit["HPA"] = "hPa";
Unit["BAR"] = "bar";
})(Unit = exports.Unit || (exports.Unit = {}));
const siUnitMap = {
[UnitGroup.None]: Unit.NONE,
[UnitGroup.Length]: Unit.M,
[UnitGroup.Pressure]: Unit.PA,
[UnitGroup.Temperature]: Unit.C,
[UnitGroup.Speed]: Unit.M_S,
};
class UnitConverter {
static getUnit(unitSrc) {
if (!unitSrc) {
unitSrc = UnitConverter.UNITS_MAP[Unit.NONE];
}
const unit = typeof unitSrc === 'string' ? unitSrc : unitSrc.unit;
const unitData = UnitConverter.UNITS_MAP?.[unit];
if (!unitData) {
return {
factor: 1,
unit: unit,
unitGroup: UnitGroup.None,
};
}
else {
return unitData;
}
}
static siToLocal(siValue, unit) {
if (isNaN(siValue)) {
return 0;
}
const unitData = UnitConverter.getUnit(unit);
if (!unitData) {
return siValue;
}
const value = unitData.conversionFormula ?
eval(unitData.conversionFormula
.replaceAll('{fromSi}', 'true')
.replaceAll('{value}', String(siValue))) :
siValue / unitData.factor;
if (!isNaN(value)) {
return value;
}
else {
return 0;
}
}
static localToSi(localValue, unit) {
const unitData = UnitConverter.getUnit(unit);
if (!unitData) {
return localValue;
}
const value = unitData.conversionFormula ?
eval(unitData.conversionFormula
.replaceAll('{fromSi}', 'false')
.replaceAll('{value}', String(localValue))) :
localValue * unitData.factor;
if (!isNaN(value)) {
return value;
}
else {
return 0;
}
}
static getUnits(unit) {
const unitData = UnitConverter.UNITS_MAP[unit];
if (!unitData) {
return [unit];
}
const { unitGroup } = unitData;
return Object.values(UnitConverter.UNITS_MAP)
.filter(unit => unit.unitGroup === unitGroup && unit.unit)
?.map(unit => unit.unit);
}
}
exports.UnitConverter = UnitConverter;
UnitConverter.UNITS_MAP = {
[Unit.NONE]: {
unit: Unit.NONE,
unitGroup: UnitGroup.Temperature,
factor: 1,
},
[Unit.C]: {
unit: Unit.C,
unitGroup: UnitGroup.Temperature,
factor: 1,
},
[Unit.F]: {
unit: Unit.F,
unitGroup: UnitGroup.Temperature,
conversionFormula: '{fromSi} ? ({value} * 1.8 + 32) : (({value} - 32) / 1.8)',
},
[Unit.M_S]: {
unit: Unit.M_S,
unitGroup: UnitGroup.Speed,
factor: 1,
},
[Unit.KM_H]: {
unit: Unit.KM_H,
unitGroup: UnitGroup.Speed,
factor: 0.277777777777778,
},
[Unit.MI_H]: {
unit: Unit.MI_H,
unitGroup: UnitGroup.Speed,
factor: 0.447038888888889,
},
[Unit.M]: {
unit: Unit.M,
unitGroup: UnitGroup.Length,
factor: 1,
},
[Unit.MM]: {
unit: Unit.MM,
unitGroup: UnitGroup.Length,
factor: 0.001,
},
[Unit.KM]: {
unit: Unit.KM,
unitGroup: UnitGroup.Length,
factor: 1000,
},
[Unit.IN]: {
unit: Unit.IN,
unitGroup: UnitGroup.Length,
factor: 0.0254,
},
[Unit.MI]: {
unit: Unit.MI,
unitGroup: UnitGroup.Length,
factor: 1609.34,
},
[Unit.PA]: {
unit: Unit.PA,
unitGroup: UnitGroup.Pressure,
factor: 1,
},
[Unit.HPA]: {
unit: Unit.HPA,
unitGroup: UnitGroup.Pressure,
factor: 0.01,
},
[Unit.BAR]: {
unit: Unit.BAR,
unitGroup: UnitGroup.Pressure,
factor: 0.00001,
},
};
/***/ }),
/***/ "./node_modules/@scrypted/sdk/dist/src sync recursive":
/*!***************************************************!*\
!*** ./node_modules/@scrypted/sdk/dist/src/ sync ***!
\***************************************************/
/***/ ((module) => {
function webpackEmptyContext(req) {
var e = new Error("Cannot find module '" + req + "'");
e.code = 'MODULE_NOT_FOUND';
throw e;
}
webpackEmptyContext.keys = () => ([]);
webpackEmptyContext.resolve = webpackEmptyContext;
webpackEmptyContext.id = "./node_modules/@scrypted/sdk/dist/src sync recursive";
module.exports = webpackEmptyContext;
/***/ }),
/***/ "./node_modules/@scrypted/sdk/dist/src/index.js":
/*!******************************************************!*\
!*** ./node_modules/@scrypted/sdk/dist/src/index.js ***!
\******************************************************/
/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
"use strict";
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
if (k2 === undefined) k2 = k;
var desc = Object.getOwnPropertyDescriptor(m, k);
if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
desc = { enumerable: true, get: function() { return m[k]; } };
}
Object.defineProperty(o, k2, desc);
}) : (function(o, m, k, k2) {
if (k2 === undefined) k2 = k;
o[k2] = m[k];
}));
var __exportStar = (this && this.__exportStar) || function(m, exports) {
for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
};
Object.defineProperty(exports, "__esModule", ({ value: true }));
exports.sdk = exports.MixinDeviceBase = exports.ScryptedDeviceBase = void 0;
__exportStar(__webpack_require__(/*! ../types/gen/index */ "./node_modules/@scrypted/sdk/dist/types/gen/index.js"), exports);
const index_1 = __webpack_require__(/*! ../types/gen/index */ "./node_modules/@scrypted/sdk/dist/types/gen/index.js");
const module_1 = __webpack_require__(/*! module */ "module");
/**
* @category Core Reference
*/
class ScryptedDeviceBase extends index_1.DeviceBase {
constructor(nativeId) {
super();
this.nativeId = nativeId;
}
get storage() {
if (!this._storage) {
this._storage = exports.sdk.deviceManager.getDeviceStorage(this.nativeId);
}
return this._storage;
}
get log() {
if (!this._log) {
this._log = exports.sdk.deviceManager.getDeviceLogger(this.nativeId);
}
return this._log;
}
get console() {
if (!this._console) {
this._console = exports.sdk.deviceManager.getDeviceConsole(this.nativeId);
}
return this._console;
}
async createMediaObject(data, mimeType) {
return exports.sdk.mediaManager.createMediaObject(data, mimeType, {
sourceId: this.id,
});
}
getMediaObjectConsole(mediaObject) {
if (typeof mediaObject.sourceId !== 'string')
return this.console;
return exports.sdk.deviceManager.getMixinConsole(mediaObject.sourceId, this.nativeId);
}
_lazyLoadDeviceState() {
if (!this._deviceState) {
if (this.nativeId) {
this._deviceState = exports.sdk.deviceManager.getDeviceState(this.nativeId);
}
else {
this._deviceState = exports.sdk.deviceManager.getDeviceState();
}
}
}
/**
* Fire an event for this device.
*/
onDeviceEvent(eventInterface, eventData) {
return exports.sdk.deviceManager.onDeviceEvent(this.nativeId, eventInterface, eventData);
}
}
exports.ScryptedDeviceBase = ScryptedDeviceBase;
/**
* @category Mixin Reference
*/
class MixinDeviceBase extends index_1.DeviceBase {
constructor(options) {
super();
this._listeners = new Set();
this.mixinDevice = options.mixinDevice;
this.mixinDeviceInterfaces = options.mixinDeviceInterfaces;
this.mixinStorageSuffix = options.mixinStorageSuffix;
this._deviceState = options.mixinDeviceState;
this.nativeId = exports.sdk.systemManager.getDeviceById(this.id).nativeId;
this.mixinProviderNativeId = options.mixinProviderNativeId;
// RpcProxy will trap all properties, and the following check/hack will determine
// if the device state came from another node worker thread.
// This should ultimately be discouraged and warned at some point in the future.
if (this._deviceState.__rpcproxy_traps_all_properties && typeof this._deviceState.id === 'string') {
this._deviceState = exports.sdk.deviceManager.createDeviceState(this._deviceState.id, this._deviceState.setState);
}
}
get storage() {
if (!this._storage) {
const mixinStorageSuffix = this.mixinStorageSuffix;
const mixinStorageKey = this.id + (mixinStorageSuffix ? ':' + mixinStorageSuffix : '');
this._storage = exports.sdk.deviceManager.getMixinStorage(mixinStorageKey, this.mixinProviderNativeId);
}
return this._storage;
}
get console() {
if (!this._console) {
if (exports.sdk.deviceManager.getMixinConsole)
this._console = exports.sdk.deviceManager.getMixinConsole(this.id, this.mixinProviderNativeId);
else
this._console = exports.sdk.deviceManager.getDeviceConsole(this.mixinProviderNativeId);
}
return this._console;
}
async createMediaObject(data, mimeType) {
return exports.sdk.mediaManager.createMediaObject(data, mimeType, {
sourceId: this.id,
});
}
getMediaObjectConsole(mediaObject) {
if (typeof mediaObject.sourceId !== 'string')
return this.console;
return exports.sdk.deviceManager.getMixinConsole(mediaObject.sourceId, this.mixinProviderNativeId);
}
/**
* Fire an event for this device.
*/
onDeviceEvent(eventInterface, eventData) {
return exports.sdk.deviceManager.onMixinEvent(this.id, this, eventInterface, eventData);
}
_lazyLoadDeviceState() {
}
manageListener(listener) {
this._listeners.add(listener);
}
release() {
for (const l of this._listeners) {
l.removeListener();
}
}
}
exports.MixinDeviceBase = MixinDeviceBase;
(function () {
function _createGetState(state) {
return function () {
this._lazyLoadDeviceState();
// @ts-ignore: accessing private property
return this._deviceState?.[state];
};
}
function _createSetState(state) {
return function (value) {
this._lazyLoadDeviceState();
// @ts-ignore: accessing private property
if (!this._deviceState) {
console.warn('device state is unavailable. the device must be discovered with deviceManager.onDeviceDiscovered or deviceManager.onDevicesChanged before the state can be set.');
}
else {
// @ts-ignore: accessing private property
this._deviceState[state] = value;
}
};
}
for (const field of Object.values(index_1.ScryptedInterfaceProperty)) {
if (field === index_1.ScryptedInterfaceProperty.nativeId)
continue;
Object.defineProperty(ScryptedDeviceBase.prototype, field, {
set: _createSetState(field),
get: _createGetState(field),
});
Object.defineProperty(MixinDeviceBase.prototype, field, {
set: _createSetState(field),
get: _createGetState(field),
});
}
})();
exports.sdk = {};
try {
let loaded = false;
try {
// todo: remove usage of process.env.SCRYPTED_SDK_MODULE, only existed in prerelease builds.
// import.meta is not a reliable way to detect es module support in webpack since webpack
// evaluates that to true at runtime.
const esModule = process.env.SCRYPTED_SDK_ES_MODULE || process.env.SCRYPTED_SDK_MODULE;
const cjsModule = process.env.SCRYPTED_SDK_CJS_MODULE || process.env.SCRYPTED_SDK_MODULE;
// @ts-expect-error
if (esModule && "undefined" !== 'undefined') {}
else if (cjsModule) {
// @ts-expect-error
if (typeof require !== 'undefined') {
// @ts-expect-error
const sdkModule = require(process.env.SCRYPTED_SDK_MODULE);
Object.assign(exports.sdk, sdkModule.getScryptedStatic());
loaded = true;
}
else {
const sdkModule = __webpack_require__("./node_modules/@scrypted/sdk/dist/src sync recursive")(cjsModule);
Object.assign(exports.sdk, sdkModule.getScryptedStatic());
loaded = true;
}
}
}
catch (e) {
console.warn("failed to load sdk module", e);
throw e;
}
if (!loaded) {
let runtimeAPI;
try {
runtimeAPI = pluginRuntimeAPI;
}
catch (e) {
}
Object.assign(exports.sdk, {
log: deviceManager.getDeviceLogger(undefined),
deviceManager,
endpointManager,
mediaManager,
systemManager,
pluginHostAPI,
...runtimeAPI,
});
}
try {
exports.sdk.systemManager.setScryptedInterfaceDescriptors?.(index_1.TYPES_VERSION, index_1.ScryptedInterfaceDescriptors)?.catch(() => { });
}
catch (e) {
}
}
catch (e) {
console.error('sdk initialization error, import @scrypted/types or use @scrypted/client instead', e);
}
exports["default"] = exports.sdk;
//# sourceMappingURL=index.js.map
/***/ }),
/***/ "./node_modules/@scrypted/sdk/dist/src/storage-settings.js":
/*!*****************************************************************!*\
!*** ./node_modules/@scrypted/sdk/dist/src/storage-settings.js ***!
\*****************************************************************/
/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
"use strict";
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
if (k2 === undefined) k2 = k;
var desc = Object.getOwnPropertyDescriptor(m, k);
if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
desc = { enumerable: true, get: function() { return m[k]; } };
}
Object.defineProperty(o, k2, desc);
}) : (function(o, m, k, k2) {
if (k2 === undefined) k2 = k;
o[k2] = m[k];
}));
var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
Object.defineProperty(o, "default", { enumerable: true, value: v });
}) : function(o, v) {
o["default"] = v;
});
var __importStar = (this && this.__importStar) || function (mod) {
if (mod && mod.__esModule) return mod;
var result = {};
if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
__setModuleDefault(result, mod);
return result;
};
Object.defineProperty(exports, "__esModule", ({ value: true }));
exports.StorageSettings = void 0;
const _1 = __importStar(__webpack_require__(/*! . */ "./node_modules/@scrypted/sdk/dist/src/index.js"));
const { systemManager } = _1.default;
function parseValue(value, setting, readDefaultValue, rawDevice) {
if (value === null || value === undefined) {
return readDefaultValue();
}
const type = setting.multiple ? 'array' : setting.type;
if (type === 'boolean') {
if (value === 'true')
return true;
if (value === 'false')
return false;
return readDefaultValue() || false;
}
if (type === 'number') {
const n = parseFloat(value);
if (!isNaN(n))
return n;
return readDefaultValue() || 0;
}
if (type === 'integer') {
const n = parseInt(value);
if (!isNaN(n))
return n;
return readDefaultValue() || 0;
}
if (type === 'array') {
if (!value)
return readDefaultValue() || [];
try {
return JSON.parse(value);
}
catch (e) {
return readDefaultValue() || [];
}
}
if (type === 'device') {
if (rawDevice)
return value;
return systemManager.getDeviceById(value) || systemManager.getDeviceById(readDefaultValue());
}
// string type, so check if it is json.
if (value && setting.json) {
try {
return JSON.parse(value);
}
catch (e) {
return readDefaultValue();
}
}
return value || readDefaultValue();
}
class StorageSettings {
constructor(device, settings) {
this.device = device;
this.settings = settings;
this.values = {};
this.hasValue = {};
for (const key of Object.keys(settings)) {
const setting = settings[key];
const rawGet = () => this.getItem(key);
let get;
if (setting.type !== 'clippath') {
get = rawGet;
}
else {
// maybe need a mapPut. clippath is the only complex type at the moment.
get = () => {
try {
return JSON.parse(rawGet());
}
catch (e) {
}
};
}
Object.defineProperty(this.values, key, {
get,
set: value => this.putSetting(key, value),
enumerable: true,
});
Object.defineProperty(this.hasValue, key, {
get: () => this.device.storage.getItem(key) != null,
enumerable: true,
});
}
}
get keys() {
const ret = {};
for (const key of Object.keys(this.settings)) {
ret[key] = key;
}
return ret;
}
async getSettings() {
const onGet = await this.options?.onGet?.();
const ret = [];
for (const [key, setting] of Object.entries(this.settings)) {
let s = Object.assign({}, setting);
if (onGet?.[key])
s = Object.assign(s, onGet[key]);
if (s.onGet)
s = Object.assign(s, await s.onGet());
if (s.hide || await this.options?.hide?.[key]?.())
continue;
s.key = key;
s.value = this.getItemInternal(key, s, true);
if (typeof s.deviceFilter === 'function')
s.deviceFilter = s.deviceFilter.toString();
ret.push(s);
delete s.onPut;
delete s.onGet;
delete s.mapPut;
delete s.mapGet;
}
return ret;
}
async putSetting(key, value) {
const setting = this.settings[key];
let oldValue;
if (setting)
oldValue = this.getItemInternal(key, setting);
return this.putSettingInternal(setting, oldValue, key, value);
}
putSettingInternal(setting, oldValue, key, value) {
if (!setting?.noStore) {
if (setting?.mapPut)
value = setting.mapPut(oldValue, value);
// nullish values should be removed, since Storage can't persist them correctly.
if (value == null)
this.device.storage.removeItem(key);
else if (typeof value === 'object')
this.device.storage.setItem(key, JSON.stringify(value));
else
this.device.storage.setItem(key, value?.toString());
}
setting?.onPut?.(oldValue, value);
if (!setting?.hide)
this.device.onDeviceEvent(_1.ScryptedInterface.Settings, undefined);
}
getItemInternal(key, setting, rawDevice) {
if (!setting)
return this.device.storage.getItem(key);
const readDefaultValue = () => {
if (setting.persistedDefaultValue != null) {
this.putSettingInternal(setting, undefined, key, setting.persistedDefaultValue);
return setting.persistedDefaultValue;
}
return setting.defaultValue;
};
const ret = parseValue(this.device.storage.getItem(key), setting, readDefaultValue, rawDevice);
return setting.mapGet ? setting.mapGet(ret) : ret;
}
getItem(key) {
return this.getItemInternal(key, this.settings[key]);
}
}
exports.StorageSettings = StorageSettings;
//# sourceMappingURL=storage-settings.js.map
/***/ }),
/***/ "./node_modules/@scrypted/sdk/dist/types/gen/index.js":
/*!************************************************************!*\
!*** ./node_modules/@scrypted/sdk/dist/types/gen/index.js ***!
\************************************************************/
/***/ ((__unused_webpack_module, exports) => {
"use strict";
Object.defineProperty(exports, "__esModule", ({ value: true }));
exports.ScryptedMimeTypes = exports.ScryptedInterface = exports.MediaPlayerState = exports.SecuritySystemObstruction = exports.SecuritySystemMode = exports.AirQuality = exports.AirPurifierMode = exports.AirPurifierStatus = exports.ChargeState = exports.LockState = exports.PanTiltZoomMovement = exports.ThermostatMode = exports.TemperatureUnit = exports.FanMode = exports.HumidityMode = exports.ScryptedDeviceType = exports.ScryptedInterfaceDescriptors = exports.ScryptedInterfaceMethod = exports.ScryptedInterfaceProperty = exports.DeviceBase = exports.TYPES_VERSION = void 0;
exports.TYPES_VERSION = "0.3.108";
class DeviceBase {
}
exports.DeviceBase = DeviceBase;
var ScryptedInterfaceProperty;
(function (ScryptedInterfaceProperty) {
ScryptedInterfaceProperty["id"] = "id";
ScryptedInterfaceProperty["info"] = "info";
ScryptedInterfaceProperty["interfaces"] = "interfaces";
ScryptedInterfaceProperty["mixins"] = "mixins";
ScryptedInterfaceProperty["name"] = "name";
ScryptedInterfaceProperty["nativeId"] = "nativeId";
ScryptedInterfaceProperty["pluginId"] = "pluginId";
ScryptedInterfaceProperty["providedInterfaces"] = "providedInterfaces";
ScryptedInterfaceProperty["providedName"] = "providedName";
ScryptedInterfaceProperty["providedRoom"] = "providedRoom";
ScryptedInterfaceProperty["providedType"] = "providedType";
ScryptedInterfaceProperty["providerId"] = "providerId";
ScryptedInterfaceProperty["room"] = "room";
ScryptedInterfaceProperty["type"] = "type";
ScryptedInterfaceProperty["scryptedRuntimeArguments"] = "scryptedRuntimeArguments";
ScryptedInterfaceProperty["on"] = "on";
ScryptedInterfaceProperty["brightness"] = "brightness";
ScryptedInterfaceProperty["colorTemperature"] = "colorTemperature";
ScryptedInterfaceProperty["rgb"] = "rgb";
ScryptedInterfaceProperty["hsv"] = "hsv";
ScryptedInterfaceProperty["buttons"] = "buttons";
ScryptedInterfaceProperty["sensors"] = "sensors";
ScryptedInterfaceProperty["running"] = "running";
ScryptedInterfaceProperty["paused"] = "paused";
ScryptedInterfaceProperty["docked"] = "docked";
ScryptedInterfaceProperty["temperatureSetting"] = "temperatureSetting";
ScryptedInterfaceProperty["temperature"] = "temperature";
ScryptedInterfaceProperty["temperatureUnit"] = "temperatureUnit";
ScryptedInterfaceProperty["humidity"] = "humidity";
ScryptedInterfaceProperty["audioVolumes"] = "audioVolumes";
ScryptedInterfaceProperty["recordingActive"] = "recordingActive";
ScryptedInterfaceProperty["ptzCapabilities"] = "ptzCapabilities";
ScryptedInterfaceProperty["lockState"] = "lockState";
ScryptedInterfaceProperty["entryOpen"] = "entryOpen";
ScryptedInterfaceProperty["batteryLevel"] = "batteryLevel";
ScryptedInterfaceProperty["chargeState"] = "chargeState";
ScryptedInterfaceProperty["online"] = "online";
ScryptedInterfaceProperty["fromMimeType"] = "fromMimeType";
ScryptedInterfaceProperty["toMimeType"] = "toMimeType";
ScryptedInterfaceProperty["converters"] = "converters";
ScryptedInterfaceProperty["binaryState"] = "binaryState";
ScryptedInterfaceProperty["tampered"] = "tampered";
ScryptedInterfaceProperty["sleeping"] = "sleeping";
ScryptedInterfaceProperty["powerDetected"] = "powerDetected";
ScryptedInterfaceProperty["audioDetected"] = "audioDetected";
ScryptedInterfaceProperty["motionDetected"] = "motionDetected";
ScryptedInterfaceProperty["ambientLight"] = "ambientLight";
ScryptedInterfaceProperty["occupied"] = "occupied";
ScryptedInterfaceProperty["flooded"] = "flooded";
ScryptedInterfaceProperty["ultraviolet"] = "ultraviolet";
ScryptedInterfaceProperty["luminance"] = "luminance";
ScryptedInterfaceProperty["position"] = "position";
ScryptedInterfaceProperty["securitySystemState"] = "securitySystemState";
ScryptedInterfaceProperty["pm10Density"] = "pm10Density";
ScryptedInterfaceProperty["pm25Density"] = "pm25Density";
ScryptedInterfaceProperty["vocDensity"] = "vocDensity";
ScryptedInterfaceProperty["noxDensity"] = "noxDensity";
ScryptedInterfaceProperty["co2ppm"] = "co2ppm";
ScryptedInterfaceProperty["airQuality"] = "airQuality";
ScryptedInterfaceProperty["airPurifierState"] = "airPurifierState";
ScryptedInterfaceProperty["filterChangeIndication"] = "filterChangeIndication";
ScryptedInterfaceProperty["filterLifeLevel"] = "filterLifeLevel";
ScryptedInterfaceProperty["humiditySetting"] = "humiditySetting";
ScryptedInterfaceProperty["fan"] = "fan";
ScryptedInterfaceProperty["applicationInfo"] = "applicationInfo";
ScryptedInterfaceProperty["systemDevice"] = "systemDevice";
})(ScryptedInterfaceProperty || (exports.ScryptedInterfaceProperty = ScryptedInterfaceProperty = {}));
var ScryptedInterfaceMethod;
(function (ScryptedInterfaceMethod) {
ScryptedInterfaceMethod["listen"] = "listen";
ScryptedInterfaceMethod["probe"] = "probe";
ScryptedInterfaceMethod["setMixins"] = "setMixins";
ScryptedInterfaceMethod["setName"] = "setName";
ScryptedInterfaceMethod["setRoom"] = "setRoom";
ScryptedInterfaceMethod["setType"] = "setType";
ScryptedInterfaceMethod["getPluginJson"] = "getPluginJson";
ScryptedInterfaceMethod["turnOff"] = "turnOff";
ScryptedInterfaceMethod["turnOn"] = "turnOn";
ScryptedInterfaceMethod["setBrightness"] = "setBrightness";
ScryptedInterfaceMethod["getTemperatureMaxK"] = "getTemperatureMaxK";
ScryptedInterfaceMethod["getTemperatureMinK"] = "getTemperatureMinK";
ScryptedInterfaceMethod["setColorTemperature"] = "setColorTemperature";
ScryptedInterfaceMethod["setRgb"] = "setRgb";
ScryptedInterfaceMethod["setHsv"] = "setHsv";
ScryptedInterfaceMethod["pressButton"] = "pressButton";
ScryptedInterfaceMethod["sendNotification"] = "sendNotification";
ScryptedInterfaceMethod["start"] = "start";
ScryptedInterfaceMethod["stop"] = "stop";
ScryptedInterfaceMethod["pause"] = "pause";
ScryptedInterfaceMethod["resume"] = "resume";
ScryptedInterfaceMethod["dock"] = "dock";
ScryptedInterfaceMethod["setTemperature"] = "setTemperature";
ScryptedInterfaceMethod["setTemperatureUnit"] = "setTemperatureUnit";
ScryptedInterfaceMethod["getPictureOptions"] = "getPictureOptions";
ScryptedInterfaceMethod["takePicture"] = "takePicture";
ScryptedInterfaceMethod["getAudioStream"] = "getAudioStream";
ScryptedInterfaceMethod["setAudioVolumes"] = "setAudioVolumes";
ScryptedInterfaceMethod["startDisplay"] = "startDisplay";
ScryptedInterfaceMethod["stopDisplay"] = "stopDisplay";
ScryptedInterfaceMethod["getVideoStream"] = "getVideoStream";
ScryptedInterfaceMethod["getVideoStreamOptions"] = "getVideoStreamOptions";
ScryptedInterfaceMethod["getPrivacyMasks"] = "getPrivacyMasks";
ScryptedInterfaceMethod["setPrivacyMasks"] = "setPrivacyMasks";
ScryptedInterfaceMethod["getVideoTextOverlays"] = "getVideoTextOverlays";
ScryptedInterfaceMethod["setVideoTextOverlay"] = "setVideoTextOverlay";
ScryptedInterfaceMethod["getRecordingStream"] = "getRecordingStream";
ScryptedInterfaceMethod["getRecordingStreamCurrentTime"] = "getRecordingStreamCurrentTime";
ScryptedInterfaceMethod["getRecordingStreamOptions"] = "getRecordingStreamOptions";
ScryptedInterfaceMethod["getRecordingStreamThumbnail"] = "getRecordingStreamThumbnail";
ScryptedInterfaceMethod["deleteRecordingStream"] = "deleteRecordingStream";
ScryptedInterfaceMethod["setRecordingActive"] = "setRecordingActive";
ScryptedInterfaceMethod["ptzCommand"] = "ptzCommand";
ScryptedInterfaceMethod["getRecordedEvents"] = "getRecordedEvents";
ScryptedInterfaceMethod["getVideoClip"] = "getVideoClip";
ScryptedInterfaceMethod["getVideoClips"] = "getVideoClips";
ScryptedInterfaceMethod["getVideoClipThumbnail"] = "getVideoClipThumbnail";
ScryptedInterfaceMethod["removeVideoClips"] = "removeVideoClips";
ScryptedInterfaceMethod["setVideoStreamOptions"] = "setVideoStreamOptions";
ScryptedInterfaceMethod["startIntercom"] = "startIntercom";
ScryptedInterfaceMethod["stopIntercom"] = "stopIntercom";
ScryptedInterfaceMethod["lock"] = "lock";
ScryptedInterfaceMethod["unlock"] = "unlock";
ScryptedInterfaceMethod["addPassword"] = "addPassword";
ScryptedInterfaceMethod["getPasswords"] = "getPasswords";
ScryptedInterfaceMethod["removePassword"] = "removePassword";
ScryptedInterfaceMethod["activate"] = "activate";
ScryptedInterfaceMethod["deactivate"] = "deactivate";
ScryptedInterfaceMethod["isReversible"] = "isReversible";
ScryptedInterfaceMethod["closeEntry"] = "closeEntry";
ScryptedInterfaceMethod["openEntry"] = "openEntry";
ScryptedInterfaceMethod["getDevice"] = "getDevice";
ScryptedInterfaceMethod["releaseDevice"] = "releaseDevice";
ScryptedInterfaceMethod["adoptDevice"] = "adoptDevice";
ScryptedInterfaceMethod["discoverDevices"] = "discoverDevices";
ScryptedInterfaceMethod["createDevice"] = "createDevice";
ScryptedInterfaceMethod["getCreateDeviceSettings"] = "getCreateDeviceSettings";
ScryptedInterfaceMethod["reboot"] = "reboot";
ScryptedInterfaceMethod["getRefreshFrequency"] = "getRefreshFrequency";
ScryptedInterfaceMethod["refresh"] = "refresh";
ScryptedInterfaceMethod["getMediaStatus"] = "getMediaStatus";
ScryptedInterfaceMethod["load"] = "load";
ScryptedInterfaceMethod["seek"] = "seek";
ScryptedInterfaceMethod["skipNext"] = "skipNext";
ScryptedInterfaceMethod["skipPrevious"] = "skipPrevious";
ScryptedInterfaceMethod["convert"] = "convert";
ScryptedInterfaceMethod["convertMedia"] = "convertMedia";
ScryptedInterfaceMethod["getSettings"] = "getSettings";
ScryptedInterfaceMethod["putSetting"] = "putSetting";
ScryptedInterfaceMethod["armSecuritySystem"] = "armSecuritySystem";
ScryptedInterfaceMethod["disarmSecuritySystem"] = "disarmSecuritySystem";
ScryptedInterfaceMethod["setAirPurifierState"] = "setAirPurifierState";
ScryptedInterfaceMethod["getReadmeMarkdown"] = "getReadmeMarkdown";
ScryptedInterfaceMethod["getOauthUrl"] = "getOauthUrl";
ScryptedInterfaceMethod["onOauthCallback"] = "onOauthCallback";
ScryptedInterfaceMethod["canMixin"] = "canMixin";
ScryptedInterfaceMethod["getMixin"] = "getMixin";
ScryptedInterfaceMethod["releaseMixin"] = "releaseMixin";
ScryptedInterfaceMethod["onRequest"] = "onRequest";
ScryptedInterfaceMethod["onConnection"] = "onConnection";
ScryptedInterfaceMethod["onPush"] = "onPush";
ScryptedInterfaceMethod["run"] = "run";
ScryptedInterfaceMethod["eval"] = "eval";
ScryptedInterfaceMethod["loadScripts"] = "loadScripts";
ScryptedInterfaceMethod["saveScript"] = "saveScript";
ScryptedInterfaceMethod["forkInterface"] = "forkInterface";
ScryptedInterfaceMethod["trackObjects"] = "trackObjects";
ScryptedInterfaceMethod["getDetectionInput"] = "getDetectionInput";
ScryptedInterfaceMethod["getObjectTypes"] = "getObjectTypes";
ScryptedInterfaceMethod["detectObjects"] = "detectObjects";
ScryptedInterfaceMethod["generateObjectDetections"] = "generateObjectDetections";
ScryptedInterfaceMethod["getDetectionModel"] = "getDetectionModel";
ScryptedInterfaceMethod["setHumidity"] = "setHumidity";
ScryptedInterfaceMethod["setFan"] = "setFan";
ScryptedInterfaceMethod["startRTCSignalingSession"] = "startRTCSignalingSession";
ScryptedInterfaceMethod["createRTCSignalingSession"] = "createRTCSignalingSession";
ScryptedInterfaceMethod["getScryptedUserAccessControl"] = "getScryptedUserAccessControl";
ScryptedInterfaceMethod["generateVideoFrames"] = "generateVideoFrames";
ScryptedInterfaceMethod["connectStream"] = "connectStream";
ScryptedInterfaceMethod["getTTYSettings"] = "getTTYSettings";
})(ScryptedInterfaceMethod || (exports.ScryptedInterfaceMethod = ScryptedInterfaceMethod = {}));
exports.ScryptedInterfaceDescriptors = {
"ScryptedDevice": {
"name": "ScryptedDevice",
"methods": [
"listen",
"probe",
"setMixins",
"setName",
"setRoom",
"setType"
],
"properties": [
"id",
"info",
"interfaces",
"mixins",
"name",
"nativeId",
"pluginId",
"providedInterfaces",
"providedName",
"providedRoom",
"providedType",
"providerId",
"room",
"type"
]
},
"ScryptedPlugin": {
"name": "ScryptedPlugin",
"methods": [
"getPluginJson"
],
"properties": []
},
"ScryptedPluginRuntime": {
"name": "ScryptedPluginRuntime",
"methods": [],
"properties": [
"scryptedRuntimeArguments"
]
},
"OnOff": {
"name": "OnOff",
"methods": [
"turnOff",
"turnOn"
],
"properties": [
"on"
]
},
"Brightness": {
"name": "Brightness",
"methods": [
"setBrightness"
],
"properties": [
"brightness"
]
},
"ColorSettingTemperature": {
"name": "ColorSettingTemperature",
"methods": [
"getTemperatureMaxK",
"getTemperatureMinK",
"setColorTemperature"
],
"properties": [
"colorTemperature"
]
},
"ColorSettingRgb": {
"name": "ColorSettingRgb",
"methods": [
"setRgb"
],
"properties": [
"rgb"
]
},
"ColorSettingHsv": {
"name": "ColorSettingHsv",
"methods": [
"setHsv"
],
"properties": [
"hsv"
]
},
"Buttons": {
"name": "Buttons",
"methods": [],
"properties": [
"buttons"
]
},
"PressButtons": {
"name": "PressButtons",
"methods": [
"pressButton"
],
"properties": []
},
"Sensors": {
"name": "Sensors",
"methods": [],
"properties": [
"sensors"
]
},
"Notifier": {
"name": "Notifier",
"methods": [
"sendNotification"
],
"properties": []
},
"StartStop": {
"name": "StartStop",
"methods": [
"start",
"stop"
],
"properties": [
"running"
]
},
"Pause": {
"name": "Pause",
"methods": [
"pause",
"resume"
],
"properties": [
"paused"
]
},
"Dock": {
"name": "Dock",
"methods": [
"dock"
],
"properties": [
"docked"
]
},
"TemperatureSetting": {
"name": "TemperatureSetting",
"methods": [
"setTemperature"
],
"properties": [
"temperatureSetting"
]
},
"Thermometer": {
"name": "Thermometer",
"methods": [
"setTemperatureUnit"
],
"properties": [
"temperature",
"temperatureUnit"
]
},
"HumiditySensor": {
"name": "HumiditySensor",
"methods": [],
"properties": [
"humidity"
]
},
"Camera": {
"name": "Camera",
"methods": [
"getPictureOptions",
"takePicture"
],
"properties": []
},
"Microphone": {
"name": "Microphone",
"methods": [
"getAudioStream"
],
"properties": []
},
"AudioVolumeControl": {
"name": "AudioVolumeControl",
"methods": [
"setAudioVolumes"
],
"properties": [
"audioVolumes"
]
},
"Display": {
"name": "Display",
"methods": [
"startDisplay",
"stopDisplay"
],
"properties": []
},
"VideoCamera": {
"name": "VideoCamera",
"methods": [
"getVideoStream",
"getVideoStreamOptions"
],
"properties": []
},
"VideoCameraMask": {
"name": "VideoCameraMask",
"methods": [
"getPrivacyMasks",
"setPrivacyMasks"
],
"properties": []
},
"VideoTextOverlays": {
"name": "VideoTextOverlays",
"methods": [
"getVideoTextOverlays",
"setVideoTextOverlay"
],
"properties": []
},
"VideoRecorder": {
"name": "VideoRecorder",
"methods": [
"getRecordingStream",
"getRecordingStreamCurrentTime",
"getRecordingStreamOptions",
"getRecordingStreamThumbnail"
],
"properties": [
"recordingActive"
]
},
"VideoRecorderManagement": {
"name": "VideoRecorderManagement",
"methods": [
"deleteRecordingStream",
"setRecordingActive"
],
"properties": []
},
"PanTiltZoom": {
"name": "PanTiltZoom",
"methods": [
"ptzCommand"
],
"properties": [
"ptzCapabilities"
]
},
"EventRecorder": {
"name": "EventRecorder",
"methods": [
"getRecordedEvents"
],
"properties": []
},
"VideoClips": {
"name": "VideoClips",
"methods": [
"getVideoClip",
"getVideoClips",
"getVideoClipThumbnail",
"removeVideoClips"
],
"properties": []
},
"VideoCameraConfiguration": {
"name": "VideoCameraConfiguration",
"methods": [
"setVideoStreamOptions"
],
"properties": []
},
"Intercom": {
"name": "Intercom",
"methods": [
"startIntercom",
"stopIntercom"
],
"properties": []
},
"Lock": {
"name": "Lock",
"methods": [
"lock",
"unlock"
],
"properties": [
"lockState"
]
},
"PasswordStore": {
"name": "PasswordStore",
"methods": [
"addPassword",
"getPasswords",
"removePassword"
],
"properties": []
},
"Scene": {
"name": "Scene",
"methods": [
"activate",
"deactivate",
"isReversible"
],
"properties": []
},
"Entry": {
"name": "Entry",
"methods": [
"closeEntry",
"openEntry"
],
"properties": []
},
"EntrySensor": {
"name": "EntrySensor",
"methods": [],
"properties": [
"entryOpen"
]
},
"DeviceProvider": {
"name": "DeviceProvider",
"methods": [
"getDevice",
"releaseDevice"
],
"properties": []
},
"DeviceDiscovery": {
"name": "DeviceDiscovery",
"methods": [
"adoptDevice",
"discoverDevices"
],
"properties": []
},
"DeviceCreator": {
"name": "DeviceCreator",
"methods": [
"createDevice",
"getCreateDeviceSettings"
],
"properties": []
},
"Battery": {
"name": "Battery",
"methods": [],
"properties": [
"batteryLevel"
]
},
"Charger": {
"name": "Charger",
"methods": [],
"properties": [
"chargeState"
]
},
"Reboot": {
"name": "Reboot",
"methods": [
"reboot"
],
"properties": []
},
"Refresh": {
"name": "Refresh",
"methods": [
"getRefreshFrequency",
"refresh"
],
"properties": []
},
"MediaPlayer": {
"name": "MediaPlayer",
"methods": [
"getMediaStatus",
"load",
"seek",
"skipNext",
"skipPrevious"
],
"properties": []
},
"Online": {
"name": "Online",
"methods": [],
"properties": [
"online"
]
},
"BufferConverter": {
"name": "BufferConverter",
"methods": [
"convert"
],
"properties": [
"fromMimeType",
"toMimeType"
]
},
"MediaConverter": {
"name": "MediaConverter",
"methods": [
"convertMedia"
],
"properties": [
"converters"
]
},
"Settings": {
"name": "Settings",
"methods": [
"getSettings",
"putSetting"
],
"properties": []
},
"BinarySensor": {
"name": "BinarySensor",
"methods": [],
"properties": [
"binaryState"
]
},
"TamperSensor": {
"name": "TamperSensor",
"methods": [],
"properties": [
"tampered"
]
},
"Sleep": {
"name": "Sleep",
"methods": [],
"properties": [
"sleeping"
]
},
"PowerSensor": {
"name": "PowerSensor",
"methods": [],
"properties": [
"powerDetected"
]
},
"AudioSensor": {
"name": "AudioSensor",
"methods": [],
"properties": [
"audioDetected"
]
},
"MotionSensor": {
"name": "MotionSensor",
"methods": [],
"properties": [
"motionDetected"
]
},
"AmbientLightSensor": {
"name": "AmbientLightSensor",
"methods": [],
"properties": [
"ambientLight"
]
},
"OccupancySensor": {
"name": "OccupancySensor",
"methods": [],
"properties": [
"occupied"
]
},
"FloodSensor": {
"name": "FloodSensor",
"methods": [],
"properties": [
"flooded"
]
},
"UltravioletSensor": {
"name": "UltravioletSensor",
"methods": [],
"properties": [
"ultraviolet"
]
},
"LuminanceSensor": {
"name": "LuminanceSensor",
"methods": [],
"properties": [
"luminance"
]
},
"PositionSensor": {
"name": "PositionSensor",
"methods": [],
"properties": [
"position"
]
},
"SecuritySystem": {
"name": "SecuritySystem",
"methods": [
"armSecuritySystem",
"disarmSecuritySystem"
],
"properties": [
"securitySystemState"
]
},
"PM10Sensor": {
"name": "PM10Sensor",
"methods": [],
"properties": [
"pm10Density"
]
},
"PM25Sensor": {
"name": "PM25Sensor",
"methods": [],
"properties": [
"pm25Density"
]
},
"VOCSensor": {
"name": "VOCSensor",
"methods": [],
"properties": [
"vocDensity"
]
},
"NOXSensor": {
"name": "NOXSensor",
"methods": [],
"properties": [
"noxDensity"
]
},
"CO2Sensor": {
"name": "CO2Sensor",
"methods": [],
"properties": [
"co2ppm"
]
},
"AirQualitySensor": {
"name": "AirQualitySensor",
"methods": [],
"properties": [
"airQuality"
]
},
"AirPurifier": {
"name": "AirPurifier",
"methods": [
"setAirPurifierState"
],
"properties": [
"airPurifierState"
]
},
"FilterMaintenance": {
"name": "FilterMaintenance",
"methods": [],
"properties": [
"filterChangeIndication",
"filterLifeLevel"
]
},
"Readme": {
"name": "Readme",
"methods": [
"getReadmeMarkdown"
],
"properties": []
},
"OauthClient": {
"name": "OauthClient",
"methods": [
"getOauthUrl",
"onOauthCallback"
],
"properties": []
},
"MixinProvider": {
"name": "MixinProvider",
"methods": [
"canMixin",
"getMixin",
"releaseMixin"
],
"properties": []
},
"HttpRequestHandler": {
"name": "HttpRequestHandler",
"methods": [
"onRequest"
],
"properties": []
},
"EngineIOHandler": {
"name": "EngineIOHandler",
"methods": [
"onConnection"
],
"properties": []
},
"PushHandler": {
"name": "PushHandler",
"methods": [
"onPush"
],
"properties": []
},
"Program": {
"name": "Program",
"methods": [
"run"
],
"properties": []
},
"Scriptable": {
"name": "Scriptable",
"methods": [
"eval",
"loadScripts",
"saveScript"
],
"properties": []
},
"ClusterForkInterface": {
"name": "ClusterForkInterface",
"methods": [
"forkInterface"
],
"properties": []
},
"ObjectTracker": {
"name": "ObjectTracker",
"methods": [
"trackObjects"
],
"properties": []
},
"ObjectDetector": {
"name": "ObjectDetector",
"methods": [
"getDetectionInput",
"getObjectTypes"
],
"properties": []
},
"ObjectDetection": {
"name": "ObjectDetection",
"methods": [
"detectObjects",
"generateObjectDetections",
"getDetectionModel"
],
"properties": []
},
"ObjectDetectionPreview": {
"name": "ObjectDetectionPreview",
"methods": [],
"properties": []
},
"ObjectDetectionGenerator": {
"name": "ObjectDetectionGenerator",
"methods": [],
"properties": []
},
"HumiditySetting": {
"name": "HumiditySetting",
"methods": [
"setHumidity"
],
"properties": [
"humiditySetting"
]
},
"Fan": {
"name": "Fan",
"methods": [
"setFan"
],
"properties": [
"fan"
]
},
"RTCSignalingChannel": {
"name": "RTCSignalingChannel",
"methods": [
"startRTCSignalingSession"
],
"properties": []
},
"RTCSignalingClient": {
"name": "RTCSignalingClient",
"methods": [
"createRTCSignalingSession"
],
"properties": []
},
"LauncherApplication": {
"name": "LauncherApplication",
"methods": [],
"properties": [
"applicationInfo"
]
},
"ScryptedUser": {
"name": "ScryptedUser",
"methods": [
"getScryptedUserAccessControl"
],
"properties": []
},
"VideoFrameGenerator": {
"name": "VideoFrameGenerator",
"