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

package/src/Devices/CompositeDevice.ts

@@ -0,0 +1,277 @@
+
+import type { Driver } from '../Definitions/Global/Drivers.js';
+import type { UnitOfMeasure } from '../Definitions/Global/UOM.js';
+
+import type { ISYDevice } from '../ISYDevice.js';
+import { DriverMap, ISYNode, NodeList } from '../ISYNode.js';
+import type { ISYScene } from '../ISYScene.js';
+import type { DriverState } from '../Model/DriverState.js';
+import type { Category, Family } from '../Definitions/index.js';
+import { ISY } from '../ISY.js';
+import type { NodeInfo } from '../Model/NodeInfo.js';
+import { NodeFactory } from './NodeFactory.js';
+import type { Constructor } from 'type-fest';
+import type { ISYDeviceNode } from './ISYDeviceNode.js';
+import type { ObjectToUnion, StringKeys } from '../Utils.js';
+
+import type { Fan } from './Insteon/InsteonFanDevice.js';
+
+
+ export type CompositeDevice<F extends Family, N extends {[x: string]: ISYDeviceNode<F,any,any,any>},R = N[keyof N]> =
+{[x in keyof N]: N[x]} & {
+
+	root: R;
+
+	events: { [x in keyof N]: N[x]['events'] };
+
+	drivers: { [x in keyof N]:  N[x]['drivers'] };
+
+	commands: { [x in keyof N]: N[x]['commands'] };
+
+	addNode: (node: NodeInfo | ISYNode, isy?: ISY) => void;
+
+
+
+} & ISYDevice<Family, any,unknown,any>;
+
+export namespace CompositeDevice {
+	export type DriversOf<N extends CompositeDevice<any,any>> = N['drivers'];
+
+	export type CommandsOf<N extends CompositeDevice<any,any>> = N['commands'];
+
+	export type EventsOf<N extends CompositeDevice<any,any>> = N['events'];
+
+	export type DriverNamesOf<N extends CompositeDevice<any,any>> = ObjectToUnion<{[x in StringKeys<DriversOf<N>>] : `${x}.${ISYNode.DriverNamesOf<N[x]> & string}`}>;
+
+	export type CommandNamesOf<N extends CompositeDevice<any, any>> = ObjectToUnion<{ [x in StringKeys<DriversOf<N>>]: `${x}.${ISYNode.CommandNamesOf<N[x]> & string}` }>;
+
+	export type EventNamesOf<N extends CompositeDevice<any, any>> = ObjectToUnion<{ [x in StringKeys<DriversOf<N>>]: `${x}.${ISYNode.EventNamesOf<N[x]> & string}` }>;
+
+	export type DriverKeysOf<N extends CompositeDevice<any, any>> = ObjectToUnion<{ [x in StringKeys<DriversOf<N>>]: `${x}.${ISYNode.DriverKeysOf<N[x]> & string}` }>;
+
+	export type CommandKeysOf<N extends CompositeDevice<any, any>> = ObjectToUnion<{ [x in StringKeys<CommandsOf<N>>]: `${x}.${ISYNode.CommandKeysOf<N[x]> & string}` }>;
+
+	export function of<F extends Family, N extends { [x: string]: ISYDeviceNode<any, any, any, any> }>(nodes: { [x in keyof N]: Constructor<N[x]> }, keyFunction: (node: NodeInfo) => [keyof N, boolean]): Constructor<CompositeDevice<F, N>>;
+	export function of<F extends Family, N extends { [x: string]: ISYDeviceNode<any, any, any, any> }>(nodes: { [x in keyof N]: Constructor<N[x]> }, keyMap: {[x in keyof N]: number | string}): Constructor<CompositeDevice<F, N>>;
+	export function of<F extends Family, N extends { [x: string]: ISYDeviceNode<any, any, any, any> }>(nodes: { [x in keyof N]: Constructor<N[x]> }, keyFunction: {[x in keyof N]: number | string} |((node: NodeInfo) => [keyof N, boolean])): Constructor<CompositeDevice<F, N>> {
+		if(keyFunction === undefined) {
+			keyFunction = (node: NodeInfo) => [node.name, true];
+		}
+		if(typeof keyFunction === 'function') {
+			return CompositeOf(nodes, keyFunction as any);
+		}
+		else if(typeof keyFunction === 'object') {
+			return CompositeOf(nodes, (node: NodeInfo | ISYNode) => {for (const key in keyFunction)
+			{
+				if(node.address.endsWith(keyFunction[key].toString())) {
+					return [key, keyFunction[key] == 1 || keyFunction[key] == '1'];
+				}
+			}});
+
+
+
+		}
+
+	}
+
+	export function isComposite(device: ISYDevice<any, any, any, any>): device is CompositeDevice<any, any> {
+		return 'addNode' in device;
+	}
+
+}
+
+
+export function CompositeOf <F extends Family, N extends {[x: string]: ISYDeviceNode<any,any,any,any>}>(nodes: {[x in keyof N]: Constructor<N[x]>}, keyFunction: (node: NodeInfo | ISYNode) => [keyof N,boolean]) : Constructor<CompositeDevice<F,N>>
+{
+return class implements ISYDevice<Family, any, unknown, any> {
+	readonly isy: ISY;
+
+	constructor(...args: any[]) {
+
+		if(args[0] instanceof ISY) {
+			this.isy = args.shift();
+			for (const nodeInfo of args as NodeInfo[]) {
+
+				this.addNode(nodeInfo, this.isy);
+			}
+		}
+
+	}
+	category: Category;
+	deviceClass: any;
+	enabled: boolean;
+	family: Family;
+	hidden: boolean;
+	isDimmable: boolean;
+	label: string;
+	model: string;
+	modelNumber: string;
+	name: any;
+	parentAddress: any;
+	productName: string;
+	scenes: ISYScene[];
+	subCategory: number;
+	type: any;
+	typeCode: string;
+	version: string;
+	vendorName: string;
+	productId: string | number;
+	modelName: string;
+	manufacturer: string;
+
+	public address: string;
+
+
+	public events: { [x in keyof N]: N[x]['events'] } = {} as any;
+
+	public drivers: { [x in keyof N]:  N[x]['drivers'] } = {} as any;
+
+	public commands: { [x in keyof N]:  N[x]['commands'] } = {} as any;
+
+	public root = null;
+
+	public addNode(node: ISYNode): void;
+	public addNode(node: NodeInfo, isy: ISY): void;
+	public addNode(node: NodeInfo | ISYNode, isy = this.isy) {
+
+		let n : ISYDeviceNode<any, any, any, any> = null;
+		if(node instanceof ISYNode) {
+			n = node as ISYDeviceNode<any, any, any, any>;
+		}
+		else
+		{
+			n = new nodes[keyFunction(node)[0]](isy, node);
+		}
+		const keyL = keyFunction(node);
+		const key = keyL[0];
+		const isRoot = keyL[1];
+
+		Object.defineProperty(this, key, n);
+
+		Object.defineProperty(this.events, key, { get(): () => any { return this[key].events; } });
+		Object.defineProperty(this.drivers, key, { get(): () => any { return this[key].drivers; } });
+		Object.defineProperty(this.commands, key, { get(): () => any { return this[key].commands; } });
+		if(isRoot) {
+			this.address = node.address;
+			this.family = n.family;
+			this.category = n.category;
+			this.deviceClass = n.deviceClass;
+			this.enabled = n.enabled;
+			this.hidden = n.hidden;
+			this.isDimmable = n.isDimmable;
+			this.label = n.label;
+			this.model = n.model;
+			this.modelNumber = n.modelNumber;
+			this.name = n.name;
+			this.parentAddress = n.parentAddress;
+			this.productName = n.productName;
+			this.scenes = n.scenes;
+			this.subCategory = n.subCategory;
+			this.type = n.type;
+			this.typeCode = n.typeCode;
+			this.version = n.version;
+			this.vendorName = n.vendorName;
+			this.productId = n.productId;
+			this.modelName = n.modelName;
+			this.manufacturer = n.manufacturer;
+			this.root = n;
+
+		}
+
+	}
+
+  } as unknown as Constructor<CompositeDevice<F,N>>;
+
+
+}
+
+
+
+
+/*
+
+export class ISYMultiNodeDevice<T extends Family, N extends NodeList>
+  implements ISYDevice<T, ISYNode.DriverMap<N>, ISYNode.CommandMap<N>, string> {
+  commands: UnionToIntersection<{ [x in keyof N]: ISYNode.CommandsOf<N[x]>; } extends Record<string, unknown> ? keyof N extends string ? { [x in keyof N]: ISYNode.CommandsOf<N[x]>; }[string & keyof N] extends Record<string, unknown> ? keyof { [x in keyof N]: ISYNode.CommandsOf<N[x]>; }[string & keyof N] extends string ? { [x in `${string & keyof N}.${string & keyof { [x in keyof N]: ISYNode.CommandsOf<N[x]>; }[string & keyof N]}`]: { [x in keyof N]: ISYNode.CommandsOf<N[x]>; }[string & keyof N][x extends `${infer A}.${infer B}` ? B extends `${infer A}.${infer B}` ? B extends `${infer A}.${infer B}` ? B extends `${infer A}.${infer B}` ? B extends `${infer A}.${infer B}` ? B extends `${infer A}.${infer B}` ? B extends `${infer A}.${infer B}` ? B extends `${infer A}.${infer B}` ? B extends `${infer A}.${infer B}` ? B extends `${infer A}.${infer B}` ? B extends `${infer A}.${infer B}` ? any : B : B : B : B : B : B : B : B : B : B : x]; } : never : never : never : never>;
+  readProperty(propertyName: keyof UnionToIntersection<{ [x in keyof N]: ISYNode.DriversOf<N[x]>; } extends Record<string, unknown> ? keyof N extends string ? { [x in keyof N]: ISYNode.DriversOf<N[x]>; }[string & keyof N] extends Record<string, unknown> ? keyof { [x in keyof N]: ISYNode.DriversOf<N[x]>; }[string & keyof N] extends string ? { [x in `${string & keyof N}.${string & keyof { [x in keyof N]: ISYNode.DriversOf<N[x]>; }[string & keyof N]}`]: { [x in keyof N]: ISYNode.DriversOf<N[x]>; }[string & keyof N][x extends `${infer A}.${infer B}` ? B extends `${infer A}.${infer B}` ? B extends `${infer A}.${infer B}` ? B extends `${infer A}.${infer B}` ? B extends `${infer A}.${infer B}` ? B extends `${infer A}.${infer B}` ? B extends `${infer A}.${infer B}` ? B extends `${infer A}.${infer B}` ? B extends `${infer A}.${infer B}` ? B extends `${infer A}.${infer B}` ? B extends `${infer A}.${infer B}` ? any : B : B : B : B : B : B : B : B : B : B : x]; } : never : never : never : never>): Promise<DriverState> {
+    throw new Error('Method not implemented.');
+  }
+  sendCommand(command: Extract<keyof UnionToIntersection<{ [x in keyof N]: ISYNode.CommandsOf<N[x]>; } extends Record<string, unknown> ? keyof N extends string ? { [x in keyof N]: ISYNode.CommandsOf<N[x]>; }[string & keyof N] extends Record<string, unknown> ? keyof { [x in keyof N]: ISYNode.CommandsOf<N[x]>; }[string & keyof N] extends string ? { [x in `${string & keyof N}.${string & keyof { [x in keyof N]: ISYNode.CommandsOf<N[x]>; }[string & keyof N]}`]: { [x in keyof N]: ISYNode.CommandsOf<N[x]>; }[string & keyof N][x extends `${infer A}.${infer B}` ? B extends `${infer A}.${infer B}` ? B extends `${infer A}.${infer B}` ? B extends `${infer A}.${infer B}` ? B extends `${infer A}.${infer B}` ? B extends `${infer A}.${infer B}` ? B extends `${infer A}.${infer B}` ? B extends `${infer A}.${infer B}` ? B extends `${infer A}.${infer B}` ? B extends `${infer A}.${infer B}` ? B extends `${infer A}.${infer B}` ? any : B : B : B : B : B : B : B : B : B : B : x]; } : never : never : never : never>, string>, parameters?: Record<string | symbol, string | number> | string | number): Promise<any> {
+    throw new Error('Method not implemented.');
+  }
+
+  updateProperty(propertyName: keyof ISYNode.DriverMap<N>, value: string): Promise<any> {
+    throw new Error('Method not implemented.');
+  }
+
+  handleControlTrigger(controlName: string): boolean {
+    throw new Error('Method not implemented.');
+  }
+
+  _parentDevice: ISYDevice<T, any, any, any>;
+  children: ISYNode<any, any, any, any>[];
+  convertTo(value: any, uom: number);
+  convertTo(value: any, uom: number, propertyName: keyof DriverMap<N>);
+  convertTo(value: unknown, uom: unknown, propertyName?: unknown): any {
+    throw new Error('Method not implemented.');
+  }
+  convertFrom(value: any, uom: number);
+  convertFrom(value: any, uom: number, propertyName: keyof DriverMap<N>);
+  convertFrom(value: unknown, uom: unknown, propertyName?: unknown): any {
+    throw new Error('Method not implemented.');
+  }
+  addLink(isyScene: ISYScene): void {
+    throw new Error('Method not implemented.');
+  }
+  addChild(childDevice: ISYNode<any, any, any, any>): void {
+    throw new Error('Method not implemented.');
+  }
+
+  readProperties(): Promise<DriverState[]> {
+    throw new Error('Method not implemented.');
+  }
+
+  refresh(): Promise<any> {
+    throw new Error('Method not implemented.');
+  }
+  refreshNotes(): Promise<void> {
+    throw new Error('Method not implemented.');
+  }
+  parseResult(node: { property: DriverState | DriverState[]; }): void {
+    throw new Error('Method not implemented.');
+  }
+
+  handlePropertyChange(propertyName: keyof ISYNode.DriverMap<N> & string, value: any, uom: UnitOfMeasure, prec: number, formattedValue: string): boolean {
+    throw new Error('Method not implemented.');
+  }
+
+  logger(arg0: string): unknown {
+    throw new Error('Method not implemented.');
+  }
+  handleEvent(evt: any): unknown {
+    throw new Error('Method not implemented.');
+  }
+  on(arg0: string, arg1: any): unknown {
+    throw new Error('Method not implemented.');
+  }
+  name: any;
+  drivers: Driver.ForAll<ISYNode.DriverMap<N>>;
+  address: string;
+  family: T;
+  typeCode: string;
+  deviceClass: any;
+  parentAddress: any;
+  category: number;
+  subCategory: number;
+  type: any;
+  scenes: ISYScene[];
+  hidden: boolean;
+  enabled: boolean;
+  productName: string;
+  model: string;
+  modelNumber: string;
+  version: string;
+  isDimmable: boolean;
+  label: string;
+
+} */

package/src/Devices/DeviceFactory.ts

@@ -15,7 +15,7 @@ export class DeviceFactory {
 
 		if ((node.family ?? Family.Insteon) == Family.Insteon) {
 
-			return InsteonDeviceFactory.getInsteonDeviceDetails(node) as any;
+			return InsteonDeviceFactory.getDeviceDetails(node) as any;
 
 		} else { return {name: 'Unsupported Device', class: null, unsupported: true} }
 	}

package/src/Devices/ISYDeviceNode.ts

@@ -1,15 +1,17 @@
+import type EventEmitter from 'events';
 import type { Category } from '../Definitions/Global/Categories.js';
 import type { Command } from '../Definitions/Global/Commands.js';
 import type { Driver } from '../Definitions/Global/Drivers.js';
 import type { Event } from '../Definitions/Global/Events.js';
 import type { Family } from '../Definitions/index.js';
+import type { NodeEvent } from '../Events/NodeEvent.js';
 import { type ISY } from '../ISY.js';
 import type { ISYDevice, ISYDeviceInfo } from '../ISYDevice.js';
 import { ISYNode } from '../ISYNode.js';
 import type { ISYScene } from '../ISYScene.js';
 import type { DriverState } from '../Model/DriverState.js';
 import type { NodeInfo } from '../Model/NodeInfo.js';
-import type { StringKeys } from '../Utils.js';
+import type {StringKeys } from '../Utils.js';
 
 export class ISYDeviceNode<
 		T extends Family,
@@ -18,7 +20,8 @@ export class ISYDeviceNode<
 		E extends ISYNode.EventSignatures = { [x in keyof D]: Event.DriverToEvent<D[x]> & { driver: x } } & { [x in keyof C]: Event.CommandToEvent<C[x]> & { command: x } }
 	>
 	extends ISYNode<T, D, C, E>
-	implements ISYDeviceInfo
+	implements ISYDeviceInfo,
+	ISYDevice<T, Driver.ForAll<D>, Command.ForAll<C>, any>
 {
 	public declare family: T;
 
@@ -27,6 +30,8 @@ export class ISYDeviceNode<
 	public readonly category: Category;
 	public readonly subCategory: number;
 
+
+
 	//public readonly isDimmable: boolean;
 
 	//public _parentDevice: ISYDeviceNode<T, any, any, any>;
@@ -80,6 +85,7 @@ export class ISYDeviceNode<
 		//   );
 		// }
 	}
+	vendorName: string;
 	manufacturer: string;
 	productId: string | number;
 	modelName: string;

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

@@ -17,7 +17,7 @@ const nodeDefId = "AlertModuleArmed";
 type Commands = AlertModuleArmed.Commands;
 type Drivers = AlertModuleArmed.Drivers;
 
-export class AlertModuleArmedNode extends Base<Drivers, Commands> implements AlertModuleArmed.Interface {
+class AlertModuleArmedNode extends Base<Drivers, Commands> implements AlertModuleArmed.Interface {
 	public override readonly commands = {
 		DON: this.on,
 		DOF: this.off,
@@ -26,12 +26,12 @@ export class AlertModuleArmedNode extends Base<Drivers, Commands> implements Ale
 		WDU: this.writeChanges
 	};
 	static override nodeDefId = "AlertModuleArmed";
-	static override implements = ["AlertModuleArmed", "SirenAlert", "SirenArm"];
-	declare readonly nodeDefId: "AlertModuleArmed";
+	static override implements = ['AlertModuleArmed', "SirenAlert", "SirenArm"];
+	declare readonly nodeDefId: 'AlertModuleArmed';
 	constructor (isy: ISY, nodeInfo: NodeInfo) {
 		super(isy, nodeInfo);
-		this.drivers.ST = Driver.create("ST", this, nodeInfo.property as DriverState, { uom: UnitOfMeasure.Percent, label: "Status", name: "status" });
-		this.drivers.ERR = Driver.create("ERR", this, nodeInfo.property as DriverState, { uom: UnitOfMeasure.Index, label: "Responding", name: "responding" });
+		this.drivers.ST = Driver.create("ST", this, nodeInfo.state['ST'], { uom: UnitOfMeasure.Percent, label: "Status", name: "status" });
+		this.drivers.ERR = Driver.create("ERR", this, nodeInfo.state['ERR'], { uom: UnitOfMeasure.Index, label: "Responding", name: "responding" });
 	}
 	async on() { return this.sendCommand("DON"); }
 	async off() { return this.sendCommand("DOF"); }
@@ -50,13 +50,12 @@ NodeFactory.register(AlertModuleArmedNode);
 
 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);
+		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);
+		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);
 	}
 	export function create(isy: ISY, nodeInfo: NodeInfo) {
 		return new AlertModuleArmedNode(isy, nodeInfo);

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

@@ -17,7 +17,7 @@ const nodeDefId = "AlertModuleSiren";
 type Commands = AlertModuleSiren.Commands;
 type Drivers = AlertModuleSiren.Drivers;
 
-export class AlertModuleSirenNode extends Base<Drivers, Commands> implements AlertModuleSiren.Interface {
+class AlertModuleSirenNode extends Base<Drivers, Commands> implements AlertModuleSiren.Interface {
 	public override readonly commands = {
 		DON: this.on,
 		DOF: this.off,
@@ -28,12 +28,12 @@ export class AlertModuleSirenNode extends Base<Drivers, Commands> implements Ale
 		WDU: this.writeChanges
 	};
 	static override nodeDefId = "AlertModuleSiren";
-	static override implements = ["AlertModuleSiren", "AlertModuleArmed", "SirenAlert", "SirenArm"];
-	declare readonly nodeDefId: "AlertModuleSiren" | "AlertModuleSiren_ADV";
+	static override implements = ['AlertModuleSiren', "AlertModuleArmed", "SirenAlert", "SirenArm"];
+	declare readonly nodeDefId: 'AlertModuleSiren' | "AlertModuleSiren_ADV";
 	constructor (isy: ISY, nodeInfo: NodeInfo) {
 		super(isy, nodeInfo);
-		this.drivers.ST = Driver.create("ST", this, nodeInfo.property as DriverState, { uom: UnitOfMeasure.Percent, label: "Status", name: "status" });
-		this.drivers.ERR = Driver.create("ERR", this, nodeInfo.property as DriverState, { uom: UnitOfMeasure.Index, label: "Responding", name: "responding" });
+		this.drivers.ST = Driver.create("ST", this, nodeInfo.state['ST'], { uom: UnitOfMeasure.Percent, label: "Status", name: "status" });
+		this.drivers.ERR = Driver.create("ERR", this, nodeInfo.state['ERR'], { uom: UnitOfMeasure.Index, label: "Responding", name: "responding" });
 	}
 	async on(onLevel?: number) { return this.sendCommand("DON", { OL: onLevel }); }
 	async off() { return this.sendCommand("DOF"); }
@@ -55,13 +55,12 @@ NodeFactory.register(AlertModuleSirenNode, "AlertModuleSiren_ADV");
 
 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);
+		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);
+		return ['AlertModuleSiren', "AlertModuleSiren_ADV"].includes(node.nodeDefId);
 	}
 	export function create(isy: ISY, nodeInfo: NodeInfo) {
 		return new AlertModuleSirenNode(isy, nodeInfo);

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

@@ -17,7 +17,7 @@ const nodeDefId = "BallastRelayLampSwitch";
 type Commands = BallastRelayLampSwitch.Commands;
 type Drivers = BallastRelayLampSwitch.Drivers;
 
-export class BallastRelayLampSwitchNode extends Base<Drivers, Commands> implements BallastRelayLampSwitch.Interface {
+class BallastRelayLampSwitchNode extends Base<Drivers, Commands> implements BallastRelayLampSwitch.Interface {
 	public override readonly commands = {
 		DON: this.on,
 		DOF: this.off,
@@ -28,12 +28,12 @@ export class BallastRelayLampSwitchNode extends Base<Drivers, Commands> implemen
 		WDU: this.writeChanges
 	};
 	static override nodeDefId = "BallastRelayLampSwitch";
-	static override implements = ["BallastRelayLampSwitch", "RelayLampOnly", "RelayLampOnly_ADV", "IRLincTx", "EZRAIN_Output", "EZIO2x4_Output", "EZIO2x4_Input", "EZIO2x4_Input_ADV", "BinaryAlarm", "BinaryAlarm_ADV", "BinaryControl", "BinaryControl_ADV", "AlertModuleArmed", "SirenAlert", "SirenArm"];
-	declare readonly nodeDefId: "BallastRelayLampSwitch" | "BallastRelayLampSwitch_ADV";
+	static override implements = ['BallastRelayLampSwitch', "RelayLampOnly", "RelayLampOnly_ADV", "IRLincTx", "EZRAIN_Output", "EZIO2x4_Output", "EZIO2x4_Input", "EZIO2x4_Input_ADV", "BinaryAlarm", "BinaryAlarm_ADV", "BinaryControl", "BinaryControl_ADV", "AlertModuleArmed", "SirenAlert", "SirenArm"];
+	declare readonly nodeDefId: 'BallastRelayLampSwitch' | "BallastRelayLampSwitch_ADV";
 	constructor (isy: ISY, nodeInfo: NodeInfo) {
 		super(isy, nodeInfo);
-		this.drivers.ST = Driver.create("ST", this, nodeInfo.property as DriverState, { uom: UnitOfMeasure.Percent, label: "Status", name: "status" });
-		this.drivers.ERR = Driver.create("ERR", this, nodeInfo.property as DriverState, { uom: UnitOfMeasure.Index, label: "Responding", name: "responding" });
+		this.drivers.ST = Driver.create("ST", this, nodeInfo.state['ST'], { uom: UnitOfMeasure.Percent, label: "Status", name: "status" });
+		this.drivers.ERR = Driver.create("ERR", this, nodeInfo.state['ERR'], { uom: UnitOfMeasure.Index, label: "Responding", name: "responding" });
 	}
 	async on(value?: (0 | 100)) { return this.sendCommand("DON", value); }
 	async off() { return this.sendCommand("DOF"); }
@@ -55,13 +55,12 @@ NodeFactory.register(BallastRelayLampSwitchNode, "BallastRelayLampSwitch_ADV");
 
 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);
+		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);
+		return ['BallastRelayLampSwitch', "BallastRelayLampSwitch_ADV"].includes(node.nodeDefId);
 	}
 	export function create(isy: ISY, nodeInfo: NodeInfo) {
 		return new BallastRelayLampSwitchNode(isy, nodeInfo);

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

@@ -17,19 +17,19 @@ const nodeDefId = "BinaryAlarm";
 type Commands = BinaryAlarm.Commands;
 type Drivers = BinaryAlarm.Drivers;
 
-export class BinaryAlarmNode extends Base<Drivers, Commands> implements BinaryAlarm.Interface {
+class BinaryAlarmNode extends Base<Drivers, Commands> implements BinaryAlarm.Interface {
 	public override readonly commands = {
 		QUERY: this.query,
 		BEEP: this.beep,
 		WDU: this.writeChanges
 	};
 	static override nodeDefId = "BinaryAlarm";
-	static override implements = ["BinaryAlarm", "BinaryControl", "BinaryControl_ADV", "SirenAlert", "SirenArm"];
-	declare readonly nodeDefId: "BinaryAlarm" | "BinaryAlarm_ADV";
+	static override implements = ['BinaryAlarm', "BinaryControl", "BinaryControl_ADV", "SirenAlert", "SirenArm"];
+	declare readonly nodeDefId: 'BinaryAlarm' | "BinaryAlarm_ADV";
 	constructor (isy: ISY, nodeInfo: NodeInfo) {
 		super(isy, nodeInfo);
-		this.drivers.ST = Driver.create("ST", this, nodeInfo.property as DriverState, { uom: UnitOfMeasure.Percent, label: "Status", name: "status" });
-		this.drivers.ERR = Driver.create("ERR", this, nodeInfo.property as DriverState, { uom: UnitOfMeasure.Index, label: "Responding", name: "responding" });
+		this.drivers.ST = Driver.create("ST", this, nodeInfo.state['ST'], { uom: UnitOfMeasure.Percent, label: "Status", name: "status" });
+		this.drivers.ERR = Driver.create("ERR", this, nodeInfo.state['ERR'], { uom: UnitOfMeasure.Index, label: "Responding", name: "responding" });
 	}
 	async query() { return this.sendCommand("QUERY"); }
 	async beep(value?: number) { return this.sendCommand("BEEP", value); }
@@ -47,13 +47,12 @@ NodeFactory.register(BinaryAlarmNode, "BinaryAlarm_ADV");
 
 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);
+		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);
+		return ['BinaryAlarm', "BallastRelayLampSwitch", "BallastRelayLampSwitch_ADV", "RelayLampSwitch", "RelayLampSwitch_ADV", "RelayLampSwitchLED", "RelayLampSwitchLED_ADV", "KeypadRelay", "KeypadRelay_ADV", "BinaryAlarm_ADV"].includes(node.nodeDefId);
 	}
 	export function create(isy: ISY, nodeInfo: NodeInfo) {
 		return new BinaryAlarmNode(isy, nodeInfo);

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

@@ -17,19 +17,19 @@ const nodeDefId = "BinaryControl";
 type Commands = BinaryControl.Commands;
 type Drivers = BinaryControl.Drivers;
 
-export class BinaryControlNode extends Base<Drivers, Commands> implements BinaryControl.Interface {
+class BinaryControlNode extends Base<Drivers, Commands> implements BinaryControl.Interface {
 	public override readonly commands = {
 		QUERY: this.query,
 		BEEP: this.beep,
 		WDU: this.writeChanges
 	};
 	static override nodeDefId = "BinaryControl";
-	static override implements = ["BinaryControl", "SirenAlert", "SirenArm"];
-	declare readonly nodeDefId: "BinaryControl" | "BinaryControl_ADV";
+	static override implements = ['BinaryControl', "SirenAlert", "SirenArm"];
+	declare readonly nodeDefId: 'BinaryControl' | "BinaryControl_ADV";
 	constructor (isy: ISY, nodeInfo: NodeInfo) {
 		super(isy, nodeInfo);
-		this.drivers.ST = Driver.create("ST", this, nodeInfo.property as DriverState, { uom: UnitOfMeasure.Percent, label: "Status", name: "status" });
-		this.drivers.ERR = Driver.create("ERR", this, nodeInfo.property as DriverState, { uom: UnitOfMeasure.Index, label: "Responding", name: "responding" });
+		this.drivers.ST = Driver.create("ST", this, nodeInfo.state['ST'], { uom: UnitOfMeasure.Percent, label: "Status", name: "status" });
+		this.drivers.ERR = Driver.create("ERR", this, nodeInfo.state['ERR'], { uom: UnitOfMeasure.Index, label: "Responding", name: "responding" });
 	}
 	async query() { return this.sendCommand("QUERY"); }
 	async beep(value?: number) { return this.sendCommand("BEEP", value); }
@@ -47,13 +47,12 @@ NodeFactory.register(BinaryControlNode, "BinaryControl_ADV");
 
 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);
+		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);
+		return ['BinaryControl', "BallastRelayLampSwitch", "BallastRelayLampSwitch_ADV", "RelayLampSwitch", "RelayLampSwitch_ADV", "RelayLampSwitchLED", "RelayLampSwitchLED_ADV", "KeypadRelay", "KeypadRelay_ADV", "BinaryAlarm", "BinaryAlarm_ADV", "BinaryControl_ADV"].includes(node.nodeDefId);
 	}
 	export function create(isy: ISY, nodeInfo: NodeInfo) {
 		return new BinaryControlNode(isy, nodeInfo);

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

@@ -17,7 +17,7 @@ const nodeDefId = "DimmerLampOnly";
 type Commands = DimmerLamp.Commands;
 type Drivers = DimmerLamp.Drivers;
 
-export class DimmerLampNode extends Base<Drivers, Commands> implements DimmerLamp.Interface {
+class DimmerLampNode extends Base<Drivers, Commands> implements DimmerLamp.Interface {
 	public override readonly commands = {
 		DON: this.on,
 		DOF: this.off,
@@ -35,14 +35,14 @@ export class DimmerLampNode extends Base<Drivers, Commands> implements DimmerLam
 		WDU: this.writeChanges
 	};
 	static override nodeDefId = "DimmerLampOnly";
-	static override implements = ["DimmerLampOnly", "IRLincTx", "SirenAlert", "SirenArm"];
-	declare readonly nodeDefId: "DimmerLampOnly";
+	static override implements = ['DimmerLampOnly', "IRLincTx", "SirenAlert", "SirenArm"];
+	declare readonly nodeDefId: 'DimmerLampOnly';
 	constructor (isy: ISY, nodeInfo: NodeInfo) {
 		super(isy, nodeInfo);
-		this.drivers.ST = Driver.create("ST", this, nodeInfo.property as DriverState, { uom: UnitOfMeasure.Percent, label: "Status", name: "status" });
-		this.drivers.OL = Driver.create("OL", this, nodeInfo.property as DriverState, { uom: UnitOfMeasure.Percent, label: "On Level", name: "onLevel" });
-		this.drivers.RR = Driver.create("RR", this, nodeInfo.property as DriverState, { uom: UnitOfMeasure.Index, label: "Ramp Rate", name: "rampRate" });
-		this.drivers.ERR = Driver.create("ERR", this, nodeInfo.property as DriverState, { uom: UnitOfMeasure.Index, label: "Responding", name: "responding" });
+		this.drivers.ST = Driver.create("ST", this, nodeInfo.state['ST'], { uom: UnitOfMeasure.Percent, label: "Status", name: "status" });
+		this.drivers.OL = Driver.create("OL", this, nodeInfo.state['OL'], { uom: UnitOfMeasure.Percent, label: "On Level", name: "onLevel" });
+		this.drivers.RR = Driver.create("RR", this, nodeInfo.state['RR'], { uom: UnitOfMeasure.Index, label: "Ramp Rate", name: "rampRate" });
+		this.drivers.ERR = Driver.create("ERR", this, nodeInfo.state['ERR'], { uom: UnitOfMeasure.Index, label: "Responding", name: "responding" });
 	}
 	async on(value?: number) { return this.sendCommand("DON", value); }
 	async off() { return this.sendCommand("DOF"); }
@@ -76,13 +76,12 @@ NodeFactory.register(DimmerLampNode);
 
 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);
+		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);
+		return ['DimmerLampOnly', "DimmerLampSwitch", "DimmerLampSwitch_ADV", "DimmerLampSwitchLED", "DimmerLampSwitchLED_ADV"].includes(node.nodeDefId);
 	}
 	export function create(isy: ISY, nodeInfo: NodeInfo) {
 		return new DimmerLampNode(isy, nodeInfo);

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

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