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

package/src/Converters.ts

@@ -15,20 +15,20 @@ const StandardConverters = {
 			from: (value: number) => value > 0
 		},
 		Percent: {
-			to: (value: number): boolean => {
-				return value > 0;
-			},
-			from: (value: boolean): number => {
-				return value ? 100 : 0;
-			}
+			to: (value: boolean) => (value ? 100 : 0),
+			from: (value: number) => value > 0
 		}
 	},
 	LevelFrom0To255: {
 		Percent: {
 			to: (value: number): number => {
+				if(value === 0) return 0;
+				if(value === 255) return 100;
 				return Math.round((value * 100) / 255);
 			},
 			from: (value: number): number => {
+				if(value === 0) return 0;
+				if(value === 100) return 255;
 				return Math.round((value * 255) / 100);
 			}
 		}
@@ -79,11 +79,11 @@ export namespace Converter {
 	export const Matter = {
 		LevelFrom0To255: {
 			LightingLevel: {
-				from: (value) =>
+				from: (value: number) =>
 					value === 1 ? 0
 					: value === 254 ? 255
 					: value,
-				to: (value) =>
+				to: (value: number) =>
 					value === 0 ? 1
 					: value === 255 ? 254
 					: value
@@ -92,15 +92,21 @@ export namespace Converter {
 		},
 		Percent: {
 			LightingLevel: {
-				from: (value) =>
+				from: (value: number) =>
 					value === 1 ? 0
 					: value === 254 ? 100
 					: Math.round(value / 254 * 100),
-				to: (value) =>
+				to: (value: number) =>
 					value === 0 ? 1
 					: value === 100 ? 254
 					: Math.round(value / 100 * 254)
 			}
+		},
+		Boolean: {
+			LightingLevel: {
+				from: (value: number) => value > 0,
+				to: (value: any) => value ? 254 : 0
+			}
 		}
 	};
 

package/src/Devices/Brultech/Generated/Channel.ts

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

package/src/Devices/Brultech/Generated/Main.ts

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

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

@@ -36,7 +36,7 @@ export class AlertModuleArmedNode extends Base<Drivers, Commands> implements Ale
 	async on() { return this.sendCommand("DON"); }
 	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;
@@ -52,7 +52,9 @@ export namespace AlertModuleArmed {
 	export interface Interface extends Omit<InstanceType<typeof AlertModuleArmedNode>, keyof ISYDeviceNode<any, any, any, any>> {
 		nodeDefId: "AlertModuleArmed";
 	}
-	export function is(node: ISYNode<any, any, any, any>): node is AlertModuleArmedNode { return ["AlertModuleArmed"].includes(node.nodeDefId); }
+	export function is(node: ISYNode<any, any, any, any>): node is AlertModuleArmedNode {
+		return ["AlertModuleArmed"].includes(node.nodeDefId);
+	}
 	export function isImplementedBy(node: ISYNode<any, any, any, any>): node is AlertModuleArmedNode {
 		return ["AlertModuleArmed", "BallastRelayLampSwitch", "BallastRelayLampSwitch_ADV", "RelayLampSwitch", "RelayLampSwitch_ADV", "RelayLampSwitchLED", "RelayLampSwitchLED_ADV", "RelayLampOnly", "RelayLampOnly_ADV", "KeypadRelay", "KeypadRelay_ADV", "FanLincMotor", "EZRAIN_Output", "AlertModuleSiren", "AlertModuleSiren_ADV"].includes(node.nodeDefId);
 	}

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

@@ -40,7 +40,7 @@ export class AlertModuleSirenNode extends Base<Drivers, Commands> implements Ale
 	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 {
 		return this.drivers.ST?.value;
@@ -57,7 +57,9 @@ export namespace AlertModuleSiren {
 	export interface Interface extends Omit<InstanceType<typeof AlertModuleSirenNode>, keyof ISYDeviceNode<any, any, any, any>> {
 		nodeDefId: "AlertModuleSiren" | "AlertModuleSiren_ADV";
 	}
-	export function is(node: ISYNode<any, any, any, any>): node is AlertModuleSirenNode { return ["AlertModuleSiren", "AlertModuleSiren_ADV"].includes(node.nodeDefId); }
+	export function is(node: ISYNode<any, any, any, any>): node is AlertModuleSirenNode {
+		return ["AlertModuleSiren", "AlertModuleSiren_ADV"].includes(node.nodeDefId);
+	}
 	export function isImplementedBy(node: ISYNode<any, any, any, any>): node is AlertModuleSirenNode {
 		return ["AlertModuleSiren", "AlertModuleSiren_ADV"].includes(node.nodeDefId);
 	}

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

@@ -35,12 +35,12 @@ export class BallastRelayLampSwitchNode extends Base<Drivers, Commands> implemen
 		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.Sml {
 		return this.drivers.ST?.value;
@@ -57,7 +57,9 @@ export namespace BallastRelayLampSwitch {
 	export interface Interface extends Omit<InstanceType<typeof BallastRelayLampSwitchNode>, keyof ISYDeviceNode<any, any, any, any>> {
 		nodeDefId: "BallastRelayLampSwitch" | "BallastRelayLampSwitch_ADV";
 	}
-	export function is(node: ISYNode<any, any, any, any>): node is BallastRelayLampSwitchNode { return ["BallastRelayLampSwitch", "BallastRelayLampSwitch_ADV"].includes(node.nodeDefId); }
+	export function is(node: ISYNode<any, any, any, any>): node is BallastRelayLampSwitchNode {
+		return ["BallastRelayLampSwitch", "BallastRelayLampSwitch_ADV"].includes(node.nodeDefId);
+	}
 	export function isImplementedBy(node: ISYNode<any, any, any, any>): node is BallastRelayLampSwitchNode {
 		return ["BallastRelayLampSwitch", "BallastRelayLampSwitch_ADV"].includes(node.nodeDefId);
 	}

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

@@ -32,7 +32,7 @@ export class BinaryAlarmNode extends Base<Drivers, Commands> implements BinaryAl
 		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 beep(value?: number) { return this.sendCommand("BEEP", value); }
 	async writeChanges() { return this.sendCommand("WDU"); }
 	public get status(): Insteon.OnLevelRelay {
 		return this.drivers.ST?.value;
@@ -49,7 +49,9 @@ export namespace BinaryAlarm {
 	export interface Interface extends Omit<InstanceType<typeof BinaryAlarmNode>, keyof ISYDeviceNode<any, any, any, any>> {
 		nodeDefId: "BinaryAlarm" | "BinaryAlarm_ADV";
 	}
-	export function is(node: ISYNode<any, any, any, any>): node is BinaryAlarmNode { return ["BinaryAlarm", "BinaryAlarm_ADV"].includes(node.nodeDefId); }
+	export function is(node: ISYNode<any, any, any, any>): node is BinaryAlarmNode {
+		return ["BinaryAlarm", "BinaryAlarm_ADV"].includes(node.nodeDefId);
+	}
 	export function isImplementedBy(node: ISYNode<any, any, any, any>): node is BinaryAlarmNode {
 		return ["BinaryAlarm", "BallastRelayLampSwitch", "BallastRelayLampSwitch_ADV", "RelayLampSwitch", "RelayLampSwitch_ADV", "RelayLampSwitchLED", "RelayLampSwitchLED_ADV", "KeypadRelay", "KeypadRelay_ADV", "BinaryAlarm_ADV"].includes(node.nodeDefId);
 	}

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

@@ -32,7 +32,7 @@ export class BinaryControlNode extends Base<Drivers, Commands> implements Binary
 		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 beep(value?: number) { return this.sendCommand("BEEP", value); }
 	async writeChanges() { return this.sendCommand("WDU"); }
 	public get status(): Insteon.OnLevelRelay {
 		return this.drivers.ST?.value;
@@ -49,7 +49,9 @@ export namespace BinaryControl {
 	export interface Interface extends Omit<InstanceType<typeof BinaryControlNode>, keyof ISYDeviceNode<any, any, any, any>> {
 		nodeDefId: "BinaryControl" | "BinaryControl_ADV";
 	}
-	export function is(node: ISYNode<any, any, any, any>): node is BinaryControlNode { return ["BinaryControl", "BinaryControl_ADV"].includes(node.nodeDefId); }
+	export function is(node: ISYNode<any, any, any, any>): node is BinaryControlNode {
+		return ["BinaryControl", "BinaryControl_ADV"].includes(node.nodeDefId);
+	}
 	export function isImplementedBy(node: ISYNode<any, any, any, any>): node is BinaryControlNode {
 		return ["BinaryControl", "BallastRelayLampSwitch", "BallastRelayLampSwitch_ADV", "RelayLampSwitch", "RelayLampSwitch_ADV", "RelayLampSwitchLED", "RelayLampSwitchLED_ADV", "KeypadRelay", "KeypadRelay_ADV", "BinaryAlarm", "BinaryAlarm_ADV", "BinaryControl_ADV"].includes(node.nodeDefId);
 	}

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

@@ -44,7 +44,7 @@ export class DimmerLampNode extends Base<Drivers, Commands> implements DimmerLam
 		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"); }
@@ -54,9 +54,9 @@ export class DimmerLampNode extends Base<Drivers, Commands> implements DimmerLam
 	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 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 writeChanges() { return this.sendCommand("WDU"); }
 	public get status(): number {
 		return this.drivers.ST?.value;
@@ -78,7 +78,9 @@ export namespace DimmerLamp {
 	export interface Interface extends Omit<InstanceType<typeof DimmerLampNode>, keyof ISYDeviceNode<any, any, any, any>> {
 		nodeDefId: "DimmerLampOnly";
 	}
-	export function is(node: ISYNode<any, any, any, any>): node is DimmerLampNode { return ["DimmerLampOnly"].includes(node.nodeDefId); }
+	export function is(node: ISYNode<any, any, any, any>): node is DimmerLampNode {
+		return ["DimmerLampOnly"].includes(node.nodeDefId);
+	}
 	export function isImplementedBy(node: ISYNode<any, any, any, any>): node is DimmerLampNode {
 		return ["DimmerLampOnly", "DimmerLampSwitch", "DimmerLampSwitch_ADV", "DimmerLampSwitchLED", "DimmerLampSwitchLED_ADV"].includes(node.nodeDefId);
 	}

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

@@ -45,7 +45,7 @@ export class DimmerLampSwitchNode extends Base<Drivers, Commands> implements Dim
 		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 DimmerLampSwitchNode extends Base<Drivers, Commands> implements Dim
 	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: number) { 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: number) { 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 DimmerLampSwitch {
 	export interface Interface extends Omit<InstanceType<typeof DimmerLampSwitchNode>, keyof ISYDeviceNode<any, any, any, any>> {
 		nodeDefId: "DimmerLampSwitch" | "DimmerLampSwitch_ADV";
 	}
-	export function is(node: ISYNode<any, any, any, any>): node is DimmerLampSwitchNode { return ["DimmerLampSwitch", "DimmerLampSwitch_ADV"].includes(node.nodeDefId); }
+	export function is(node: ISYNode<any, any, any, any>): node is DimmerLampSwitchNode {
+		return ["DimmerLampSwitch", "DimmerLampSwitch_ADV"].includes(node.nodeDefId);
+	}
 	export function isImplementedBy(node: ISYNode<any, any, any, any>): node is DimmerLampSwitchNode {
 		return ["DimmerLampSwitch", "DimmerLampSwitch_ADV"].includes(node.nodeDefId);
 	}

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

@@ -46,7 +46,7 @@ export class DimmerLampSwitchLedNode extends Base<Drivers, Commands> implements
 		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"); }
@@ -56,11 +56,11 @@ export class DimmerLampSwitchLedNode extends Base<Drivers, Commands> implements
 	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 led(value: Insteon.I3RgbLed) { 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 updateOnLevel(value: number) { return this.sendCommand("OL", value); }
+	async updateRampRate(value: Insteon.RampRate) { return this.sendCommand("RR", 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(): number {
 		return this.drivers.ST?.value;
@@ -83,7 +83,9 @@ export namespace DimmerLampSwitchLed {
 	export interface Interface extends Omit<InstanceType<typeof DimmerLampSwitchLedNode>, keyof ISYDeviceNode<any, any, any, any>> {
 		nodeDefId: "DimmerLampSwitchLED" | "DimmerLampSwitchLED_ADV";
 	}
-	export function is(node: ISYNode<any, any, any, any>): node is DimmerLampSwitchLedNode { return ["DimmerLampSwitchLED", "DimmerLampSwitchLED_ADV"].includes(node.nodeDefId); }
+	export function is(node: ISYNode<any, any, any, any>): node is DimmerLampSwitchLedNode {
+		return ["DimmerLampSwitchLED", "DimmerLampSwitchLED_ADV"].includes(node.nodeDefId);
+	}
 	export function isImplementedBy(node: ISYNode<any, any, any, any>): node is DimmerLampSwitchLedNode {
 		return ["DimmerLampSwitchLED", "DimmerLampSwitchLED_ADV"].includes(node.nodeDefId);
 	}

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

@@ -43,7 +43,7 @@ export class DimmerMotorSwitchNode extends Base<Drivers, Commands> implements Di
 		this.drivers.DUR = Driver.create("DUR", this, nodeInfo.property as DriverState, { uom: UnitOfMeasure.DurationInSeconds, label: "Max Duration", name: "maxDuration" });
 		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"); }
@@ -51,10 +51,10 @@ export class DimmerMotorSwitchNode extends Base<Drivers, Commands> implements Di
 	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 updateMaxDuration(value: number) { return this.sendCommand("DUR", { value: value }); }
-	async backlight(value: number) { 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 updateMaxDuration(value: number) { return this.sendCommand("DUR", value); }
+	async backlight(value: number) { return this.sendCommand("BL", value); }
 	async writeChanges() { return this.sendCommand("WDU"); }
 	public get status(): number {
 		return this.drivers.ST?.value;
@@ -77,7 +77,9 @@ export namespace DimmerMotorSwitch {
 	export interface Interface extends Omit<InstanceType<typeof DimmerMotorSwitchNode>, keyof ISYDeviceNode<any, any, any, any>> {
 		nodeDefId: "DimmerMotorSwitch" | "DimmerMotorSwitch_ADV";
 	}
-	export function is(node: ISYNode<any, any, any, any>): node is DimmerMotorSwitchNode { return ["DimmerMotorSwitch", "DimmerMotorSwitch_ADV"].includes(node.nodeDefId); }
+	export function is(node: ISYNode<any, any, any, any>): node is DimmerMotorSwitchNode {
+		return ["DimmerMotorSwitch", "DimmerMotorSwitch_ADV"].includes(node.nodeDefId);
+	}
 	export function isImplementedBy(node: ISYNode<any, any, any, any>): node is DimmerMotorSwitchNode {
 		return ["DimmerMotorSwitch", "DimmerMotorSwitch_ADV"].includes(node.nodeDefId);
 	}

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

@@ -29,7 +29,7 @@ export class DimmerSwitchNode extends Base<Drivers, Commands> implements DimmerS
 		super(isy, nodeInfo);
 		this.drivers.ERR = Driver.create("ERR", this, nodeInfo.property as DriverState, { uom: UnitOfMeasure.Index, label: "Responding", name: "responding" });
 	}
-	async backlight(value: number) { return this.sendCommand("BL", { value: 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;
@@ -43,7 +43,9 @@ export namespace DimmerSwitch {
 	export interface Interface extends Omit<InstanceType<typeof DimmerSwitchNode>, keyof ISYDeviceNode<any, any, any, any>> {
 		nodeDefId: "DimmerSwitchOnly" | "DimmerSwitchOnly_ADV";
 	}
-	export function is(node: ISYNode<any, any, any, any>): node is DimmerSwitchNode { return ["DimmerSwitchOnly", "DimmerSwitchOnly_ADV"].includes(node.nodeDefId); }
+	export function is(node: ISYNode<any, any, any, any>): node is DimmerSwitchNode {
+		return ["DimmerSwitchOnly", "DimmerSwitchOnly_ADV"].includes(node.nodeDefId);
+	}
 	export function isImplementedBy(node: ISYNode<any, any, any, any>): node is DimmerSwitchNode {
 		return ["DimmerSwitchOnly", "DimmerLampSwitch", "DimmerLampSwitch_ADV", "DimmerLampSwitchLED", "DimmerLampSwitchLED_ADV", "DimmerSwitchOnly_ADV"].includes(node.nodeDefId);
 	}

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

@@ -48,7 +48,9 @@ export namespace DoorLock {
 	export interface Interface extends Omit<InstanceType<typeof DoorLockNode>, keyof ISYDeviceNode<any, any, any, any>> {
 		nodeDefId: "DoorLock";
 	}
-	export function is(node: ISYNode<any, any, any, any>): node is DoorLockNode { return ["DoorLock"].includes(node.nodeDefId); }
+	export function is(node: ISYNode<any, any, any, any>): node is DoorLockNode {
+		return ["DoorLock"].includes(node.nodeDefId);
+	}
 	export function isImplementedBy(node: ISYNode<any, any, any, any>): node is DoorLockNode {
 		return ["DoorLock", "RelayLampSwitch", "RelayLampSwitch_ADV", "RelayLampSwitchLED", "RelayLampSwitchLED_ADV", "KeypadRelay", "KeypadRelay_ADV", "FanLincMotor"].includes(node.nodeDefId);
 	}

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

@@ -45,7 +45,9 @@ export namespace Ezio2x4Input {
 	export interface Interface extends Omit<InstanceType<typeof Ezio2x4InputNode>, keyof ISYDeviceNode<any, any, any, any>> {
 		nodeDefId: "EZIO2x4_Input" | "EZIO2x4_Input_ADV";
 	}
-	export function is(node: ISYNode<any, any, any, any>): node is Ezio2x4InputNode { return ["EZIO2x4_Input", "EZIO2x4_Input_ADV"].includes(node.nodeDefId); }
+	export function is(node: ISYNode<any, any, any, any>): node is Ezio2x4InputNode {
+		return ["EZIO2x4_Input", "EZIO2x4_Input_ADV"].includes(node.nodeDefId);
+	}
 	export function isImplementedBy(node: ISYNode<any, any, any, any>): node is Ezio2x4InputNode {
 		return ["EZIO2x4_Input", "BallastRelayLampSwitch", "BallastRelayLampSwitch_ADV", "RelayLampSwitch", "RelayLampSwitch_ADV", "RelayLampSwitchLED", "RelayLampSwitchLED_ADV", "KeypadRelay", "KeypadRelay_ADV", "KeypadButton", "KeypadButton_ADV", "EZRAIN_Input", "EZRAIN_Input_ADV", "EZIO2x4_Input_ADV"].includes(node.nodeDefId);
 	}

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

@@ -32,7 +32,7 @@ export class Ezio2x4OutputNode extends Base<Drivers, Commands> implements Ezio2x
 		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 writeChanges() { return this.sendCommand("WDU"); }
@@ -50,7 +50,9 @@ export namespace Ezio2x4Output {
 	export interface Interface extends Omit<InstanceType<typeof Ezio2x4OutputNode>, keyof ISYDeviceNode<any, any, any, any>> {
 		nodeDefId: "EZIO2x4_Output";
 	}
-	export function is(node: ISYNode<any, any, any, any>): node is Ezio2x4OutputNode { return ["EZIO2x4_Output"].includes(node.nodeDefId); }
+	export function is(node: ISYNode<any, any, any, any>): node is Ezio2x4OutputNode {
+		return ["EZIO2x4_Output"].includes(node.nodeDefId);
+	}
 	export function isImplementedBy(node: ISYNode<any, any, any, any>): node is Ezio2x4OutputNode {
 		return ["EZIO2x4_Output", "BallastRelayLampSwitch", "BallastRelayLampSwitch_ADV", "RelayLampSwitch", "RelayLampSwitch_ADV", "RelayLampSwitchLED", "RelayLampSwitchLED_ADV", "RelayLampOnly", "RelayLampOnly_ADV", "KeypadRelay", "KeypadRelay_ADV", "FanLincMotor", "EZRAIN_Output"].includes(node.nodeDefId);
 	}

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

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

package/src/Devices/Insteon/Generated/EzrainOutput.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 = "EZRAIN_Output";
-
+
 type Commands = EzrainOutput.Commands;
 type Drivers = EzrainOutput.Drivers;
-
+
 export class EzrainOutputNode extends Base<Drivers, Commands> implements EzrainOutput.Interface {
 	public override readonly commands = {
 		DON: this.on,
@@ -33,11 +33,11 @@ export class EzrainOutputNode extends Base<Drivers, Commands> implements EzrainO
 		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 writeChanges() { return this.sendCommand("WDU"); }
-	async beep(value?: number) { return this.sendCommand("BEEP", { value: value }); }
+	async beep(value?: number) { return this.sendCommand("BEEP", value); }
 	public get status(): Insteon.OnLevelRelay {
 		return this.drivers.ST?.value;
 	}
@@ -45,14 +45,16 @@ export class EzrainOutputNode extends Base<Drivers, Commands> implements EzrainO
 		return this.drivers.ERR?.value;
 	}
 }
-
+
 NodeFactory.register(EzrainOutputNode);
-
+
 export namespace EzrainOutput {
 	export interface Interface extends Omit<InstanceType<typeof EzrainOutputNode>, keyof ISYDeviceNode<any, any, any, any>> {
 		nodeDefId: "EZRAIN_Output";
 	}
-	export function is(node: ISYNode<any, any, any, any>): node is EzrainOutputNode { return ["EZRAIN_Output"].includes(node.nodeDefId); }
+	export function is(node: ISYNode<any, any, any, any>): node is EzrainOutputNode {
+		return ["EZRAIN_Output"].includes(node.nodeDefId);
+	}
 	export function isImplementedBy(node: ISYNode<any, any, any, any>): node is EzrainOutputNode {
 		return ["EZRAIN_Output", "BallastRelayLampSwitch", "BallastRelayLampSwitch_ADV", "RelayLampSwitch", "RelayLampSwitch_ADV", "RelayLampSwitchLED", "RelayLampSwitchLED_ADV", "RelayLampOnly", "RelayLampOnly_ADV", "KeypadRelay", "KeypadRelay_ADV", "FanLincMotor"].includes(node.nodeDefId);
 	}

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

@@ -35,12 +35,12 @@ export class FanLincMotorNode extends Base<Drivers, Commands> implements FanLinc
 		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: Insteon.FanLevel) { return this.sendCommand("DON", { value: value }); }
+	async on(value: Insteon.FanLevel) { 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.FanLevel {
 		return this.drivers.ST?.value;
@@ -56,7 +56,9 @@ export namespace FanLincMotor {
 	export interface Interface extends Omit<InstanceType<typeof FanLincMotorNode>, keyof ISYDeviceNode<any, any, any, any>> {
 		nodeDefId: "FanLincMotor";
 	}
-	export function is(node: ISYNode<any, any, any, any>): node is FanLincMotorNode { return ["FanLincMotor"].includes(node.nodeDefId); }
+	export function is(node: ISYNode<any, any, any, any>): node is FanLincMotorNode {
+		return ["FanLincMotor"].includes(node.nodeDefId);
+	}
 	export function isImplementedBy(node: ISYNode<any, any, any, any>): node is FanLincMotorNode {
 		return ["FanLincMotor"].includes(node.nodeDefId);
 	}

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

@@ -47,15 +47,15 @@ export class I3KeypadFlagsNode extends Base<Drivers, Commands> implements I3Keyp
 		this.drivers.GV8 = Driver.create("GV8", this, nodeInfo.property as DriverState, { uom: UnitOfMeasure.Boolean, label: "Cleanup Reports", name: "cleanupReports" });
 		this.drivers.ERR = Driver.create("ERR", this, nodeInfo.property as DriverState, { uom: UnitOfMeasure.Index, label: "Responding", name: "responding" });
 	}
-	async updateMode(value: Insteon.I3RelayDim) { return this.sendCommand("GV0", { value: value }); }
-	async updateProgramLock(value: Insteon.I3OnOff) { return this.sendCommand("GV1", { value: value }); }
-	async updateResumeDim(value: Insteon.I3OnOff) { return this.sendCommand("GV2", { value: value }); }
-	async updateRelayAtFullOn(value: Insteon.I3OnOff) { return this.sendCommand("GV3", { value: value }); }
-	async updateKeyBeep(value: Insteon.I3OnOff) { return this.sendCommand("GV4", { value: value }); }
-	async updateDisableRf(value: Insteon.I3OnOff) { return this.sendCommand("GV5", { value: value }); }
-	async updateButtonLock(value: Insteon.I3OnOff) { return this.sendCommand("GV6", { value: value }); }
-	async updateErrorBlink(value: Insteon.I3OnOff) { return this.sendCommand("GV7", { value: value }); }
-	async updateCleanupReports(value: Insteon.I3OnOff) { return this.sendCommand("GV8", { value: value }); }
+	async updateMode(value: Insteon.I3RelayDim) { return this.sendCommand("GV0", value); }
+	async updateProgramLock(value: Insteon.I3OnOff) { return this.sendCommand("GV1", value); }
+	async updateResumeDim(value: Insteon.I3OnOff) { return this.sendCommand("GV2", value); }
+	async updateRelayAtFullOn(value: Insteon.I3OnOff) { return this.sendCommand("GV3", value); }
+	async updateKeyBeep(value: Insteon.I3OnOff) { return this.sendCommand("GV4", value); }
+	async updateDisableRf(value: Insteon.I3OnOff) { return this.sendCommand("GV5", value); }
+	async updateButtonLock(value: Insteon.I3OnOff) { return this.sendCommand("GV6", value); }
+	async updateErrorBlink(value: Insteon.I3OnOff) { return this.sendCommand("GV7", value); }
+	async updateCleanupReports(value: Insteon.I3OnOff) { return this.sendCommand("GV8", value); }
 	async query() { return this.sendCommand("QUERY"); }
 	async writeChanges() { return this.sendCommand("WDU"); }
 	public get mode(): Insteon.I3RelayDim {
@@ -96,7 +96,9 @@ export namespace I3KeypadFlags {
 	export interface Interface extends Omit<InstanceType<typeof I3KeypadFlagsNode>, keyof ISYDeviceNode<any, any, any, any>> {
 		nodeDefId: "I3KeypadFlags";
 	}
-	export function is(node: ISYNode<any, any, any, any>): node is I3KeypadFlagsNode { return ["I3KeypadFlags"].includes(node.nodeDefId); }
+	export function is(node: ISYNode<any, any, any, any>): node is I3KeypadFlagsNode {
+		return ["I3KeypadFlags"].includes(node.nodeDefId);
+	}
 	export function isImplementedBy(node: ISYNode<any, any, any, any>): node is I3KeypadFlagsNode {
 		return ["I3KeypadFlags"].includes(node.nodeDefId);
 	}

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

@@ -43,13 +43,13 @@ export class I3PaddleFlagsNode extends Base<Drivers, Commands> implements I3Padd
 		this.drivers.GV7 = Driver.create("GV7", this, nodeInfo.property as DriverState, { uom: UnitOfMeasure.Boolean, label: "Error Blink", name: "errorBlink" });
 		this.drivers.ERR = Driver.create("ERR", this, nodeInfo.property as DriverState, { uom: UnitOfMeasure.Index, label: "Responding", name: "responding" });
 	}
-	async updateMode(value: Insteon.I3RelayDim) { return this.sendCommand("GV0", { value: value }); }
-	async updateProgramLock(value: Insteon.I3OnOff) { return this.sendCommand("GV1", { value: value }); }
-	async updateResumeDim(value: Insteon.I3OnOff) { return this.sendCommand("GV2", { value: value }); }
-	async updateKeyBeep(value: Insteon.I3OnOff) { return this.sendCommand("GV4", { value: value }); }
-	async updateDisableRf(value: Insteon.I3OnOff) { return this.sendCommand("GV5", { value: value }); }
-	async updateButtonLock(value: Insteon.I3OnOff) { return this.sendCommand("GV6", { value: value }); }
-	async updateErrorBlink(value: Insteon.I3OnOff) { return this.sendCommand("GV7", { value: value }); }
+	async updateMode(value: Insteon.I3RelayDim) { return this.sendCommand("GV0", value); }
+	async updateProgramLock(value: Insteon.I3OnOff) { return this.sendCommand("GV1", value); }
+	async updateResumeDim(value: Insteon.I3OnOff) { return this.sendCommand("GV2", value); }
+	async updateKeyBeep(value: Insteon.I3OnOff) { return this.sendCommand("GV4", value); }
+	async updateDisableRf(value: Insteon.I3OnOff) { return this.sendCommand("GV5", value); }
+	async updateButtonLock(value: Insteon.I3OnOff) { return this.sendCommand("GV6", value); }
+	async updateErrorBlink(value: Insteon.I3OnOff) { return this.sendCommand("GV7", value); }
 	async query() { return this.sendCommand("QUERY"); }
 	async writeChanges() { return this.sendCommand("WDU"); }
 	public get mode(): Insteon.I3RelayDim {
@@ -84,7 +84,9 @@ export namespace I3PaddleFlags {
 	export interface Interface extends Omit<InstanceType<typeof I3PaddleFlagsNode>, keyof ISYDeviceNode<any, any, any, any>> {
 		nodeDefId: "I3PaddleFlags";
 	}
-	export function is(node: ISYNode<any, any, any, any>): node is I3PaddleFlagsNode { return ["I3PaddleFlags"].includes(node.nodeDefId); }
+	export function is(node: ISYNode<any, any, any, any>): node is I3PaddleFlagsNode {
+		return ["I3PaddleFlags"].includes(node.nodeDefId);
+	}
 	export function isImplementedBy(node: ISYNode<any, any, any, any>): node is I3PaddleFlagsNode {
 		return ["I3PaddleFlags", "I3KeypadFlags"].includes(node.nodeDefId);
 	}

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

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

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

@@ -29,7 +29,7 @@ export class IrLincTxNode extends Base<Drivers, Commands> implements IrLincTx.In
 		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 beep(value?: number) { return this.sendCommand("BEEP", value); }
 	async writeChanges() { return this.sendCommand("WDU"); }
 	public get responding(): Insteon.Error {
 		return this.drivers.ERR?.value;
@@ -42,7 +42,9 @@ export namespace IrLincTx {
 	export interface Interface extends Omit<InstanceType<typeof IrLincTxNode>, keyof ISYDeviceNode<any, any, any, any>> {
 		nodeDefId: "IRLincTx";
 	}
-	export function is(node: ISYNode<any, any, any, any>): node is IrLincTxNode { return ["IRLincTx"].includes(node.nodeDefId); }
+	export function is(node: ISYNode<any, any, any, any>): node is IrLincTxNode {
+		return ["IRLincTx"].includes(node.nodeDefId);
+	}
 	export function isImplementedBy(node: ISYNode<any, any, any, any>): node is IrLincTxNode {
 		return ["IRLincTx", "Thermostat", "TempLinc", "DimmerMotorSwitch", "DimmerMotorSwitch_ADV", "DimmerLampSwitch", "DimmerLampSwitch_ADV", "DimmerLampSwitchLED", "DimmerLampSwitchLED_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"].includes(node.nodeDefId);
 	}