isy-nodejs 1.0.2-alpha.3 → 1.0.2-alpha.4

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

@@ -3,7 +3,7 @@
 import { UnitOfMeasure } from "../../../Definitions/Global/UOM.js";
 import { Family } from "../../../Definitions/Global/Families.js";
 import type { NodeInfo } from "../../../Model/NodeInfo.js";
-import type { ISY } from "../../../ISY.js";
+import { ISY } from "../../../ISY.js";
 import type { ISYNode } from "../../../ISYNode.js";
 import { Base } from "../index.js";
 import { ISYDeviceNode } from "../../ISYDeviceNode.js";
@@ -12,20 +12,21 @@ import { Insteon } from "../../../Definitions/index.js";
 import type { DriverState } from "../../../Model/DriverState.js";
 import { NodeFactory } from "../../NodeFactory.js";
 
-export const nodeDefId = "PIR2844";
+const nodeDefId = "PIR2844";
 
 type Commands = Pir2844.Commands;
 type Drivers = Pir2844.Drivers;
 
 export class Pir2844Node extends Base<Drivers, Commands> implements Pir2844.Interface {
-	public readonly commands = {
+	public override readonly commands = {
 		CLITEMP: this.calibrateTemperature,
 		QUERY: this.query,
 		BEEP: this.beep,
 		WDU: this.writeChanges
 	};
-	static nodeDefId = "PIR2844";
-	declare readonly nodeDefId: "PIR2844";
+	static override nodeDefId = "PIR2844";
+	static override implements = ["PIR2844"];
+	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" });
@@ -35,18 +36,10 @@ export class Pir2844Node extends Base<Drivers, Commands> implements Pir2844.Inte
 		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" });
 	}
-	async calibrateTemperature(value: number) {
-		return this.sendCommand("CLITEMP", { value: value });
-	}
-	async query() {
-		return this.sendCommand("QUERY");
-	}
-	async beep(value?: number) {
-		return this.sendCommand("BEEP", { value: value });
-	}
-	async writeChanges() {
-		return this.sendCommand("WDU");
-	}
+	async calibrateTemperature(value: number) { return this.sendCommand("CLITEMP", { value: value }); }
+	async query() { return this.sendCommand("QUERY"); }
+	async beep(value?: number) { return this.sendCommand("BEEP", { value: value }); }
+	async writeChanges() { return this.sendCommand("WDU"); }
 	public get status(): Insteon.OnLevelRelay {
 		return this.drivers.ST?.value;
 	}
@@ -68,13 +61,15 @@ export class Pir2844Node extends Base<Drivers, Commands> implements Pir2844.Inte
 }
 
 NodeFactory.register(Pir2844Node);
+NodeFactory.register(Pir2844Node, "PIR2844_ADV");
 
 export namespace Pir2844 {
 	export interface Interface extends Omit<InstanceType<typeof Pir2844Node>, keyof ISYDeviceNode<any, any, any, any>> {
-		nodeDefId: "PIR2844";
+		nodeDefId: "PIR2844" | "PIR2844_ADV";
 	}
-	export function is(node: ISYNode<any, any, any, any>): node is Pir2844Node {
-		return node.nodeDefId === nodeDefId;
+	export function is(node: ISYNode<any, any, any, any>): node is Pir2844Node { 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);
 	}
 	export function create(isy: ISY, nodeInfo: NodeInfo) {
 		return new Pir2844Node(isy, nodeInfo);

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

@@ -3,7 +3,7 @@
 import { UnitOfMeasure } from "../../../Definitions/Global/UOM.js";
 import { Family } from "../../../Definitions/Global/Families.js";
 import type { NodeInfo } from "../../../Model/NodeInfo.js";
-import type { ISY } from "../../../ISY.js";
+import { ISY } from "../../../ISY.js";
 import type { ISYNode } from "../../../ISYNode.js";
 import { Base } from "../index.js";
 import { ISYDeviceNode } from "../../ISYDeviceNode.js";
@@ -12,41 +12,32 @@ import { Insteon } from "../../../Definitions/index.js";
 import type { DriverState } from "../../../Model/DriverState.js";
 import { NodeFactory } from "../../NodeFactory.js";
 
-export const nodeDefId = "PIR2844OnOff";
+const nodeDefId = "PIR2844OnOff";
 
 type Commands = Pir2844OnOff.Commands;
 type Drivers = Pir2844OnOff.Drivers;
 
 export class Pir2844OnOffNode extends Base<Drivers, Commands> implements Pir2844OnOff.Interface {
-	public readonly commands = {
+	public override readonly commands = {
 		DON: this.on,
 		DOF: this.off,
 		QUERY: this.query,
 		BEEP: this.beep,
 		WDU: this.writeChanges
 	};
-	static nodeDefId = "PIR2844OnOff";
-	declare readonly nodeDefId: "PIR2844OnOff";
+	static override nodeDefId = "PIR2844OnOff";
+	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" });
 	}
-	async on(value?: (0 | 100)) {
-		return this.sendCommand("DON", { value: value });
-	}
-	async off() {
-		return this.sendCommand("DOF");
-	}
-	async query() {
-		return this.sendCommand("QUERY");
-	}
-	async beep(value?: number) {
-		return this.sendCommand("BEEP", { value: value });
-	}
-	async writeChanges() {
-		return this.sendCommand("WDU");
-	}
+	async on(value?: (0 | 100)) { return this.sendCommand("DON", { value: value }); }
+	async off() { return this.sendCommand("DOF"); }
+	async query() { return this.sendCommand("QUERY"); }
+	async beep(value?: number) { return this.sendCommand("BEEP", { value: value }); }
+	async writeChanges() { return this.sendCommand("WDU"); }
 	public get status(): Insteon.OnLevelRelay {
 		return this.drivers.ST?.value;
 	}
@@ -56,13 +47,15 @@ export class Pir2844OnOffNode extends Base<Drivers, Commands> implements Pir2844
 }
 
 NodeFactory.register(Pir2844OnOffNode);
+NodeFactory.register(Pir2844OnOffNode, "PIR2844OnOff_ADV");
 
 export namespace Pir2844OnOff {
 	export interface Interface extends Omit<InstanceType<typeof Pir2844OnOffNode>, keyof ISYDeviceNode<any, any, any, any>> {
-		nodeDefId: "PIR2844OnOff";
+		nodeDefId: "PIR2844OnOff" | "PIR2844OnOff_ADV";
 	}
-	export function is(node: ISYNode<any, any, any, any>): node is Pir2844OnOffNode {
-		return node.nodeDefId === nodeDefId;
+	export function is(node: ISYNode<any, any, any, any>): node is Pir2844OnOffNode { 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);
 	}
 	export function create(isy: ISY, nodeInfo: NodeInfo) {
 		return new Pir2844OnOffNode(isy, nodeInfo);

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

@@ -3,7 +3,7 @@
 import { UnitOfMeasure } from "../../../Definitions/Global/UOM.js";
 import { Family } from "../../../Definitions/Global/Families.js";
 import type { NodeInfo } from "../../../Model/NodeInfo.js";
-import type { ISY } from "../../../ISY.js";
+import { ISY } from "../../../ISY.js";
 import type { ISYNode } from "../../../ISYNode.js";
 import { Base } from "../index.js";
 import { ISYDeviceNode } from "../../ISYDeviceNode.js";
@@ -12,20 +12,21 @@ import { Insteon } from "../../../Definitions/index.js";
 import type { DriverState } from "../../../Model/DriverState.js";
 import { NodeFactory } from "../../NodeFactory.js";
 
-export const nodeDefId = "PIR2844C";
+const nodeDefId = "PIR2844C";
 
 type Commands = Pir2844c.Commands;
 type Drivers = Pir2844c.Drivers;
 
 export class Pir2844cNode extends Base<Drivers, Commands> implements Pir2844c.Interface {
-	public readonly commands = {
+	public override readonly commands = {
 		CLITEMP: this.calibrateTemperature,
 		QUERY: this.query,
 		BEEP: this.beep,
 		WDU: this.writeChanges
 	};
-	static nodeDefId = "PIR2844C";
-	declare readonly nodeDefId: "PIR2844C";
+	static override nodeDefId = "PIR2844C";
+	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" });
@@ -35,18 +36,10 @@ export class Pir2844cNode extends Base<Drivers, Commands> implements Pir2844c.In
 		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" });
 	}
-	async calibrateTemperature(value: number) {
-		return this.sendCommand("CLITEMP", { value: value });
-	}
-	async query() {
-		return this.sendCommand("QUERY");
-	}
-	async beep(value?: number) {
-		return this.sendCommand("BEEP", { value: value });
-	}
-	async writeChanges() {
-		return this.sendCommand("WDU");
-	}
+	async calibrateTemperature(value: number) { return this.sendCommand("CLITEMP", { value: value }); }
+	async query() { return this.sendCommand("QUERY"); }
+	async beep(value?: number) { return this.sendCommand("BEEP", { value: value }); }
+	async writeChanges() { return this.sendCommand("WDU"); }
 	public get status(): Insteon.OnLevelRelay {
 		return this.drivers.ST?.value;
 	}
@@ -68,13 +61,15 @@ export class Pir2844cNode extends Base<Drivers, Commands> implements Pir2844c.In
 }
 
 NodeFactory.register(Pir2844cNode);
+NodeFactory.register(Pir2844cNode, "PIR2844C_ADV");
 
 export namespace Pir2844c {
 	export interface Interface extends Omit<InstanceType<typeof Pir2844cNode>, keyof ISYDeviceNode<any, any, any, any>> {
-		nodeDefId: "PIR2844C";
+		nodeDefId: "PIR2844C" | "PIR2844C_ADV";
 	}
-	export function is(node: ISYNode<any, any, any, any>): node is Pir2844cNode {
-		return node.nodeDefId === nodeDefId;
+	export function is(node: ISYNode<any, any, any, any>): node is Pir2844cNode { return ["PIR2844C", "PIR2844C_ADV"].includes(node.nodeDefId); }
+	export function isImplementedBy(node: ISYNode<any, any, any, any>): node is Pir2844cNode {
+		return ["PIR2844C", "PIR2844C_ADV"].includes(node.nodeDefId);
 	}
 	export function create(isy: ISY, nodeInfo: NodeInfo) {
 		return new Pir2844cNode(isy, nodeInfo);

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

@@ -1,9 +1,9 @@
-/* THIS FILE WAS AUTOMATICALLY GENERATED. DO NOT EDIT DIRECTLY. */
-
+/* THIS FILE WAS AUTOMATICALLY GENERATED. DO NOT EDIT DIRECTLY. */
+
 import { UnitOfMeasure } from "../../../Definitions/Global/UOM.js";
 import { Family } from "../../../Definitions/Global/Families.js";
 import type { NodeInfo } from "../../../Model/NodeInfo.js";
-import type { ISY } from "../../../ISY.js";
+import { ISY } from "../../../ISY.js";
 import type { ISYNode } from "../../../ISYNode.js";
 import { Base } from "../index.js";
 import { ISYDeviceNode } from "../../ISYDeviceNode.js";
@@ -11,14 +11,14 @@ import { Driver } from "../../../Definitions/Global/Drivers.js";
 import { Insteon } from "../../../Definitions/index.js";
 import type { DriverState } from "../../../Model/DriverState.js";
 import { NodeFactory } from "../../NodeFactory.js";
-
-export const nodeDefId = "RelayLampOnly";
-
+
+const nodeDefId = "RelayLampOnly";
+
 type Commands = RelayLamp.Commands;
 type Drivers = RelayLamp.Drivers;
-
+
 export class RelayLampNode extends Base<Drivers, Commands> implements RelayLamp.Interface {
-	public readonly commands = {
+	public override readonly commands = {
 		DON: this.on,
 		DOF: this.off,
 		DFOF: this.fastOff,
@@ -27,51 +27,39 @@ export class RelayLampNode extends Base<Drivers, Commands> implements RelayLamp.
 		BEEP: this.beep,
 		WDU: this.writeChanges
 	};
-	static nodeDefId = "RelayLampOnly";
-	declare readonly nodeDefId: "RelayLampOnly";
+	static override nodeDefId = "RelayLampOnly";
+	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.ST = Driver.create("ST", this, nodeInfo.property as DriverState, { uom: UnitOfMeasure.Boolean, label: "Status", name: "status" });
 		this.drivers.ERR = Driver.create("ERR", this, nodeInfo.property as DriverState, { uom: UnitOfMeasure.Index, label: "Responding", name: "responding" });
-		
 	}
-	async on(value?: (0 | 100)) {
-		return this.sendCommand("DON", { value: value });
-	}
-	async off() {
-		return this.sendCommand("DOF");
-	}
-	async fastOff() {
-		return this.sendCommand("DFOF");
-	}
-	async fastOn() {
-		return this.sendCommand("DFON");
-	}
-	async query() {
-		return this.sendCommand("QUERY");
-	}
-	async beep(value?: number) {
-		return this.sendCommand("BEEP", { value: value });
-	}
-	async writeChanges() {
-		return this.sendCommand("WDU");
-	}
-	public get status(): Insteon.OnLevelRelay {
+	async on(value?: (0 | 100)) { return this.sendCommand("DON", { value: value }); }
+	async off() { return this.sendCommand("DOF"); }
+	async fastOff() { return this.sendCommand("DFOF"); }
+	async fastOn() { return this.sendCommand("DFON"); }
+	async query() { return this.sendCommand("QUERY"); }
+	async beep(value?: number) { return this.sendCommand("BEEP", { value: value }); }
+	async writeChanges() { return this.sendCommand("WDU"); }
+	public get status(): Insteon.OnLevelRelay | Insteon.OnLevelRelay {
 		return this.drivers.ST?.value;
 	}
 	public get responding(): Insteon.Error {
 		return this.drivers.ERR?.value;
 	}
 }
-
+
 NodeFactory.register(RelayLampNode);
-
+NodeFactory.register(RelayLampNode, "RelayLampOnly_ADV");
+
 export namespace RelayLamp {
 	export interface Interface extends Omit<InstanceType<typeof RelayLampNode>, keyof ISYDeviceNode<any, any, any, any>> {
-		nodeDefId: "RelayLampOnly";
+		nodeDefId: "RelayLampOnly" | "RelayLampOnly_ADV";
 	}
-	export function is(node: ISYNode<any, any, any, any>): node is RelayLampNode {
-		return node.nodeDefId === nodeDefId;
+	export function is(node: ISYNode<any, any, any, any>): node is RelayLampNode { 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);
 	}
 	export function create(isy: ISY, nodeInfo: NodeInfo) {
 		return new RelayLampNode(isy, nodeInfo);
@@ -109,8 +97,8 @@ export namespace RelayLamp {
 	};
 	export type Drivers = {
 		ST: {
-			uom: UnitOfMeasure.Percent;
-			value: Insteon.OnLevelRelay;
+			uom: UnitOfMeasure.Boolean | UnitOfMeasure.Percent;
+			value: Insteon.OnLevelRelay | Insteon.OnLevelRelay;
 			label: "Status";
 			name: "status";
 		};

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

@@ -1,9 +1,9 @@
-/* THIS FILE WAS AUTOMATICALLY GENERATED. DO NOT EDIT DIRECTLY. */
-
+/* THIS FILE WAS AUTOMATICALLY GENERATED. DO NOT EDIT DIRECTLY. */
+
 import { UnitOfMeasure } from "../../../Definitions/Global/UOM.js";
 import { Family } from "../../../Definitions/Global/Families.js";
 import type { NodeInfo } from "../../../Model/NodeInfo.js";
-import type { ISY } from "../../../ISY.js";
+import { ISY } from "../../../ISY.js";
 import type { ISYNode } from "../../../ISYNode.js";
 import { Base } from "../index.js";
 import { ISYDeviceNode } from "../../ISYDeviceNode.js";
@@ -11,12 +11,12 @@ import { Driver } from "../../../Definitions/Global/Drivers.js";
 import { Insteon } from "../../../Definitions/index.js";
 import type { DriverState } from "../../../Model/DriverState.js";
 import { NodeFactory } from "../../NodeFactory.js";
-
-export const nodeDefId = "RelayLampSwitch";
-
+
+const nodeDefId = "RelayLampSwitch";
+
 type Commands = RelayLampSwitch.Commands;
 type Drivers = RelayLampSwitch.Drivers;
-
+
 export class RelayLampSwitchNode extends Base<Drivers, Commands> implements RelayLampSwitch.Interface {
 	public override readonly commands = {
 		DON: this.on,
@@ -28,53 +28,40 @@ export class RelayLampSwitchNode extends Base<Drivers, Commands> implements Rela
 		BL: this.backlight,
 		WDU: this.writeChanges
 	};
-    static override nodeDefId = "RelayLampSwitch";
-	declare readonly nodeDefId: "RelayLampSwitch";
+	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";
 	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.ST = Driver.create("ST", this, nodeInfo.property as DriverState, { uom: UnitOfMeasure.Boolean, label: "Status", name: "status" });
 		this.drivers.ERR = Driver.create("ERR", this, nodeInfo.property as DriverState, { uom: UnitOfMeasure.Index, label: "Responding", name: "responding" });
 	}
-	async on(value?: (0 | 100)) {
-		return this.sendCommand("DON", { value: value });
-	}
-	async off() {
-		return this.sendCommand("DOF");
-	}
-	async fastOff() {
-		return this.sendCommand("DFOF");
-	}
-	async fastOn() {
-		return this.sendCommand("DFON");
-	}
-	async query() {
-		return this.sendCommand("QUERY");
-	}
-	async beep(value?: number) {
-		return this.sendCommand("BEEP", { value: value });
-	}
-	async backlight(value: number) {
-		return this.sendCommand("BL", { value: value });
-	}
-	async writeChanges() {
-		return this.sendCommand("WDU");
-	}
-	public get status(): Insteon.OnLevelRelay {
+	async on(value?: (0 | 100)) { return this.sendCommand("DON", { value: value }); }
+	async off() { return this.sendCommand("DOF"); }
+	async fastOff() { return this.sendCommand("DFOF"); }
+	async fastOn() { return this.sendCommand("DFON"); }
+	async query() { return this.sendCommand("QUERY"); }
+	async beep(value?: number) { return this.sendCommand("BEEP", { value: value }); }
+	async backlight(value: number) { return this.sendCommand("BL", { value: value }); }
+	async writeChanges() { return this.sendCommand("WDU"); }
+	public get status(): Insteon.OnLevelRelay | Insteon.OnLevelRelay {
 		return this.drivers.ST?.value;
 	}
 	public get responding(): Insteon.Error {
 		return this.drivers.ERR?.value;
 	}
 }
-
+
 NodeFactory.register(RelayLampSwitchNode);
-
+NodeFactory.register(RelayLampSwitchNode, "RelayLampSwitch_ADV");
+
 export namespace RelayLampSwitch {
 	export interface Interface extends Omit<InstanceType<typeof RelayLampSwitchNode>, keyof ISYDeviceNode<any, any, any, any>> {
-		nodeDefId: "RelayLampSwitch";
+		nodeDefId: "RelayLampSwitch" | "RelayLampSwitch_ADV";
 	}
-	export function is(node: ISYNode<any, any, any, any>): node is RelayLampSwitchNode {
-		return node.nodeDefId === nodeDefId;
+	export function is(node: ISYNode<any, any, any, any>): node is RelayLampSwitchNode { 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);
 	}
 	export function create(isy: ISY, nodeInfo: NodeInfo) {
 		return new RelayLampSwitchNode(isy, nodeInfo);
@@ -116,8 +103,8 @@ export namespace RelayLampSwitch {
 	};
 	export type Drivers = {
 		ST: {
-			uom: UnitOfMeasure.Percent;
-			value: Insteon.OnLevelRelay;
+			uom: UnitOfMeasure.Boolean | UnitOfMeasure.Percent;
+			value: Insteon.OnLevelRelay | Insteon.OnLevelRelay;
 			label: "Status";
 			name: "status";
 		};

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

@@ -3,7 +3,7 @@
 import { UnitOfMeasure } from "../../../Definitions/Global/UOM.js";
 import { Family } from "../../../Definitions/Global/Families.js";
 import type { NodeInfo } from "../../../Model/NodeInfo.js";
-import type { ISY } from "../../../ISY.js";
+import { ISY } from "../../../ISY.js";
 import type { ISYNode } from "../../../ISYNode.js";
 import { Base } from "../index.js";
 import { ISYDeviceNode } from "../../ISYDeviceNode.js";
@@ -12,13 +12,13 @@ import { Insteon } from "../../../Definitions/index.js";
 import type { DriverState } from "../../../Model/DriverState.js";
 import { NodeFactory } from "../../NodeFactory.js";
 
-export const nodeDefId = "RelayLampSwitchLED";
+const nodeDefId = "RelayLampSwitchLED";
 
 type Commands = RelayLampSwitchLed.Commands;
 type Drivers = RelayLampSwitchLed.Drivers;
 
 export class RelayLampSwitchLedNode extends Base<Drivers, Commands> implements RelayLampSwitchLed.Interface {
-	public readonly commands = {
+	public override readonly commands = {
 		DON: this.on,
 		DOF: this.off,
 		DFOF: this.fastOff,
@@ -29,41 +29,24 @@ export class RelayLampSwitchLedNode extends Base<Drivers, Commands> implements R
 		BL: this.backlight,
 		WDU: this.writeChanges
 	};
-	static nodeDefId = "RelayLampSwitchLED";
-	declare readonly nodeDefId: "RelayLampSwitchLED";
+	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";
 	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.ST = Driver.create("ST", this, nodeInfo.property as DriverState, { uom: UnitOfMeasure.Boolean, label: "Status", name: "status" });
 		this.drivers.ERR = Driver.create("ERR", this, nodeInfo.property as DriverState, { uom: UnitOfMeasure.Index, label: "Responding", name: "responding" });
 	}
-	async on(value?: (0 | 100)) {
-		return this.sendCommand("DON", { value: value });
-	}
-	async off() {
-		return this.sendCommand("DOF");
-	}
-	async fastOff() {
-		return this.sendCommand("DFOF");
-	}
-	async fastOn() {
-		return this.sendCommand("DFON");
-	}
-	async query() {
-		return this.sendCommand("QUERY");
-	}
-	async beep(value?: number) {
-		return this.sendCommand("BEEP", { value: value });
-	}
-	async led(value: number) {
-		return this.sendCommand("LED", { value: value });
-	}
-	async backlight(value: number) {
-		return this.sendCommand("BL", { value: value });
-	}
-	async writeChanges() {
-		return this.sendCommand("WDU");
-	}
-	public get status(): Insteon.OnLevelRelay {
+	async on(value?: (0 | 100)) { return this.sendCommand("DON", { value: value }); }
+	async off() { return this.sendCommand("DOF"); }
+	async fastOff() { return this.sendCommand("DFOF"); }
+	async fastOn() { return this.sendCommand("DFON"); }
+	async query() { return this.sendCommand("QUERY"); }
+	async beep(value?: number) { return this.sendCommand("BEEP", { value: value }); }
+	async led(value: number) { return this.sendCommand("LED", { value: value }); }
+	async backlight(value: number) { return this.sendCommand("BL", { value: value }); }
+	async writeChanges() { return this.sendCommand("WDU"); }
+	public get status(): Insteon.OnLevelRelay | Insteon.OnLevelRelay {
 		return this.drivers.ST?.value;
 	}
 	public get responding(): Insteon.Error {
@@ -72,13 +55,15 @@ export class RelayLampSwitchLedNode extends Base<Drivers, Commands> implements R
 }
 
 NodeFactory.register(RelayLampSwitchLedNode);
+NodeFactory.register(RelayLampSwitchLedNode, "RelayLampSwitchLED_ADV");
 
 export namespace RelayLampSwitchLed {
 	export interface Interface extends Omit<InstanceType<typeof RelayLampSwitchLedNode>, keyof ISYDeviceNode<any, any, any, any>> {
-		nodeDefId: "RelayLampSwitchLED";
+		nodeDefId: "RelayLampSwitchLED" | "RelayLampSwitchLED_ADV";
 	}
-	export function is(node: ISYNode<any, any, any, any>): node is RelayLampSwitchLedNode {
-		return node.nodeDefId === nodeDefId;
+	export function is(node: ISYNode<any, any, any, any>): node is RelayLampSwitchLedNode { 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);
 	}
 	export function create(isy: ISY, nodeInfo: NodeInfo) {
 		return new RelayLampSwitchLedNode(isy, nodeInfo);
@@ -124,8 +109,8 @@ export namespace RelayLampSwitchLed {
 	};
 	export type Drivers = {
 		ST: {
-			uom: UnitOfMeasure.Percent;
-			value: Insteon.OnLevelRelay;
+			uom: UnitOfMeasure.Boolean | UnitOfMeasure.Percent;
+			value: Insteon.OnLevelRelay | Insteon.OnLevelRelay;
 			label: "Status";
 			name: "status";
 		};

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

@@ -3,7 +3,7 @@
 import { UnitOfMeasure } from "../../../Definitions/Global/UOM.js";
 import { Family } from "../../../Definitions/Global/Families.js";
 import type { NodeInfo } from "../../../Model/NodeInfo.js";
-import type { ISY } from "../../../ISY.js";
+import { ISY } from "../../../ISY.js";
 import type { ISYNode } from "../../../ISYNode.js";
 import { Base } from "../index.js";
 import { ISYDeviceNode } from "../../ISYDeviceNode.js";
@@ -12,45 +12,42 @@ import { Insteon } from "../../../Definitions/index.js";
 import type { DriverState } from "../../../Model/DriverState.js";
 import { NodeFactory } from "../../NodeFactory.js";
 
-export const nodeDefId = "RelaySwitchOnly";
+const nodeDefId = "RelaySwitchOnly";
 
 type Commands = RelaySwitch.Commands;
 type Drivers = RelaySwitch.Drivers;
 
 export class RelaySwitchNode extends Base<Drivers, Commands> implements RelaySwitch.Interface {
-	public readonly commands = {
+	public override readonly commands = {
 		BEEP: this.beep,
 		BL: this.backlight,
 		WDU: this.writeChanges
 	};
-	static nodeDefId = "RelaySwitchOnly";
-	declare readonly nodeDefId: "RelaySwitchOnly";
+	static override nodeDefId = "RelaySwitchOnly";
+	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" });
 	}
-	async beep(value?: number) {
-		return this.sendCommand("BEEP", { value: value });
-	}
-	async backlight(value: number) {
-		return this.sendCommand("BL", { value: value });
-	}
-	async writeChanges() {
-		return this.sendCommand("WDU");
-	}
+	async beep(value?: number) { return this.sendCommand("BEEP", { value: value }); }
+	async backlight(value: number) { return this.sendCommand("BL", { value: value }); }
+	async writeChanges() { return this.sendCommand("WDU"); }
 	public get responding(): Insteon.Error {
 		return this.drivers.ERR?.value;
 	}
 }
 
 NodeFactory.register(RelaySwitchNode);
+NodeFactory.register(RelaySwitchNode, "RelaySwitchOnly_ADV");
 
 export namespace RelaySwitch {
 	export interface Interface extends Omit<InstanceType<typeof RelaySwitchNode>, keyof ISYDeviceNode<any, any, any, any>> {
-		nodeDefId: "RelaySwitchOnly";
+		nodeDefId: "RelaySwitchOnly" | "RelaySwitchOnly_ADV";
 	}
-	export function is(node: ISYNode<any, any, any, any>): node is RelaySwitchNode {
-		return node.nodeDefId === nodeDefId;
+	export function is(node: ISYNode<any, any, any, any>): node is RelaySwitchNode { 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", "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);