npm - isy-nodejs - Versions diffs - 1.0.7-alpha.0 → 1.0.9-alpha.1 - Mend

isy-nodejs 1.0.7-alpha.0 → 1.0.9-alpha.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (456) hide show

package/src/Devices/Insteon/Generated/KeypadButton.ts CHANGED Viewed

@@ -17,19 +17,19 @@ const nodeDefId = "KeypadButton";
 type Commands = KeypadButton.Commands;
 type Drivers = KeypadButton.Drivers;
-export class KeypadButtonNode extends Base<Drivers, Commands> implements KeypadButton.Interface {
+class KeypadButtonNode extends Base<Drivers, Commands> implements KeypadButton.Interface {
 	public override readonly commands = {
 		QUERY: this.query,
 		BL: this.backlight,
 		WDU: this.writeChanges
 	};
 	static override nodeDefId = "KeypadButton";
-	static override implements = ["KeypadButton", "EZIO2x4_Input", "EZIO2x4_Input_ADV", "SirenAlert", "SirenArm"];
-	declare readonly nodeDefId: "KeypadButton" | "KeypadButton_ADV";
+	static override implements = ['KeypadButton', "EZIO2x4_Input", "EZIO2x4_Input_ADV", "SirenAlert", "SirenArm"];
+	declare readonly nodeDefId: 'KeypadButton' | "KeypadButton_ADV";
 	constructor (isy: ISY, nodeInfo: NodeInfo) {
 		super(isy, nodeInfo);
-		this.drivers.ST = Driver.create("ST", this, nodeInfo.property as DriverState, { uom: UnitOfMeasure.Percent, label: "Status", name: "status" });
-		this.drivers.ERR = Driver.create("ERR", this, nodeInfo.property as DriverState, { uom: UnitOfMeasure.Index, label: "Responding", name: "responding" });
+		this.drivers.ST = Driver.create("ST", this, nodeInfo.state['ST'], { uom: UnitOfMeasure.Percent, label: "Status", name: "status" });
+		this.drivers.ERR = Driver.create("ERR", this, nodeInfo.state['ERR'], { uom: UnitOfMeasure.Index, label: "Responding", name: "responding" });
 	}
 	async query() { return this.sendCommand("QUERY"); }
 	async backlight(value: Insteon.Backlight) { return this.sendCommand("BL", value); }
@@ -47,13 +47,12 @@ NodeFactory.register(KeypadButtonNode, "KeypadButton_ADV");
 export namespace KeypadButton {
 	export interface Interface extends Omit<InstanceType<typeof KeypadButtonNode>, keyof ISYDeviceNode<any, any, any, any>> {
-		nodeDefId: "KeypadButton" | "KeypadButton_ADV";
 	}
 	export function is(node: ISYNode<any, any, any, any>): node is KeypadButtonNode {
-		return ["KeypadButton", "KeypadButton_ADV"].includes(node.nodeDefId);
+		return ['KeypadButton', "KeypadButton_ADV"].includes(node.nodeDefId);
 	}
 	export function isImplementedBy(node: ISYNode<any, any, any, any>): node is KeypadButtonNode {
-		return ["KeypadButton", "KeypadRelay", "KeypadRelay_ADV", "KeypadButton_ADV"].includes(node.nodeDefId);
+		return ['KeypadButton', "KeypadRelay", "KeypadRelay_ADV", "KeypadButton_ADV"].includes(node.nodeDefId);
 	}
 	export function create(isy: ISY, nodeInfo: NodeInfo) {
 		return new KeypadButtonNode(isy, nodeInfo);

package/src/Devices/Insteon/Generated/KeypadDimmer.ts CHANGED Viewed

@@ -17,7 +17,7 @@ const nodeDefId = "KeypadDimmer";
 type Commands = KeypadDimmer.Commands;
 type Drivers = KeypadDimmer.Drivers;
-export class KeypadDimmerNode extends Base<Drivers, Commands> implements KeypadDimmer.Interface {
+class KeypadDimmerNode extends Base<Drivers, Commands> implements KeypadDimmer.Interface {
 	public override readonly commands = {
 		DON: this.on,
 		DOF: this.off,
@@ -36,14 +36,14 @@ export class KeypadDimmerNode extends Base<Drivers, Commands> implements KeypadD
 		WDU: this.writeChanges
 	};
 	static override nodeDefId = "KeypadDimmer";
-	static override implements = ["KeypadDimmer", "RelaySwitchOnlyPlusQuery", "RelaySwitchOnlyPlusQuery_ADV", "RelaySwitchOnly", "RelaySwitchOnly_ADV", "RemoteLinc2", "RemoteLinc2_ADV", "IRLincTx", "SirenAlert", "SirenArm"];
-	declare readonly nodeDefId: "KeypadDimmer" | "KeypadDimmer_ADV";
+	static override implements = ['KeypadDimmer', "RelaySwitchOnlyPlusQuery", "RelaySwitchOnlyPlusQuery_ADV", "RelaySwitchOnly", "RelaySwitchOnly_ADV", "RemoteLinc2", "RemoteLinc2_ADV", "IRLincTx", "SirenAlert", "SirenArm"];
+	declare readonly nodeDefId: 'KeypadDimmer' | "KeypadDimmer_ADV";
 	constructor (isy: ISY, nodeInfo: NodeInfo) {
 		super(isy, nodeInfo);
-		this.drivers.ST = Driver.create("ST", this, nodeInfo.property as DriverState, { uom: UnitOfMeasure.Percent, label: "Status", name: "status" });
-		this.drivers.OL = Driver.create("OL", this, nodeInfo.property as DriverState, { uom: UnitOfMeasure.Percent, label: "On Level", name: "onLevel" });
-		this.drivers.RR = Driver.create("RR", this, nodeInfo.property as DriverState, { uom: UnitOfMeasure.Index, label: "Ramp Rate", name: "rampRate" });
-		this.drivers.ERR = Driver.create("ERR", this, nodeInfo.property as DriverState, { uom: UnitOfMeasure.Index, label: "Responding", name: "responding" });
+		this.drivers.ST = Driver.create("ST", this, nodeInfo.state['ST'], { uom: UnitOfMeasure.Percent, label: "Status", name: "status" });
+		this.drivers.OL = Driver.create("OL", this, nodeInfo.state['OL'], { uom: UnitOfMeasure.Percent, label: "On Level", name: "onLevel" });
+		this.drivers.RR = Driver.create("RR", this, nodeInfo.state['RR'], { uom: UnitOfMeasure.Index, label: "Ramp Rate", name: "rampRate" });
+		this.drivers.ERR = Driver.create("ERR", this, nodeInfo.state['ERR'], { uom: UnitOfMeasure.Index, label: "Responding", name: "responding" });
 	}
 	async on(value?: number) { return this.sendCommand("DON", value); }
 	async off() { return this.sendCommand("DOF"); }
@@ -79,13 +79,12 @@ NodeFactory.register(KeypadDimmerNode, "KeypadDimmer_ADV");
 export namespace KeypadDimmer {
 	export interface Interface extends Omit<InstanceType<typeof KeypadDimmerNode>, keyof ISYDeviceNode<any, any, any, any>> {
-		nodeDefId: "KeypadDimmer" | "KeypadDimmer_ADV";
 	}
 	export function is(node: ISYNode<any, any, any, any>): node is KeypadDimmerNode {
-		return ["KeypadDimmer", "KeypadDimmer_ADV"].includes(node.nodeDefId);
+		return ['KeypadDimmer', "KeypadDimmer_ADV"].includes(node.nodeDefId);
 	}
 	export function isImplementedBy(node: ISYNode<any, any, any, any>): node is KeypadDimmerNode {
-		return ["KeypadDimmer", "KeypadDimmer_ADV"].includes(node.nodeDefId);
+		return ['KeypadDimmer', "KeypadDimmer_ADV"].includes(node.nodeDefId);
 	}
 	export function create(isy: ISY, nodeInfo: NodeInfo) {
 		return new KeypadDimmerNode(isy, nodeInfo);

package/src/Devices/Insteon/Generated/KeypadRelay.ts CHANGED Viewed

@@ -17,7 +17,7 @@ const nodeDefId = "KeypadRelay";
 type Commands = KeypadRelay.Commands;
 type Drivers = KeypadRelay.Drivers;
-export class KeypadRelayNode extends Base<Drivers, Commands> implements KeypadRelay.Interface {
+class KeypadRelayNode extends Base<Drivers, Commands> implements KeypadRelay.Interface {
 	public override readonly commands = {
 		DON: this.on,
 		DOF: this.off,
@@ -29,12 +29,12 @@ export class KeypadRelayNode extends Base<Drivers, Commands> implements KeypadRe
 		WDU: this.writeChanges
 	};
 	static override nodeDefId = "KeypadRelay";
-	static override implements = ["KeypadRelay", "IRLincTx", "KeypadButton", "KeypadButton_ADV", "EZRAIN_Output", "EZIO2x4_Output", "EZIO2x4_Input", "EZIO2x4_Input_ADV", "DoorLock", "BinaryAlarm", "BinaryAlarm_ADV", "BinaryControl", "BinaryControl_ADV", "AlertModuleArmed", "SirenAlert", "SirenArm", "PIR2844OnOff", "PIR2844OnOff_ADV"];
-	declare readonly nodeDefId: "KeypadRelay" | "KeypadRelay_ADV";
+	static override implements = ['KeypadRelay', "IRLincTx", "KeypadButton", "KeypadButton_ADV", "EZRAIN_Output", "EZIO2x4_Output", "EZIO2x4_Input", "EZIO2x4_Input_ADV", "DoorLock", "BinaryAlarm", "BinaryAlarm_ADV", "BinaryControl", "BinaryControl_ADV", "AlertModuleArmed", "SirenAlert", "SirenArm", "PIR2844OnOff", "PIR2844OnOff_ADV"];
+	declare readonly nodeDefId: 'KeypadRelay' | "KeypadRelay_ADV";
 	constructor (isy: ISY, nodeInfo: NodeInfo) {
 		super(isy, nodeInfo);
-		this.drivers.ST = Driver.create("ST", this, nodeInfo.property as DriverState, { uom: UnitOfMeasure.Percent, label: "Status", name: "status" });
-		this.drivers.ERR = Driver.create("ERR", this, nodeInfo.property as DriverState, { uom: UnitOfMeasure.Index, label: "Responding", name: "responding" });
+		this.drivers.ST = Driver.create("ST", this, nodeInfo.state['ST'], { uom: UnitOfMeasure.Percent, label: "Status", name: "status" });
+		this.drivers.ERR = Driver.create("ERR", this, nodeInfo.state['ERR'], { uom: UnitOfMeasure.Index, label: "Responding", name: "responding" });
 	}
 	async on(value?: (0 | 100)) { return this.sendCommand("DON", value); }
 	async off() { return this.sendCommand("DOF"); }
@@ -57,13 +57,12 @@ NodeFactory.register(KeypadRelayNode, "KeypadRelay_ADV");
 export namespace KeypadRelay {
 	export interface Interface extends Omit<InstanceType<typeof KeypadRelayNode>, keyof ISYDeviceNode<any, any, any, any>> {
-		nodeDefId: "KeypadRelay" | "KeypadRelay_ADV";
 	}
 	export function is(node: ISYNode<any, any, any, any>): node is KeypadRelayNode {
-		return ["KeypadRelay", "KeypadRelay_ADV"].includes(node.nodeDefId);
+		return ['KeypadRelay', "KeypadRelay_ADV"].includes(node.nodeDefId);
 	}
 	export function isImplementedBy(node: ISYNode<any, any, any, any>): node is KeypadRelayNode {
-		return ["KeypadRelay", "KeypadRelay_ADV"].includes(node.nodeDefId);
+		return ['KeypadRelay', "KeypadRelay_ADV"].includes(node.nodeDefId);
 	}
 	export function create(isy: ISY, nodeInfo: NodeInfo) {
 		return new KeypadRelayNode(isy, nodeInfo);

package/src/Devices/Insteon/Generated/OnOffControl.ts CHANGED Viewed

@@ -17,15 +17,15 @@ const nodeDefId = "OnOffControl";
 type Commands = OnOffControl.Commands;
 type Drivers = OnOffControl.Drivers;
-export class OnOffControlNode extends Base<Drivers, Commands> implements OnOffControl.Interface {
+class OnOffControlNode extends Base<Drivers, Commands> implements OnOffControl.Interface {
 	public override readonly commands = {};
 	static override nodeDefId = "OnOffControl";
-	static override implements = ["OnOffControl", "SirenAlert", "SirenArm"];
-	declare readonly nodeDefId: "OnOffControl" | "OnOffControl_ADV";
+	static override implements = ['OnOffControl', "SirenAlert", "SirenArm"];
+	declare readonly nodeDefId: 'OnOffControl' | "OnOffControl_ADV";
 	constructor (isy: ISY, nodeInfo: NodeInfo) {
 		super(isy, nodeInfo);
-		this.drivers.ST = Driver.create("ST", this, nodeInfo.property as DriverState, { uom: UnitOfMeasure.Percent, label: "Status", name: "status" });
-		this.drivers.ERR = Driver.create("ERR", this, nodeInfo.property as DriverState, { uom: UnitOfMeasure.Index, label: "Responding", name: "responding" });
+		this.drivers.ST = Driver.create("ST", this, nodeInfo.state['ST'], { uom: UnitOfMeasure.Percent, label: "Status", name: "status" });
+		this.drivers.ERR = Driver.create("ERR", this, nodeInfo.state['ERR'], { uom: UnitOfMeasure.Index, label: "Responding", name: "responding" });
 	}
 	public get status(): Insteon.OnLevelRelay {
 		return this.drivers.ST?.value;
@@ -40,13 +40,12 @@ NodeFactory.register(OnOffControlNode, "OnOffControl_ADV");
 export namespace OnOffControl {
 	export interface Interface extends Omit<InstanceType<typeof OnOffControlNode>, keyof ISYDeviceNode<any, any, any, any>> {
-		nodeDefId: "OnOffControl" | "OnOffControl_ADV";
 	}
 	export function is(node: ISYNode<any, any, any, any>): node is OnOffControlNode {
-		return ["OnOffControl", "OnOffControl_ADV"].includes(node.nodeDefId);
+		return ['OnOffControl', "OnOffControl_ADV"].includes(node.nodeDefId);
 	}
 	export function isImplementedBy(node: ISYNode<any, any, any, any>): node is OnOffControlNode {
-		return ["OnOffControl", "X10", "OnOffControl_ADV"].includes(node.nodeDefId);
+		return ['OnOffControl', "X10", "OnOffControl_ADV"].includes(node.nodeDefId);
 	}
 	export function create(isy: ISY, nodeInfo: NodeInfo) {
 		return new OnOffControlNode(isy, nodeInfo);

package/src/Devices/Insteon/Generated/Pir2844.ts CHANGED Viewed

@@ -17,7 +17,7 @@ const nodeDefId = "PIR2844";
 type Commands = Pir2844.Commands;
 type Drivers = Pir2844.Drivers;
-export class Pir2844Node extends Base<Drivers, Commands> implements Pir2844.Interface {
+class Pir2844Node extends Base<Drivers, Commands> implements Pir2844.Interface {
 	public override readonly commands = {
 		CLITEMP: this.calibrateTemperature,
 		QUERY: this.query,
@@ -25,16 +25,16 @@ export class Pir2844Node extends Base<Drivers, Commands> implements Pir2844.Inte
 		WDU: this.writeChanges
 	};
 	static override nodeDefId = "PIR2844";
-	static override implements = ["PIR2844", "PIR2844C", "PIR2844C_ADV"];
-	declare readonly nodeDefId: "PIR2844" | "PIR2844_ADV";
+	static override implements = ['PIR2844', "PIR2844C", "PIR2844C_ADV"];
+	declare readonly nodeDefId: 'PIR2844' | "PIR2844_ADV";
 	constructor (isy: ISY, nodeInfo: NodeInfo) {
 		super(isy, nodeInfo);
-		this.drivers.ST = Driver.create("ST", this, nodeInfo.property as DriverState, { uom: UnitOfMeasure.Percent, label: "Status", name: "status" });
-		this.drivers.CLITEMP = Driver.create("CLITEMP", this, nodeInfo.property as DriverState, { uom: UnitOfMeasure.Fahrenheit, label: "Temperature", name: "temperature" });
-		this.drivers.LUMIN = Driver.create("LUMIN", this, nodeInfo.property as DriverState, { uom: UnitOfMeasure.Percent, label: "Luminance", name: "luminance" });
-		this.drivers.BATLVL = Driver.create("BATLVL", this, nodeInfo.property as DriverState, { uom: UnitOfMeasure.Percent, label: "Battery Level", name: "batteryLevel" });
-		this.drivers.GV1 = Driver.create("GV1", this, nodeInfo.property as DriverState, { uom: UnitOfMeasure.Boolean, label: "Battery Powered", name: "batteryPowered" });
-		this.drivers.ERR = Driver.create("ERR", this, nodeInfo.property as DriverState, { uom: UnitOfMeasure.Index, label: "Responding", name: "responding" });
+		this.drivers.ST = Driver.create("ST", this, nodeInfo.state['ST'], { uom: UnitOfMeasure.Percent, label: "Status", name: "status" });
+		this.drivers.CLITEMP = Driver.create("CLITEMP", this, nodeInfo.state['CLITEMP'], { uom: UnitOfMeasure.Fahrenheit, label: "Temperature", name: "temperature" });
+		this.drivers.LUMIN = Driver.create("LUMIN", this, nodeInfo.state['LUMIN'], { uom: UnitOfMeasure.Percent, label: "Luminance", name: "luminance" });
+		this.drivers.BATLVL = Driver.create("BATLVL", this, nodeInfo.state['BATLVL'], { uom: UnitOfMeasure.Percent, label: "Battery Level", name: "batteryLevel" });
+		this.drivers.GV1 = Driver.create("GV1", this, nodeInfo.state['GV1'], { uom: UnitOfMeasure.Boolean, label: "Battery Powered", name: "batteryPowered" });
+		this.drivers.ERR = Driver.create("ERR", this, nodeInfo.state['ERR'], { uom: UnitOfMeasure.Index, label: "Responding", name: "responding" });
 	}
 	async calibrateTemperature(value: number) { return this.sendCommand("CLITEMP", value); }
 	async query() { return this.sendCommand("QUERY"); }
@@ -65,13 +65,12 @@ NodeFactory.register(Pir2844Node, "PIR2844_ADV");
 export namespace Pir2844 {
 	export interface Interface extends Omit<InstanceType<typeof Pir2844Node>, keyof ISYDeviceNode<any, any, any, any>> {
-		nodeDefId: "PIR2844" | "PIR2844_ADV";
 	}
 	export function is(node: ISYNode<any, any, any, any>): node is Pir2844Node {
-		return ["PIR2844", "PIR2844_ADV"].includes(node.nodeDefId);
+		return ['PIR2844', "PIR2844_ADV"].includes(node.nodeDefId);
 	}
 	export function isImplementedBy(node: ISYNode<any, any, any, any>): node is Pir2844Node {
-		return ["PIR2844", "PIR2844_ADV"].includes(node.nodeDefId);
+		return ['PIR2844', "PIR2844_ADV"].includes(node.nodeDefId);
 	}
 	export function create(isy: ISY, nodeInfo: NodeInfo) {
 		return new Pir2844Node(isy, nodeInfo);

package/src/Devices/Insteon/Generated/Pir2844OnOff.ts CHANGED Viewed

@@ -17,7 +17,7 @@ const nodeDefId = "PIR2844OnOff";
 type Commands = Pir2844OnOff.Commands;
 type Drivers = Pir2844OnOff.Drivers;
-export class Pir2844OnOffNode extends Base<Drivers, Commands> implements Pir2844OnOff.Interface {
+class Pir2844OnOffNode extends Base<Drivers, Commands> implements Pir2844OnOff.Interface {
 	public override readonly commands = {
 		DON: this.on,
 		DOF: this.off,
@@ -26,12 +26,12 @@ export class Pir2844OnOffNode extends Base<Drivers, Commands> implements Pir2844
 		WDU: this.writeChanges
 	};
 	static override nodeDefId = "PIR2844OnOff";
-	static override implements = ["PIR2844OnOff"];
-	declare readonly nodeDefId: "PIR2844OnOff" | "PIR2844OnOff_ADV";
+	static override implements = ['PIR2844OnOff'];
+	declare readonly nodeDefId: 'PIR2844OnOff' | "PIR2844OnOff_ADV";
 	constructor (isy: ISY, nodeInfo: NodeInfo) {
 		super(isy, nodeInfo);
-		this.drivers.ST = Driver.create("ST", this, nodeInfo.property as DriverState, { uom: UnitOfMeasure.Percent, label: "Status", name: "status" });
-		this.drivers.ERR = Driver.create("ERR", this, nodeInfo.property as DriverState, { uom: UnitOfMeasure.Index, label: "Responding", name: "responding" });
+		this.drivers.ST = Driver.create("ST", this, nodeInfo.state['ST'], { uom: UnitOfMeasure.Percent, label: "Status", name: "status" });
+		this.drivers.ERR = Driver.create("ERR", this, nodeInfo.state['ERR'], { uom: UnitOfMeasure.Index, label: "Responding", name: "responding" });
 	}
 	async on(value?: (0 | 100)) { return this.sendCommand("DON", value); }
 	async off() { return this.sendCommand("DOF"); }
@@ -51,13 +51,12 @@ NodeFactory.register(Pir2844OnOffNode, "PIR2844OnOff_ADV");
 export namespace Pir2844OnOff {
 	export interface Interface extends Omit<InstanceType<typeof Pir2844OnOffNode>, keyof ISYDeviceNode<any, any, any, any>> {
-		nodeDefId: "PIR2844OnOff" | "PIR2844OnOff_ADV";
 	}
 	export function is(node: ISYNode<any, any, any, any>): node is Pir2844OnOffNode {
-		return ["PIR2844OnOff", "PIR2844OnOff_ADV"].includes(node.nodeDefId);
+		return ['PIR2844OnOff', "PIR2844OnOff_ADV"].includes(node.nodeDefId);
 	}
 	export function isImplementedBy(node: ISYNode<any, any, any, any>): node is Pir2844OnOffNode {
-		return ["PIR2844OnOff", "RelayLampSwitch", "RelayLampSwitch_ADV", "RelayLampSwitchLED", "RelayLampSwitchLED_ADV", "KeypadRelay", "KeypadRelay_ADV", "PIR2844OnOff_ADV"].includes(node.nodeDefId);
+		return ['PIR2844OnOff', "RelayLampSwitch", "RelayLampSwitch_ADV", "RelayLampSwitchLED", "RelayLampSwitchLED_ADV", "KeypadRelay", "KeypadRelay_ADV", "PIR2844OnOff_ADV"].includes(node.nodeDefId);
 	}
 	export function create(isy: ISY, nodeInfo: NodeInfo) {
 		return new Pir2844OnOffNode(isy, nodeInfo);

package/src/Devices/Insteon/Generated/Pir2844c.ts CHANGED Viewed

@@ -17,7 +17,7 @@ const nodeDefId = "PIR2844C";
 type Commands = Pir2844c.Commands;
 type Drivers = Pir2844c.Drivers;
-export class Pir2844cNode extends Base<Drivers, Commands> implements Pir2844c.Interface {
+class Pir2844cNode extends Base<Drivers, Commands> implements Pir2844c.Interface {
 	public override readonly commands = {
 		CLITEMP: this.calibrateTemperature,
 		QUERY: this.query,
@@ -25,16 +25,16 @@ export class Pir2844cNode extends Base<Drivers, Commands> implements Pir2844c.In
 		WDU: this.writeChanges
 	};
 	static override nodeDefId = "PIR2844C";
-	static override implements = ["PIR2844C"];
-	declare readonly nodeDefId: "PIR2844C" | "PIR2844C_ADV";
+	static override implements = ['PIR2844C'];
+	declare readonly nodeDefId: 'PIR2844C' | "PIR2844C_ADV";
 	constructor (isy: ISY, nodeInfo: NodeInfo) {
 		super(isy, nodeInfo);
-		this.drivers.ST = Driver.create("ST", this, nodeInfo.property as DriverState, { uom: UnitOfMeasure.Percent, label: "Status", name: "status" });
-		this.drivers.CLITEMP = Driver.create("CLITEMP", this, nodeInfo.property as DriverState, { uom: UnitOfMeasure.Celsius, label: "Temperature", name: "temperature" });
-		this.drivers.LUMIN = Driver.create("LUMIN", this, nodeInfo.property as DriverState, { uom: UnitOfMeasure.Percent, label: "Luminance", name: "luminance" });
-		this.drivers.BATLVL = Driver.create("BATLVL", this, nodeInfo.property as DriverState, { uom: UnitOfMeasure.Percent, label: "Battery Level", name: "batteryLevel" });
-		this.drivers.GV1 = Driver.create("GV1", this, nodeInfo.property as DriverState, { uom: UnitOfMeasure.Boolean, label: "Battery Powered", name: "batteryPowered" });
-		this.drivers.ERR = Driver.create("ERR", this, nodeInfo.property as DriverState, { uom: UnitOfMeasure.Index, label: "Responding", name: "responding" });
+		this.drivers.ST = Driver.create("ST", this, nodeInfo.state['ST'], { uom: UnitOfMeasure.Percent, label: "Status", name: "status" });
+		this.drivers.CLITEMP = Driver.create("CLITEMP", this, nodeInfo.state['CLITEMP'], { uom: UnitOfMeasure.Celsius, label: "Temperature", name: "temperature" });
+		this.drivers.LUMIN = Driver.create("LUMIN", this, nodeInfo.state['LUMIN'], { uom: UnitOfMeasure.Percent, label: "Luminance", name: "luminance" });
+		this.drivers.BATLVL = Driver.create("BATLVL", this, nodeInfo.state['BATLVL'], { uom: UnitOfMeasure.Percent, label: "Battery Level", name: "batteryLevel" });
+		this.drivers.GV1 = Driver.create("GV1", this, nodeInfo.state['GV1'], { uom: UnitOfMeasure.Boolean, label: "Battery Powered", name: "batteryPowered" });
+		this.drivers.ERR = Driver.create("ERR", this, nodeInfo.state['ERR'], { uom: UnitOfMeasure.Index, label: "Responding", name: "responding" });
 	}
 	async calibrateTemperature(value: number) { return this.sendCommand("CLITEMP", value); }
 	async query() { return this.sendCommand("QUERY"); }
@@ -65,13 +65,12 @@ NodeFactory.register(Pir2844cNode, "PIR2844C_ADV");
 export namespace Pir2844c {
 	export interface Interface extends Omit<InstanceType<typeof Pir2844cNode>, keyof ISYDeviceNode<any, any, any, any>> {
-		nodeDefId: "PIR2844C" | "PIR2844C_ADV";
 	}
 	export function is(node: ISYNode<any, any, any, any>): node is Pir2844cNode {
-		return ["PIR2844C", "PIR2844C_ADV"].includes(node.nodeDefId);
+		return ['PIR2844C', "PIR2844C_ADV"].includes(node.nodeDefId);
 	}
 	export function isImplementedBy(node: ISYNode<any, any, any, any>): node is Pir2844cNode {
-		return ["PIR2844C", "PIR2844", "PIR2844_ADV", "PIR2844C_ADV"].includes(node.nodeDefId);
+		return ['PIR2844C', "PIR2844", "PIR2844_ADV", "PIR2844C_ADV"].includes(node.nodeDefId);
 	}
 	export function create(isy: ISY, nodeInfo: NodeInfo) {
 		return new Pir2844cNode(isy, nodeInfo);

package/src/Devices/Insteon/Generated/RelayLamp.ts CHANGED Viewed

@@ -17,7 +17,7 @@ const nodeDefId = "RelayLampOnly";
 type Commands = RelayLamp.Commands;
 type Drivers = RelayLamp.Drivers;
-export class RelayLampNode extends Base<Drivers, Commands> implements RelayLamp.Interface {
+class RelayLampNode extends Base<Drivers, Commands> implements RelayLamp.Interface {
 	public override readonly commands = {
 		DON: this.on,
 		DOF: this.off,
@@ -28,12 +28,12 @@ export class RelayLampNode extends Base<Drivers, Commands> implements RelayLamp.
 		WDU: this.writeChanges
 	};
 	static override nodeDefId = "RelayLampOnly";
-	static override implements = ["RelayLampOnly", "IRLincTx", "EZRAIN_Output", "EZIO2x4_Output", "AlertModuleArmed", "SirenAlert", "SirenArm"];
-	declare readonly nodeDefId: "RelayLampOnly" | "RelayLampOnly_ADV";
+	static override implements = ['RelayLampOnly', "IRLincTx", "EZRAIN_Output", "EZIO2x4_Output", "AlertModuleArmed", "SirenAlert", "SirenArm"];
+	declare readonly nodeDefId: 'RelayLampOnly' | "RelayLampOnly_ADV";
 	constructor (isy: ISY, nodeInfo: NodeInfo) {
 		super(isy, nodeInfo);
-		this.drivers.ST = Driver.create("ST", this, nodeInfo.property as DriverState, { uom: UnitOfMeasure.Percent, label: "Status", name: "status" });
-		this.drivers.ERR = Driver.create("ERR", this, nodeInfo.property as DriverState, { uom: UnitOfMeasure.Index, label: "Responding", name: "responding" });
+		this.drivers.ST = Driver.create("ST", this, nodeInfo.state['ST'], { uom: UnitOfMeasure.Percent, label: "Status", name: "status" });
+		this.drivers.ERR = Driver.create("ERR", this, nodeInfo.state['ERR'], { uom: UnitOfMeasure.Index, label: "Responding", name: "responding" });
 	}
 	async on(value?: (0 | 100)) { return this.sendCommand("DON", value); }
 	async off() { return this.sendCommand("DOF"); }
@@ -55,13 +55,12 @@ NodeFactory.register(RelayLampNode, "RelayLampOnly_ADV");
 export namespace RelayLamp {
 	export interface Interface extends Omit<InstanceType<typeof RelayLampNode>, keyof ISYDeviceNode<any, any, any, any>> {
-		nodeDefId: "RelayLampOnly" | "RelayLampOnly_ADV";
 	}
 	export function is(node: ISYNode<any, any, any, any>): node is RelayLampNode {
-		return ["RelayLampOnly", "RelayLampOnly_ADV"].includes(node.nodeDefId);
+		return ['RelayLampOnly', "RelayLampOnly_ADV"].includes(node.nodeDefId);
 	}
 	export function isImplementedBy(node: ISYNode<any, any, any, any>): node is RelayLampNode {
-		return ["RelayLampOnly", "BallastRelayLampSwitch", "BallastRelayLampSwitch_ADV", "RelayLampSwitch", "RelayLampSwitch_ADV", "RelayLampSwitchLED", "RelayLampSwitchLED_ADV", "RelayLampOnly_ADV"].includes(node.nodeDefId);
+		return ['RelayLampOnly', "BallastRelayLampSwitch", "BallastRelayLampSwitch_ADV", "RelayLampSwitch", "RelayLampSwitch_ADV", "RelayLampSwitchLED", "RelayLampSwitchLED_ADV", "RelayLampOnly_ADV"].includes(node.nodeDefId);
 	}
 	export function create(isy: ISY, nodeInfo: NodeInfo) {
 		return new RelayLampNode(isy, nodeInfo);

package/src/Devices/Insteon/Generated/RelayLampSwitch.ts CHANGED Viewed

@@ -17,7 +17,7 @@ const nodeDefId = "RelayLampSwitch";
 type Commands = RelayLampSwitch.Commands;
 type Drivers = RelayLampSwitch.Drivers;
-export class RelayLampSwitchNode extends Base<Drivers, Commands> implements RelayLampSwitch.Interface {
+class RelayLampSwitchNode extends Base<Drivers, Commands> implements RelayLampSwitch.Interface {
 	public override readonly commands = {
 		DON: this.on,
 		DOF: this.off,
@@ -29,12 +29,12 @@ export class RelayLampSwitchNode extends Base<Drivers, Commands> implements Rela
 		WDU: this.writeChanges
 	};
 	static override nodeDefId = "RelayLampSwitch";
-	static override implements = ["RelayLampSwitch", "RelaySwitchOnlyPlusQuery", "RelaySwitchOnlyPlusQuery_ADV", "RelaySwitchOnly", "RelaySwitchOnly_ADV", "RelayLampOnly", "RelayLampOnly_ADV", "IRLincTx", "EZRAIN_Output", "EZIO2x4_Output", "EZIO2x4_Input", "EZIO2x4_Input_ADV", "DoorLock", "BinaryAlarm", "BinaryAlarm_ADV", "BinaryControl", "BinaryControl_ADV", "AlertModuleArmed", "SirenAlert", "SirenArm", "PIR2844OnOff", "PIR2844OnOff_ADV"];
-	declare readonly nodeDefId: "RelayLampSwitch" | "RelayLampSwitch_ADV";
+	static override implements = ['RelayLampSwitch', "RelaySwitchOnlyPlusQuery", "RelaySwitchOnlyPlusQuery_ADV", "RelaySwitchOnly", "RelaySwitchOnly_ADV", "RelayLampOnly", "RelayLampOnly_ADV", "IRLincTx", "EZRAIN_Output", "EZIO2x4_Output", "EZIO2x4_Input", "EZIO2x4_Input_ADV", "DoorLock", "BinaryAlarm", "BinaryAlarm_ADV", "BinaryControl", "BinaryControl_ADV", "AlertModuleArmed", "SirenAlert", "SirenArm", "PIR2844OnOff", "PIR2844OnOff_ADV"];
+	declare readonly nodeDefId: 'RelayLampSwitch' | "RelayLampSwitch_ADV";
 	constructor (isy: ISY, nodeInfo: NodeInfo) {
 		super(isy, nodeInfo);
-		this.drivers.ST = Driver.create("ST", this, nodeInfo.property as DriverState, { uom: UnitOfMeasure.Percent, label: "Status", name: "status" });
-		this.drivers.ERR = Driver.create("ERR", this, nodeInfo.property as DriverState, { uom: UnitOfMeasure.Index, label: "Responding", name: "responding" });
+		this.drivers.ST = Driver.create("ST", this, nodeInfo.state['ST'], { uom: UnitOfMeasure.Percent, label: "Status", name: "status" });
+		this.drivers.ERR = Driver.create("ERR", this, nodeInfo.state['ERR'], { uom: UnitOfMeasure.Index, label: "Responding", name: "responding" });
 	}
 	async on(value?: (0 | 100)) { return this.sendCommand("DON", value); }
 	async off() { return this.sendCommand("DOF"); }
@@ -57,13 +57,12 @@ NodeFactory.register(RelayLampSwitchNode, "RelayLampSwitch_ADV");
 export namespace RelayLampSwitch {
 	export interface Interface extends Omit<InstanceType<typeof RelayLampSwitchNode>, keyof ISYDeviceNode<any, any, any, any>> {
-		nodeDefId: "RelayLampSwitch" | "RelayLampSwitch_ADV";
 	}
 	export function is(node: ISYNode<any, any, any, any>): node is RelayLampSwitchNode {
-		return ["RelayLampSwitch", "RelayLampSwitch_ADV"].includes(node.nodeDefId);
+		return ['RelayLampSwitch', "RelayLampSwitch_ADV"].includes(node.nodeDefId);
 	}
 	export function isImplementedBy(node: ISYNode<any, any, any, any>): node is RelayLampSwitchNode {
-		return ["RelayLampSwitch", "RelayLampSwitch_ADV"].includes(node.nodeDefId);
+		return ['RelayLampSwitch', "RelayLampSwitch_ADV"].includes(node.nodeDefId);
 	}
 	export function create(isy: ISY, nodeInfo: NodeInfo) {
 		return new RelayLampSwitchNode(isy, nodeInfo);

package/src/Devices/Insteon/Generated/RelayLampSwitchLed.ts CHANGED Viewed

@@ -17,7 +17,7 @@ const nodeDefId = "RelayLampSwitchLED";
 type Commands = RelayLampSwitchLed.Commands;
 type Drivers = RelayLampSwitchLed.Drivers;
-export class RelayLampSwitchLedNode extends Base<Drivers, Commands> implements RelayLampSwitchLed.Interface {
+class RelayLampSwitchLedNode extends Base<Drivers, Commands> implements RelayLampSwitchLed.Interface {
 	public override readonly commands = {
 		DON: this.on,
 		DOF: this.off,
@@ -30,12 +30,12 @@ export class RelayLampSwitchLedNode extends Base<Drivers, Commands> implements R
 		WDU: this.writeChanges
 	};
 	static override nodeDefId = "RelayLampSwitchLED";
-	static override implements = ["RelayLampSwitchLED", "RelaySwitchOnlyPlusQuery", "RelaySwitchOnlyPlusQuery_ADV", "RelaySwitchOnly", "RelaySwitchOnly_ADV", "RelayLampOnly", "RelayLampOnly_ADV", "IRLincTx", "EZRAIN_Output", "EZIO2x4_Output", "EZIO2x4_Input", "EZIO2x4_Input_ADV", "DoorLock", "BinaryAlarm", "BinaryAlarm_ADV", "BinaryControl", "BinaryControl_ADV", "AlertModuleArmed", "SirenAlert", "SirenArm", "PIR2844OnOff", "PIR2844OnOff_ADV"];
-	declare readonly nodeDefId: "RelayLampSwitchLED" | "RelayLampSwitchLED_ADV";
+	static override implements = ['RelayLampSwitchLED', "RelaySwitchOnlyPlusQuery", "RelaySwitchOnlyPlusQuery_ADV", "RelaySwitchOnly", "RelaySwitchOnly_ADV", "RelayLampOnly", "RelayLampOnly_ADV", "IRLincTx", "EZRAIN_Output", "EZIO2x4_Output", "EZIO2x4_Input", "EZIO2x4_Input_ADV", "DoorLock", "BinaryAlarm", "BinaryAlarm_ADV", "BinaryControl", "BinaryControl_ADV", "AlertModuleArmed", "SirenAlert", "SirenArm", "PIR2844OnOff", "PIR2844OnOff_ADV"];
+	declare readonly nodeDefId: 'RelayLampSwitchLED' | "RelayLampSwitchLED_ADV";
 	constructor (isy: ISY, nodeInfo: NodeInfo) {
 		super(isy, nodeInfo);
-		this.drivers.ST = Driver.create("ST", this, nodeInfo.property as DriverState, { uom: UnitOfMeasure.Percent, label: "Status", name: "status" });
-		this.drivers.ERR = Driver.create("ERR", this, nodeInfo.property as DriverState, { uom: UnitOfMeasure.Index, label: "Responding", name: "responding" });
+		this.drivers.ST = Driver.create("ST", this, nodeInfo.state['ST'], { uom: UnitOfMeasure.Percent, label: "Status", name: "status" });
+		this.drivers.ERR = Driver.create("ERR", this, nodeInfo.state['ERR'], { uom: UnitOfMeasure.Index, label: "Responding", name: "responding" });
 	}
 	async on(value?: (0 | 100)) { return this.sendCommand("DON", value); }
 	async off() { return this.sendCommand("DOF"); }
@@ -59,13 +59,12 @@ NodeFactory.register(RelayLampSwitchLedNode, "RelayLampSwitchLED_ADV");
 export namespace RelayLampSwitchLed {
 	export interface Interface extends Omit<InstanceType<typeof RelayLampSwitchLedNode>, keyof ISYDeviceNode<any, any, any, any>> {
-		nodeDefId: "RelayLampSwitchLED" | "RelayLampSwitchLED_ADV";
 	}
 	export function is(node: ISYNode<any, any, any, any>): node is RelayLampSwitchLedNode {
-		return ["RelayLampSwitchLED", "RelayLampSwitchLED_ADV"].includes(node.nodeDefId);
+		return ['RelayLampSwitchLED', "RelayLampSwitchLED_ADV"].includes(node.nodeDefId);
 	}
 	export function isImplementedBy(node: ISYNode<any, any, any, any>): node is RelayLampSwitchLedNode {
-		return ["RelayLampSwitchLED", "RelayLampSwitchLED_ADV"].includes(node.nodeDefId);
+		return ['RelayLampSwitchLED', "RelayLampSwitchLED_ADV"].includes(node.nodeDefId);
 	}
 	export function create(isy: ISY, nodeInfo: NodeInfo) {
 		return new RelayLampSwitchLedNode(isy, nodeInfo);

package/src/Devices/Insteon/Generated/RelaySwitch.ts CHANGED Viewed

@@ -17,18 +17,18 @@ const nodeDefId = "RelaySwitchOnly";
 type Commands = RelaySwitch.Commands;
 type Drivers = RelaySwitch.Drivers;
-export class RelaySwitchNode extends Base<Drivers, Commands> implements RelaySwitch.Interface {
+class RelaySwitchNode extends Base<Drivers, Commands> implements RelaySwitch.Interface {
 	public override readonly commands = {
 		BEEP: this.beep,
 		BL: this.backlight,
 		WDU: this.writeChanges
 	};
 	static override nodeDefId = "RelaySwitchOnly";
-	static override implements = ["RelaySwitchOnly", "IRLincTx", "SirenAlert", "SirenArm"];
-	declare readonly nodeDefId: "RelaySwitchOnly" | "RelaySwitchOnly_ADV";
+	static override implements = ['RelaySwitchOnly', "IRLincTx", "SirenAlert", "SirenArm"];
+	declare readonly nodeDefId: 'RelaySwitchOnly' | "RelaySwitchOnly_ADV";
 	constructor (isy: ISY, nodeInfo: NodeInfo) {
 		super(isy, nodeInfo);
-		this.drivers.ERR = Driver.create("ERR", this, nodeInfo.property as DriverState, { uom: UnitOfMeasure.Index, label: "Responding", name: "responding" });
+		this.drivers.ERR = Driver.create("ERR", this, nodeInfo.state['ERR'], { uom: UnitOfMeasure.Index, label: "Responding", name: "responding" });
 	}
 	async beep(value?: number) { return this.sendCommand("BEEP", value); }
 	async backlight(value: number) { return this.sendCommand("BL", value); }
@@ -43,13 +43,12 @@ NodeFactory.register(RelaySwitchNode, "RelaySwitchOnly_ADV");
 export namespace RelaySwitch {
 	export interface Interface extends Omit<InstanceType<typeof RelaySwitchNode>, keyof ISYDeviceNode<any, any, any, any>> {
-		nodeDefId: "RelaySwitchOnly" | "RelaySwitchOnly_ADV";
 	}
 	export function is(node: ISYNode<any, any, any, any>): node is RelaySwitchNode {
-		return ["RelaySwitchOnly", "RelaySwitchOnly_ADV"].includes(node.nodeDefId);
+		return ['RelaySwitchOnly', "RelaySwitchOnly_ADV"].includes(node.nodeDefId);
 	}
 	export function isImplementedBy(node: ISYNode<any, any, any, any>): node is RelaySwitchNode {
-		return ["RelaySwitchOnly", "DimmerMotorSwitch", "DimmerMotorSwitch_ADV", "DimmerLampSwitch", "DimmerLampSwitch_ADV", "DimmerLampSwitchLED", "DimmerLampSwitchLED_ADV", "KeypadDimmer", "KeypadDimmer_ADV", "RelayLampSwitch", "RelayLampSwitch_ADV", "RelayLampSwitchLED", "RelayLampSwitchLED_ADV", "RelaySwitchOnlyPlusQuery", "RelaySwitchOnlyPlusQuery_ADV", "RelaySwitchOnly_ADV"].includes(node.nodeDefId);
+		return ['RelaySwitchOnly', "DimmerMotorSwitch", "DimmerMotorSwitch_ADV", "DimmerLampSwitch", "DimmerLampSwitch_ADV", "DimmerLampSwitchLED", "DimmerLampSwitchLED_ADV", "KeypadDimmer", "KeypadDimmer_ADV", "RelayLampSwitch", "RelayLampSwitch_ADV", "RelayLampSwitchLED", "RelayLampSwitchLED_ADV", "RelaySwitchOnlyPlusQuery", "RelaySwitchOnlyPlusQuery_ADV", "RelaySwitchOnly_ADV"].includes(node.nodeDefId);
 	}
 	export function create(isy: ISY, nodeInfo: NodeInfo) {
 		return new RelaySwitchNode(isy, nodeInfo);

package/src/Devices/Insteon/Generated/RelaySwitchOnlyPlusQuery.ts CHANGED Viewed

@@ -17,7 +17,7 @@ const nodeDefId = "RelaySwitchOnlyPlusQuery";
 type Commands = RelaySwitchOnlyPlusQuery.Commands;
 type Drivers = RelaySwitchOnlyPlusQuery.Drivers;
-export class RelaySwitchOnlyPlusQueryNode extends Base<Drivers, Commands> implements RelaySwitchOnlyPlusQuery.Interface {
+class RelaySwitchOnlyPlusQueryNode extends Base<Drivers, Commands> implements RelaySwitchOnlyPlusQuery.Interface {
 	public override readonly commands = {
 		QUERY: this.query,
 		BEEP: this.beep,
@@ -25,11 +25,11 @@ export class RelaySwitchOnlyPlusQueryNode extends Base<Drivers, Commands> implem
 		WDU: this.writeChanges
 	};
 	static override nodeDefId = "RelaySwitchOnlyPlusQuery";
-	static override implements = ["RelaySwitchOnlyPlusQuery", "RelaySwitchOnly", "RelaySwitchOnly_ADV", "IRLincTx", "SirenAlert", "SirenArm"];
-	declare readonly nodeDefId: "RelaySwitchOnlyPlusQuery" | "RelaySwitchOnlyPlusQuery_ADV";
+	static override implements = ['RelaySwitchOnlyPlusQuery', "RelaySwitchOnly", "RelaySwitchOnly_ADV", "IRLincTx", "SirenAlert", "SirenArm"];
+	declare readonly nodeDefId: 'RelaySwitchOnlyPlusQuery' | "RelaySwitchOnlyPlusQuery_ADV";
 	constructor (isy: ISY, nodeInfo: NodeInfo) {
 		super(isy, nodeInfo);
-		this.drivers.ERR = Driver.create("ERR", this, nodeInfo.property as DriverState, { uom: UnitOfMeasure.Index, label: "Responding", name: "responding" });
+		this.drivers.ERR = Driver.create("ERR", this, nodeInfo.state['ERR'], { uom: UnitOfMeasure.Index, label: "Responding", name: "responding" });
 	}
 	async query() { return this.sendCommand("QUERY"); }
 	async beep(value?: number) { return this.sendCommand("BEEP", value); }
@@ -45,13 +45,12 @@ NodeFactory.register(RelaySwitchOnlyPlusQueryNode, "RelaySwitchOnlyPlusQuery_ADV
 export namespace RelaySwitchOnlyPlusQuery {
 	export interface Interface extends Omit<InstanceType<typeof RelaySwitchOnlyPlusQueryNode>, keyof ISYDeviceNode<any, any, any, any>> {
-		nodeDefId: "RelaySwitchOnlyPlusQuery" | "RelaySwitchOnlyPlusQuery_ADV";
 	}
 	export function is(node: ISYNode<any, any, any, any>): node is RelaySwitchOnlyPlusQueryNode {
-		return ["RelaySwitchOnlyPlusQuery", "RelaySwitchOnlyPlusQuery_ADV"].includes(node.nodeDefId);
+		return ['RelaySwitchOnlyPlusQuery', "RelaySwitchOnlyPlusQuery_ADV"].includes(node.nodeDefId);
 	}
 	export function isImplementedBy(node: ISYNode<any, any, any, any>): node is RelaySwitchOnlyPlusQueryNode {
-		return ["RelaySwitchOnlyPlusQuery", "DimmerMotorSwitch", "DimmerMotorSwitch_ADV", "DimmerLampSwitch", "DimmerLampSwitch_ADV", "DimmerLampSwitchLED", "DimmerLampSwitchLED_ADV", "KeypadDimmer", "KeypadDimmer_ADV", "RelayLampSwitch", "RelayLampSwitch_ADV", "RelayLampSwitchLED", "RelayLampSwitchLED_ADV", "RelaySwitchOnlyPlusQuery_ADV"].includes(node.nodeDefId);
+		return ['RelaySwitchOnlyPlusQuery', "DimmerMotorSwitch", "DimmerMotorSwitch_ADV", "DimmerLampSwitch", "DimmerLampSwitch_ADV", "DimmerLampSwitchLED", "DimmerLampSwitchLED_ADV", "KeypadDimmer", "KeypadDimmer_ADV", "RelayLampSwitch", "RelayLampSwitch_ADV", "RelayLampSwitchLED", "RelayLampSwitchLED_ADV", "RelaySwitchOnlyPlusQuery_ADV"].includes(node.nodeDefId);
 	}
 	export function create(isy: ISY, nodeInfo: NodeInfo) {
 		return new RelaySwitchOnlyPlusQueryNode(isy, nodeInfo);

package/src/Devices/Insteon/Generated/RemoteLinc2.ts CHANGED Viewed

@@ -17,17 +17,17 @@ const nodeDefId = "RemoteLinc2";
 type Commands = RemoteLinc2.Commands;
 type Drivers = RemoteLinc2.Drivers;
-export class RemoteLinc2Node extends Base<Drivers, Commands> implements RemoteLinc2.Interface {
+class RemoteLinc2Node extends Base<Drivers, Commands> implements RemoteLinc2.Interface {
 	public override readonly commands = {
 		WDU: this.writeChanges
 	};
 	static override nodeDefId = "RemoteLinc2";
-	static override implements = ["RemoteLinc2", "SirenAlert", "SirenArm"];
-	declare readonly nodeDefId: "RemoteLinc2" | "RemoteLinc2_ADV";
+	static override implements = ['RemoteLinc2', "SirenAlert", "SirenArm"];
+	declare readonly nodeDefId: 'RemoteLinc2' | "RemoteLinc2_ADV";
 	constructor (isy: ISY, nodeInfo: NodeInfo) {
 		super(isy, nodeInfo);
-		this.drivers.ST = Driver.create("ST", this, nodeInfo.property as DriverState, { uom: UnitOfMeasure.Percent, label: "Status", name: "status" });
-		this.drivers.ERR = Driver.create("ERR", this, nodeInfo.property as DriverState, { uom: UnitOfMeasure.Index, label: "Responding", name: "responding" });
+		this.drivers.ST = Driver.create("ST", this, nodeInfo.state['ST'], { uom: UnitOfMeasure.Percent, label: "Status", name: "status" });
+		this.drivers.ERR = Driver.create("ERR", this, nodeInfo.state['ERR'], { uom: UnitOfMeasure.Index, label: "Responding", name: "responding" });
 	}
 	async writeChanges() { return this.sendCommand("WDU"); }
 	public get status(): number {
@@ -43,13 +43,12 @@ NodeFactory.register(RemoteLinc2Node, "RemoteLinc2_ADV");
 export namespace RemoteLinc2 {
 	export interface Interface extends Omit<InstanceType<typeof RemoteLinc2Node>, keyof ISYDeviceNode<any, any, any, any>> {
-		nodeDefId: "RemoteLinc2" | "RemoteLinc2_ADV";
 	}
 	export function is(node: ISYNode<any, any, any, any>): node is RemoteLinc2Node {
-		return ["RemoteLinc2", "RemoteLinc2_ADV"].includes(node.nodeDefId);
+		return ['RemoteLinc2', "RemoteLinc2_ADV"].includes(node.nodeDefId);
 	}
 	export function isImplementedBy(node: ISYNode<any, any, any, any>): node is RemoteLinc2Node {
-		return ["RemoteLinc2", "DimmerMotorSwitch", "DimmerMotorSwitch_ADV", "DimmerLampSwitch", "DimmerLampSwitch_ADV", "DimmerLampSwitchLED", "DimmerLampSwitchLED_ADV", "KeypadDimmer", "KeypadDimmer_ADV", "RemoteLinc2_ADV"].includes(node.nodeDefId);
+		return ['RemoteLinc2', "DimmerMotorSwitch", "DimmerMotorSwitch_ADV", "DimmerLampSwitch", "DimmerLampSwitch_ADV", "DimmerLampSwitchLED", "DimmerLampSwitchLED_ADV", "KeypadDimmer", "KeypadDimmer_ADV", "RemoteLinc2_ADV"].includes(node.nodeDefId);
 	}
 	export function create(isy: ISY, nodeInfo: NodeInfo) {
 		return new RemoteLinc2Node(isy, nodeInfo);