isy-nodejs 1.0.1-alpha.25 → 1.0.1-alpha.27

package/package.json

@@ -2,7 +2,7 @@
     "name": "isy-nodejs",
     "description": "Node.js wrapper for ISY interface including websockets for change notifications. Fork of isy-js by Rod Toll. Designed to be used in a node.js application.",
     "license": "MIT",
-    "version": "1.0.1-alpha.25",
+    "version": "1.0.1-alpha.27",
     "author": {
         "name": "Pradeep Mouli"
     },
@@ -69,5 +69,5 @@
     "publishConfig": {
         "access": "public"
     },
-    "gitHead": "99f03336e2db40ef91e58b059969abba6534c74a"
+    "gitHead": "6818f4140be310656690e21c6a451f42cae1ef8f"
 }

package/src/Converters.ts

@@ -1,4 +1,3 @@
-
 import { UnitOfMeasure } from './Definitions/Global/UOM.js';
 import { type StringKeys } from './Utils.js';
 
@@ -9,26 +8,21 @@ let NullConverter: Converter<any, any>;
 	from: (value: any) => value;
 }
 
-BooleanPercentage = {
-	to: (value: number): boolean => {
-		return value > 0;
-	},
-	from: (value: boolean): number => {
-		return value ? 100 : 0;
-	}
-};
-
-const StandardConverters: {
-	[x in `${keyof typeof UnitOfMeasure}`]?: { [y in `${keyof typeof UnitOfMeasure}`]?: Converter<any, any> };
-} = {
+const StandardConverters = {
 	Boolean: {
 		LevelFrom0To255: {
 			to: (value: boolean) => (value ? 255 : 0),
 			from: (value: number) => value > 0
 		},
-		Percent: BooleanPercentage
+		Percent: {
+			to: (value: number): boolean => {
+				return value > 0;
+			},
+			from: (value: boolean): number => {
+				return value ? 100 : 0;
+			}
+		}
 	},
-	Percent: {},
 	LevelFrom0To255: {
 		Percent: {
 			to: (value: number): number => {
@@ -41,8 +35,8 @@ const StandardConverters: {
 	}
 };
 
-StandardConverters.Percent.LevelFrom0To255 = invert(StandardConverters.LevelFrom0To255.Percent);
-StandardConverters.LevelFrom0To255.Boolean = invert(StandardConverters.Boolean.LevelFrom0To255);
+//StandardConverters.Percent.LevelFrom0To255 = invert(StandardConverters.LevelFrom0To255.Percent);
+//StandardConverters.LevelFrom0To255.Boolean = invert(StandardConverters.Boolean.LevelFrom0To255);
 
 export const StdConverterRegistry = new Map<UnitOfMeasure | string, Map<UnitOfMeasure | string, Converter<any, any>>>();
 
@@ -51,8 +45,8 @@ export const ConverterRegistry = new Map<string, Converter<any, any>>();
 function registerConverters() {
 	for (const from in StandardConverters) {
 		for (const to in StandardConverters[from]) {
-			registerConverter(UnitOfMeasure[from], UnitOfMeasure[to], StandardConverters[from][to] as Converter<any, any>);
-			registerConverter(UnitOfMeasure[to], UnitOfMeasure[from], invert(StandardConverters[from][to]) as Converter<any, any>);
+			registerConverter(from, to, StandardConverters[from][to] as Converter<any, any>);
+			registerConverter(to, from, invert(StandardConverters[from][to]) as Converter<any, any>);
 		}
 	}
 	for (const from in Converter.Matter) {
@@ -64,8 +58,8 @@ function registerConverters() {
 }
 
 export function registerConverter(
-	from: keyof typeof StandardConverters | UnitOfMeasure | keyof typeof Converter.Matter | string,
-	to: keyof typeof StandardConverters | UnitOfMeasure | keyof typeof Converter.Matter | string,
+	from: keyof typeof StandardConverters | keyof typeof Converter.Matter | string,
+	to: keyof typeof StandardConverters | keyof typeof Converter.Matter | string,
 	converter: Converter<any, any>
 ) {
 	if (!StdConverterRegistry.has(from)) {
@@ -94,6 +88,7 @@ export namespace Converter {
 					: value === 255 ? 254
 					: value
 			}
+
 		}
 	};
 
@@ -108,7 +103,7 @@ export namespace Converter {
 	export type MatterConverters = `${MatterISYConvertibleTypes}.${ISYMatterConvertibleTypes}` | `${ISYMatterConvertibleTypes}.${MatterISYConvertibleTypes}`;
 
 	export type KnownConverters = StandardConverters | MatterConverters;
-
+	const cache: { [x: string]: Converter<any, any> } = {};
 	export function get(label: KnownConverters): Converter<any, any>;
 	export function get(from: UnitOfMeasure, to: UnitOfMeasure);
 	export function get(from: ConverterTypes, to: ConverterTypes);
@@ -116,16 +111,25 @@ export namespace Converter {
 	export function get(from: MatterISYConvertibleTypes, to: ISYMatterConvertibleTypes);
 	export function get(to: ISYMatterConvertibleTypes, from: MatterISYConvertibleTypes);
 	export function get(from: UnitOfMeasure | `${keyof typeof UnitOfMeasure}` | string, to?: UnitOfMeasure | `${keyof typeof UnitOfMeasure}` | string): Converter<any, any> {
+		if (to === undefined) {
+			return ConverterRegistry.get(from as string) ?? NullConverter;
+		}
+		if (cache[`${from}.${to}`]) {
+			return cache[`${from}.${to}`];
+		} else if (cache[`${to}.${from}`]) {
+			cache[`${from}.${to}`] = invert(cache[`${to}.${from}`]);
+			return cache[`${from}.${to}`];
+		}
 		let isString = typeof from === 'string';
-		let fuom = isString ? UnitOfMeasure[from] : from;
+		let fuom = isString ? from : UnitOfMeasure[from];
 		if (to) {
-			let tuom = typeof to === 'string' ? UnitOfMeasure[to] : to;
+			let tuom = typeof to === 'string' ? to : UnitOfMeasure[to];
 
 			if (StdConverterRegistry.has(fuom)) {
-				return StdConverterRegistry.get(fuom).get(tuom);
+				if (StdConverterRegistry.get(fuom).has(tuom)) {
+					return StdConverterRegistry.get(fuom).get(tuom);
+				}
 			}
-		} else if (typeof from === 'string') {
-			return ConverterRegistry.get(from);
 		}
 		return NullConverter;
 	}

package/src/Definitions/Global/Commands.ts

@@ -1,10 +1,22 @@
 import { TimeFormatLocalization } from '@project-chip/matter.js/cluster';
 import type { Identity, Merge, UnionToIntersection } from '@project-chip/matter.js/util';
 import type { Sign } from 'crypto';
+import type { UnitOfMeasure } from './UOM.js';
+
+/*export class Command<T extends string> extends Function {
+
+	constructor(public readonly label: string) {
+		super();
+	}
+
+	public async execute(...args: any[]): Promise<Boolean> {
+		return this(...args);
+	}
+}*/
 
 export namespace Command {
 
-    export type Signature<F extends {name: string} = CallableFunction, L extends string = string,N extends string = string> = F & {label: L, name: N };
+    export type Signature<F extends {name} = CallableFunction, L extends string = string,N extends string = string> = F & {label: L, name: N,} ;
 
     export type Signatures<C extends string> = {[K in C]: Signature<(...args: any[]) => Promise<Boolean>, string, string>};
 

package/src/Definitions/Global/Drivers.ts

@@ -427,6 +427,7 @@ export namespace Driver {
 						converter ? converter.from(initState.value)
 						:	(node.convertFrom(initState?.value, initState?.uom, driver as D) as T)
 					:	null,
+				rawValue: initState ? initState.value : null,
 				formattedValue: initState ? initState.formatted : null,
 				pendingValue: null
 			},
@@ -437,22 +438,30 @@ export namespace Driver {
 				return s;
 			},
 			apply(state: DriverState, notify = false) {
-				let previousValue = this.state.value;
-				this.state.value = converter ? converter.from(state.value) : node.convertFrom(state.value, state.uom, driver as D);
-				this.state.formattedValue = state.formatted;
-				if (previousValue == this.state.value) {
+				let previousValue = this.state.rawValue;
+				this.state.rawValue = state.value;
+				if (previousValue === this.state.rawValue) {
 					return false;
 				}
+				if (state.uom != this.uom) {
+					this.serverUom == state.uom;
+					this.state.value = converter ? converter.from(this.state.rawValue) : Converter.convert(state.uom, this.uom, this.state.rawValue);
+				} else if (converter) {
+					this.state.value = converter.from(state.value);
+				} else {
+					this.state.value = state.value;
+				}
+				this.state.formattedValue = state.formatted;
 				if (notify) node.events.emit(`${this.name}Changed`, driver as D, this.state.value, previousValue, this.state.formattedValue);
 				return true;
 			},
 			patch(value: T, formattedValue: string, uom: UnitOfMeasure, prec: number, notify = true) {
-				let previousValue = this.state.value;
-
+				let previousValue = this.state.rawValue;
+				this.state.rawValue = value;
 				this.state.formattedValue = formattedValue;
 				if (uom != this.uom) {
 					this.serverUom == uom;
-					this.state.value = converter ? converter.from(value) : Converter.convert(uom, this.uom, value);
+					this.state.value = converter ? converter.from(this.state.rawValue) : Converter.convert(uom, this.uom, this.state.rawValue);
 
 				}
 				else if(converter)
@@ -466,7 +475,7 @@ export namespace Driver {
 				if (previousValue == this.state.value) {
 					return false;
 				}
-				if (notify) node.events.emit(`${this.name}Changed`, driver as D, value, previousValue, formattedValue);
+				if (notify) node.events.emit(`${this.name}Changed`, driver as D, this.state.value,  previousValue, formattedValue);
 				return true;
 			},
 			get value() {

package/src/Devices/Insteon/DimmerLampSwitch.ts

@@ -1,19 +1,18 @@
 /* THIS FILE WAS AUTOMATICALLY GENERATED. DO NOT EDIT DIRECTLY. */
 
-import { UnitOfMeasure } from '../../Definitions/Global/UOM.js';
+import { Driver } from '../../Definitions/Global/Drivers.js';
 import { Family } from '../../Definitions/Global/Families.js';
-import type { NodeInfo } from '../../Model/NodeInfo.js';
+import { UnitOfMeasure } from '../../Definitions/Global/UOM.js';
+import { Insteon } from '../../Definitions/index.js';
 import type { ISY } from '../../ISY.js';
 import type { ISYNode } from '../../ISYNode.js';
-import { InsteonBaseDevice as Base } from './InsteonBaseDevice.js';
-import { ISYDeviceNode } from '../ISYDeviceNode.js';
-import { Driver } from '../../Definitions/Global/Drivers.js';
-import { Insteon } from '../../Definitions/index.js';
 import type { DriverState } from '../../Model/DriverState.js';
+import type { NodeInfo } from '../../Model/NodeInfo.js';
+import { ISYDeviceNode } from '../ISYDeviceNode.js';
 import { NodeFactory } from '../NodeFactory.js';
+import { InsteonBaseDevice as Base } from './InsteonBaseDevice.js';
 
-
-export const nodeDefId = "DimmerLampSwitch";
+export const nodeDefId = 'DimmerLampSwitch';
 
 type Commands = DimmerLampSwitch.Commands;
 type Drivers = DimmerLampSwitch.Drivers;
@@ -36,60 +35,59 @@ export class DimmerLampSwitchNode extends Base<Drivers, Commands> implements Dim
 		BL: this.backlight,
 		WDU: this.writeChanges
 	};
-	static override nodeDefId = "DimmerLampSwitch";
-	declare readonly nodeDefId: "DimmerLampSwitch";
-	constructor (isy: ISY, nodeInfo: NodeInfo) {
+	static override nodeDefId = 'DimmerLampSwitch';
+	declare readonly nodeDefId: 'DimmerLampSwitch';
+	constructor(isy: ISY, nodeInfo: NodeInfo) {
 		super(isy, nodeInfo);
-		this.drivers.ST = Driver.create("ST", this, nodeInfo.property as DriverState, { uom: UnitOfMeasure.Percent, label: "Status", name: "status" });
-		this.drivers.OL = Driver.create("OL", this, nodeInfo.property as DriverState, { uom: UnitOfMeasure.Percent, label: "On Level", name: "onLevel" });
-		this.drivers.RR = Driver.create("RR", this, nodeInfo.property as DriverState, { uom: UnitOfMeasure.Index, label: "Ramp Rate", name: "rampRate" });
-		this.drivers.ERR = Driver.create("ERR", this, nodeInfo.property as DriverState, { uom: UnitOfMeasure.Index, label: "Responding", name: "responding" });
-		
+		this.drivers.ST = Driver.create('ST', this, nodeInfo.state['ST'], { uom: UnitOfMeasure.LevelFrom0To255, label: 'Status', name: 'status' });
+		this.drivers.OL = Driver.create('OL', this, nodeInfo.state['OL'] as DriverState, { uom: UnitOfMeasure.Percent, label: 'On Level', name: 'onLevel' });
+		this.drivers.RR = Driver.create('RR', this, nodeInfo.state['RR'] as DriverState, { uom: UnitOfMeasure.Index, label: 'Ramp Rate', name: 'rampRate' });
+		this.drivers.ERR = Driver.create('ERR', this, nodeInfo.state['ERR'] as DriverState, { uom: UnitOfMeasure.Index, label: 'Responding', name: 'responding' });
 	}
 	async on(value?: number) {
-		return this.sendCommand("DON", { value: value });
+		return this.sendCommand('DON', value);
 	}
 	async off() {
-		return this.sendCommand("DOF");
+		return this.sendCommand('DOF');
 	}
 	async fastOff() {
-		return this.sendCommand("DFOF");
+		return this.sendCommand('DFOF');
 	}
 	async fastOn() {
-		return this.sendCommand("DFON");
+		return this.sendCommand('DFON');
 	}
 	async brighten() {
-		return this.sendCommand("BRT");
+		return this.sendCommand('BRT');
 	}
 	async dim() {
-		return this.sendCommand("DIM");
+		return this.sendCommand('DIM');
 	}
 	async fadeUp() {
-		return this.sendCommand("FDUP");
+		return this.sendCommand('FDUP');
 	}
 	async fadeDown() {
-		return this.sendCommand("FDDOWN");
+		return this.sendCommand('FDDOWN');
 	}
 	async fadeStop() {
-		return this.sendCommand("FDSTOP");
+		return this.sendCommand('FDSTOP');
 	}
 	async query() {
-		return this.sendCommand("QUERY");
+		return this.sendCommand('QUERY');
 	}
 	async beep(value?: number) {
-		return this.sendCommand("BEEP", { value: value });
+		return this.sendCommand('BEEP', { value: value });
 	}
 	async updateOnLevel(value: number) {
-		return this.sendCommand("OL", { value: value });
+		return this.sendCommand('OL', { value: value });
 	}
 	async updateRampRate(value: number) {
-		return this.sendCommand("RR", { value: value });
+		return this.sendCommand('RR', { value: value });
 	}
 	async backlight(value: number) {
-		return this.sendCommand("BL", { value: value });
+		return this.sendCommand('BL', { value: value });
 	}
 	async writeChanges() {
-		return this.sendCommand("WDU");
+		return this.sendCommand('WDU');
 	}
 	public get status(): number {
 		return this.drivers.ST?.value;
@@ -109,7 +107,7 @@ NodeFactory.register(DimmerLampSwitchNode);
 
 export namespace DimmerLampSwitch {
 	export interface Interface extends Omit<InstanceType<typeof DimmerLampSwitchNode>, keyof ISYDeviceNode<any, any, any, any>> {
-		nodeDefId: "DimmerLampSwitch";
+		nodeDefId: 'DimmerLampSwitch';
 	}
 	export function is(node: ISYNode<any, any, any, any>): node is DimmerLampSwitchNode {
 		return node.nodeDefId === nodeDefId;
@@ -120,90 +118,90 @@ export namespace DimmerLampSwitch {
 	export const Node = DimmerLampSwitchNode;
 	export type Commands = {
 		DON: ((value?: number) => Promise<boolean>) & {
-			label: "On";
-			name: "on";
+			label: 'On';
+			name: 'on';
 		};
 		DOF: (() => Promise<boolean>) & {
-			label: "Off";
-			name: "off";
+			label: 'Off';
+			name: 'off';
 		};
 		DFOF: (() => Promise<boolean>) & {
-			label: "Fast Off";
-			name: "fastOff";
+			label: 'Fast Off';
+			name: 'fastOff';
 		};
 		DFON: (() => Promise<boolean>) & {
-			label: "Fast On";
-			name: "fastOn";
+			label: 'Fast On';
+			name: 'fastOn';
 		};
 		BRT: (() => Promise<boolean>) & {
-			label: "Brighten";
-			name: "brighten";
+			label: 'Brighten';
+			name: 'brighten';
 		};
 		DIM: (() => Promise<boolean>) & {
-			label: "Dim";
-			name: "dim";
+			label: 'Dim';
+			name: 'dim';
 		};
 		FDUP: (() => Promise<boolean>) & {
-			label: "Fade Up";
-			name: "fadeUp";
+			label: 'Fade Up';
+			name: 'fadeUp';
 		};
 		FDDOWN: (() => Promise<boolean>) & {
-			label: "Fade Down";
-			name: "fadeDown";
+			label: 'Fade Down';
+			name: 'fadeDown';
 		};
 		FDSTOP: (() => Promise<boolean>) & {
-			label: "Fade Stop";
-			name: "fadeStop";
+			label: 'Fade Stop';
+			name: 'fadeStop';
 		};
 		QUERY: (() => Promise<boolean>) & {
-			label: "Query";
-			name: "query";
+			label: 'Query';
+			name: 'query';
 		};
 		BEEP: ((value?: number) => Promise<boolean>) & {
-			label: "Beep";
-			name: "beep";
+			label: 'Beep';
+			name: 'beep';
 		};
 		OL: ((value: number) => Promise<boolean>) & {
-			label: "On Level";
-			name: "updateOnLevel";
+			label: 'On Level';
+			name: 'updateOnLevel';
 		};
 		RR: ((value: number) => Promise<boolean>) & {
-			label: "Ramp Rate";
-			name: "updateRampRate";
+			label: 'Ramp Rate';
+			name: 'updateRampRate';
 		};
 		BL: ((value: number) => Promise<boolean>) & {
-			label: "Backlight";
-			name: "backlight";
+			label: 'Backlight';
+			name: 'backlight';
 		};
 		WDU: (() => Promise<boolean>) & {
-			label: "Write Changes";
-			name: "writeChanges";
+			label: 'Write Changes';
+			name: 'writeChanges';
 		};
 	};
 	export type Drivers = {
 		ST: {
-			uom: UnitOfMeasure.Percent;
+			uom: UnitOfMeasure.LevelFrom0To255;
 			value: number;
-			label: "Status";
-			name: "status";
+			label: 'Status';
+			name: 'status';
 		};
 		OL: {
 			uom: UnitOfMeasure.Percent;
 			value: number;
-			label: "On Level";
-			name: "onLevel";
+			label: 'On Level';
+			name: 'onLevel';
 		};
 		RR: {
 			uom: UnitOfMeasure.Index;
 			value: number;
-			label: "Ramp Rate";
-			name: "rampRate";
+			label: 'Ramp Rate';
+			name: 'rampRate';
 		};
 		ERR: {
 			uom: UnitOfMeasure.Index;
 			value: Insteon.Error;
-			label: "Responding";
-			name: "responding";
+			label: 'Responding';
+			name: 'responding';
 		};
 	};
 }

package/src/Devices/Insteon/Generated/DimmerLampSwitch.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,13 @@ 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";
-
+import { validateHeaderName } from 'http';
+
 export const nodeDefId = "DimmerLampSwitch";
-
+
 type Commands = DimmerLampSwitch.Commands;
 type Drivers = DimmerLampSwitch.Drivers;
-
+
 export class DimmerLampSwitchNode extends Base<Drivers, Commands> implements DimmerLampSwitch.Interface {
 	public readonly commands = {
 		DON: this.on,
@@ -102,9 +103,9 @@ export class DimmerLampSwitchNode extends Base<Drivers, Commands> implements Dim
 		return this.drivers.ERR?.value;
 	}
 }
-
+
 NodeFactory.register(DimmerLampSwitchNode);
-
+
 export namespace DimmerLampSwitch {
 	export interface Interface extends Omit<InstanceType<typeof DimmerLampSwitchNode>, keyof ISYDeviceNode<any, any, any, any>> {
 		nodeDefId: "DimmerLampSwitch";

package/src/Devices/Insteon/RelayLampSwitch.ts

@@ -1,18 +1,18 @@
 /* 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 type { ISYNode } from "../../ISYNode.js";
-import { InsteonBaseDevice } from "./InsteonBaseDevice.js";
-import { ISYDeviceNode } from "../ISYDeviceNode.js";
-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";
+import { Driver } from '../../Definitions/Global/Drivers.js';
+import { Family } from '../../Definitions/Global/Families.js';
+import { UnitOfMeasure } from '../../Definitions/Global/UOM.js';
+import { Insteon } from '../../Definitions/index.js';
+import type { ISY } from '../../ISY.js';
+import type { ISYNode } from '../../ISYNode.js';
+import type { DriverState } from '../../Model/DriverState.js';
+import type { NodeInfo } from '../../Model/NodeInfo.js';
+import { ISYDeviceNode } from '../ISYDeviceNode.js';
+import { NodeFactory } from '../NodeFactory.js';
+import { InsteonBaseDevice } from './InsteonBaseDevice.js';
 
-export const nodeDefId = "RelayLampSwitch";
+export const nodeDefId = 'RelayLampSwitch';
 
 type Commands = RelayLampSwitch.Commands;
 type Drivers = RelayLampSwitch.Drivers;
@@ -32,11 +32,11 @@ export class RelayLampSwitchNode extends InsteonBaseDevice<Drivers, Commands> im
 	declare readonly nodeDefId: 'RelayLampSwitch';
 	constructor(isy: ISY, nodeInfo: NodeInfo) {
 		super(isy, nodeInfo);
-		this.drivers.ST = Driver.create('ST', this, nodeInfo.property as DriverState, { uom: UnitOfMeasure.Percent, label: 'Status', name: 'status' });
-		this.drivers.ERR = Driver.create('ERR', this, nodeInfo.property as DriverState, { uom: UnitOfMeasure.Index, label: 'Responding', name: 'responding' });
+		this.drivers.ST = Driver.create('ST', this, nodeInfo.state['ST'], { uom: UnitOfMeasure.Boolean, label: 'Status', name: 'status' });
+		this.drivers.ERR = Driver.create('ERR', this, nodeInfo.state['ERR'], { uom: UnitOfMeasure.Index, label: 'Responding', name: 'responding' });
 	}
 	async on(value?: 0 | 100) {
-		return this.sendCommand('DON', { value: value });
+		return this.sendCommand('DON', value);
 	}
 	async off() {
 		return this.sendCommand('DOF');
@@ -59,7 +59,7 @@ export class RelayLampSwitchNode extends InsteonBaseDevice<Drivers, Commands> im
 	async writeChanges() {
 		return this.sendCommand('WDU');
 	}
-	public get status(): Insteon.OnLevelRelay {
+	public get status(): boolean {
 		return this.drivers.ST?.value;
 	}
 	public get responding(): Insteon.Error {
@@ -71,7 +71,7 @@ NodeFactory.register(RelayLampSwitchNode);
 
 export namespace RelayLampSwitch {
 	export interface Interface extends Omit<InstanceType<typeof RelayLampSwitchNode>, keyof ISYDeviceNode<any, any, any, any>> {
-		nodeDefId: "RelayLampSwitch";
+		nodeDefId: 'RelayLampSwitch';
 	}
 	export function is(node: ISYNode<any, any, any, any>): node is RelayLampSwitchNode {
 		return node.nodeDefId === nodeDefId;
@@ -81,51 +81,51 @@ export namespace RelayLampSwitch {
 	}
 	export const Node = RelayLampSwitchNode;
 	export type Commands = {
-		DON: ((value?: (0 | 100)) => Promise<boolean>) & {
-			label: "On";
-			name: "on";
+		DON: ((value?: 0 | 100) => Promise<boolean>) & {
+			label: 'On';
+			name: 'on';
 		};
 		DOF: (() => Promise<boolean>) & {
-			label: "Off";
-			name: "off";
+			label: 'Off';
+			name: 'off';
 		};
 		DFOF: (() => Promise<boolean>) & {
-			label: "Fast Off";
-			name: "fastOff";
+			label: 'Fast Off';
+			name: 'fastOff';
 		};
 		DFON: (() => Promise<boolean>) & {
-			label: "Fast On";
-			name: "fastOn";
+			label: 'Fast On';
+			name: 'fastOn';
 		};
 		QUERY: (() => Promise<boolean>) & {
-			label: "Query";
-			name: "query";
+			label: 'Query';
+			name: 'query';
 		};
 		BEEP: ((value?: number) => Promise<boolean>) & {
-			label: "Beep";
-			name: "beep";
+			label: 'Beep';
+			name: 'beep';
 		};
 		BL: ((value: number) => Promise<boolean>) & {
-			label: "Backlight";
-			name: "backlight";
+			label: 'Backlight';
+			name: 'backlight';
 		};
 		WDU: (() => Promise<boolean>) & {
-			label: "Write Changes";
-			name: "writeChanges";
+			label: 'Write Changes';
+			name: 'writeChanges';
 		};
 	};
 	export type Drivers = {
 		ST: {
-			uom: UnitOfMeasure.Percent;
-			value: Insteon.OnLevelRelay;
-			label: "Status";
-			name: "status";
+			uom: UnitOfMeasure.Boolean;
+			value: boolean;
+			label: 'Status';
+			name: 'status';
 		};
 		ERR: {
 			uom: UnitOfMeasure.Index;
 			value: Insteon.Error;
-			label: "Responding";
-			name: "responding";
+			label: 'Responding';
+			name: 'responding';
 		};
 	};
 }