isy-nodejs 1.0.2-alpha.4 → 1.0.3-alpha.0

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

@@ -32,7 +32,7 @@ export class KeypadButtonNode extends Base<Drivers, Commands> implements KeypadB
 		this.drivers.ERR = Driver.create("ERR", this, nodeInfo.property as DriverState, { uom: UnitOfMeasure.Index, label: "Responding", name: "responding" });
 	}
 	async query() { return this.sendCommand("QUERY"); }
-	async backlight(value: Insteon.Backlight) { return this.sendCommand("BL", { value: value }); }
+	async backlight(value: Insteon.Backlight) { return this.sendCommand("BL", value); }
 	async writeChanges() { return this.sendCommand("WDU"); }
 	public get status(): Insteon.OnLevelRelay {
 		return this.drivers.ST?.value;
@@ -49,7 +49,9 @@ 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); }
+	export function is(node: ISYNode<any, any, any, any>): node is KeypadButtonNode {
+		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);
 	}

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

@@ -36,7 +36,7 @@ export class KeypadDimmerNode extends Base<Drivers, Commands> implements KeypadD
 		WDU: this.writeChanges
 	};
 	static override nodeDefId = "KeypadDimmer";
-	static override implements = ["KeypadDimmer", "RemoteLinc2", "RemoteLinc2_ADV", "IRLincTx", "SirenAlert", "SirenArm"];
+	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);
@@ -45,7 +45,7 @@ export class KeypadDimmerNode extends Base<Drivers, Commands> implements KeypadD
 		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" });
 	}
-	async on(value?: number) { return this.sendCommand("DON", { value: value }); }
+	async on(value?: number) { return this.sendCommand("DON", value); }
 	async off() { return this.sendCommand("DOF"); }
 	async fastOff() { return this.sendCommand("DFOF"); }
 	async fastOn() { return this.sendCommand("DFON"); }
@@ -55,10 +55,10 @@ export class KeypadDimmerNode extends Base<Drivers, Commands> implements KeypadD
 	async fadeDown() { return this.sendCommand("FDDOWN"); }
 	async fadeStop() { return this.sendCommand("FDSTOP"); }
 	async query() { return this.sendCommand("QUERY"); }
-	async beep(value?: number) { return this.sendCommand("BEEP", { value: value }); }
-	async updateOnLevel(value: number) { return this.sendCommand("OL", { value: value }); }
-	async updateRampRate(value: Insteon.RampRate) { return this.sendCommand("RR", { value: value }); }
-	async backlight(value: Insteon.Backlight) { return this.sendCommand("BL", { value: value }); }
+	async beep(value?: number) { return this.sendCommand("BEEP", value); }
+	async updateOnLevel(value: number) { return this.sendCommand("OL", value); }
+	async updateRampRate(value: Insteon.RampRate) { return this.sendCommand("RR", value); }
+	async backlight(value: Insteon.Backlight) { return this.sendCommand("BL", value); }
 	async writeChanges() { return this.sendCommand("WDU"); }
 	public get status(): number {
 		return this.drivers.ST?.value;
@@ -81,7 +81,9 @@ 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); }
+	export function is(node: ISYNode<any, any, any, any>): node is KeypadDimmerNode {
+		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);
 	}

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

@@ -1,5 +1,5 @@
-/* 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";
@@ -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";
-
+
 const nodeDefId = "KeypadRelay";
-
+
 type Commands = KeypadRelay.Commands;
 type Drivers = KeypadRelay.Drivers;
-
+
 export class KeypadRelayNode extends Base<Drivers, Commands> implements KeypadRelay.Interface {
 	public override readonly commands = {
 		DON: this.on,
@@ -33,33 +33,35 @@ export class KeypadRelayNode extends Base<Drivers, Commands> implements KeypadRe
 	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.Boolean, label: "Status", name: "status" });
+		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 on(value?: (0 | 100)) { return this.sendCommand("DON", 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 beep(value?: number) { return this.sendCommand("BEEP", value); }
+	async backlight(value: Insteon.Backlight) { return this.sendCommand("BL", value); }
 	async writeChanges() { return this.sendCommand("WDU"); }
-	public get status(): number {
+	public get status(): Insteon.OnLevelRelay {
 		return this.drivers.ST?.value;
 	}
 	public get responding(): Insteon.Error {
 		return this.drivers.ERR?.value;
 	}
 }
-
+
 NodeFactory.register(KeypadRelayNode);
 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); }
+	export function is(node: ISYNode<any, any, any, any>): node is KeypadRelayNode {
+		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);
 	}
@@ -92,7 +94,7 @@ export namespace KeypadRelay {
 			label: "Beep";
 			name: "beep";
 		};
-		BL: ((value: number) => Promise<boolean>) & {
+		BL: ((value: Insteon.Backlight) => Promise<boolean>) & {
 			label: "Backlight";
 			name: "backlight";
 		};
@@ -103,8 +105,8 @@ export namespace KeypadRelay {
 	};
 	export type Drivers = {
 		ST: {
-			uom: UnitOfMeasure.Boolean;
-			value: number;
+			uom: UnitOfMeasure.Percent;
+			value: Insteon.OnLevelRelay;
 			label: "Status";
 			name: "status";
 		};

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

@@ -24,10 +24,10 @@ export class OnOffControlNode extends Base<Drivers, Commands> implements OnOffCo
 	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.Boolean, label: "Status", name: "status" });
+		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" });
 	}
-	public get status(): Insteon.OnLevelRelay | Insteon.OnLevelRelay {
+	public get status(): Insteon.OnLevelRelay {
 		return this.drivers.ST?.value;
 	}
 	public get responding(): Insteon.Error {
@@ -42,7 +42,9 @@ 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); }
+	export function is(node: ISYNode<any, any, any, any>): node is OnOffControlNode {
+		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);
 	}
@@ -53,8 +55,8 @@ export namespace OnOffControl {
 	export type Commands = {};
 	export type Drivers = {
 		ST: {
-			uom: UnitOfMeasure.Boolean | UnitOfMeasure.Percent;
-			value: Insteon.OnLevelRelay | Insteon.OnLevelRelay;
+			uom: UnitOfMeasure.Percent;
+			value: Insteon.OnLevelRelay;
 			label: "Status";
 			name: "status";
 		};

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

@@ -25,7 +25,7 @@ export class Pir2844Node extends Base<Drivers, Commands> implements Pir2844.Inte
 		WDU: this.writeChanges
 	};
 	static override nodeDefId = "PIR2844";
-	static override implements = ["PIR2844"];
+	static override implements = ["PIR2844", "PIR2844C", "PIR2844C_ADV"];
 	declare readonly nodeDefId: "PIR2844" | "PIR2844_ADV";
 	constructor (isy: ISY, nodeInfo: NodeInfo) {
 		super(isy, nodeInfo);
@@ -36,9 +36,9 @@ 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 calibrateTemperature(value: number) { return this.sendCommand("CLITEMP", value); }
 	async query() { return this.sendCommand("QUERY"); }
-	async beep(value?: number) { return this.sendCommand("BEEP", { value: value }); }
+	async beep(value?: number) { return this.sendCommand("BEEP", value); }
 	async writeChanges() { return this.sendCommand("WDU"); }
 	public get status(): Insteon.OnLevelRelay {
 		return this.drivers.ST?.value;
@@ -67,7 +67,9 @@ 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); }
+	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);
 	}

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

@@ -33,10 +33,10 @@ export class Pir2844OnOffNode extends Base<Drivers, Commands> implements Pir2844
 		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 on(value?: (0 | 100)) { return this.sendCommand("DON", value); }
 	async off() { return this.sendCommand("DOF"); }
 	async query() { return this.sendCommand("QUERY"); }
-	async beep(value?: number) { return this.sendCommand("BEEP", { value: value }); }
+	async beep(value?: number) { return this.sendCommand("BEEP", value); }
 	async writeChanges() { return this.sendCommand("WDU"); }
 	public get status(): Insteon.OnLevelRelay {
 		return this.drivers.ST?.value;
@@ -53,7 +53,9 @@ 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); }
+	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);
 	}

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

@@ -36,9 +36,9 @@ 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 calibrateTemperature(value: number) { return this.sendCommand("CLITEMP", value); }
 	async query() { return this.sendCommand("QUERY"); }
-	async beep(value?: number) { return this.sendCommand("BEEP", { value: value }); }
+	async beep(value?: number) { return this.sendCommand("BEEP", value); }
 	async writeChanges() { return this.sendCommand("WDU"); }
 	public get status(): Insteon.OnLevelRelay {
 		return this.drivers.ST?.value;
@@ -67,10 +67,12 @@ 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); }
-	export function isImplementedBy(node: ISYNode<any, any, any, any>): node is Pir2844cNode {
+	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", "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

@@ -32,17 +32,17 @@ export class RelayLampNode extends Base<Drivers, Commands> implements RelayLamp.
 	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.Boolean, label: "Status", name: "status" });
+		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 on(value?: (0 | 100)) { return this.sendCommand("DON", 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 beep(value?: number) { return this.sendCommand("BEEP", value); }
 	async writeChanges() { return this.sendCommand("WDU"); }
-	public get status(): Insteon.OnLevelRelay | Insteon.OnLevelRelay {
+	public get status(): Insteon.OnLevelRelay {
 		return this.drivers.ST?.value;
 	}
 	public get responding(): Insteon.Error {
@@ -57,7 +57,9 @@ 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); }
+	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);
 	}
@@ -97,8 +99,8 @@ export namespace RelayLamp {
 	};
 	export type Drivers = {
 		ST: {
-			uom: UnitOfMeasure.Boolean | UnitOfMeasure.Percent;
-			value: Insteon.OnLevelRelay | Insteon.OnLevelRelay;
+			uom: UnitOfMeasure.Percent;
+			value: Insteon.OnLevelRelay;
 			label: "Status";
 			name: "status";
 		};

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

@@ -33,18 +33,18 @@ export class RelayLampSwitchNode extends Base<Drivers, Commands> implements Rela
 	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.Boolean, label: "Status", name: "status" });
+		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 on(value?: (0 | 100)) { return this.sendCommand("DON", 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 beep(value?: number) { return this.sendCommand("BEEP", value); }
+	async backlight(value: number) { return this.sendCommand("BL", value); }
 	async writeChanges() { return this.sendCommand("WDU"); }
-	public get status(): Insteon.OnLevelRelay | Insteon.OnLevelRelay {
+	public get status(): Insteon.OnLevelRelay {
 		return this.drivers.ST?.value;
 	}
 	public get responding(): Insteon.Error {
@@ -59,7 +59,9 @@ 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); }
+	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);
 	}
@@ -103,8 +105,8 @@ export namespace RelayLampSwitch {
 	};
 	export type Drivers = {
 		ST: {
-			uom: UnitOfMeasure.Boolean | UnitOfMeasure.Percent;
-			value: Insteon.OnLevelRelay | Insteon.OnLevelRelay;
+			uom: UnitOfMeasure.Percent;
+			value: Insteon.OnLevelRelay;
 			label: "Status";
 			name: "status";
 		};

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

@@ -34,19 +34,19 @@ export class RelayLampSwitchLedNode extends Base<Drivers, Commands> implements R
 	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.Boolean, label: "Status", name: "status" });
+		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 on(value?: (0 | 100)) { return this.sendCommand("DON", 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 beep(value?: number) { return this.sendCommand("BEEP", value); }
+	async led(value: Insteon.I3RgbLed) { return this.sendCommand("LED", value); }
+	async backlight(value: number) { return this.sendCommand("BL", value); }
 	async writeChanges() { return this.sendCommand("WDU"); }
-	public get status(): Insteon.OnLevelRelay | Insteon.OnLevelRelay {
+	public get status(): Insteon.OnLevelRelay {
 		return this.drivers.ST?.value;
 	}
 	public get responding(): Insteon.Error {
@@ -61,7 +61,9 @@ 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); }
+	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);
 	}
@@ -94,7 +96,7 @@ export namespace RelayLampSwitchLed {
 			label: "Beep";
 			name: "beep";
 		};
-		LED: ((value: number) => Promise<boolean>) & {
+		LED: ((value: Insteon.I3RgbLed) => Promise<boolean>) & {
 			label: "LED";
 			name: "led";
 		};
@@ -109,8 +111,8 @@ export namespace RelayLampSwitchLed {
 	};
 	export type Drivers = {
 		ST: {
-			uom: UnitOfMeasure.Boolean | UnitOfMeasure.Percent;
-			value: Insteon.OnLevelRelay | Insteon.OnLevelRelay;
+			uom: UnitOfMeasure.Percent;
+			value: Insteon.OnLevelRelay;
 			label: "Status";
 			name: "status";
 		};

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

@@ -30,8 +30,8 @@ export class RelaySwitchNode extends Base<Drivers, Commands> implements RelaySwi
 		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 beep(value?: number) { return this.sendCommand("BEEP", value); }
+	async backlight(value: number) { return this.sendCommand("BL", value); }
 	async writeChanges() { return this.sendCommand("WDU"); }
 	public get responding(): Insteon.Error {
 		return this.drivers.ERR?.value;
@@ -45,9 +45,11 @@ 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); }
+	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);
+		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

@@ -32,8 +32,8 @@ export class RelaySwitchOnlyPlusQueryNode extends Base<Drivers, Commands> implem
 		this.drivers.ERR = Driver.create("ERR", this, nodeInfo.property as DriverState, { uom: UnitOfMeasure.Index, label: "Responding", name: "responding" });
 	}
 	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 beep(value?: number) { return this.sendCommand("BEEP", value); }
+	async backlight(value: number) { return this.sendCommand("BL", value); }
 	async writeChanges() { return this.sendCommand("WDU"); }
 	public get responding(): Insteon.Error {
 		return this.drivers.ERR?.value;
@@ -47,9 +47,11 @@ 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); }
+	export function is(node: ISYNode<any, any, any, any>): node is RelaySwitchOnlyPlusQueryNode {
+		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", "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

@@ -45,7 +45,9 @@ 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); }
+	export function is(node: ISYNode<any, any, any, any>): node is RemoteLinc2Node {
+		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);
 	}

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

@@ -40,10 +40,10 @@ export class SirenNode extends Base<Drivers, Commands> implements Siren.Interfac
 	}
 	async on(duration?: number) { return this.sendCommand("DON", { DUR: duration }); }
 	async off() { return this.sendCommand("DOF"); }
-	async arm(value: Insteon.SirenMode) { return this.sendCommand("ARM", { value: value }); }
+	async arm(value: Insteon.SirenMode) { return this.sendCommand("ARM", value); }
 	async disarm() { return this.sendCommand("DISARM"); }
 	async query() { return this.sendCommand("QUERY"); }
-	async beep(value?: number) { return this.sendCommand("BEEP", { value: value }); }
+	async beep(value?: number) { return this.sendCommand("BEEP", value); }
 	async writeChanges() { return this.sendCommand("WDU"); }
 	public get siren(): Insteon.OnLevelRelay {
 		return this.drivers.ST?.value;
@@ -69,7 +69,9 @@ export namespace Siren {
 	export interface Interface extends Omit<InstanceType<typeof SirenNode>, keyof ISYDeviceNode<any, any, any, any>> {
 		nodeDefId: "Siren" | "Siren_ADV";
 	}
-	export function is(node: ISYNode<any, any, any, any>): node is SirenNode { return ["Siren", "Siren_ADV"].includes(node.nodeDefId); }
+	export function is(node: ISYNode<any, any, any, any>): node is SirenNode {
+		return ["Siren", "Siren_ADV"].includes(node.nodeDefId);
+	}
 	export function isImplementedBy(node: ISYNode<any, any, any, any>): node is SirenNode {
 		return ["Siren", "Siren_ADV"].includes(node.nodeDefId);
 	}

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

@@ -38,7 +38,9 @@ export namespace SirenAlert {
 	export interface Interface extends Omit<InstanceType<typeof SirenAlertNode>, keyof ISYDeviceNode<any, any, any, any>> {
 		nodeDefId: "SirenAlert" | "SirenArm";
 	}
-	export function is(node: ISYNode<any, any, any, any>): node is SirenAlertNode { return ["SirenAlert", "SirenArm"].includes(node.nodeDefId); }
+	export function is(node: ISYNode<any, any, any, any>): node is SirenAlertNode {
+		return ["SirenAlert", "SirenArm"].includes(node.nodeDefId);
+	}
 	export function isImplementedBy(node: ISYNode<any, any, any, any>): node is SirenAlertNode {
 		return ["SirenAlert", "X10", "Thermostat", "TempLinc", "OnOffControl", "OnOffControl_ADV", "DimmerMotorSwitch", "DimmerMotorSwitch_ADV", "DimmerLampSwitch", "DimmerLampSwitch_ADV", "DimmerLampSwitchLED", "DimmerLampSwitchLED_ADV", "DimmerSwitchOnly", "DimmerSwitchOnly_ADV", "DimmerLampOnly", "KeypadDimmer", "KeypadDimmer_ADV", "BallastRelayLampSwitch", "BallastRelayLampSwitch_ADV", "RelayLampSwitch", "RelayLampSwitch_ADV", "RelayLampSwitchLED", "RelayLampSwitchLED_ADV", "RelaySwitchOnlyPlusQuery", "RelaySwitchOnlyPlusQuery_ADV", "RelaySwitchOnly", "RelaySwitchOnly_ADV", "RelayLampOnly", "RelayLampOnly_ADV", "KeypadRelay", "KeypadRelay_ADV", "RemoteLinc2", "RemoteLinc2_ADV", "IRLincTx", "FanLincMotor", "KeypadButton", "KeypadButton_ADV", "EZRAIN_Output", "EZRAIN_Input", "EZRAIN_Input_ADV", "EZIO2x4_Output", "EZIO2x4_Input", "EZIO2x4_Input_ADV", "IMETER_SOLO", "DoorLock", "BinaryAlarm", "BinaryAlarm_ADV", "BinaryControl", "BinaryControl_ADV", "AlertModuleSiren", "AlertModuleSiren_ADV", "AlertModuleArmed", "Siren", "Siren_ADV", "SirenArm", "PIR2844_ADV", "PIR2844C_ADV", "PIR2844OnOff_ADV"].includes(node.nodeDefId);
 	}

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

@@ -44,13 +44,13 @@ export class TempLincNode extends Base<Drivers, Commands> implements TempLinc.In
 		this.drivers.CLIHCS = Driver.create("CLIHCS", this, nodeInfo.property as DriverState, { uom: UnitOfMeasure.ThermostatHeatCoolState, label: "Heat/Cool State", name: "heatCoolState" });
 		this.drivers.ERR = Driver.create("ERR", this, nodeInfo.property as DriverState, { uom: UnitOfMeasure.Index, label: "Responding", name: "responding" });
 	}
-	async updateHeatSetpoint(value: number) { return this.sendCommand("CLISPH", { value: value }); }
-	async updateCoolSetpoint(value: number) { return this.sendCommand("CLISPC", { value: value }); }
-	async updateMode(value: (0 | 1 | 2 | 3 | 5)) { return this.sendCommand("CLIMD", { value: value }); }
-	async updateFanMode(value: (7 | 8)) { return this.sendCommand("CLIFS", { value: value }); }
+	async updateHeatSetpoint(value: number) { return this.sendCommand("CLISPH", value); }
+	async updateCoolSetpoint(value: number) { return this.sendCommand("CLISPC", value); }
+	async updateMode(value: (0 | 1 | 2 | 3 | 5)) { return this.sendCommand("CLIMD", value); }
+	async updateFanMode(value: (7 | 8)) { return this.sendCommand("CLIFS", value); }
 	async setpointUp() { return this.sendCommand("BRT"); }
 	async setpointDown() { return this.sendCommand("DIM"); }
-	async beep(value?: number) { return this.sendCommand("BEEP", { value: value }); }
+	async beep(value?: number) { return this.sendCommand("BEEP", value); }
 	async query() { return this.sendCommand("QUERY"); }
 	async setTime() { return this.sendCommand("SETTIME"); }
 	async writeChanges() { return this.sendCommand("WDU"); }
@@ -86,7 +86,9 @@ export namespace TempLinc {
 	export interface Interface extends Omit<InstanceType<typeof TempLincNode>, keyof ISYDeviceNode<any, any, any, any>> {
 		nodeDefId: "TempLinc";
 	}
-	export function is(node: ISYNode<any, any, any, any>): node is TempLincNode { return ["TempLinc"].includes(node.nodeDefId); }
+	export function is(node: ISYNode<any, any, any, any>): node is TempLincNode {
+		return ["TempLinc"].includes(node.nodeDefId);
+	}
 	export function isImplementedBy(node: ISYNode<any, any, any, any>): node is TempLincNode {
 		return ["TempLinc", "Thermostat"].includes(node.nodeDefId);
 	}

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

@@ -44,13 +44,13 @@ export class ThermostatNode extends Base<Drivers, Commands> implements Thermosta
 		this.drivers.CLIHCS = Driver.create("CLIHCS", this, nodeInfo.property as DriverState, { uom: UnitOfMeasure.ThermostatHeatCoolState, label: "Heat/Cool State", name: "heatCoolState" });
 		this.drivers.ERR = Driver.create("ERR", this, nodeInfo.property as DriverState, { uom: UnitOfMeasure.Index, label: "Responding", name: "responding" });
 	}
-	async updateHeatSetpoint(value: number) { return this.sendCommand("CLISPH", { value: value }); }
-	async updateCoolSetpoint(value: number) { return this.sendCommand("CLISPC", { value: value }); }
-	async updateMode(value: (0 | 1 | 2 | 3 | 5 | 6 | 7)) { return this.sendCommand("CLIMD", { value: value }); }
-	async updateFanMode(value: (7 | 8)) { return this.sendCommand("CLIFS", { value: value }); }
+	async updateHeatSetpoint(value: number) { return this.sendCommand("CLISPH", value); }
+	async updateCoolSetpoint(value: number) { return this.sendCommand("CLISPC", value); }
+	async updateMode(value: (0 | 1 | 2 | 3 | 5 | 6 | 7)) { return this.sendCommand("CLIMD", value); }
+	async updateFanMode(value: (7 | 8)) { return this.sendCommand("CLIFS", value); }
 	async setpointUp() { return this.sendCommand("BRT"); }
 	async setpointDown() { return this.sendCommand("DIM"); }
-	async beep(value?: number) { return this.sendCommand("BEEP", { value: value }); }
+	async beep(value?: number) { return this.sendCommand("BEEP", value); }
 	async query() { return this.sendCommand("QUERY"); }
 	async setTime() { return this.sendCommand("SETTIME"); }
 	async writeChanges() { return this.sendCommand("WDU"); }
@@ -86,7 +86,9 @@ export namespace Thermostat {
 	export interface Interface extends Omit<InstanceType<typeof ThermostatNode>, keyof ISYDeviceNode<any, any, any, any>> {
 		nodeDefId: "Thermostat";
 	}
-	export function is(node: ISYNode<any, any, any, any>): node is ThermostatNode { return ["Thermostat"].includes(node.nodeDefId); }
+	export function is(node: ISYNode<any, any, any, any>): node is ThermostatNode {
+		return ["Thermostat"].includes(node.nodeDefId);
+	}
 	export function isImplementedBy(node: ISYNode<any, any, any, any>): node is ThermostatNode {
 		return ["Thermostat"].includes(node.nodeDefId);
 	}

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

@@ -52,7 +52,9 @@ export namespace X10 {
 	export interface Interface extends Omit<InstanceType<typeof X10Node>, keyof ISYDeviceNode<any, any, any, any>> {
 		nodeDefId: "X10";
 	}
-	export function is(node: ISYNode<any, any, any, any>): node is X10Node { return ["X10"].includes(node.nodeDefId); }
+	export function is(node: ISYNode<any, any, any, any>): node is X10Node {
+		return ["X10"].includes(node.nodeDefId);
+	}
 	export function isImplementedBy(node: ISYNode<any, any, any, any>): node is X10Node {
 		return ["X10"].includes(node.nodeDefId);
 	}