lavva.exalushome
Version:
Library implementing communication and abstraction layers for ExalusHome system
1,028 lines • 37.8 kB
JavaScript
var __rest = (this && this.__rest) || function (s, e) {
var t = {};
for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
t[p] = s[p];
if (s != null && typeof Object.getOwnPropertySymbols === "function")
for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
t[p[i]] = s[p[i]];
}
return t;
};
import { DeviceResponseType } from "./IDevice";
export class DeviceState {
constructor() {
this._type = "";
this._data = null;
this._typeAsEnum = DeviceResponseType.Unknown;
this._serializedDataWithoutTime = "";
}
get Data() {
return this._data;
}
set Data(value) {
this._data = value;
let { Time } = value, justData = __rest(value, ["Time"]);
this._serializedDataWithoutTime = JSON.stringify(justData);
}
get Type() {
return this._type;
}
set Type(value) {
this._type = value;
}
get TypeAsEnum() {
return this._typeAsEnum;
}
set TypeAsEnum(value) {
this._typeAsEnum = value;
}
get StatesComparisonData() {
return this._serializedDataWithoutTime;
}
}
export var StateReliability;
(function (StateReliability) {
/// <summary>
/// pewny
/// </summary>
StateReliability[StateReliability["Confident"] = 0] = "Confident";
/// <summary>
/// niepewny
/// </summary>
StateReliability[StateReliability["Unconfident"] = 1] = "Unconfident";
})(StateReliability || (StateReliability = {}));
/// ON/OFF state
export class ChannelOnOffDeviceState extends DeviceState {
constructor(state) {
super();
this.TypeAsEnum = DeviceResponseType.ChannelOnOffState;
this.Type = "ChannelOnOffState";
this.Data = state.state;
}
}
export class ChannelOnOffState {
constructor() {
this.Channel = 0;
this.StateReliability = StateReliability.Unconfident;
this.State = ChannelOnOffStateEnum.Unknown;
this.Time = "";
}
}
export var ChannelOnOffStateEnum;
(function (ChannelOnOffStateEnum) {
ChannelOnOffStateEnum[ChannelOnOffStateEnum["On"] = 0] = "On";
ChannelOnOffStateEnum[ChannelOnOffStateEnum["Off"] = 1] = "Off";
ChannelOnOffStateEnum[ChannelOnOffStateEnum["Unknown"] = 2] = "Unknown";
})(ChannelOnOffStateEnum || (ChannelOnOffStateEnum = {}));
export class ChannelHallStateState extends DeviceState {
constructor(state) {
super();
this.TypeAsEnum = DeviceResponseType.HallState;
this.Type = "IHallState";
this.Data = state.state;
}
}
export class HallState {
constructor() {
this.Channel = 0;
this.StateReliability = StateReliability.Unconfident;
this.Time = "";
this.State = false;
}
}
export class ChannelSceneExecutedState extends DeviceState {
constructor(state) {
super();
this.TypeAsEnum = DeviceResponseType.SceneExecuted;
this.Type = "ISceneExecuted";
this.Data = state.state;
}
}
export class SceneExecutedState {
constructor() {
this.Channel = 0;
this.StateReliability = StateReliability.Unconfident;
this.Time = "";
}
}
/// intercom
export class IntercomDeviceState extends DeviceState {
constructor(state) {
super();
this.TypeAsEnum = DeviceResponseType.IntercomState;
this.Type = "IntercomState";
this.Data = state.state;
}
}
export class IntercomState {
constructor() {
this.Channel = 0;
this.StateReliability = StateReliability.Unconfident;
this.State = IntercomStateEnum.Unknown;
this.Time = "";
}
}
export var IntercomStateEnum;
(function (IntercomStateEnum) {
IntercomStateEnum[IntercomStateEnum["Idle"] = 0] = "Idle";
IntercomStateEnum[IntercomStateEnum["IncomingCall"] = 1] = "IncomingCall";
IntercomStateEnum[IntercomStateEnum["AnsweringCall"] = 2] = "AnsweringCall";
IntercomStateEnum[IntercomStateEnum["Busy"] = 3] = "Busy";
IntercomStateEnum[IntercomStateEnum["NoAnswerToCall"] = 4] = "NoAnswerToCall";
IntercomStateEnum[IntercomStateEnum["Unknown"] = 5] = "Unknown";
})(IntercomStateEnum || (IntercomStateEnum = {}));
/// online camera
export class OnlineCameraState extends DeviceState {
constructor(state) {
super();
this.TypeAsEnum = DeviceResponseType.OnlineCamera;
this.Type = "OnlineCameraState";
this.Data = state.state;
}
}
/// DoorBellState
export class DoorBellDeviceState extends DeviceState {
constructor(state) {
super();
this.TypeAsEnum = DeviceResponseType.DoorBellState;
this.Type = "DoorBellState";
this.Data = state.state;
}
}
export class DoorBellState {
constructor() {
this.Channel = 0;
this.StateReliability = StateReliability.Unconfident;
this.State = DoorBellStateEnum.Relased;
this.Time = "";
}
}
export var DoorBellStateEnum;
(function (DoorBellStateEnum) {
DoorBellStateEnum[DoorBellStateEnum["Pressed"] = 0] = "Pressed";
DoorBellStateEnum[DoorBellStateEnum["Relased"] = 1] = "Relased";
DoorBellStateEnum[DoorBellStateEnum["PressedAndRelased"] = 2] = "PressedAndRelased";
})(DoorBellStateEnum || (DoorBellStateEnum = {}));
/// reed position
export class ReedStateDeviceState extends DeviceState {
constructor(state) {
super();
this.TypeAsEnum = DeviceResponseType.ReedState;
this.Type = "ReedState";
this.Data = state.state;
}
}
export class ReedState {
constructor() {
this.Channel = 0;
this.StateReliability = StateReliability.Unconfident;
this.State = false;
this.Time = "";
}
}
/// blind position
export class BlindPositionDeviceState extends DeviceState {
constructor(state) {
super();
this.TypeAsEnum = DeviceResponseType.BlindPosition;
this.Type = "BlindPostionState";
this.Data = state.state;
}
GetBlindStatus() {
switch (this.Data.Position) {
case 200:
return BlindStatusCode.UnableToMove;
case 201:
return BlindStatusCode.MotorOverheatedPleaseWait;
default:
return BlindStatusCode.Working;
}
}
}
export var BlindStatusCode;
(function (BlindStatusCode) {
BlindStatusCode[BlindStatusCode["Unknown"] = 0] = "Unknown";
BlindStatusCode[BlindStatusCode["Working"] = 1] = "Working";
BlindStatusCode[BlindStatusCode["UnableToMove"] = 200] = "UnableToMove";
BlindStatusCode[BlindStatusCode["MotorOverheatedPleaseWait"] = 201] = "MotorOverheatedPleaseWait";
})(BlindStatusCode || (BlindStatusCode = {}));
export class BlindPostionState {
constructor() {
this.Channel = 0;
this.StateReliability = StateReliability.Unconfident;
this.Position = 0;
this.RawPosition = 0;
this.Time = "";
}
}
/// ButtonState
export class RemoteButtonDeviceState extends DeviceState {
constructor(state) {
super();
this.TypeAsEnum = DeviceResponseType.RemoteButtonState;
this.Type = "RemoteButtonState";
this.Data = state.state;
}
}
export class RemoteButtonState {
constructor() {
this.Channel = 0;
this.StateReliability = StateReliability.Unconfident;
this.State = RemoteButtonStateEnum.Relased;
this.Time = "";
}
}
export var RemoteButtonStateEnum;
(function (RemoteButtonStateEnum) {
RemoteButtonStateEnum[RemoteButtonStateEnum["Pressed"] = 1] = "Pressed";
RemoteButtonStateEnum[RemoteButtonStateEnum["Relased"] = 2] = "Relased";
RemoteButtonStateEnum[RemoteButtonStateEnum["PressedAndRelased"] = 3] = "PressedAndRelased";
})(RemoteButtonStateEnum || (RemoteButtonStateEnum = {}));
/// device light color
export class LightColorDeviceState extends DeviceState {
constructor(state) {
super();
this.TypeAsEnum = DeviceResponseType.LightColor;
this.Type = "LightColorState";
this.Data = state.state;
}
}
export class LightColorState {
constructor() {
this.Channel = 0;
this.StateReliability = StateReliability.Unconfident;
this.R = 0;
this.G = 0;
this.B = 0;
this.Time = "";
}
}
/// light warmth
export class LightWarmthDeviceState extends DeviceState {
constructor(state) {
super();
this.TypeAsEnum = DeviceResponseType.LightWarmth;
this.Type = "LightWarmthState";
this.Data = state.state;
}
}
export class LightWarmthState {
constructor() {
this.Channel = 0;
this.StateReliability = StateReliability.Unconfident;
this.Temperature = 0;
this.Time = "";
}
}
/// light brightness
export class LightBrightnessDeviceState extends DeviceState {
constructor(state) {
super();
this.TypeAsEnum = DeviceResponseType.LightBrightness;
this.Type = "LightBrightnessState";
this.Data = state.state;
}
}
export class LightBrightnessState {
constructor() {
this.Channel = 0;
this.StateReliability = StateReliability.Unconfident;
this.Brightness = 0;
this.Time = "";
}
}
/// MeasuredTemperature
export class MeasuredTemperatureDeviceState extends DeviceState {
constructor(state) {
super();
this.TypeAsEnum = DeviceResponseType.MeasuredTemperature;
this.Type = "MeasuredTemperatureState";
this.Data = state.state;
}
}
export class MeasuredTemperatureState {
constructor() {
this.Channel = 0;
this.StateReliability = StateReliability.Unconfident;
this.Temperature = 0;
this.Type = MeasuredTemperatureTypeEnum.InsideTemperature;
this.Time = "";
}
}
var MeasuredTemperatureTypeEnum;
(function (MeasuredTemperatureTypeEnum) {
MeasuredTemperatureTypeEnum[MeasuredTemperatureTypeEnum["AirTemperature"] = 0] = "AirTemperature";
MeasuredTemperatureTypeEnum[MeasuredTemperatureTypeEnum["InsideTemperature"] = 1] = "InsideTemperature";
MeasuredTemperatureTypeEnum[MeasuredTemperatureTypeEnum["OutsideTemperature"] = 2] = "OutsideTemperature";
MeasuredTemperatureTypeEnum[MeasuredTemperatureTypeEnum["FloorTemperature"] = 3] = "FloorTemperature";
MeasuredTemperatureTypeEnum[MeasuredTemperatureTypeEnum["SafetyTemperature"] = 4] = "SafetyTemperature";
MeasuredTemperatureTypeEnum[MeasuredTemperatureTypeEnum["SetTemperature"] = 5] = "SetTemperature";
})(MeasuredTemperatureTypeEnum || (MeasuredTemperatureTypeEnum = {}));
/// battery state
export class BatteryDeviceState extends DeviceState {
constructor(state) {
super();
this.TypeAsEnum = DeviceResponseType.BatteryState;
this.Type = "BatteryState";
this.Data = state.state;
}
}
export class BatteryState {
constructor() {
this.Channel = 0;
this.StateReliability = StateReliability.Unconfident;
this.State = BatteryStateEnum.Half;
this.Percentage = -1;
this.Time = "";
}
}
export var BatteryStateEnum;
(function (BatteryStateEnum) {
BatteryStateEnum[BatteryStateEnum["Unknown"] = -1] = "Unknown";
BatteryStateEnum[BatteryStateEnum["Full"] = 0] = "Full";
BatteryStateEnum[BatteryStateEnum["Empty"] = 1] = "Empty";
BatteryStateEnum[BatteryStateEnum["Half"] = 2] = "Half";
BatteryStateEnum[BatteryStateEnum["Percentage"] = 3] = "Percentage";
BatteryStateEnum[BatteryStateEnum["Low"] = 4] = "Low";
BatteryStateEnum[BatteryStateEnum["ExternalPower"] = 5] = "ExternalPower";
})(BatteryStateEnum || (BatteryStateEnum = {}));
/// measured brightness
export class MeasuredBrightnessDeviceState extends DeviceState {
constructor(state) {
super();
this.TypeAsEnum = DeviceResponseType.MeasuredBrightness;
this.Type = "MeasuredBrightnessState";
this.Data = state.state;
}
}
export class MeasuredBrightnessState {
constructor() {
this.Channel = 0;
this.StateReliability = StateReliability.Unconfident;
this.Brightness = 0;
this.Time = "";
}
}
/// measured energy
export class MeasuredEnergyDeviceState extends DeviceState {
constructor(state) {
super();
this.TypeAsEnum = DeviceResponseType.MeasuredEnergy;
this.Type = "MeasuredEnergyState";
this.Data = state.state;
this.Data.MeasurementParameters = new Map(Object.entries(state.state.MeasurementParameters));
}
}
export class MeasuredEnergyState {
constructor() {
this.Channel = 0;
this.StateReliability = StateReliability.Unconfident;
this.Time = "";
this.MeasurementParameters = new Map();
}
}
export var EnergyMeasurementParameter;
(function (EnergyMeasurementParameter) {
EnergyMeasurementParameter["Voltage"] = "Voltage";
EnergyMeasurementParameter["Current"] = "Current";
EnergyMeasurementParameter["PhaseShift"] = "PhaseShift";
EnergyMeasurementParameter["ActivePower"] = "ActivePower";
EnergyMeasurementParameter["ReactivePower"] = "ReactivePower";
EnergyMeasurementParameter["ApparentPower"] = "ApparentPower";
EnergyMeasurementParameter["PowerFactor"] = "PowerFactor";
EnergyMeasurementParameter["ActiveForwardEnergy"] = "ActiveForwardEnergy";
EnergyMeasurementParameter["ActiveReverseEnergy"] = "ActiveReverseEnergy";
EnergyMeasurementParameter["ApparentEnergy"] = "ApparentEnergy";
EnergyMeasurementParameter["ReactiveForwardEnergy"] = "ReactiveForwardEnergy";
EnergyMeasurementParameter["ReactiveReverseEnergy"] = "ReactiveReverseEnergy";
EnergyMeasurementParameter["Frequency"] = "Frequency";
EnergyMeasurementParameter["SPIErrorRate"] = "SPIErrorRate";
EnergyMeasurementParameter["CRCErrorRate"] = "CRCErrorRate";
EnergyMeasurementParameter["Timestamp"] = "Timestamp";
EnergyMeasurementParameter["FailedMeasurementsRate"] = "FailedMeasurementsRate";
EnergyMeasurementParameter["FundamentalActivePower"] = "FundamentalActivePower";
EnergyMeasurementParameter["HarmonicActivePower"] = "HarmonicActivePower";
})(EnergyMeasurementParameter || (EnergyMeasurementParameter = {}));
/// measured distance
export class MeasuredDistanceDeviceState extends DeviceState {
constructor(state) {
super();
this.TypeAsEnum = DeviceResponseType.MeasuredDistance;
this.Type = "MeasuredDistanceState";
this.Data = state.state;
}
}
export class MeasuredDistanceState {
constructor() {
this.Channel = 0;
this.StateReliability = StateReliability.Unconfident;
this.Distance = 0;
this.DetectedObject = DetectedObjectStateEnum.No;
this.Time = "";
}
}
export var DetectedObjectStateEnum;
(function (DetectedObjectStateEnum) {
DetectedObjectStateEnum[DetectedObjectStateEnum["No"] = 0] = "No";
DetectedObjectStateEnum[DetectedObjectStateEnum["Yes"] = 1] = "Yes";
})(DetectedObjectStateEnum || (DetectedObjectStateEnum = {}));
/// movement detection
export class MovementSensorDeviceState extends DeviceState {
constructor(state) {
super();
this.TypeAsEnum = DeviceResponseType.MovementSensorState;
this.Type = "MovementSensorState";
this.Data = state.state;
}
}
export class MovementSensorState {
constructor() {
this.Channel = 0;
this.StateReliability = StateReliability.Unconfident;
/// <summary>
/// percentage 0% no movement, 100% intense movement
/// </summary>
this.Intensity = 0;
this.Movement = MovementStateEnum.No;
this.Time = "";
}
}
export var MovementStateEnum;
(function (MovementStateEnum) {
MovementStateEnum[MovementStateEnum["No"] = 0] = "No";
MovementStateEnum[MovementStateEnum["Yes"] = 1] = "Yes";
})(MovementStateEnum || (MovementStateEnum = {}));
/// remote blind control button
export class BlindRemoteButtonDeviceState extends DeviceState {
constructor(state) {
super();
this.TypeAsEnum = DeviceResponseType.BlindRemoteButtonState;
this.Type = "BlindRemoteButtonState";
this.Data = state.state;
}
}
export class BlindRemoteButtonState {
constructor() {
this.Channel = 0;
this.StateReliability = StateReliability.Unconfident;
this.State = BlindRemoteButtonStateEnum.StopReleased;
this.Time = "";
}
}
export var BlindRemoteButtonStateEnum;
(function (BlindRemoteButtonStateEnum) {
BlindRemoteButtonStateEnum[BlindRemoteButtonStateEnum["OpenPressed"] = 1] = "OpenPressed";
BlindRemoteButtonStateEnum[BlindRemoteButtonStateEnum["OpenReleased"] = 2] = "OpenReleased";
BlindRemoteButtonStateEnum[BlindRemoteButtonStateEnum["StopPressed"] = 3] = "StopPressed";
BlindRemoteButtonStateEnum[BlindRemoteButtonStateEnum["StopReleased"] = 4] = "StopReleased";
BlindRemoteButtonStateEnum[BlindRemoteButtonStateEnum["ClosePressed"] = 5] = "ClosePressed";
BlindRemoteButtonStateEnum[BlindRemoteButtonStateEnum["CloseReleased"] = 6] = "CloseReleased";
})(BlindRemoteButtonStateEnum || (BlindRemoteButtonStateEnum = {}));
/// remote facade control button
export class FacadeRemoteButtonDeviceState extends DeviceState {
constructor(state) {
super();
this.TypeAsEnum = DeviceResponseType.FacadeRemoteButtonState;
this.Type = "FacadeRemoteButtonState";
this.Data = state.state;
}
}
export class FacadeRemoteButtonState {
constructor() {
this.Channel = 0;
this.StateReliability = StateReliability.Unconfident;
this.State = FacadeRemoteButtonStateEnum.StopReleased;
this.Time = "";
}
}
export var FacadeRemoteButtonStateEnum;
(function (FacadeRemoteButtonStateEnum) {
FacadeRemoteButtonStateEnum[FacadeRemoteButtonStateEnum["OpenPressed"] = 1] = "OpenPressed";
FacadeRemoteButtonStateEnum[FacadeRemoteButtonStateEnum["OpenReleased"] = 2] = "OpenReleased";
FacadeRemoteButtonStateEnum[FacadeRemoteButtonStateEnum["StopPressed"] = 3] = "StopPressed";
FacadeRemoteButtonStateEnum[FacadeRemoteButtonStateEnum["StopReleased"] = 4] = "StopReleased";
FacadeRemoteButtonStateEnum[FacadeRemoteButtonStateEnum["ClosePressed"] = 5] = "ClosePressed";
FacadeRemoteButtonStateEnum[FacadeRemoteButtonStateEnum["CloseReleased"] = 6] = "CloseReleased";
})(FacadeRemoteButtonStateEnum || (FacadeRemoteButtonStateEnum = {}));
/// signal strenght
export class SignalStrenghtDeviceState extends DeviceState {
constructor(state) {
super();
this.TypeAsEnum = DeviceResponseType.SignalStrength;
this.Type = "SignalStrenghtState";
this.Data = state.state;
}
}
export class SignalStrenghtState {
constructor() {
this.Channel = 0;
this.StateReliability = StateReliability.Unconfident;
this.Quality = LinkQualityEnum.Unknown;
this.MeasurementTime = "";
this.DidLastTaskSucceded = false;
this.Percentage = 0;
this.SuccededExecutionsPercentage = 0;
this.SuccededTransmissionsPercentage = 0;
this.Time = "";
}
}
export var LinkQualityEnum;
(function (LinkQualityEnum) {
LinkQualityEnum[LinkQualityEnum["Unknown"] = 0] = "Unknown";
LinkQualityEnum[LinkQualityEnum["Excellent"] = 1] = "Excellent";
LinkQualityEnum[LinkQualityEnum["Good"] = 2] = "Good";
LinkQualityEnum[LinkQualityEnum["Acceptable"] = 3] = "Acceptable";
LinkQualityEnum[LinkQualityEnum["Low"] = 4] = "Low";
LinkQualityEnum[LinkQualityEnum["Terrible"] = 5] = "Terrible";
LinkQualityEnum[LinkQualityEnum["NoLink"] = 6] = "NoLink";
})(LinkQualityEnum || (LinkQualityEnum = {}));
/// gate position
export class GatePositionDeviceState extends DeviceState {
constructor(state) {
super();
this.TypeAsEnum = DeviceResponseType.GatePosition;
this.Type = "GatePositionState";
this.Data = state.state;
}
}
export class GatePositionState {
constructor() {
this.Channel = 0;
this.StateReliability = StateReliability.Unconfident;
this.PositionType = GatePositionTypeEnum.Unknown;
this.Position = 0;
this.Time = "";
}
}
export var GatePositionTypeEnum;
(function (GatePositionTypeEnum) {
GatePositionTypeEnum[GatePositionTypeEnum["Unknown"] = 0] = "Unknown";
GatePositionTypeEnum[GatePositionTypeEnum["Open"] = 1] = "Open";
GatePositionTypeEnum[GatePositionTypeEnum["PartiallyOpen"] = 2] = "PartiallyOpen";
GatePositionTypeEnum[GatePositionTypeEnum["Close"] = 3] = "Close";
GatePositionTypeEnum[GatePositionTypeEnum["On"] = 4] = "On";
GatePositionTypeEnum[GatePositionTypeEnum["Off"] = 5] = "Off";
GatePositionTypeEnum[GatePositionTypeEnum["Percentage"] = 6] = "Percentage";
})(GatePositionTypeEnum || (GatePositionTypeEnum = {}));
/// gateway position
export class GatewayPositionDeviceState extends DeviceState {
constructor(state) {
super();
this.TypeAsEnum = DeviceResponseType.GatewayPosition;
this.Type = "GatewayPositionState";
this.Data = state.state;
}
}
export class GatewayPositionState {
constructor() {
this.Channel = 0;
this.StateReliability = StateReliability.Unconfident;
this.PositionType = GatewayPositionTypeEnum.Unknown;
this.Position = 0;
this.Time = "";
}
}
export var GatewayPositionTypeEnum;
(function (GatewayPositionTypeEnum) {
GatewayPositionTypeEnum[GatewayPositionTypeEnum["Unknown"] = 0] = "Unknown";
GatewayPositionTypeEnum[GatewayPositionTypeEnum["Open"] = 1] = "Open";
GatewayPositionTypeEnum[GatewayPositionTypeEnum["PartiallyOpen"] = 2] = "PartiallyOpen";
GatewayPositionTypeEnum[GatewayPositionTypeEnum["Close"] = 3] = "Close";
GatewayPositionTypeEnum[GatewayPositionTypeEnum["On"] = 4] = "On";
GatewayPositionTypeEnum[GatewayPositionTypeEnum["Off"] = 5] = "Off";
})(GatewayPositionTypeEnum || (GatewayPositionTypeEnum = {}));
export class GateControllerHealthDeviceState extends DeviceState {
constructor(state) {
super();
this.TypeAsEnum = DeviceResponseType.GateControllerHealth;
this.Type = "GateControllerHealthState";
this.Data = state.state;
}
}
export class GateControllerHealthState {
constructor() {
this.Channel = 0;
this.StateReliability = StateReliability.Unconfident;
this.Time = "";
this.ResistanceOrOpticBarStatus = ResistanceOrOpticBarStatusEnum.Unknown;
this.PhotoCellsActive = false;
this.LastAutotestFailed = false;
this.AutotestSwitchOn = false;
this.ExternalLimitSwitchAActive = false;
this.ExternalLimitSwitchBActive = false;
this.InertionBreaksOk = false;
this.ObstacleDetected = false;
}
}
export var ResistanceOrOpticBarStatusEnum;
(function (ResistanceOrOpticBarStatusEnum) {
ResistanceOrOpticBarStatusEnum[ResistanceOrOpticBarStatusEnum["Unknown"] = -1] = "Unknown";
ResistanceOrOpticBarStatusEnum[ResistanceOrOpticBarStatusEnum["Inactive"] = 0] = "Inactive";
ResistanceOrOpticBarStatusEnum[ResistanceOrOpticBarStatusEnum["Active"] = 1] = "Active";
ResistanceOrOpticBarStatusEnum[ResistanceOrOpticBarStatusEnum["UnconnectedOrMalfunction"] = 2] = "UnconnectedOrMalfunction";
})(ResistanceOrOpticBarStatusEnum || (ResistanceOrOpticBarStatusEnum = {}));
/// blind calibration status
export class BlindCalibrationDeviceState extends DeviceState {
constructor(state) {
super();
this.TypeAsEnum = DeviceResponseType.BlindCalibration;
this.Type = "BlindCalibrationState";
this.Data = state.state;
}
}
export class BlindCalibrationState {
constructor() {
this.Channel = 0;
this.StateReliability = StateReliability.Unconfident;
this.CalibrationStatus = BlindCalibrationStatusEnum.AutoLernIdle;
this.Time = "";
}
}
export var BlindCalibrationStatusEnum;
(function (BlindCalibrationStatusEnum) {
BlindCalibrationStatusEnum[BlindCalibrationStatusEnum["AutoLernIdle"] = 0] = "AutoLernIdle";
BlindCalibrationStatusEnum[BlindCalibrationStatusEnum["AutoLernInProgress"] = 1] = "AutoLernInProgress";
BlindCalibrationStatusEnum[BlindCalibrationStatusEnum["AutoLernSuccessfull"] = 2] = "AutoLernSuccessfull";
BlindCalibrationStatusEnum[BlindCalibrationStatusEnum["AutoLernCancelled"] = 4] = "AutoLernCancelled";
})(BlindCalibrationStatusEnum || (BlindCalibrationStatusEnum = {}));
/// humidity sensor
export class HumiditySensorDeviceState extends DeviceState {
constructor(state) {
super();
this.TypeAsEnum = DeviceResponseType.HumiditySensorState;
this.Type = "HumiditySensorState";
this.Data = state.state;
}
}
export class HumiditySensorState {
constructor() {
this.Channel = 0;
this.StateReliability = StateReliability.Unconfident;
this.Type = HumidityTypeEnum.AirHumidity;
this.Humidity = 0;
this.Time = "";
}
}
export var HumidityTypeEnum;
(function (HumidityTypeEnum) {
HumidityTypeEnum[HumidityTypeEnum["AirHumidity"] = 0] = "AirHumidity";
HumidityTypeEnum[HumidityTypeEnum["InsideHumidity"] = 1] = "InsideHumidity";
HumidityTypeEnum[HumidityTypeEnum["OutsideHumidity"] = 2] = "OutsideHumidity";
HumidityTypeEnum[HumidityTypeEnum["SafetyHumidity"] = 3] = "SafetyHumidity";
HumidityTypeEnum[HumidityTypeEnum["SetHumidity"] = 4] = "SetHumidity";
})(HumidityTypeEnum || (HumidityTypeEnum = {}));
/// Vibration sensor
export class VibrationSensorDeviceState extends DeviceState {
constructor(state) {
super();
this.TypeAsEnum = DeviceResponseType.VibrationSensorState;
this.Type = "VibrationSensorState";
this.Data = state.state;
}
}
export class VibrationSensorState {
constructor() {
this.Channel = 0;
this.StateReliability = StateReliability.Unconfident;
this.Vibration = VibrationTypeEnum.No;
this.Acceleration_X = 0;
this.Acceleration_Y = 0;
this.Acceleration_Z = 0;
this.AccelerationModule = 0;
this.Time = "";
}
}
export var VibrationTypeEnum;
(function (VibrationTypeEnum) {
VibrationTypeEnum[VibrationTypeEnum["No"] = 0] = "No";
VibrationTypeEnum[VibrationTypeEnum["Yes"] = 1] = "Yes";
})(VibrationTypeEnum || (VibrationTypeEnum = {}));
/// binary sensor
export class BinarySensorStateDeviceState extends DeviceState {
constructor(state) {
super();
this.TypeAsEnum = DeviceResponseType.BinarySensorState;
this.Type = "BinarySensorState";
this.Data = state.state;
}
}
export class BinarySensorState {
constructor() {
this.Channel = 0;
this.StateReliability = StateReliability.Unconfident;
this.State = BinarySensorStateEnum.Low;
this.Time = "";
}
}
export var BinarySensorStateEnum;
(function (BinarySensorStateEnum) {
BinarySensorStateEnum[BinarySensorStateEnum["High"] = 1] = "High";
BinarySensorStateEnum[BinarySensorStateEnum["Low"] = 0] = "Low";
})(BinarySensorStateEnum || (BinarySensorStateEnum = {}));
/// ConfigurationState
export class ConfigurationDeviceState extends DeviceState {
constructor(state) {
super();
this.TypeAsEnum = DeviceResponseType.ConfigurationState;
this.Type = "ConfigurationState";
this.Data = state.state;
}
}
export class ConfigurationState {
constructor() {
this.Channel = 0;
this.StateReliability = StateReliability.Unconfident;
this.Configuration = ConfigurationStateEnum.Unknown;
this.Time = "";
}
}
export var ConfigurationStateEnum;
(function (ConfigurationStateEnum) {
ConfigurationStateEnum[ConfigurationStateEnum["Unknown"] = 0] = "Unknown";
ConfigurationStateEnum[ConfigurationStateEnum["OngoingConfiguration"] = 1] = "OngoingConfiguration";
ConfigurationStateEnum[ConfigurationStateEnum["NotConfigured"] = 2] = "NotConfigured";
ConfigurationStateEnum[ConfigurationStateEnum["Configured"] = 3] = "Configured";
ConfigurationStateEnum[ConfigurationStateEnum["PartiallyConfigured"] = 4] = "PartiallyConfigured";
})(ConfigurationStateEnum || (ConfigurationStateEnum = {}));
/// BlindOpenCloseTime
export class BlindOpenCloseTimeDeviceState extends DeviceState {
constructor(state) {
super();
this.TypeAsEnum = DeviceResponseType.BlindOpenCloseTime;
this.Type = "BlindOpenCloseTimeState";
this.Data = state.state;
}
}
export class BlindOpenCloseTimeState {
constructor() {
this.Channel = 0;
this.StateReliability = StateReliability.Unconfident;
this.Vibration = VibrationTypeEnum.No;
this.CloseTime = 0;
this.OpenTime = 0;
this.HallCounter = 0;
this.Time = "";
}
}
/// OvercurrentProtection
export class OvercurrentProtectionDeviceState extends DeviceState {
constructor(state) {
super();
this.TypeAsEnum = DeviceResponseType.OvercurrentProtectionState;
this.Type = "OvercurrentProtectionState";
this.Data = state.state;
}
}
export class OvercurrentProtectionState {
constructor() {
this.Channel = 0;
this.StateReliability = StateReliability.Unconfident;
this.OverrcurrentDetected = false;
this.Time = "";
}
}
/// OvercurrentProtectionThreshold
export class OvercurrentProtectionThresholdDeviceState extends DeviceState {
constructor(state) {
super();
this.TypeAsEnum = DeviceResponseType.OvercurrentProtectionThreshold;
this.Type = "OvercurrentProtectionThresholdState";
this.Data = state.state;
}
}
export class OvercurrentProtectionThresholdState {
constructor() {
this.Channel = 0;
this.StateReliability = StateReliability.Unconfident;
this.Current = 0;
this.Time = "";
}
}
/// FacadePositionDeviceState
export class FacadePositionDeviceState extends DeviceState {
constructor(state) {
super();
this.TypeAsEnum = DeviceResponseType.FacadePosition;
this.Type = "FacadePositionState";
this.Data = state.state;
}
}
export class FacadePositionState {
constructor() {
this.Channel = 0;
this.StateReliability = StateReliability.Unconfident;
this.Position = 0;
this.Tilt = 0;
this.Time = "";
}
}
export class FacadeTypeDeviceState extends DeviceState {
constructor(state) {
super();
this.TypeAsEnum = DeviceResponseType.FacadeType;
this.Type = "FacadeTypeState";
this.Data = state.state;
}
}
export class FacadeTypeState {
constructor() {
this.Channel = 0;
this.StateReliability = StateReliability.Unconfident;
this.Time = "";
this.FType = FacadeType.Facade180;
}
}
/// CurrentWindThreshold
export class CurrentWindThresholdDeviceState extends DeviceState {
constructor(state) {
super();
this.TypeAsEnum = DeviceResponseType.CurrentWindThreshold;
this.Type = "CurrentWindThresholdState";
this.Data = state.state;
}
}
export class CurrentWindThresholdState {
constructor() {
this.Channel = 0;
this.StateReliability = StateReliability.Unconfident;
this.WindThreshold = WindThresholdStateEnum.Unknown;
this.Time = "";
}
}
export var WindThresholdStateEnum;
(function (WindThresholdStateEnum) {
WindThresholdStateEnum[WindThresholdStateEnum["Unknown"] = 0] = "Unknown";
WindThresholdStateEnum[WindThresholdStateEnum["Below"] = 1] = "Below";
WindThresholdStateEnum[WindThresholdStateEnum["Exceeded"] = 2] = "Exceeded";
WindThresholdStateEnum[WindThresholdStateEnum["Inactive"] = 3] = "Inactive";
})(WindThresholdStateEnum || (WindThresholdStateEnum = {}));
/// CurrentLightThreshold
export class CurrentLightThresholdDeviceState extends DeviceState {
constructor(state) {
super();
this.TypeAsEnum = DeviceResponseType.CurrentLightThreshold;
this.Type = "CurrentLightThresholdState";
this.Data = state.state;
}
}
export class CurrentLightThresholdState {
constructor() {
this.Channel = 0;
this.StateReliability = StateReliability.Unconfident;
this.LightThreshold = LightThresholdStateEnum.Unknown;
this.Value = 0;
this.Time = "";
}
}
export var LightThresholdStateEnum;
(function (LightThresholdStateEnum) {
LightThresholdStateEnum[LightThresholdStateEnum["Unknown"] = 0] = "Unknown";
LightThresholdStateEnum[LightThresholdStateEnum["Below"] = 1] = "Below";
LightThresholdStateEnum[LightThresholdStateEnum["Exceeded"] = 2] = "Exceeded";
})(LightThresholdStateEnum || (LightThresholdStateEnum = {}));
/// WindSpeed
export class WindSpeedDeviceState extends DeviceState {
constructor(state) {
super();
this.TypeAsEnum = DeviceResponseType.WindSpeedState;
this.Type = "WindSpeedState";
this.Data = state.state;
}
}
export class WindSpeedState {
constructor() {
this.Channel = 0;
this.StateReliability = StateReliability.Unconfident;
this.Value = 0;
this.Time = "";
}
}
//flood sensor
export class FloodSensorDeviceState extends DeviceState {
constructor(state) {
super();
this.TypeAsEnum = DeviceResponseType.FloodSensorState;
this.Type = "FloodSensorState";
this.Data = state.state;
}
}
export class FloodSensorState {
constructor() {
this.Channel = 0;
this.StateReliability = StateReliability.Unconfident;
this.State = FloodSensorStates.NoFloodDetected;
this.Time = "";
}
}
export var FloodSensorStates;
(function (FloodSensorStates) {
FloodSensorStates[FloodSensorStates["FloodDetected"] = 1] = "FloodDetected";
FloodSensorStates[FloodSensorStates["NoFloodDetected"] = 0] = "NoFloodDetected";
})(FloodSensorStates || (FloodSensorStates = {}));
export var HumidityType;
(function (HumidityType) {
HumidityType[HumidityType["AirHumidity"] = 0] = "AirHumidity";
HumidityType[HumidityType["InsideHumidity"] = 1] = "InsideHumidity";
HumidityType[HumidityType["OutsideHumidity"] = 2] = "OutsideHumidity";
HumidityType[HumidityType["SafetyHumidity"] = 3] = "SafetyHumidity";
HumidityType[HumidityType["SetHumidity"] = 4] = "SetHumidity";
})(HumidityType || (HumidityType = {}));
//Pressure
export class PressureSensorDeviceState extends DeviceState {
constructor(state) {
super();
this.TypeAsEnum = DeviceResponseType.PressureSensorState;
this.Type = "PressureSensorState";
this.Data = state.state;
}
}
export class PressureSensorState {
constructor() {
this.Channel = 0;
this.StateReliability = StateReliability.Unconfident;
this.Pressure = 0;
this.Time = "";
this.PressureType = PressureType.OutsidePressure;
}
}
export var PressureType;
(function (PressureType) {
PressureType[PressureType["InsidePressure"] = 0] = "InsidePressure";
PressureType[PressureType["OutsidePressure"] = 1] = "OutsidePressure";
PressureType[PressureType["SetPressure"] = 2] = "SetPressure";
})(PressureType || (PressureType = {}));
export var FacadeType;
(function (FacadeType) {
FacadeType[FacadeType["Facade90"] = 0] = "Facade90";
FacadeType[FacadeType["Facade180"] = 1] = "Facade180";
})(FacadeType || (FacadeType = {}));
// TamperProtection
export class TamperProtectionDeviceState extends DeviceState {
constructor(state) {
super();
this.TypeAsEnum = DeviceResponseType.TamperProtectionState;
this.Type = "TamperProtection";
this.Data = state.state;
}
}
export class TamperProtectionState {
constructor() {
this.Channel = 0;
this.StateReliability = StateReliability.Unconfident;
this.State = TamperProtectionStatus.OK;
this.Time = "";
}
}
export var TamperProtectionStatus;
(function (TamperProtectionStatus) {
TamperProtectionStatus[TamperProtectionStatus["OK"] = 0] = "OK";
TamperProtectionStatus[TamperProtectionStatus["Breach"] = 1] = "Breach";
})(TamperProtectionStatus || (TamperProtectionStatus = {}));
//LightRGB
export class LightRGBWDeviceState extends DeviceState {
constructor(state) {
super();
this.TypeAsEnum = DeviceResponseType.LightRGBWState;
this.Type = "LightRGBW";
this.Data = state.state;
}
}
export class LightRGBWState {
constructor() {
this.StateReliability = StateReliability.Confident;
this.Time = "";
this.R = 0;
this.G = 0;
this.B = 0;
this.W = 0;
this.Channel = 0;
this.Brightness = 0;
}
}
//BlindError
export class BlindErrorDeviceState extends DeviceState {
constructor(state) {
super();
this.TypeAsEnum = DeviceResponseType.BlindErrorState;
this.Type = "BlindError";
this.Data = state.state;
}
}
export class BlindErrorState {
constructor() {
this.Channel = 0;
this.StateReliability = StateReliability.Unconfident;
this.ErrorCode = BlindErrorCode.Unknown;
this.ErrorData = new Map();
this.Reset = false;
this.Time = "";
}
}
export var BlindErrorCode;
(function (BlindErrorCode) {
BlindErrorCode[BlindErrorCode["Unknown"] = 0] = "Unknown";
BlindErrorCode[BlindErrorCode["ObstacleDetected"] = 1] = "ObstacleDetected";
BlindErrorCode[BlindErrorCode["MotorFailure"] = 2] = "MotorFailure";
})(BlindErrorCode || (BlindErrorCode = {}));
//# sourceMappingURL=IDeviceState.js.map